unexport ToolFor

Author: jba

mcp/client_list_test.go

@@ -24,12 +24,14 @@ func TestList(t *testing.T) {
 	t.Run("tools", func(t *testing.T) {
 		var wantTools []*mcp.Tool
 		for _, name := range []string{"apple", "banana", "cherry"} {
-			t := &mcp.Tool{Name: name, Description: name + " tool"}
-			// Previously, we could add t to wantTools, because AddTool modified
-			// it. Now, AddTool gets a copy.
-			tt, h := mcp.ToolFor(t, SayHi)
+			tt := &mcp.Tool{Name: name, Description: name + " tool"}
+			mcp.AddTool(server, tt, SayHi)
+			is, err := jsonschema.For[SayHiParams](nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			tt.InputSchema = is
 			wantTools = append(wantTools, tt)
-			server.AddTool(tt, h)
 		}
 		t.Run("list", func(t *testing.T) {
 			res, err := clientSession.ListTools(ctx, nil)

mcp/server.go

@@ -150,6 +150,8 @@ 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.
+//
+// Most users will prefer the top-level function [AddTool].
 func (s *Server) AddTool(t *Tool, h ToolHandler) {
 	if t.InputSchema == nil {
 		// This prevents the tool author from forgetting to write a schema where
@@ -167,15 +169,15 @@ func (s *Server) AddTool(t *Tool, h ToolHandler) {
 		func() bool { s.tools.add(st); return true })
 }
 
-// ToolFor returns a shallow copy of t and a [ToolHandler] that wraps h.
+// 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.
 //
-// Most users will call [AddTool]. Use [ToolFor] if you wish to wrap the ToolHandler
+// 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) {
+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))
@@ -250,9 +252,15 @@ func toolForErr[In, Out any](t *Tool, h ToolHandlerFor[In, Out]) (*Tool, ToolHan
 	return &tt, th, nil
 }
 
-// AddTool is a convenience for s.AddTool(ToolFor(t, h)).
+// AddTool adds a tool and handler to the server.
+//
+// A shallow copy of the tool is made first.
+// If the tool's input schema is nil, the copy's input schema 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 copy's output schema is set to the schema inferred from Out.
 func AddTool[In, Out any](s *Server, t *Tool, h ToolHandlerFor[In, Out]) {
-	s.AddTool(ToolFor(t, h))
+	s.AddTool(toolFor(t, h))
 }
 
 // RemoveTools removes the tools with the given names.

mcp/tool.go

@@ -18,11 +18,6 @@ import (
 // against the input schema.
 type ToolHandler func(context.Context, *ServerRequest[*CallToolParams]) (*CallToolResult, error)
 
-// type CallToolRequest struct {
-// 	Request *ServerRequest
-// 	Params  *CallToolParams
-// }
-
 // A ToolHandlerFor handles a call to tools/call with typed arguments and results.
 type ToolHandlerFor[In, Out any] func(context.Context, *ServerRequest[*CallToolParams], In) (*CallToolResult, Out, error)