WIP: Generic Tool Abstraction

mcpserver/args.go

		explanationArgument,
		explanationArgument,
		explanationArgument,
@@ -0,0 +1,40 @@
+package mcpserver
+
+import "github.com/mark3labs/mcp-go/mcp"
+
+var (
+	explainationArgument = mcp.WithString("explanation",
+		mcp.Description("One sentence explanation for why this directory is being listed."),
+	)
+	environmentSourceArgument = mcp.WithString("environment_source",
+		mcp.Description("Absolute path to the source git repository for the environment."),
+		mcp.Required(),
+	)
+	environmentIDArgument = mcp.WithString("environment_id",
+		mcp.Description("The ID of the environment for this command. Must call `environment_create` first."),
+		mcp.Required(),
+	)
+)
+
+func newRepositoryTool(name string, description string, args ...mcp.ToolOption) mcp.Tool {
+	opts := []mcp.ToolOption{
+		mcp.WithDescription(description),
+		explainationArgument,
+		environmentSourceArgument,
+	}
+	opts = append(opts, args...)
+
+	return mcp.NewTool(name, opts...)
+}
+
+func newEnvironmentTool(name string, description string, args ...mcp.ToolOption) mcp.Tool {
+	opts := []mcp.ToolOption{
+		mcp.WithDescription(description),
+		explainationArgument,
+		environmentSourceArgument,
+		environmentIDArgument,
+	}
+	opts = append(opts, args...)
+
+	return mcp.NewTool(name, opts...)
+}

		explanationArgument,

		explanationArgument,

mcpserver/mcpserver.go

)
	return BaseRequest{
		Explanation: explanation,
	}, nil
func dagFromContext(ctx context.Context) (*dagger.Client, error) {
	dag, ok := ctx.Value(daggerClientKey{}).(*dagger.Client)
	if !ok {
		return nil, fmt.Errorf("dagger client not found in context")
	}
	return dag, nil
}
import (
	"context"
	"fmt"
	"dagger.io/dagger"
	"github.com/dagger/container-use/environment"
	"github.com/dagger/container-use/repository"
	"github.com/mark3labs/mcp-go/mcp"
)
@@ -0,0 +1,107 @@
+package mcpserver
+
+import (
+	"context"
+
+	"dagger.io/dagger"
+	"github.com/dagger/container-use/environment"
+	"github.com/dagger/container-use/repository"
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+func dagFromContext(ctx context.Context) *dagger.Client {
+	dag, ok := ctx.Value(daggerClientKey{}).(*dagger.Client)
+	if !ok {
+		panic("dagger client not found in context")
+	}
+	return dag
+}
+
+type Request interface {
+	isRequest()
+}
+
+type BaseRequest struct {
+	Explanation string `json:"explanation"`
+}
+
+func (BaseRequest) isRequest() {}
+
+type BaseRepositoryRequest struct {
+	BaseRequest
+
+	EnvironmentSource string `json:"environment_source"`
+}
+
+type BaseEnvironmentRequest struct {
+	BaseRepositoryRequest
+
+	EnvironmentID string `json:"environment_id"`
+}
+
+type Response any
+
+type ToolResponse[T Response] struct {
+	Message string
+	Data    T
+}
+
+func openRepositoryFromRequest(ctx context.Context, request BaseRepositoryRequest) (*repository.Repository, error) {
+	repo, err := repository.Open(ctx, request.EnvironmentSource)
+	if err != nil {
+		return nil, err
+	}
+	return repo, nil
+}
+
+func openEnvironmentFromRequest(ctx context.Context, request BaseEnvironmentRequest) (*repository.Repository, *environment.Environment, error) {
+	repo, err := openRepositoryFromRequest(ctx, request.BaseRepositoryRequest)
+	if err != nil {
+		return nil, nil, err
+	}
+	env, err := repo.Get(ctx, dagFromContext(ctx), request.EnvironmentID)
+	if err != nil {
+		return nil, nil, err
+	}
+	return repo, env, nil
+}
+
+func parseBaseRequest(request mcp.CallToolRequest) (BaseRequest, error) {
+	explanation, err := request.RequireString("explanation")
+	if err != nil {
+		return BaseRequest{}, err
+	}
+	return BaseRequest{
+		Explanation: explanation,
+	}, nil
+}
+
+func parseBaseRepositoryRequest(request mcp.CallToolRequest) (BaseRepositoryRequest, error) {
+	base, err := parseBaseRequest(request)
+	if err != nil {
+		return BaseRepositoryRequest{}, err
+	}
+	environmentSource, err := request.RequireString("environment_source")
+	if err != nil {
+		return BaseRepositoryRequest{}, err
+	}
+	return BaseRepositoryRequest{
+		BaseRequest:       base,
+		EnvironmentSource: environmentSource,
+	}, nil
+}
+
+func parseBaseEnvironmentRequest(request mcp.CallToolRequest) (BaseEnvironmentRequest, error) {
+	base, err := parseBaseRepositoryRequest(request)
+	if err != nil {
+		return BaseEnvironmentRequest{}, err
+	}
+	environmentID, err := request.RequireString("environment_id")
+	if err != nil {
+		return BaseEnvironmentRequest{}, err
+	}
+	return BaseEnvironmentRequest{
+		BaseRepositoryRequest: base,
+		EnvironmentID:         environmentID,
+	}, nil
+}

	return BaseRequest{
		Explanation: explanation,
	}, nil

func dagFromContext(ctx context.Context) (*dagger.Client, error) {
	dag, ok := ctx.Value(daggerClientKey{}).(*dagger.Client)
	if !ok {
		return nil, fmt.Errorf("dagger client not found in context")
	}
	return dag, nil
}

import (
	"context"
	"fmt"
	"dagger.io/dagger"
	"github.com/dagger/container-use/environment"
	"github.com/dagger/container-use/repository"
	"github.com/mark3labs/mcp-go/mcp"
)