Auto-set server.transport in Transport#initialize

## Motivation and Context

Transport subclasses (StreamableHTTPTransport, StdioTransport) already
receive the server in their constructor, but users must manually call
`server.transport = transport` after creating a transport instance.
This is boilerplate that can be eliminated by setting the connection
automatically in `Transport#initialize`.

## How Has This Been Tested?

All existing tests pass. Redundant `server.transport = transport` lines
were removed from tests, examples, README.md, and conformance server.

## Breaking Changes

None. Existing code that manually sets `server.transport = transport`
continues to work (idempotent assignment).

Author: koic

README.md

@@ -126,7 +126,6 @@ class McpController < ActionController::API
     )
     # Since the `MCP-Session-Id` is not shared across requests, `stateless: true` is set.
     transport = MCP::Server::Transports::StreamableHTTPTransport.new(server, stateless: true)
-    server.transport = transport
     status, headers, body = transport.handle_request(request)
 
     render(json: body.first, status: status, headers: headers)
@@ -821,7 +820,61 @@ This enables servers to leverage the client's LLM capabilities without needing d
 - **Tool Support**: When using tools in sampling requests, clients must declare `sampling.tools` capability
 - **Human-in-the-Loop**: Clients can implement user approval before forwarding requests to LLMs
 
-**Using Sampling in Tools:**
+**Usage Example (Stdio transport):**
+
+`Server#create_sampling_message` is for single-client transports (e.g., `StdioTransport`).
+For multi-client transports (e.g., `StreamableHTTPTransport`), use `server_context.create_sampling_message` inside tools instead,
+which routes the request to the correct client session.
+
+```ruby
+server = MCP::Server.new(name: "my_server")
+transport = MCP::Server::Transports::StdioTransport.new(server)
+```
+
+Client must declare sampling capability during initialization.
+This happens automatically when the client connects.
+
+```ruby
+result = server.create_sampling_message(
+  messages: [
+    { role: "user", content: { type: "text", text: "What is the capital of France?" } }
+  ],
+  max_tokens: 100,
+  system_prompt: "You are a helpful assistant.",
+  temperature: 0.7
+)
+```
+
+Result contains the LLM response:
+
+```ruby
+{
+  role: "assistant",
+  content: { type: "text", text: "The capital of France is Paris." },
+  model: "claude-3-sonnet-20240307",
+  stopReason: "endTurn"
+}
+```
+
+**Parameters:**
+
+Required:
+
+- `messages:` (Array) - Array of message objects with `role` and `content`
+- `max_tokens:` (Integer) - Maximum tokens in the response
+
+Optional:
+
+- `system_prompt:` (String) - System prompt for the LLM
+- `model_preferences:` (Hash) - Model selection preferences (e.g., `{ intelligencePriority: 0.8 }`)
+- `include_context:` (String) - Context inclusion: `"none"`, `"thisServer"`, or `"allServers"` (soft-deprecated)
+- `temperature:` (Float) - Sampling temperature
+- `stop_sequences:` (Array) - Sequences that stop generation
+- `metadata:` (Hash) - Additional metadata
+- `tools:` (Array) - Tools available to the LLM (requires `sampling.tools` capability)
+- `tool_choice:` (Hash) - Tool selection mode (e.g., `{ mode: "auto" }`)
+
+**Using Sampling in Tools (works with both Stdio and HTTP transports):**
 
 Tools that accept a `server_context:` parameter can call `create_sampling_message` on it.
 The request is automatically routed to the correct client session.
