da5f9225ac
## Motivation and Context The MCP specification defines `sampling/createMessage` to request LLM completions from the client. The Ruby SDK did not yet support server-to-client requests, so the server had no way to ask the client to sample an LLM. This caused the `tools-call-sampling` conformance test to fail. This adds `Server#create_sampling_message` to send a `sampling/createMessage` request to the client via the transport layer. The method validates that the client declared the `sampling` capability during initialization, and optionally checks the `sampling.tools` capability when tools or tool_choice parameters are provided. On the transport side, `Transport#send_request` is introduced as an abstract method, with implementations in both `StdioTransport` and `StreamableHTTPTransport`. Each transport assigns a unique request ID, sends the JSON-RPC request to the client, and blocks until the client responds. Client capabilities are stored per session via `ServerSession`, so validation is scoped to the originating client. `ServerSession#create_sampling_message` uses `build_sampling_params` for capability validation and sends the request directly through the transport with the session ID, following the same pattern as `notify_progress`. `Server#create_sampling_message` is the public API for single-client transports (e.g., StdioTransport). For multi-client transports (e.g., StreamableHTTPTransport), `ServerSession#create_sampling_message` must be used to route requests to the correct client. Tools using `server_context.create_sampling_message` automatically route to the correct session regardless of transport. `StreamableHTTPTransport#send_request` requires `session_id` to prevent broadcasting sampling requests to all connected clients. Missing or invalid session IDs raise explicit errors instead of silently failing. The `include_context` parameter is soft-deprecated in the MCP specification but is included for compatibility with existing clients that declare the `sampling.context` capability. Python and TypeScript SDKs also retain this parameter. Ref: https://modelcontextprotocol.io/specification/latest/server/utilities/sampling ## How Has This Been Tested? Added comprehensive tests in `test/mcp/server_sampling_test.rb` covering required and optional parameters, capability validation, error handling, nil-param omission, per-session capability isolation, and HTTP init capability scoping. Added transport tests in `test/mcp/server/transports/stdio_transport_test.rb` and `test/mcp/server/transports/streamable_http_transport_test.rb` for `send_request` round-trip behavior, error responses, stateless mode rejection, missing session_id, invalid session_id, and no-active-stream error. Conformance: `tools-call-sampling` is removed from expected failures. The conformance server's `TestSampling` tool now calls `server_context.create_sampling_message` instead of returning a stub error. This aligns the Ruby SDK with the MCP specification and other SDK implementations. ## Breaking Changes None for end users. `Transport#send_request` is a new abstract method. `ServerSession#create_sampling_message` is a new method.
58 lines
1.5 KiB
Ruby
58 lines
1.5 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require "securerandom"
|
|
|
|
module MCP
|
|
class Transport
|
|
# Initialize the transport with the server instance
|
|
def initialize(server)
|
|
@server = server
|
|
end
|
|
|
|
# Send a response to the client
|
|
def send_response(response)
|
|
raise NotImplementedError, "Subclasses must implement send_response"
|
|
end
|
|
|
|
# Open the transport connection
|
|
def open
|
|
raise NotImplementedError, "Subclasses must implement open"
|
|
end
|
|
|
|
# Close the transport connection
|
|
def close
|
|
raise NotImplementedError, "Subclasses must implement close"
|
|
end
|
|
|
|
# Handle a JSON request
|
|
# Returns a response that should be sent back to the client
|
|
def handle_json_request(request)
|
|
response = @server.handle_json(request)
|
|
send_response(response) if response
|
|
end
|
|
|
|
# Handle an incoming request
|
|
# Returns a response that should be sent back to the client
|
|
def handle_request(request)
|
|
response = @server.handle(request)
|
|
send_response(response) if response
|
|
end
|
|
|
|
# Send a notification to the client.
|
|
# Returns true if the notification was sent successfully.
|
|
def send_notification(method, params = nil)
|
|
raise NotImplementedError, "Subclasses must implement send_notification"
|
|
end
|
|
|
|
# Send a JSON-RPC request to the client and wait for a response.
|
|
def send_request(method, params = nil)
|
|
raise NotImplementedError, "Subclasses must implement send_request"
|
|
end
|
|
|
|
private
|
|
|
|
def generate_request_id
|
|
SecureRandom.uuid
|
|
end
|
|
end
|
|
end
|