v2

Author: jba

mcp/content_nil_test.go

@@ -52,8 +52,8 @@ func TestContentUnmarshalNil(t *testing.T) {
 		{
 			name:    "CallToolResultFor nil Content",
 			json:    `{"content":[{"type":"text","text":"hello"}]}`,
-			content: &mcp.CallToolResultFor[string]{},
-			want:    &mcp.CallToolResultFor[string]{Content: []mcp.Content{&mcp.TextContent{Text: "hello"}}},
+			content: &mcp.CallToolResult{},
+			want:    &mcp.CallToolResult{Content: []mcp.Content{&mcp.TextContent{Text: "hello"}}},
 		},
 	}
 

mcp/example_middleware_test.go

@@ -72,7 +72,7 @@ func Example_loggingMiddleware() {
 	server.AddReceivingMiddleware(loggingMiddleware)
 
 	// Add a simple tool
-	server.AddTool(
+	mcp.AddTool(server,
 		&mcp.Tool{
 			Name:        "greet",
 			Description: "Greet someone with logging.",
@@ -89,19 +89,19 @@ func Example_loggingMiddleware() {
 		},
 		func(
 			ctx context.Context,
-			req *mcp.ServerRequest[*mcp.CallToolParamsFor[map[string]any]],
-		) (*mcp.CallToolResultFor[any], error) {
-			name, ok := req.Params.Arguments["name"].(string)
+			req *mcp.ServerRequest[*mcp.CallToolParams], args map[string]any,
+		) (*mcp.CallToolResult, any, error) {
+			name, ok := args["name"].(string)
 			if !ok {
-				return nil, fmt.Errorf("name parameter is required and must be a string")
+				return nil, nil, fmt.Errorf("name parameter is required and must be a string")
 			}
 
 			message := fmt.Sprintf("Hello, %s!", name)
-			return &mcp.CallToolResultFor[any]{
+			return &mcp.CallToolResult{
 				Content: []mcp.Content{
 					&mcp.TextContent{Text: message},
 				},
-			}, nil
+			}, nil, nil
 		},
 	)
 

mcp/mcp_test.go

@@ -246,7 +246,7 @@ func TestEndToEnd(t *testing.T) {
 			t.Errorf("tools/call 'fail' mismatch (-want +got):\n%s", diff)
 		}
 
-		s.AddRawTool(&Tool{Name: "T", InputSchema: &jsonschema.Schema{}}, nopHandler)
+		s.AddTool(&Tool{Name: "T", InputSchema: &jsonschema.Schema{}}, nopHandler)
 		waitForNotification(t, "tools")
 		s.RemoveTools("T")
 		waitForNotification(t, "tools")
@@ -657,7 +657,7 @@ func TestCancellation(t *testing.T) {
 		return nil, nil
 	}
 	_, cs := basicConnection(t, func(s *Server) {
-		s.AddRawTool(&Tool{Name: "slow"}, slowRequest)
+		s.AddTool(&Tool{Name: "slow", InputSchema: &jsonschema.Schema{}}, slowRequest)
 	})
 	defer cs.Close()
 
@@ -946,8 +946,8 @@ func TestAddTool_DuplicateNoPanicAndNoDuplicate(t *testing.T) {
 		// This case was written specifically to reproduce a bug where duplicate tools where causing jsonschema errors
 		t1 := &Tool{Name: "dup", Description: "first", InputSchema: &jsonschema.Schema{}}
 		t2 := &Tool{Name: "dup", Description: "second", InputSchema: &jsonschema.Schema{}}
-		s.AddRawTool(t1, nopHandler)
-		s.AddRawTool(t2, nopHandler)
+		s.AddTool(t1, nopHandler)
+		s.AddTool(t2, nopHandler)
 	})
 	defer cs.Close()
 

mcp/protocol.go

@@ -879,8 +879,6 @@ type Tool struct {
 	// If not provided, Annotations.Title should be used for display if present,
 	// otherwise Name.
 	Title string `json:"title,omitempty"`
-
-	newArgs func() any
 }
 
 // Additional properties describing a Tool to clients.

mcp/protocol_test.go

@@ -519,7 +519,7 @@ func TestContentUnmarshal(t *testing.T) {
 		Meta:              Meta{"m": true},
 		Content:           content,
 		IsError:           true,
-		StructuredContent: 3,
+		StructuredContent: 3.0,
 	}
 	var gotf CallToolResult
 	roundtrip(ctrf, &gotf)

mcp/server.go

@@ -140,7 +140,7 @@ func (s *Server) RemovePrompts(names ...string) {
 		func() bool { return s.prompts.remove(names...) })
 }
 
-// AddRawTool adds a [Tool] to the server, or replaces one with the same name.
+// AddTool adds a [Tool] to the server, or replaces one with the same name.
 // The Tool argument must not be modified after this call.
 //
 // The tool's input schema must be non-nil. For a tool that takes no input,
@@ -150,7 +150,14 @@ func (s *Server) RemovePrompts(names ...string) {
 // When the handler is invoked as part of a CallTool request, req.Params.Arguments
 // will be a json.RawMessage. Unmarshaling the arguments and validating them against the
 // input schema are the handler author's responsibility.
-func (s *Server) AddRawTool(t *Tool, h RawToolHandler) {
+func (s *Server) AddTool(t *Tool, h ToolHandler) {
+	if t.InputSchema == nil {
+		// This prevents the tool author from forgetting to write a schema where
+		// one should be provided. If we papered over this by supplying the empty
+		// schema, then every input would be validated and the problem wouldn't be
+		// discovered until runtime, when the LLM sent bad data.
+		panic(fmt.Errorf("AddTool %q: missing input schema", t.Name))
+	}
 	st := &serverTool{tool: t, handler: h}
 	// Assume there was a change, since add replaces existing tools.
 	// (It's possible a tool was replaced with an identical one, but not worth checking.)
@@ -160,43 +167,50 @@ func (s *Server) AddRawTool(t *Tool, h RawToolHandler) {
 		func() bool { s.tools.add(st); return true })
 }
 
+// ToolFor returns a shallow copy of t and a [ToolHandler] that wraps h.
 // If the tool's input schema is nil, it is set to the schema inferred from the In
 // type parameter, using [jsonschema.For].
 // If the tool's output schema is nil and the Out type parameter is not the empty
 // interface, then the output schema is set to the schema inferred from Out.
-func RawToolHandlerFor[In, Out any](t *Tool, h ToolHandlerFor[In, Out]) RawToolHandler {
-	hh, err := toolForErr(t, h)
+//
+// Most users will call [AddTool]. Use [ToolFor] if you wish to wrap the ToolHandler
+// before calling [Server.AddTool].
+func ToolFor[In, Out any](t *Tool, h ToolHandlerFor[In, Out]) (*Tool, ToolHandler) {
+	tt, hh, err := toolForErr(t, h)
 	if err != nil {
 		panic(fmt.Sprintf("ToolFor: tool %q: %v", t.Name, err))
 	}
-	return hh
+	return tt, hh
 }
 
 // TODO(v0.3.0): test
-func toolForErr[In, Out any](t *Tool, h ToolHandlerFor[In, Out]) (RawToolHandler, error) {
+func toolForErr[In, Out any](t *Tool, h ToolHandlerFor[In, Out]) (*Tool, ToolHandler, error) {
 	var err error
-	inputSchema := t.InputSchema
-	if inputSchema == nil {
-		inputSchema, err = jsonschema.For[In](nil)
+	tt := *t
+	tt.InputSchema = t.InputSchema
+	if tt.InputSchema == nil {
+		tt.InputSchema, err = jsonschema.For[In](nil)
 		if err != nil {
-			return nil, fmt.Errorf("input schema: %w", err)
+			return nil, nil, fmt.Errorf("input schema: %w", err)
 		}
 	}
-	inputResolved, err := inputSchema.Resolve(&jsonschema.ResolveOptions{ValidateDefaults: true})
+	inputResolved, err := tt.InputSchema.Resolve(&jsonschema.ResolveOptions{ValidateDefaults: true})
 	if err != nil {
-		return nil, fmt.Errorf("resolving input schema: %w", err)
+		return nil, nil, fmt.Errorf("resolving input schema: %w", err)
 	}
 
-	outputSchema := t.OutputSchema
-	if outputSchema == nil && reflect.TypeFor[Out]() != reflect.TypeFor[any]() {
-		outputSchema, err = jsonschema.For[Out](nil)
+	if tt.OutputSchema == nil && reflect.TypeFor[Out]() != reflect.TypeFor[any]() {
+		tt.OutputSchema, err = jsonschema.For[Out](nil)
 	}
 	if err != nil {
-		return nil, fmt.Errorf("output schema: %w", err)
+		return nil, nil, fmt.Errorf("output schema: %w", err)
 	}
-	outputResolved, err := outputSchema.Resolve(&jsonschema.ResolveOptions{ValidateDefaults: true})
-	if err != nil {
-		return nil, fmt.Errorf("resolving output schema: %w", err)
+	var outputResolved *jsonschema.Resolved
+	if tt.OutputSchema != nil {
+		outputResolved, err = tt.OutputSchema.Resolve(&jsonschema.ResolveOptions{ValidateDefaults: true})
+		if err != nil {
+			return nil, nil, fmt.Errorf("resolving output schema: %w", err)
+		}
 	}
 
 	th := func(ctx context.Context, req *ServerRequest[*CallToolParams]) (*CallToolResult, error) {
@@ -228,12 +242,12 @@ func toolForErr[In, Out any](t *Tool, h ToolHandlerFor[In, Out]) (RawToolHandler
 		return res, nil
 	}
 
-	return th, nil
+	return &tt, th, nil
 }
 
-// AddTool is a convenience for s.AddRawTool(t, RawToolHandler(t, h)).
+// AddTool is a convenience for s.AddTool(ToolFor(t, h)).
 func AddTool[In, Out any](s *Server, t *Tool, h ToolHandlerFor[In, Out]) {
-	s.AddRawTool(t, RawToolHandlerFor(t, h))
+	s.AddTool(ToolFor(t, h))
 }
 
 // RemoveTools removes the tools with the given names.

mcp/server_example_test.go

@@ -16,12 +16,12 @@ type SayHiParams struct {
 	Name string `json:"name"`
 }
 
-func SayHi(ctx context.Context, req *mcp.ServerRequest[*mcp.CallToolParamsFor[SayHiParams]]) (*mcp.CallToolResultFor[any], error) {
-	return &mcp.CallToolResultFor[any]{
+func SayHi(ctx context.Context, req *mcp.ServerRequest[*mcp.CallToolParams], args SayHiParams) (*mcp.CallToolResult, any, error) {
+	return &mcp.CallToolResult{
 		Content: []mcp.Content{
-			&mcp.TextContent{Text: "Hi " + req.Params.Arguments.Name},
+			&mcp.TextContent{Text: "Hi " + args.Name},
 		},
-	}, nil
+	}, nil, nil
 }
 
 func ExampleServer() {

mcp/server_test.go

@@ -296,7 +296,7 @@ func TestServerCapabilities(t *testing.T) {
 		{
 			name: "With tools",
 			configureServer: func(s *Server) {
-				s.AddRawTool(tool, nil)
+				s.AddTool(tool, nil)
 			},
 			wantCapabilities: &ServerCapabilities{
 				Logging: &LoggingCapabilities{},
@@ -322,7 +322,7 @@ func TestServerCapabilities(t *testing.T) {
 				s.AddPrompt(&Prompt{Name: "p"}, nil)
 				s.AddResource(&Resource{URI: "file:///r"}, nil)
 				s.AddResourceTemplate(&ResourceTemplate{URITemplate: "file:///rt"}, nil)
-				s.AddRawTool(tool, nil)
+				s.AddTool(tool, nil)
 			},
 			serverOpts: ServerOptions{
 				SubscribeHandler: func(context.Context, *ServerRequest[*SubscribeParams]) error {