rename Delegate to Transport; update callsites

findleyr · findleyr · commit 578446a94a8d · 2025-08-12T18:54:00.000Z
diff --git a/examples/client/listfeatures/main.go b/examples/client/listfeatures/main.go
@@ -41,7 +41,7 @@ func main() {
 	ctx := context.Background()
 	cmd := exec.Command(args[0], args[1:]...)
 	client := mcp.NewClient(&mcp.Implementation{Name: "mcp-client", Version: "v1.0.0"}, nil)
-	cs, err := client.Connect(ctx, mcp.NewCommandTransport(cmd), nil)
+	cs, err := client.Connect(ctx, &mcp.CommandTransport{Command: cmd}, nil)
 	if err != nil {
 		log.Fatal(err)
 	}
diff --git a/examples/server/hello/main.go b/examples/server/hello/main.go
@@ -58,7 +58,7 @@ func main() {
 		log.Printf("MCP handler listening at %s", *httpAddr)
 		http.ListenAndServe(*httpAddr, handler)
 	} else {
-		t := &mcp.LoggingTransport{Delegate: &mcp.StdioTransport{}, Writer: os.Stderr}
+		t := &mcp.LoggingTransport{Transport: &mcp.StdioTransport{}, Writer: os.Stderr}
 		if err := server.Run(context.Background(), t); err != nil {
 			log.Printf("Server failed: %v", err)
 		}
diff --git a/examples/server/memory/main.go b/examples/server/memory/main.go
@@ -137,7 +137,7 @@ func main() {
 		log.Printf("MCP handler listening at %s", *httpAddr)
 		http.ListenAndServe(*httpAddr, handler)
 	} else {
-		t := mcp.NewLoggingTransport(mcp.NewStdioTransport(), os.Stderr)
+		t := &mcp.LoggingTransport{Transport: &mcp.StdioTransport{}, Writer: os.Stderr}
 		if err := server.Run(context.Background(), t); err != nil {
 			log.Printf("Server failed: %v", err)
 		}
diff --git a/examples/server/sequentialthinking/main.go b/examples/server/sequentialthinking/main.go
@@ -536,7 +536,7 @@ func main() {
 			log.Fatal(err)
 		}
 	} else {
-		t := mcp.NewLoggingTransport(mcp.NewStdioTransport(), os.Stderr)
+		t := &mcp.LoggingTransport{Transport: &mcp.StdioTransport{}, Writer: os.Stderr}
 		if err := server.Run(context.Background(), t); err != nil {
 			log.Printf("Server failed: %v", err)
 		}
diff --git a/internal/readme/client/client.go b/internal/readme/client/client.go
@@ -20,7 +20,7 @@ func main() {
 	client := mcp.NewClient(&mcp.Implementation{Name: "mcp-client", Version: "v1.0.0"}, nil)
 
 	// Connect to a server over stdin/stdout
-	transport := mcp.NewCommandTransport(exec.Command("myserver"))
+	transport := &mcp.CommandTransport{Command: exec.Command("myserver")}
 	session, err := client.Connect(ctx, transport, nil)
 	if err != nil {
 		log.Fatal(err)
diff --git a/internal/readme/server/server.go b/internal/readme/server/server.go
@@ -28,7 +28,7 @@ func main() {
 
 	mcp.AddTool(server, &mcp.Tool{Name: "greet", Description: "say hi"}, SayHi)
 	// Run the server over stdin/stdout, until the client disconnects
-	if err := server.Run(context.Background(), mcp.NewStdioTransport()); err != nil {
+	if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
 		log.Fatal(err)
 	}
 }
diff --git a/mcp/cmd.go b/mcp/cmd.go
@@ -29,7 +29,7 @@ type CommandTransport struct {
 //
 //go:fix inline
 func NewCommandTransport(cmd *exec.Cmd) *CommandTransport {
-	return &CommandTransport{cmd}
+	return &CommandTransport{Command: cmd}
 }
 
 // Connect starts the command, and connects to it over stdin/stdout.
diff --git a/mcp/cmd_test.go b/mcp/cmd_test.go
@@ -49,7 +49,7 @@ func runServer() {
 
 	server := mcp.NewServer(testImpl, nil)
 	mcp.AddTool(server, &mcp.Tool{Name: "greet", Description: "say hi"}, SayHi)
-	if err := server.Run(ctx, mcp.NewStdioTransport()); err != nil {
+	if err := server.Run(ctx, &mcp.StdioTransport{}); err != nil {
 		log.Fatal(err)
 	}
 }
@@ -59,7 +59,7 @@ func runCancelContextServer() {
 	defer done()
 
 	server := mcp.NewServer(testImpl, nil)
-	if err := server.Run(ctx, mcp.NewStdioTransport()); err != nil {
+	if err := server.Run(ctx, &mcp.StdioTransport{}); err != nil {
 		log.Fatal(err)
 	}
 }
@@ -116,7 +116,7 @@ func TestServerInterrupt(t *testing.T) {
 	cmd := createServerCommand(t, "default")
 
 	client := mcp.NewClient(testImpl, nil)
-	_, err := client.Connect(ctx, mcp.NewCommandTransport(cmd), nil)
+	_, err := client.Connect(ctx, &mcp.CommandTransport{Command: cmd}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -198,7 +198,7 @@ func TestCmdTransport(t *testing.T) {
 	cmd := createServerCommand(t, "default")
 
 	client := mcp.NewClient(&mcp.Implementation{Name: "client", Version: "v0.0.1"}, nil)
-	session, err := client.Connect(ctx, mcp.NewCommandTransport(cmd), nil)
+	session, err := client.Connect(ctx, &mcp.CommandTransport{Command: cmd}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/mcp/mcp_test.go b/mcp/mcp_test.go
@@ -774,7 +774,7 @@ func TestNoJSONNull(t *testing.T) {
 
 	// Collect logs, to sanity check that we don't write JSON null anywhere.
 	var logbuf safeBuffer
-	ct = NewLoggingTransport(ct, &logbuf)
+	ct = &LoggingTransport{Transport: ct, Writer: &logbuf}
 
 	s := NewServer(testImpl, nil)
 	ss, err := s.Connect(ctx, st, nil)
diff --git a/mcp/sse.go b/mcp/sse.go
@@ -347,8 +347,6 @@ type SSEClientTransportOptions struct {
 // NewSSEClientTransport returns a new client transport that connects to the
 // SSE server at the provided URL.
 //
-// NewSSEClientTransport panics if the given URL is invalid.
-//
 // Deprecated: use an SSEClientTransport literal.
 //
 //go:fix inline
diff --git a/mcp/sse_example_test.go b/mcp/sse_example_test.go
@@ -35,7 +35,7 @@ func ExampleSSEHandler() {
 	defer httpServer.Close()
 
 	ctx := context.Background()
-	transport := mcp.NewSSEClientTransport(httpServer.URL, nil)
+	transport := &mcp.SSEClientTransport{Endpoint: httpServer.URL}
 	client := mcp.NewClient(&mcp.Implementation{Name: "test", Version: "v1.0.0"}, nil)
 	cs, err := client.Connect(ctx, transport, nil)
 	if err != nil {
diff --git a/mcp/sse_test.go b/mcp/sse_test.go
@@ -44,9 +44,10 @@ func TestSSEServer(t *testing.T) {
 				}),
 			}
 
-			clientTransport := NewSSEClientTransport(httpServer.URL, &SSEClientTransportOptions{
+			clientTransport := &SSEClientTransport{
+				Endpoint:   httpServer.URL,
 				HTTPClient: customClient,
-			})
+			}
 
 			c := NewClient(testImpl, nil)
 			cs, err := c.Connect(ctx, clientTransport, nil)
diff --git a/mcp/streamable_test.go b/mcp/streamable_test.go
@@ -77,9 +77,10 @@ func TestStreamableTransports(t *testing.T) {
 			}
 			jar.SetCookies(u, []*http.Cookie{{Name: "test-cookie", Value: "test-value"}})
 			httpClient := &http.Client{Jar: jar}
-			transport := NewStreamableClientTransport(httpServer.URL, &StreamableClientTransportOptions{
+			transport := &StreamableClientTransport{
+				Endpoint:   httpServer.URL,
 				HTTPClient: httpClient,
-			})
+			}
 			client := NewClient(testImpl, nil)
 			session, err := client.Connect(ctx, transport, nil)
 			if err != nil {
@@ -173,7 +174,7 @@ func TestClientReplay(t *testing.T) {
 			notifications <- params.Message
 		},
 	})
-	clientSession, err := client.Connect(ctx, NewStreamableClientTransport(proxy.URL, nil), nil)
+	clientSession, err := client.Connect(ctx, &StreamableClientTransport{Endpoint: proxy.URL}, nil)
 	if err != nil {
 		t.Fatalf("client.Connect() failed: %v", err)
 	}
@@ -239,7 +240,7 @@ func TestServerInitiatedSSE(t *testing.T) {
 		notifications <- "toolListChanged"
 	},
 	})
-	clientSession, err := client.Connect(ctx, NewStreamableClientTransport(httpServer.URL, nil), nil)
+	clientSession, err := client.Connect(ctx, &StreamableClientTransport{Endpoint: httpServer.URL}, nil)
 	if err != nil {
 		t.Fatalf("client.Connect() failed: %v", err)
 	}
@@ -765,7 +766,7 @@ func TestStreamableClientTransportApplicationJSON(t *testing.T) {
 	httpServer := httptest.NewServer(http.HandlerFunc(serverHandler))
 	defer httpServer.Close()
 
-	transport := NewStreamableClientTransport(httpServer.URL, nil)
+	transport := &StreamableClientTransport{Endpoint: httpServer.URL}
 	client := NewClient(testImpl, nil)
 	session, err := client.Connect(ctx, transport, nil)
 	if err != nil {
diff --git a/mcp/transport.go b/mcp/transport.go
@@ -211,8 +211,8 @@ func call(ctx context.Context, conn *jsonrpc2.Connection, method string, params
 // A LoggingTransport is a [Transport] that delegates to another transport,
 // writing RPC logs to an io.Writer.
 type LoggingTransport struct {
-	Delegate Transport
-	Writer   io.Writer
+	Transport Transport
+	Writer    io.Writer
 }
 
 // NewLoggingTransport creates a new LoggingTransport that delegates to the
@@ -222,13 +222,13 @@ type LoggingTransport struct {
 //
 //go:fix inline
 func NewLoggingTransport(delegate Transport, w io.Writer) *LoggingTransport {
-	return &LoggingTransport{Delegate: delegate, Writer: w}
+	return &LoggingTransport{Transport: delegate, Writer: w}
 }
 
 // Connect connects the underlying transport, returning a [Connection] that writes
 // logs to the configured destination.
 func (t *LoggingTransport) Connect(ctx context.Context) (Connection, error) {
-	delegate, err := t.Delegate.Connect(ctx)
+	delegate, err := t.Transport.Connect(ctx)
 	if err != nil {
 		return nil, err
 	}

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ func main() {`
`41`	`41`	`ctx := context.Background()`
`42`	`42`	`cmd := exec.Command(args[0], args[1:]...)`
`43`	`43`	`client := mcp.NewClient(&mcp.Implementation{Name: "mcp-client", Version: "v1.0.0"}, nil)`
`44`		`- cs, err := client.Connect(ctx, mcp.NewCommandTransport(cmd), nil)`
	`44`	`+ cs, err := client.Connect(ctx, &mcp.CommandTransport{Command: cmd}, nil)`
`45`	`45`	`if err != nil {`
`46`	`46`	`log.Fatal(err)`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ func main() {`
`58`	`58`	`log.Printf("MCP handler listening at %s", *httpAddr)`
`59`	`59`	`http.ListenAndServe(*httpAddr, handler)`
`60`	`60`	`} else {`
`61`		`- t := &mcp.LoggingTransport{Delegate: &mcp.StdioTransport{}, Writer: os.Stderr}`
	`61`	`+ t := &mcp.LoggingTransport{Transport: &mcp.StdioTransport{}, Writer: os.Stderr}`
`62`	`62`	`if err := server.Run(context.Background(), t); err != nil {`
`63`	`63`	`log.Printf("Server failed: %v", err)`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ func main() {`
`137`	`137`	`log.Printf("MCP handler listening at %s", *httpAddr)`
`138`	`138`	`http.ListenAndServe(*httpAddr, handler)`
`139`	`139`	`} else {`
`140`		`- t := mcp.NewLoggingTransport(mcp.NewStdioTransport(), os.Stderr)`
	`140`	`+ t := &mcp.LoggingTransport{Transport: &mcp.StdioTransport{}, Writer: os.Stderr}`
`141`	`141`	`if err := server.Run(context.Background(), t); err != nil {`
`142`	`142`	`log.Printf("Server failed: %v", err)`
`143`	`143`	`}`
Original file line number	Diff line number	Diff line change
`@@ -536,7 +536,7 @@ func main() {`
`536`	`536`	`log.Fatal(err)`
`537`	`537`	`}`
`538`	`538`	`} else {`
`539`		`- t := mcp.NewLoggingTransport(mcp.NewStdioTransport(), os.Stderr)`
	`539`	`+ t := &mcp.LoggingTransport{Transport: &mcp.StdioTransport{}, Writer: os.Stderr}`
`540`	`540`	`if err := server.Run(context.Background(), t); err != nil {`
`541`	`541`	`log.Printf("Server failed: %v", err)`
`542`	`542`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ func main() {`
`28`	`28`
`29`	`29`	`mcp.AddTool(server, &mcp.Tool{Name: "greet", Description: "say hi"}, SayHi)`
`30`	`30`	`// Run the server over stdin/stdout, until the client disconnects`
`31`		`- if err := server.Run(context.Background(), mcp.NewStdioTransport()); err != nil {`
	`31`	`+ if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {`
`32`	`32`	`log.Fatal(err)`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ type CommandTransport struct {`
`29`	`29`	`//`
`30`	`30`	`//go:fix inline`
`31`	`31`	`func NewCommandTransport(cmd exec.Cmd) CommandTransport {`
`32`		`- return &CommandTransport{cmd}`
	`32`	`+ return &CommandTransport{Command: cmd}`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`// Connect starts the command, and connects to it over stdin/stdout.`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ func runServer() {`
`49`	`49`
`50`	`50`	`server := mcp.NewServer(testImpl, nil)`
`51`	`51`	`mcp.AddTool(server, &mcp.Tool{Name: "greet", Description: "say hi"}, SayHi)`
`52`		`- if err := server.Run(ctx, mcp.NewStdioTransport()); err != nil {`
	`52`	`+ if err := server.Run(ctx, &mcp.StdioTransport{}); err != nil {`
`53`	`53`	`log.Fatal(err)`
`54`	`54`	`}`
`55`	`55`	`}`
`@@ -59,7 +59,7 @@ func runCancelContextServer() {`
`59`	`59`	`defer done()`
`60`	`60`
`61`	`61`	`server := mcp.NewServer(testImpl, nil)`
`62`		`- if err := server.Run(ctx, mcp.NewStdioTransport()); err != nil {`
	`62`	`+ if err := server.Run(ctx, &mcp.StdioTransport{}); err != nil {`
`63`	`63`	`log.Fatal(err)`
`64`	`64`	`}`
`65`	`65`	`}`
`@@ -116,7 +116,7 @@ func TestServerInterrupt(t *testing.T) {`
`116`	`116`	`cmd := createServerCommand(t, "default")`
`117`	`117`
`118`	`118`	`client := mcp.NewClient(testImpl, nil)`
`119`		`- _, err := client.Connect(ctx, mcp.NewCommandTransport(cmd), nil)`
	`119`	`+ _, err := client.Connect(ctx, &mcp.CommandTransport{Command: cmd}, nil)`
`120`	`120`	`if err != nil {`
`121`	`121`	`t.Fatal(err)`
`122`	`122`	`}`
`@@ -198,7 +198,7 @@ func TestCmdTransport(t *testing.T) {`
`198`	`198`	`cmd := createServerCommand(t, "default")`
`199`	`199`
`200`	`200`	`client := mcp.NewClient(&mcp.Implementation{Name: "client", Version: "v0.0.1"}, nil)`
`201`		`- session, err := client.Connect(ctx, mcp.NewCommandTransport(cmd), nil)`
	`201`	`+ session, err := client.Connect(ctx, &mcp.CommandTransport{Command: cmd}, nil)`
`202`	`202`	`if err != nil {`
`203`	`203`	`t.Fatal(err)`
`204`	`204`	`}`