.

Author: jba

mcp/tool.go

@@ -11,7 +11,6 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/modelcontextprotocol/go-sdk/internal/util"
 	"github.com/modelcontextprotocol/go-sdk/jsonschema"
 )
 
@@ -90,7 +89,7 @@ func newServerTool[In, Out any](t *Tool, h ToolHandlerFor[In, Out]) (*serverTool
 func setSchema[T any](sfield **jsonschema.Schema, rfield **jsonschema.Resolved) error {
 	var err error
 	if *sfield == nil {
-		*sfield, err = SchemaFor[T]()
+		*sfield, err = jsonschema.For[T]()
 	}
 	if err != nil {
 		return err
@@ -126,31 +125,6 @@ func unmarshalSchema(data json.RawMessage, resolved *jsonschema.Resolved, v any)
 	return nil
 }
 
-// SchemaFor returns a JSON Schema for type T.
-// It is like [jsonschema.For], but also uses "mcp" struct field tags
-// for property descriptions.
-//
-// For example, the call
-//
-//	SchemaFor[struct{ B int `mcp:"desc"` }]()
-//
-// returns a schema with this value for "properties":
-//
-//	{"B": {"type": "integer", "description": "desc"}}
-func SchemaFor[T any]() (*jsonschema.Schema, error) {
-	// Infer the schema based on "json" tags alone.
-	s, err := jsonschema.For[T]()
-	if err != nil {
-		return nil, err
-	}
-
-	// Add descriptions from "mcp" tags.
-	if err := addDescriptions(reflect.TypeFor[T](), s); err != nil {
-		return nil, err
-	}
-	return s, nil
-}
-
 // schemaJSON returns the JSON value for s as a string, or a string indicating an error.
 func schemaJSON(s *jsonschema.Schema) string {
 	m, err := json.Marshal(s)

mcp/tool_test.go

@@ -132,49 +132,3 @@ func TestUnmarshalSchema(t *testing.T) {
 
 	}
 }
-
-func TestSchemaFor(t *testing.T) {
-	type S1 struct {
-		G int `mcp:"gdesc"`
-	}
-	type S2 struct {
-		A int
-		B int `json:"b"`
-		C int `mcp:"cdesc"`
-		D int `json:"d" mcp:"ddesc"`
-		E int `json:"-"`
-		F S1  `json:"f"`
-		S1
-	}
-
-	got, err := SchemaFor[S2]()
-	if err != nil {
-		t.Fatal(err)
-	}
-	i := "integer"
-	s1 := &jsonschema.Schema{
-		Type:                 "object",
-		Required:             []string{"G"},
-		AdditionalProperties: falseSchema(),
-		Properties: map[string]*jsonschema.Schema{
-			"G": {Type: i, Description: "gdesc"},
-		},
-	}
-	want := &jsonschema.Schema{
-		Type: "object",
-		Properties: map[string]*jsonschema.Schema{
-			"A":  {Type: i},
-			"b":  {Type: i},
-			"C":  {Type: i, Description: "cdesc"},
-			"d":  {Type: i, Description: "ddesc"},
-			"f":  s1,
-			"S1": s1,
-		},
-		Required:             []string{"A", "b", "C", "d", "f", "S1"},
-		AdditionalProperties: falseSchema(),
-	}
-	if diff := cmp.Diff(want, got, cmp.AllowUnexported(jsonschema.Schema{})); diff != "" {
-		t.Errorf("mismatch (-want, +got):\n%s", diff)
-		t.Log(schemaJSON(got))
-	}
-}