Merge branch 'main' into stateless-http

# Conflicts:
#	mcp/streamable.go

Author: ln-12

examples/sse/main.go

@@ -7,13 +7,18 @@ package main
 import (
 	"context"
 	"flag"
+	"fmt"
 	"log"
 	"net/http"
+	"os"
 
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
 
-var httpAddr = flag.String("http", "", "use SSE HTTP at this address")
+var (
+	host = flag.String("host", "localhost", "host to listen on")
+	port = flag.String("port", "8080", "port to listen on")
+)
 
 type SayHiParams struct {
 	Name string `json:"name"`
@@ -28,19 +33,27 @@ func SayHi(ctx context.Context, cc *mcp.ServerSession, params *mcp.CallToolParam
 }
 
 func main() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "Usage: %s [options]\n\n", os.Args[0])
+		fmt.Fprintf(os.Stderr, "This program runs MCP servers over SSE HTTP.\n\n")
+		fmt.Fprintf(os.Stderr, "Options:\n")
+		flag.PrintDefaults()
+		fmt.Fprintf(os.Stderr, "\nEndpoints:\n")
+		fmt.Fprintf(os.Stderr, "  /greeter1 - Greeter 1 service\n")
+		fmt.Fprintf(os.Stderr, "  /greeter2 - Greeter 2 service\n")
+		os.Exit(1)
+	}
 	flag.Parse()
 
-	if httpAddr == nil || *httpAddr == "" {
-		log.Fatal("http address not set")
-	}
+	addr := fmt.Sprintf("%s:%s", *host, *port)
 
 	server1 := mcp.NewServer(&mcp.Implementation{Name: "greeter1"}, nil)
 	mcp.AddTool(server1, &mcp.Tool{Name: "greet1", Description: "say hi"}, SayHi)
 
 	server2 := mcp.NewServer(&mcp.Implementation{Name: "greeter2"}, nil)
 	mcp.AddTool(server2, &mcp.Tool{Name: "greet2", Description: "say hello"}, SayHi)
 
-	log.Printf("MCP servers serving at %s", *httpAddr)
+	log.Printf("MCP servers serving at %s", addr)
 	handler := mcp.NewSSEHandler(func(request *http.Request) *mcp.Server {
 		url := request.URL.Path
 		log.Printf("Handling request for URL %s\n", url)
@@ -53,5 +66,5 @@ func main() {
 			return nil
 		}
 	})
-	http.ListenAndServe(*httpAddr, handler)
+	log.Fatal(http.ListenAndServe(addr, handler))
 }

internal/jsonrpc2/conn.go

@@ -125,7 +125,7 @@ func (c *Connection) updateInFlight(f func(*inFlightState)) {
 		// that and avoided making any updates that would cause the state to be
 		// non-idle.)
 		if !s.idle() {
-			panic("jsonrpc2_v2: updateInFlight transitioned to non-idle when already done")
+			panic("jsonrpc2: updateInFlight transitioned to non-idle when already done")
 		}
 		return
 	default:
@@ -718,7 +718,7 @@ func (c *Connection) processResult(from any, req *incomingRequest, result any, e
 	req.cancel()
 	c.updateInFlight(func(s *inFlightState) {
 		if s.incoming == 0 {
-			panic("jsonrpc2_v2: processResult called when incoming count is already zero")
+			panic("jsonrpc2: processResult called when incoming count is already zero")
 		}
 		s.incoming--
 	})

mcp/create-repo.sh

@@ -29,7 +29,7 @@ const DefaultPageSize = 1000
 // A Server is an instance of an MCP server.
 //
 // Servers expose server-side MCP features, which can serve one or more MCP
-// sessions by using [Server.Start] or [Server.Run].
+// sessions by using [Server.Run].
 type Server struct {
 	// fixed at creation
 	impl *Implementation
@@ -77,8 +77,7 @@ type ServerOptions struct {
 // NewServer creates a new MCP server. The resulting server has no features:
 // add features using the various Server.AddXXX methods, and the [AddTool] function.
 //
-// The server can be connected to one or more MCP clients using [Server.Start]
-// or [Server.Run].
+// The server can be connected to one or more MCP clients using [Server.Run].
 //
 // The first argument must not be nil.
 //
@@ -745,7 +744,7 @@ func (ss *ServerSession) handle(ctx context.Context, req *jsonrpc.Request) (any,
 	}
 	// For the streamable transport, we need the request ID to correlate
 	// server->client calls and notifications to the incoming request from which
-	// they originated. See [idContext] for details.
+	// they originated. See [idContextKey] for details.
 	ctx = context.WithValue(ctx, idContextKey{}, req.ID)
 	return handleReceive(ctx, ss, req)
 }

mcp/server.go

@@ -44,7 +44,7 @@ type MethodHandler[S Session] func(ctx context.Context, _ S, method string, para
 // the compiler would complain.
 type methodHandler any // MethodHandler[*ClientSession] | MethodHandler[*ServerSession]
 
-// A Session is either a ClientSession or a ServerSession.
+// A Session is either a [ClientSession] or a [ServerSession].
 type Session interface {
 	*ClientSession | *ServerSession
 	// ID returns the session ID, or the empty string if there is none.
@@ -57,7 +57,7 @@ type Session interface {
 	getConn() *jsonrpc2.Connection
 }
 
-// Middleware is a function from MethodHandlers to MethodHandlers.
+// Middleware is a function from [MethodHandler] to [MethodHandler].
 type Middleware[S Session] func(MethodHandler[S]) MethodHandler[S]
 
 // addMiddleware wraps the handler in the middleware functions.
@@ -203,7 +203,7 @@ func serverMethod[P Params, R Result](
 	}
 }
 
-// clientMethod is glue for creating a typedMethodHandler from a method on Server.
+// clientMethod is glue for creating a typedMethodHandler from a method on Client.
 func clientMethod[P Params, R Result](
 	f func(*Client, context.Context, *ClientSession, P) (R, error),
 ) typedMethodHandler[*ClientSession, P, R] {

mcp/shared.go

@@ -55,13 +55,14 @@ type SSEHandler struct {
 // Sessions are created when the client issues a GET request to the server,
 // which must accept text/event-stream responses (server-sent events).
 // For each such request, a new [SSEServerTransport] is created with a distinct
-// messages endpoint, and connected to the server returned by getServer. It is
-// up to the user whether getServer returns a distinct [Server] for each new
-// request, or reuses an existing server.
-//
+// messages endpoint, and connected to the server returned by getServer.
 // The SSEHandler also handles requests to the message endpoints, by
 // delegating them to the relevant server transport.
 //
+// The getServer function may return a distinct [Server] for each new
+// request, or reuse an existing server. If it returns nil, the handler
+// will return a 400 Bad Request.
+//
 // TODO(rfindley): add options.
 func NewSSEHandler(getServer func(request *http.Request) *Server) *SSEHandler {
 	return &SSEHandler{
@@ -208,8 +209,12 @@ func (h *SSEHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 		h.mu.Unlock()
 	}()
 
-	// TODO(hxjiang): getServer returns nil will panic.
 	server := h.getServer(req)
+	if server == nil {
+		// The getServer argument to NewSSEHandler returned nil.
+		http.Error(w, "no server available", http.StatusBadRequest)
+		return
+	}
 	ss, err := server.Connect(req.Context(), transport)
 	if err != nil {
 		http.Error(w, "connection failed", http.StatusInternalServerError)