Merge branch 'main' into output-validation

Author: jba

README.md

@@ -33,16 +33,12 @@ open-ended discussion. See [CONTRIBUTING.md](/CONTRIBUTING.md) for details.
 
 ## Package documentation
 
-The SDK consists of three importable packages:
+The SDK consists of two importable packages:
 
 - The
   [`github.com/modelcontextprotocol/go-sdk/mcp`](https://pkg.go.dev/github.com/modelcontextprotocol/go-sdk/mcp)
   package defines the primary APIs for constructing and using MCP clients and
   servers.
-- The
-  [`github.com/modelcontextprotocol/go-sdk/jsonschema`](https://pkg.go.dev/github.com/modelcontextprotocol/go-sdk/jsonschema)
-  package provides an implementation of [JSON
-  Schema](https://json-schema.org/), used for MCP tool input and output schema.
 - The
   [`github.com/modelcontextprotocol/go-sdk/jsonrpc`](https://pkg.go.dev/github.com/modelcontextprotocol/go-sdk/jsonrpc) package is for users implementing
   their own transports.

examples/client/listfeatures/main.go

@@ -31,10 +31,10 @@ func main() {
 	flag.Parse()
 	args := flag.Args()
 	if len(args) == 0 {
-		fmt.Fprintf(os.Stderr, "Usage: listfeatures <command> [<args>]")
-		fmt.Fprintf(os.Stderr, "List all features for a stdio MCP server")
+		fmt.Fprintln(os.Stderr, "Usage: listfeatures <command> [<args>]")
+		fmt.Fprintln(os.Stderr, "List all features for a stdio MCP server")
 		fmt.Fprintln(os.Stderr)
-		fmt.Fprintf(os.Stderr, "Example: listfeatures npx @modelcontextprotocol/server-everything")
+		fmt.Fprintln(os.Stderr, "Example:\n\tlistfeatures npx @modelcontextprotocol/server-everything")
 		os.Exit(2)
 	}
 

examples/client/loadtest/main.go

@@ -0,0 +1,122 @@
+// Copyright 2025 The Go MCP SDK Authors. All rights reserved.
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+
+// The load command load tests a streamable MCP server
+//
+// Usage: loadtest <URL>
+//
+// For example:
+//
+//	loadtest -tool=greet -args='{"name": "foo"}' http://localhost:8080
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+var (
+	duration = flag.Duration("duration", 1*time.Minute, "duration of the load test")
+	tool     = flag.String("tool", "", "tool to call")
+	jsonArgs = flag.String("args", "", "JSON arguments to pass")
+	workers  = flag.Int("workers", 10, "number of concurrent workers")
+	timeout  = flag.Duration("timeout", 1*time.Second, "request timeout")
+	qps      = flag.Int("qps", 100, "tool calls per second, per worker")
+	verbose  = flag.Bool("v", false, "if set, enable verbose logging")
+)
+
+func main() {
+	flag.Usage = func() {
+		out := flag.CommandLine.Output()
+		fmt.Fprintf(out, "Usage: loadtest [flags] <URL>")
+		fmt.Fprintf(out, "Load test a streamable HTTP server (CTRL-C to end early)")
+		fmt.Fprintln(out)
+		fmt.Fprintf(out, "Example: loadtest -tool=greet -args='{\"name\": \"foo\"}' http://localhost:8080\n")
+		fmt.Fprintln(out)
+		fmt.Fprintln(out, "Flags:")
+		flag.PrintDefaults()
+	}
+	flag.Parse()
+	args := flag.Args()
+	if len(args) != 1 || *tool == "" {
+		flag.Usage()
+		os.Exit(2)
+	}
+
+	parentCtx, cancel := context.WithTimeout(context.Background(), *duration)
+	defer cancel()
+	parentCtx, stop := signal.NotifyContext(parentCtx, os.Interrupt)
+	defer stop()
+
+	var (
+		start   = time.Now()
+		success atomic.Int64
+		failure atomic.Int64
+	)
+
+	// Run the test.
+	var wg sync.WaitGroup
+	for range *workers {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			client := mcp.NewClient(&mcp.Implementation{Name: "mcp-client", Version: "v1.0.0"}, nil)
+			cs, err := client.Connect(parentCtx, &mcp.StreamableClientTransport{Endpoint: args[0]}, nil)
+			if err != nil {
+				log.Fatal(err)
+			}
+			defer cs.Close()
+
+			ticker := time.NewTicker(1 * time.Second / time.Duration(*qps))
+			defer ticker.Stop()
+
+			for range ticker.C {
+				ctx, cancel := context.WithTimeout(parentCtx, *timeout)
+				defer cancel()
+
+				res, err := cs.CallTool(ctx, &mcp.CallToolParams{Name: *tool, Arguments: json.RawMessage(*jsonArgs)})
+				if err != nil {
+					if parentCtx.Err() != nil {
+						return // test ended
+					}
+					failure.Add(1)
+					if *verbose {
+						log.Printf("FAILURE: %v", err)
+					}
+				} else {
+					success.Add(1)
+					if *verbose {
+						data, err := json.Marshal(res)
+						if err != nil {
+							log.Fatalf("marshalling result: %v", err)
+						}
+						log.Printf("SUCCESS: %s", string(data))
+					}
+				}
+			}
+		}()
+	}
+	wg.Wait()
+	stop() // restore the interrupt signal
+
+	// Print stats.
+	var (
+		dur  = time.Since(start)
+		succ = success.Load()
+		fail = failure.Load()
+	)
+	fmt.Printf("Results (in %s):\n", dur)
+	fmt.Printf("\tsuccess: %d (%g QPS)\n", succ, float64(succ)/dur.Seconds())
+	fmt.Printf("\tfailure: %d (%g QPS)\n", fail, float64(fail)/dur.Seconds())
+}

examples/http/README.md

@@ -0,0 +1,66 @@
+# MCP HTTP Example
+
+This example demonstrates how to use the Model Context Protocol (MCP) over HTTP using the streamable transport. It includes both a server and client implementation.
+
+## Overview
+
+The example implements:
+- A server that provides a `cityTime` tool
+- A client that connects to the server, lists available tools, and calls the `cityTime` tool
+
+## Usage
+
+Start the Server
+
+```bash
+go run main.go server
+```
+This starts an MCP server on `http://localhost:8080` (default) that provides a `cityTime` tool.
+
+To run a client in another terminal:
+
+```bash
+go run main.go client
+```
+
+The client will:
+1. Connect to the server
+2. List available tools
+3. Call the `cityTime` tool for NYC, San Francisco, and Boston
+4. Display the results
+
+At any given time you can pass a custom URL to the program to run it on a custom host/port:
+
+```
+go run main.go -host 0.0.0.0 -port 9000 server
+```
+
+## Testing with real-world MCP Clients
+
+Once the server is started, assuming it's the default
+localhost:8080, you can try to add it to a popular MCP client:
+
+    claude mcp add -t http timezone http://localhost:8080
+
+Once added, Claude Code will be able to discover and use the `cityTime` tool provided by this server.
+
+In Claude Code:
+
+    > what's the timezone
+
+    ⏺ I'll get the current time in a major US city for you.
+
+    ⏺ timezone - cityTime (MCP)(city: "nyc")
+      ⎿ The current time in New York City is 7:30:16 PM EDT on Wedn
+        esday, July 23, 2025
+
+
+    ⏺ The current timezone is EDT (Eastern Daylight Time), and it's
+       7:30 PM on Wednesday, July 23, 2025.
+
+    > what timezones do you support?
+
+    ⏺ The timezone tool supports three US cities:
+      - NYC (Eastern Time)
+      - SF (Pacific Time)
+      - Boston (Eastern Time)

examples/http/logging_middleware.go

@@ -0,0 +1,51 @@
+// Copyright 2025 The Go MCP SDK Authors. All rights reserved.
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"log"
+	"net/http"
+	"time"
+)
+
+// responseWriter wraps http.ResponseWriter to capture the status code.
+type responseWriter struct {
+	http.ResponseWriter
+	statusCode int
+}
+
+func (rw *responseWriter) WriteHeader(code int) {
+	rw.statusCode = code
+	rw.ResponseWriter.WriteHeader(code)
+}
+
+func loggingHandler(handler http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+
+		// Create a response writer wrapper to capture status code.
+		wrapped := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
+
+		// Log request details.
+		log.Printf("[REQUEST] %s | %s | %s %s",
+			start.Format(time.RFC3339),
+			r.RemoteAddr,
+			r.Method,
+			r.URL.Path)
+
+		// Call the actual handler.
+		handler.ServeHTTP(wrapped, r)
+
+		// Log response details.
+		duration := time.Since(start)
+		log.Printf("[RESPONSE] %s | %s | %s %s | Status: %d | Duration: %v",
+			time.Now().Format(time.RFC3339),
+			r.RemoteAddr,
+			r.Method,
+			r.URL.Path,
+			wrapped.statusCode,
+			duration)
+	})
+}