@@ -1120,7 +1173,6 @@ For more details, see the [MCP Logging specification](https://modelcontextprotoc
 ```ruby
 server = MCP::Server.new(name: "my_server")
 transport = MCP::Server::Transports::StdioTransport.new(server)
-server.transport = transport
 
 # The client first configures the logging level (on the client side):
 transport.send_request(
@@ -1174,8 +1226,6 @@ server = MCP::Server.new(name: "my_server")
 # Default Streamable HTTP - session oriented
 transport = MCP::Server::Transports::StreamableHTTPTransport.new(server)
 
-server.transport = transport
-
 # When tools change, notify clients
 server.define_tool(name: "new_tool") { |**args| { result: "ok" } }
 server.notify_tools_list_changed

conformance/server.rb

@@ -394,7 +394,7 @@ def initialize(port: DEFAULT_PORT)
 
     def start
       server = build_server
-      transport = build_transport(server)
+      transport = MCP::Server::Transports::StreamableHTTPTransport.new(server)
       configure_handlers(server)
       rack_app = build_rack_app(transport)
 
@@ -480,12 +480,6 @@ def resource_templates
       ]
     end
 
-    def build_transport(server)
-      transport = MCP::Server::Transports::StreamableHTTPTransport.new(server)
-      server.transport = transport
-      transport
-    end
-
     def configure_handlers(server)
       server.logging_message_notification = MCP::LoggingMessageNotification.new(level: "debug")
       server.server_context = server

examples/http_server.rb

@@ -94,7 +94,6 @@ def template(args, server_context:)
 
 # Create the Streamable HTTP transport
 transport = MCP::Server::Transports::StreamableHTTPTransport.new(server)
-server.transport = transport
 
 # Create a logger for MCP-specific logging
 mcp_logger = Logger.new($stdout)

examples/streamable_http_server.rb

@@ -63,7 +63,6 @@ def call(message:, delay: 0)
 
 # Create the Streamable HTTP transport
 transport = MCP::Server::Transports::StreamableHTTPTransport.new(server)
-server.transport = transport
 
 # Create a logger for MCP request/response logging
 mcp_logger = Logger.new($stdout)

lib/mcp/transport.rb

@@ -7,6 +7,7 @@ class Transport
     # Initialize the transport with the server instance
     def initialize(server)
       @server = server
+      server.transport = self
     end
 
     # Send a response to the client

test/mcp/progress_test.rb

@@ -26,7 +26,6 @@ def handle_request(request); end
     setup do
       @server = Server.new(name: "test_server")
       @transport = MockTransport.new(@server)
-      @server.transport = @transport
       @session = ServerSession.new(server: @server, transport: @transport)
     end
 

test/mcp/server/transports/stdio_notification_integration_test.rb

@@ -61,7 +61,6 @@ def closed?
             resources: [],
           )
           @transport = StdioTransport.new(@server)
-          @server.transport = @transport
         end
 
         teardown do

test/mcp/server/transports/streamable_http_notification_integration_test.rb

@@ -15,7 +15,6 @@ class StreamableHTTPNotificationIntegrationTest < ActiveSupport::TestCase
             resources: [],
           )
           @transport = StreamableHTTPTransport.new(@server)
-          @server.transport = @transport
         end
 
         test "server notification methods send SSE notifications through HTTP transport" do

test/mcp/server/transports/streamable_http_transport_test.rb

@@ -2591,7 +2591,6 @@ def string
           server = Server.new(name: "test", tools: [], prompts: [], resources: [])
           server.logging_message_notification = MCP::LoggingMessageNotification.new(level: "debug")
           transport = StreamableHTTPTransport.new(server)
-          server.transport = transport
 
           server.define_tool(name: "log_tool") do |server_context:|
             server_context.notify_log_message(data: "secret", level: "info")
@@ -2668,7 +2667,6 @@ def string
         test "session-scoped progress notification is sent only to the originating session" do
           server = Server.new(name: "test", tools: [], prompts: [], resources: [])
           transport = StreamableHTTPTransport.new(server)
-          server.transport = transport
 
           server.define_tool(name: "progress_tool") do |server_context:|
             server_context.report_progress(50, total: 100, message: "halfway")
@@ -2749,7 +2747,6 @@ def string
         test "each session stores its own client info independently" do
           server = Server.new(name: "test", tools: [], prompts: [], resources: [])
           transport = StreamableHTTPTransport.new(server)
-          server.transport = transport
 
           # Initialize session 1 with client "alpha".
           init1 = create_rack_request(
@@ -2794,7 +2791,6 @@ def string
         test "each session stores its own logging level independently" do
           server = Server.new(name: "test", tools: [], prompts: [], resources: [])
           transport = StreamableHTTPTransport.new(server)
-          server.transport = transport
 
           # Initialize two sessions.
           init1 = create_rack_request(

test/mcp/server_notification_test.rb

@@ -36,7 +36,6 @@ def handle_request(request); end
       )
 
       @mock_transport = MockTransport.new(@server)
-      @server.transport = @mock_transport
     end
 
     test "#notify_tools_list_changed sends notification through transport" do
@@ -122,14 +121,13 @@ def handle_request(request); end
     end
 
     test "notification methods handle transport errors gracefully" do
-      # Create a transport that raises errors
-      error_transport = Class.new(MockTransport) do
+      # Replace server's transport with one that raises on send_notification.
+      Class.new(MockTransport) do
         def send_notification(method, params = nil)
           raise StandardError, "Transport error"
         end
       end.new(@server)
 
-      @server.transport = error_transport
       @server.logging_message_notification = MCP::LoggingMessageNotification.new(level: "error")
 
       # Mock the exception reporter