modelcontextprotocol/go-sdk
Watch
1
0
Fork
You've already forked go-sdk
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

internal/mcp: rename Make* to New*

Browse source 
Change-Id: I8d3d2ca125b7c24dd265937c4fe910ea823ab811
Reviewed-on: https://go-review.googlesource.com/c/tools/+/670537
Reviewed-by: Robert Findley <rfindley@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
This commit is contained in:
Jonathan Amsterdam 2025-05-07 11:50:44 -04:00 • committed by Robert Findley
commit e0e304e51e
11 changed files with 32 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

4
examples/hello/main.go
View file

@ -40,10 +40,10 @@ func main() {
flag.Parse()
server := mcp.NewServer("greeter", "v0.0.1", nil)
server.AddTools(mcp.MakeTool("greet", "say hi", SayHi, mcp.Input(
server.AddTools(mcp.NewTool("greet", "say hi", SayHi, mcp.Input(
mcp.Property("name", mcp.Description("the name to say hi to")),
)))
server.AddPrompts(mcp.MakePrompt("greet", "", PromptHi))
server.AddPrompts(mcp.NewPrompt("greet", "", PromptHi))
if *httpAddr != "" {
handler := mcp.NewSSEHandler(func(*http.Request) *mcp.Server {

4
examples/sse/main.go
View file

@ -33,10 +33,10 @@ func main() {
}
server1 := mcp.NewServer("greeter1", "v0.0.1", nil)
server1.AddTools(mcp.MakeTool("greet1", "say hi", SayHi))
server1.AddTools(mcp.NewTool("greet1", "say hi", SayHi))
server2 := mcp.NewServer("greeter2", "v0.0.1", nil)
server2.AddTools(mcp.MakeTool("greet2", "say hello", SayHi))
server2.AddTools(mcp.NewTool("greet2", "say hello", SayHi))
log.Printf("MCP servers serving at %s\n", *httpAddr)
handler := mcp.NewSSEHandler(func(request *http.Request) *mcp.Server {

2
mcp/cmd_test.go
View file

@ -31,7 +31,7 @@ func runServer() {
ctx := context.Background()
server := mcp.NewServer("greeter", "v0.0.1", nil)
server.AddTools(mcp.MakeTool("greet", "say hi", SayHi))
server.AddTools(mcp.NewTool("greet", "say hi", SayHi))
if err := server.Run(ctx, mcp.NewStdIOTransport(), nil); err != nil {
log.Fatal(err)

12
mcp/mcp_test.go
View file

@ -38,18 +38,18 @@ func TestEndToEnd(t *testing.T) {
s := NewServer("testServer", "v1.0.0", nil)
// The 'greet' tool says hi.
s.AddTools(MakeTool("greet", "say hi", sayHi))
s.AddTools(NewTool("greet", "say hi", sayHi))
// The 'fail' tool returns this error.
failure := errors.New("mcp failure")
s.AddTools(
MakeTool("fail", "just fail", func(context.Context, *ClientConnection, struct{}) ([]Content, error) {
NewTool("fail", "just fail", func(context.Context, *ClientConnection, struct{}) ([]Content, error) {
return nil, failure
}),
)
s.AddPrompts(
MakePrompt("code_review", "do a code review", func(_ context.Context, _ *ClientConnection, params struct{ Code string }) (*protocol.GetPromptResult, error) {
NewPrompt("code_review", "do a code review", func(_ context.Context, _ *ClientConnection, params struct{ Code string }) (*protocol.GetPromptResult, error) {
return &protocol.GetPromptResult{
Description: "Code review prompt",
Messages: []protocol.PromptMessage{
@ -57,7 +57,7 @@ func TestEndToEnd(t *testing.T) {
},
}, nil
}),
MakePrompt("fail", "", func(_ context.Context, _ *ClientConnection, params struct{}) (*protocol.GetPromptResult, error) {
NewPrompt("fail", "", func(_ context.Context, _ *ClientConnection, params struct{}) (*protocol.GetPromptResult, error) {
return nil, failure
}),
)
@ -218,7 +218,7 @@ func basicConnection(t *testing.T, tools ...*Tool) (*ClientConnection, *Client)
}
func TestServerClosing(t *testing.T) {
cc, c := basicConnection(t, MakeTool("greet", "say hi", sayHi))
cc, c := basicConnection(t, NewTool("greet", "say hi", sayHi))
defer c.Close()
ctx := context.Background()
@ -293,7 +293,7 @@ func TestCancellation(t *testing.T) {
}
return nil, nil
}
_, sc := basicConnection(t, MakeTool("slow", "a slow request", slowRequest))
_, sc := basicConnection(t, NewTool("slow", "a slow request", slowRequest))
defer sc.Close()
ctx, cancel := context.WithCancel(context.Background())

4
mcp/prompt.go
View file

@ -25,7 +25,7 @@ type Prompt struct {
Handler PromptHandler
}
// MakePrompt is a helper to use reflection to create a prompt for the given
// NewPrompt is a helper to use reflection to create a prompt for the given
// handler.
//
// The arguments for the prompt are extracted from the request type for the
@ -33,7 +33,7 @@ type Prompt struct {
// of type string or *string. The argument names for the resulting prompt
// definition correspond to the JSON names of the request fields, and any
// fields that are not marked "omitempty" are considered required.
func MakePrompt[TReq any](name, description string, handler func(context.Context, *ClientConnection, TReq) (*protocol.GetPromptResult, error), opts ...PromptOption) *Prompt {
func NewPrompt[TReq any](name, description string, handler func(context.Context, *ClientConnection, TReq) (*protocol.GetPromptResult, error), opts ...PromptOption) *Prompt {
schema, err := jsonschema.For[TReq]()
if err != nil {
panic(err)

12
mcp/prompt_test.go
View file

@ -13,26 +13,26 @@ import (
"github.com/modelcontextprotocol/go-sdk/mcp/protocol"
)
// testPromptHandler is used for type inference in TestMakePrompt.
// testPromptHandler is used for type inference in TestNewPrompt.
func testPromptHandler[T any](context.Context, *mcp.ClientConnection, T) (*protocol.GetPromptResult, error) {
panic("not implemented")
}
func TestMakePrompt(t *testing.T) {
func TestNewPrompt(t *testing.T) {
tests := []struct {
prompt *mcp.Prompt
want []protocol.PromptArgument
}{
{
mcp.MakePrompt("empty", "", testPromptHandler[struct{}]),
mcp.NewPrompt("empty", "", testPromptHandler[struct{}]),
nil,
},
{
mcp.MakePrompt("add_arg", "", testPromptHandler[struct{}], mcp.Argument("x")),
mcp.NewPrompt("add_arg", "", testPromptHandler[struct{}], mcp.Argument("x")),
[]protocol.PromptArgument{{Name: "x"}},
},
{
mcp.MakePrompt("combo", "", testPromptHandler[struct {
mcp.NewPrompt("combo", "", testPromptHandler[struct {
Name string `json:"name"`
Country string `json:"country,omitempty"`
State string
@ -48,7 +48,7 @@ func TestMakePrompt(t *testing.T) {
}
for _, test := range tests {
if diff := cmp.Diff(test.want, test.prompt.Definition.Arguments); diff != "" {
t.Errorf("MakePrompt(%v) mismatch (-want +got):\n%s", test.prompt.Definition.Name, diff)
t.Errorf("NewPrompt(%v) mismatch (-want +got):\n%s", test.prompt.Definition.Name, diff)
}
}
}

2
mcp/server_example_test.go
View file

@ -27,7 +27,7 @@ func ExampleServer() {
clientTransport, serverTransport := mcp.NewLocalTransport()
server := mcp.NewServer("greeter", "v0.0.1", nil)
server.AddTools(mcp.MakeTool("greet", "say hi", SayHi))
server.AddTools(mcp.NewTool("greet", "say hi", SayHi))
clientConnection, err := server.Connect(ctx, serverTransport, nil)
if err != nil {

2
mcp/sse_example_test.go
View file

@ -26,7 +26,7 @@ func Add(ctx context.Context, cc *mcp.ClientConnection, params *AddParams) ([]mc
func ExampleSSEHandler() {
server := mcp.NewServer("adder", "v0.0.1", nil)
server.AddTools(mcp.MakeTool("add", "add two numbers", Add))
server.AddTools(mcp.NewTool("add", "add two numbers", Add))
handler := mcp.NewSSEHandler(func(*http.Request) *mcp.Server { return server })
httpServer := httptest.NewServer(handler)

2
mcp/sse_test.go
View file

@ -20,7 +20,7 @@ func TestSSEServer(t *testing.T) {
t.Run(fmt.Sprintf("closeServerFirst=%t", closeServerFirst), func(t *testing.T) {
ctx := context.Background()
server := NewServer("testServer", "v1.0.0", nil)
server.AddTools(MakeTool("greet", "say hi", sayHi))
server.AddTools(NewTool("greet", "say hi", sayHi))
sseHandler := NewSSEHandler(func(*http.Request) *Server { return server })

6
mcp/tool.go
View file

@ -23,7 +23,7 @@ type Tool struct {
Handler ToolHandler
}
// MakeTool is a helper to make a tool using reflection on the given handler.
// NewTool is a helper to make a tool using reflection on the given handler.
//
// If provided, variadic [ToolOption] values may be used to customize the tool.
//
@ -32,11 +32,11 @@ type Tool struct {
// schema may be customized using the [Input] option.
//
// The handler request type must translate to a valid schema, as documented by
// [jsonschema.ForType]; otherwise, MakeTool panics.
// [jsonschema.ForType]; otherwise, NewTool panics.
//
// TODO: just have the handler return a CallToolResult: returning []Content is
// going to be inconsistent with other server features.
func MakeTool[TReq any](name, description string, handler func(context.Context, *ClientConnection, TReq) ([]Content, error), opts ...ToolOption) *Tool {
func NewTool[TReq any](name, description string, handler func(context.Context, *ClientConnection, TReq) ([]Content, error), opts ...ToolOption) *Tool {
schema, err := jsonschema.For[TReq]()
if err != nil {
panic(err)

14
mcp/tool_test.go
View file

@ -14,18 +14,18 @@ import (
"github.com/modelcontextprotocol/go-sdk/jsonschema"
)
// testToolHandler is used for type inference in TestMakeTool.
// testToolHandler is used for type inference in TestNewTool.
func testToolHandler[T any](context.Context, *mcp.ClientConnection, T) ([]mcp.Content, error) {
panic("not implemented")
}
func TestMakeTool(t *testing.T) {
func TestNewTool(t *testing.T) {
tests := []struct {
tool *mcp.Tool
want *jsonschema.Schema
}{
{
mcp.MakeTool("basic", "", testToolHandler[struct {
mcp.NewTool("basic", "", testToolHandler[struct {
Name string `json:"name"`
}]),
&jsonschema.Schema{
@ -38,7 +38,7 @@ func TestMakeTool(t *testing.T) {
},
},
{
mcp.MakeTool("enum", "", testToolHandler[struct{ Name string }], mcp.Input(
mcp.NewTool("enum", "", testToolHandler[struct{ Name string }], mcp.Input(
mcp.Property("Name", mcp.Enum("x", "y", "z")),
)),
&jsonschema.Schema{
@ -51,7 +51,7 @@ func TestMakeTool(t *testing.T) {
},
},
{
mcp.MakeTool("required", "", testToolHandler[struct {
mcp.NewTool("required", "", testToolHandler[struct {
Name string `json:"name"`
Language string `json:"language"`
X int `json:"x,omitempty"`
@ -71,7 +71,7 @@ func TestMakeTool(t *testing.T) {
},
},
{
mcp.MakeTool("set_schema", "", testToolHandler[struct {
mcp.NewTool("set_schema", "", testToolHandler[struct {
X int `json:"x,omitempty"`
Y int `json:"y,omitempty"`
}], mcp.Input(
@ -84,7 +84,7 @@ func TestMakeTool(t *testing.T) {
}
for _, test := range tests {
if diff := cmp.Diff(test.want, test.tool.Definition.InputSchema, cmpopts.IgnoreUnexported(jsonschema.Schema{})); diff != "" {
t.Errorf("MakeTool(%v) mismatch (-want +got):\n%s", test.tool.Definition.Name, diff)
t.Errorf("NewTool(%v) mismatch (-want +got):\n%s", test.tool.Definition.Name, diff)
}
}
}