a4a885683c
## Motivation and Context `MCP::Client#tools`, `#resources`, `#resource_templates`, and `#prompts` follow `nextCursor` until the server stops offering one. The `seen` set in `fetch_all_pages` catches a server that repeats or cycles cursors, but a fresh cursor on every response walks past that guard, and the client keeps requesting and retaining pages for as long as the server keeps producing them. The transports' per-message limits do not help here, since each individual page can be small. `MCP::Client.new` now takes `max_pages:`, defaulting to `MAX_PAGES` (1000). Reaching it raises `PaginationLimitError` rather than truncating the collection silently, since a short array would be indistinguishable from a server that genuinely ran out of items. The single-page `list_*` methods are unchanged, so callers who need their own policy still have one. ## How Has This Been Tested? New tests in `test/mcp/client_test.rb` cover a server that returns a distinct cursor per page, the boundary where a server stops exactly at `max_pages`, and the argument validation. The existing repeat-cursor and cycling-cursor tests are unaffected. `bundle exec rake` (tests, RuboCop, and conformance baseline) passes. ## Breaking Changes An all-pages call against a server offering more than 1000 pages now raises `MCP::Client::PaginationLimitError` instead of continuing. Pass a larger `max_pages:` to `MCP::Client.new` if that is expected.
2137 lines
78 KiB
Ruby
2137 lines
78 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require "test_helper"
|
|
require "securerandom"
|
|
|
|
module MCP
|
|
class ClientTest < Minitest::Test
|
|
def test_connect_delegates_to_transport_and_forwards_keyword_args
|
|
transport = mock
|
|
init_result = {
|
|
"protocolVersion" => "2025-11-25",
|
|
"capabilities" => { "tools" => {} },
|
|
"serverInfo" => { "name" => "test-server", "version" => "1.0" },
|
|
}
|
|
transport.expects(:connect).with(
|
|
client_info: { name: "my-app", version: "1.0" },
|
|
protocol_version: "2025-11-25",
|
|
capabilities: { roots: {} },
|
|
).returns(init_result).once
|
|
|
|
result = Client.new(transport: transport).connect(
|
|
client_info: { name: "my-app", version: "1.0" },
|
|
protocol_version: "2025-11-25",
|
|
capabilities: { roots: {} },
|
|
)
|
|
|
|
assert_equal(init_result, result)
|
|
end
|
|
|
|
def test_connect_passes_nil_defaults_to_transport
|
|
transport = mock
|
|
transport.expects(:connect)
|
|
.with(client_info: nil, protocol_version: nil, capabilities: {})
|
|
.returns({ "protocolVersion" => "2025-11-25" }).once
|
|
|
|
Client.new(transport: transport).connect
|
|
end
|
|
|
|
def test_connect_is_noop_when_transport_does_not_respond_to_connect
|
|
transport = mock
|
|
transport.stubs(:respond_to?).with(:connect).returns(false)
|
|
transport.stubs(:respond_to?).with(:server_info).returns(false)
|
|
|
|
client = Client.new(transport: transport)
|
|
|
|
assert_nil(client.connect)
|
|
assert_nil(client.server_info)
|
|
end
|
|
|
|
def test_on_elicitation_registers_handler_on_transport
|
|
transport = mock
|
|
handler = proc { { action: "accept", content: {} } }
|
|
transport.expects(:on_server_request).with("elicitation/create")
|
|
|
|
Client.new(transport: transport).on_elicitation(&handler)
|
|
end
|
|
|
|
def test_on_elicitation_is_accepted_when_transport_does_not_support_server_requests
|
|
# The handler still answers embedded `elicitation/create` requests of SEP-2322 `input_required` results,
|
|
# which need no server-to-client route. Refusing to register it would lock stdio clients,
|
|
# and every modern-lifecycle connection, out of the only way the spec leaves for asking.
|
|
transport = mock
|
|
transport.stubs(:respond_to?).with(:on_server_request).returns(false)
|
|
|
|
Client.new(transport: transport).on_elicitation { { action: "accept", content: {} } }
|
|
end
|
|
|
|
def test_on_sampling_registers_handler_on_transport
|
|
transport = mock
|
|
handler = proc { { role: "assistant", content: { type: "text", text: "hi" } } }
|
|
transport.expects(:on_server_request).with("sampling/createMessage")
|
|
|
|
Client.new(transport: transport).on_sampling(&handler)
|
|
end
|
|
|
|
def test_on_sampling_is_accepted_when_transport_does_not_support_server_requests
|
|
transport = mock
|
|
transport.stubs(:respond_to?).with(:on_server_request).returns(false)
|
|
|
|
Client.new(transport: transport).on_sampling { { role: "assistant", content: { type: "text", text: "hi" } } }
|
|
end
|
|
|
|
def test_on_roots_registers_handler_on_transport
|
|
transport = mock
|
|
handler = proc { { roots: [{ uri: "file:///project", name: "Project" }] } }
|
|
transport.expects(:on_server_request).with("roots/list")
|
|
|
|
Client.new(transport: transport).on_roots(&handler)
|
|
end
|
|
|
|
# A transport that declares `mode:` on `connect`, recording what it received.
|
|
# The `:not_forwarded` sentinel distinguishes "Client did not forward mode" from
|
|
# "Client forwarded mode: :legacy".
|
|
class ModeAwareTransport
|
|
attr_reader :received
|
|
|
|
def connect(client_info: nil, protocol_version: nil, capabilities: {}, mode: :not_forwarded)
|
|
@received = {
|
|
client_info: client_info,
|
|
protocol_version: protocol_version,
|
|
capabilities: capabilities,
|
|
mode: mode,
|
|
}
|
|
{ "supportedVersions" => ["2026-07-28"] }
|
|
end
|
|
end
|
|
|
|
def test_connect_defaults_to_auto_on_transports_declaring_mode
|
|
transport = ModeAwareTransport.new
|
|
|
|
Client.new(transport: transport).connect
|
|
|
|
assert_equal(:auto, transport.received[:mode])
|
|
end
|
|
|
|
def test_connect_keeps_the_legacy_call_shape_for_transports_without_mode
|
|
# Custom transports whose `connect` does not declare `mode:` keep receiving
|
|
# the historical call shape, so the `:auto` default cannot break them.
|
|
transport = mock
|
|
transport.expects(:connect).with(
|
|
client_info: nil, protocol_version: nil, capabilities: {},
|
|
).returns({ "protocolVersion" => "2025-11-25" }).once
|
|
|
|
Client.new(transport: transport).connect
|
|
end
|
|
|
|
def test_connect_routes_explicit_legacy_through_the_legacy_call_shape
|
|
transport = ModeAwareTransport.new
|
|
|
|
Client.new(transport: transport).connect(mode: :legacy)
|
|
|
|
assert_equal(:not_forwarded, transport.received[:mode])
|
|
end
|
|
|
|
def test_connect_pins_legacy_for_an_explicit_stable_protocol_version
|
|
# An explicitly requested legacy-generation version must never be overridden
|
|
# by the default negotiation adopting the modern lifecycle.
|
|
transport = ModeAwareTransport.new
|
|
|
|
Client.new(transport: transport).connect(protocol_version: "2025-11-25")
|
|
|
|
assert_equal(:not_forwarded, transport.received[:mode])
|
|
assert_equal("2025-11-25", transport.received[:protocol_version])
|
|
end
|
|
|
|
def test_connect_negotiates_automatically_for_an_explicit_modern_protocol_version
|
|
transport = ModeAwareTransport.new
|
|
|
|
Client.new(transport: transport).connect(protocol_version: "2026-07-28")
|
|
|
|
assert_equal(:auto, transport.received[:mode])
|
|
end
|
|
|
|
def test_connect_raises_for_explicit_non_legacy_mode_on_a_transport_without_mode
|
|
transport = mock
|
|
transport.expects(:connect).never
|
|
|
|
error = assert_raises(ArgumentError) do
|
|
Client.new(transport: transport).connect(mode: :modern)
|
|
end
|
|
|
|
assert_includes(error.message, "does not support mode:")
|
|
end
|
|
|
|
def test_connect_rejects_unknown_modes
|
|
transport = ModeAwareTransport.new
|
|
|
|
assert_raises(ArgumentError) do
|
|
Client.new(transport: transport).connect(mode: :bogus)
|
|
end
|
|
end
|
|
|
|
def test_discover_returns_a_discover_result
|
|
transport = mock
|
|
transport.expects(:send_request).with do |args|
|
|
args[:request][:method] == "server/discover"
|
|
end.returns({
|
|
"result" => {
|
|
"supportedVersions" => ["2026-07-28"],
|
|
"capabilities" => { "tools" => {} },
|
|
"_meta" => { "io.modelcontextprotocol/serverInfo" => { "name" => "test-server", "version" => "1.0" } },
|
|
"instructions" => "Optional instructions",
|
|
"ttlMs" => 3_600_000,
|
|
"cacheScope" => "public",
|
|
},
|
|
}).once
|
|
|
|
result = Client.new(transport: transport).discover
|
|
|
|
assert_equal(["2026-07-28"], result.supported_versions)
|
|
assert_equal({ "tools" => {} }, result.capabilities)
|
|
assert_equal({ "name" => "test-server", "version" => "1.0" }, result.server_info)
|
|
assert_equal("Optional instructions", result.instructions)
|
|
assert_equal(3_600_000, result.ttl_ms)
|
|
assert_equal("public", result.cache_scope)
|
|
end
|
|
|
|
def test_discover_maps_a_top_level_server_info_as_a_fallback
|
|
# Servers built against the frozen SEP text still stamp `serverInfo` at the top level;
|
|
# the finalized spec moved it into the result `_meta`.
|
|
transport = mock
|
|
transport.expects(:send_request).returns({
|
|
"result" => {
|
|
"supportedVersions" => ["2026-07-28"],
|
|
"serverInfo" => { "name" => "sep-era-server", "version" => "1.0" },
|
|
},
|
|
}).once
|
|
|
|
result = Client.new(transport: transport).discover
|
|
|
|
assert_equal({ "name" => "sep-era-server", "version" => "1.0" }, result.server_info)
|
|
end
|
|
|
|
def test_discover_raises_validation_error_on_missing_result
|
|
transport = mock
|
|
transport.expects(:send_request).returns({}).once
|
|
|
|
assert_raises(Client::ValidationError) do
|
|
Client.new(transport: transport).discover
|
|
end
|
|
end
|
|
|
|
def test_discover_raises_server_error_on_jsonrpc_error
|
|
transport = mock
|
|
transport.expects(:send_request).returns({
|
|
"error" => { "code" => -32601, "message" => "Method not found" },
|
|
}).once
|
|
|
|
error = assert_raises(Client::ServerError) do
|
|
Client.new(transport: transport).discover
|
|
end
|
|
|
|
assert_equal(-32601, error.code)
|
|
end
|
|
|
|
def test_era_independent_readers_on_a_legacy_result
|
|
transport = mock
|
|
transport.stubs(:server_info).returns({
|
|
"protocolVersion" => "2025-11-25",
|
|
"capabilities" => { "tools" => {} },
|
|
"serverInfo" => { "name" => "legacy-server", "version" => "1.0" },
|
|
"instructions" => "Be helpful",
|
|
})
|
|
|
|
client = Client.new(transport: transport)
|
|
|
|
assert_equal("2025-11-25", client.protocol_version)
|
|
assert_equal({ "tools" => {} }, client.server_capabilities)
|
|
assert_equal("Be helpful", client.instructions)
|
|
assert_equal({ "name" => "legacy-server", "version" => "1.0" }, client.server_implementation)
|
|
end
|
|
|
|
def test_era_independent_readers_on_a_modern_result
|
|
# A modern `DiscoverResult` has no `protocolVersion`; the adopted version comes
|
|
# from the transport. `serverInfo` sits in the result `_meta` per the final spec.
|
|
transport = mock
|
|
transport.stubs(:protocol_version).returns("2026-07-28")
|
|
transport.stubs(:server_info).returns({
|
|
"supportedVersions" => ["2026-07-28"],
|
|
"capabilities" => { "tools" => {} },
|
|
"instructions" => "Be helpful",
|
|
"_meta" => { "io.modelcontextprotocol/serverInfo" => { "name" => "modern-server", "version" => "2.0" } },
|
|
"ttlMs" => 0,
|
|
"cacheScope" => "private",
|
|
})
|
|
|
|
client = Client.new(transport: transport)
|
|
|
|
assert_equal("2026-07-28", client.protocol_version)
|
|
assert_equal({ "tools" => {} }, client.server_capabilities)
|
|
assert_equal("Be helpful", client.instructions)
|
|
assert_equal({ "name" => "modern-server", "version" => "2.0" }, client.server_implementation)
|
|
end
|
|
|
|
def test_server_implementation_falls_back_to_the_top_level_and_tolerates_absence
|
|
transport = mock
|
|
transport.stubs(:server_info).returns({
|
|
"supportedVersions" => ["2026-07-28"],
|
|
"serverInfo" => { "name" => "top-level", "version" => "1.0" },
|
|
})
|
|
|
|
assert_equal({ "name" => "top-level", "version" => "1.0" }, Client.new(transport: transport).server_implementation)
|
|
|
|
anonymous = mock
|
|
anonymous.stubs(:server_info).returns({ "supportedVersions" => ["2026-07-28"] })
|
|
|
|
assert_nil(Client.new(transport: anonymous).server_implementation)
|
|
end
|
|
|
|
def test_era_independent_readers_return_nil_before_connect
|
|
transport = mock
|
|
transport.stubs(:respond_to?).with(:server_info).returns(false)
|
|
transport.stubs(:respond_to?).with(:protocol_version).returns(false)
|
|
|
|
client = Client.new(transport: transport)
|
|
|
|
assert_nil(client.protocol_version)
|
|
assert_nil(client.server_capabilities)
|
|
assert_nil(client.instructions)
|
|
assert_nil(client.server_implementation)
|
|
end
|
|
|
|
def test_connected_delegates_to_transport_when_supported
|
|
transport = mock
|
|
transport.expects(:connected?).returns(true)
|
|
|
|
assert_predicate(Client.new(transport: transport), :connected?)
|
|
end
|
|
|
|
def test_connected_returns_true_when_transport_does_not_respond_to_connected
|
|
transport = mock
|
|
transport.stubs(:respond_to?).with(:connected?).returns(false)
|
|
|
|
assert_predicate(Client.new(transport: transport), :connected?)
|
|
end
|
|
|
|
def test_server_info_delegates_to_transport_when_supported
|
|
transport = mock
|
|
init_result = { "protocolVersion" => "2025-11-25" }
|
|
transport.expects(:server_info).returns(init_result)
|
|
|
|
assert_equal(init_result, Client.new(transport: transport).server_info)
|
|
end
|
|
|
|
def test_server_info_returns_nil_when_transport_does_not_expose_it
|
|
transport = mock
|
|
transport.stubs(:respond_to?).with(:server_info).returns(false)
|
|
|
|
assert_nil(Client.new(transport: transport).server_info)
|
|
end
|
|
|
|
def test_tools_sends_request_to_transport_and_returns_tools_array
|
|
transport = mock
|
|
mock_response = {
|
|
"result" => {
|
|
"tools" => [
|
|
{
|
|
"name" => "tool1",
|
|
"description" => "tool1",
|
|
"inputSchema" => {},
|
|
"outputSchema" => { "type" => "object", "properties" => { "result" => { "type" => "string" } } },
|
|
"annotations" => { "readOnlyHint" => true, "title" => "Tool One" },
|
|
},
|
|
{ "name" => "tool2", "description" => "tool2", "inputSchema" => {} },
|
|
],
|
|
},
|
|
}
|
|
|
|
# Only checking for the essential parts of the request
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "tools/list" && args.dig(:request, :jsonrpc) == "2.0"
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
tools = client.tools
|
|
|
|
assert_equal(2, tools.size)
|
|
assert_equal("tool1", tools.first.name)
|
|
assert_equal({ "type" => "object", "properties" => { "result" => { "type" => "string" } } }, tools.first.output_schema)
|
|
assert_equal({ "readOnlyHint" => true, "title" => "Tool One" }, tools.first.annotations)
|
|
assert_equal("tool2", tools.last.name)
|
|
assert_nil(tools.last.output_schema)
|
|
assert_nil(tools.last.annotations)
|
|
end
|
|
|
|
def test_tools_returns_empty_array_when_no_tools
|
|
transport = mock
|
|
mock_response = { "result" => { "tools" => [] } }
|
|
|
|
# Only checking for the essential parts of the request
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "tools/list" && args.dig(:request, :jsonrpc) == "2.0"
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
tools = client.tools
|
|
|
|
assert_equal([], tools)
|
|
end
|
|
|
|
def test_tools_excludes_invalid_x_mcp_header_definitions_on_a_modern_connection
|
|
# SEP-2243: on the modern lifecycle a tool definition violating the `x-mcp-header`
|
|
# constraints MUST be excluded from `tools/list` results, with a warning naming the tool.
|
|
transport = mock
|
|
transport.stubs(:modern?).returns(true)
|
|
mock_response = {
|
|
"result" => {
|
|
"tools" => [
|
|
{ "name" => "valid_tool", "inputSchema" => { "type" => "object" } },
|
|
{
|
|
"name" => "invalid_tool",
|
|
"inputSchema" => {
|
|
"type" => "object",
|
|
"properties" => { "value" => { "type" => "string", "x-mcp-header" => "bad name" } },
|
|
},
|
|
},
|
|
],
|
|
},
|
|
}
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
client = Client.new(transport: transport)
|
|
|
|
# `rake` runs the suite with `-W0`, which silences `Kernel#warn`; restore warnings
|
|
# locally so the SHOULD-level warning is observable.
|
|
original_verbose = $VERBOSE
|
|
$VERBOSE = false
|
|
tools = nil
|
|
_out, warning = capture_io { tools = client.tools }
|
|
$VERBOSE = original_verbose
|
|
|
|
assert_equal(["valid_tool"], tools.map(&:name))
|
|
assert_includes(warning, "invalid_tool")
|
|
end
|
|
|
|
def test_tools_keeps_invalid_x_mcp_header_definitions_on_a_legacy_connection
|
|
transport = mock
|
|
transport.stubs(:modern?).returns(false)
|
|
mock_response = {
|
|
"result" => {
|
|
"tools" => [
|
|
{
|
|
"name" => "invalid_tool",
|
|
"inputSchema" => {
|
|
"type" => "object",
|
|
"properties" => { "value" => { "type" => "string", "x-mcp-header" => "bad name" } },
|
|
},
|
|
},
|
|
],
|
|
},
|
|
}
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
client = Client.new(transport: transport)
|
|
|
|
assert_equal(["invalid_tool"], client.tools.map(&:name))
|
|
end
|
|
|
|
def test_call_tool_sends_request_to_transport_and_returns_content
|
|
transport = mock
|
|
tool = MCP::Client::Tool.new(name: "tool1", description: "tool1", input_schema: {})
|
|
arguments = { foo: "bar" }
|
|
mock_response = {
|
|
"result" => { "content" => [{ "type": "text", "text": "Hello, world!" }] },
|
|
}
|
|
|
|
# Only checking for the essential parts of the request
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "tools/call" &&
|
|
args.dig(:request, :jsonrpc) == "2.0" &&
|
|
args.dig(:request, :params, :name) == "tool1" &&
|
|
args.dig(:request, :params, :arguments) == arguments
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.call_tool(tool: tool, arguments: arguments)
|
|
content = result.dig("result", "content")
|
|
|
|
assert_equal([{ type: "text", text: "Hello, world!" }], content)
|
|
end
|
|
|
|
def test_call_tool_by_name
|
|
transport = mock
|
|
arguments = { foo: "bar" }
|
|
mock_response = {
|
|
"result" => { "content" => [{ "type": "text", "text": "Hello, world!" }] },
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :params, :name) == "tool1" &&
|
|
args.dig(:request, :params, :arguments) == arguments
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.call_tool(name: "tool1", arguments: arguments)
|
|
content = result.dig("result", "content")
|
|
|
|
assert_equal([{ type: "text", text: "Hello, world!" }], content)
|
|
end
|
|
|
|
def test_call_tool_raises_input_required_error_when_result_type_is_input_required
|
|
# Per SEP-2322, a result with `resultType: "input_required"` is not a final result;
|
|
# surface it instead of returning it as a normal result.
|
|
transport = mock
|
|
tool = MCP::Client::Tool.new(name: "tool1", description: "tool1", input_schema: {})
|
|
mock_response = {
|
|
"result" => {
|
|
"resultType" => "input_required",
|
|
"inputRequests" => {
|
|
"1" => { "method" => "elicitation/create", "params" => { "mode" => "form", "message" => "Name?" } },
|
|
},
|
|
"requestState" => "opaque-state",
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(Client::InputRequiredError) do
|
|
client.call_tool(tool: tool, arguments: {})
|
|
end
|
|
|
|
assert_equal(
|
|
{ "1" => { "method" => "elicitation/create", "params" => { "mode" => "form", "message" => "Name?" } } },
|
|
error.input_requests,
|
|
)
|
|
assert_equal("opaque-state", error.request_state)
|
|
assert_equal(mock_response["result"], error.result)
|
|
end
|
|
|
|
def test_call_tool_returns_normally_when_result_type_is_complete
|
|
transport = mock
|
|
tool = MCP::Client::Tool.new(name: "tool1", description: "tool1", input_schema: {})
|
|
mock_response = {
|
|
"result" => {
|
|
"resultType" => "complete",
|
|
"content" => [{ "type" => "text", "text" => "done" }],
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.call_tool(tool: tool, arguments: {})
|
|
|
|
assert_equal("done", result.dig("result", "content", 0, "text"))
|
|
end
|
|
|
|
def test_call_tool_returns_normally_when_result_type_is_absent
|
|
# Regression guard: stable-protocol servers never send `resultType`.
|
|
transport = mock
|
|
tool = MCP::Client::Tool.new(name: "tool1", description: "tool1", input_schema: {})
|
|
mock_response = {
|
|
"result" => { "content" => [{ "type" => "text", "text" => "done" }] },
|
|
}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.call_tool(tool: tool, arguments: {})
|
|
|
|
assert_equal("done", result.dig("result", "content", 0, "text"))
|
|
end
|
|
|
|
def test_list_tools_raises_input_required_error_for_input_required_results
|
|
# The recognition lives in the shared request path, so every client method is covered, not only tools/call.
|
|
transport = mock
|
|
mock_response = {
|
|
"result" => { "resultType" => "input_required", "inputRequests" => {} },
|
|
}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
assert_raises(Client::InputRequiredError) { client.list_tools }
|
|
end
|
|
|
|
def test_call_tool_drives_the_input_required_loop_with_a_configured_handler
|
|
transport = mock
|
|
sent_requests = []
|
|
input_required_response = {
|
|
"result" => {
|
|
"resultType" => "input_required",
|
|
"inputRequests" => {
|
|
"region" => { "method" => "elicitation/create", "params" => { "message" => "Which region?" } },
|
|
},
|
|
"requestState" => "state-1",
|
|
},
|
|
}
|
|
final_response = { "result" => { "content" => [{ "type" => "text", "text" => "done" }] } }
|
|
transport.expects(:send_request).twice.with do |args|
|
|
sent_requests << args[:request]
|
|
true
|
|
end.returns(input_required_response, final_response)
|
|
|
|
handled_params = nil
|
|
client = Client.new(transport: transport)
|
|
client.on_elicitation do |params|
|
|
handled_params = params
|
|
{ action: "accept", content: { value: "us-east-1" } }
|
|
end
|
|
|
|
response = client.call_tool(name: "my_tool", arguments: { city: "Tokyo" })
|
|
|
|
assert_equal("done", response.dig("result", "content", 0, "text"))
|
|
assert_equal({ "message" => "Which region?" }, handled_params)
|
|
|
|
first_leg, retry_leg = sent_requests
|
|
# The ORIGINAL params are preserved; the answers ride under the same keys with
|
|
# the byte-exact `requestState` echo, on a fresh JSON-RPC id.
|
|
assert_equal("my_tool", retry_leg.dig(:params, :name))
|
|
assert_equal({ city: "Tokyo" }, retry_leg.dig(:params, :arguments))
|
|
assert_equal(
|
|
{ "region" => { action: "accept", content: { value: "us-east-1" } } },
|
|
retry_leg.dig(:params, :inputResponses),
|
|
)
|
|
assert_equal("state-1", retry_leg.dig(:params, :requestState))
|
|
refute_equal(first_leg[:id], retry_leg[:id])
|
|
end
|
|
|
|
def test_input_required_loop_backs_off_on_request_state_only_legs
|
|
transport = mock
|
|
state_only_response = {
|
|
"result" => { "resultType" => "input_required", "requestState" => "busy-state" },
|
|
}
|
|
final_response = { "result" => { "content" => [] } }
|
|
transport.stubs(:send_request).returns(state_only_response, state_only_response, final_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
client.on_elicitation { |_params| {} }
|
|
slept = []
|
|
client.stubs(:sleep).with { |seconds| slept << seconds }
|
|
|
|
response = client.call_tool(name: "my_tool")
|
|
|
|
assert_equal(final_response, response)
|
|
|
|
# Exponential from 50ms, matching the Python SDK.
|
|
assert_equal([0.05, 0.1], slept)
|
|
end
|
|
|
|
def test_input_required_loop_raises_after_max_rounds
|
|
transport = mock
|
|
input_required_response = {
|
|
"result" => {
|
|
"resultType" => "input_required",
|
|
"inputRequests" => { "q" => { "method" => "elicitation/create", "params" => {} } },
|
|
"requestState" => "state-1",
|
|
},
|
|
}
|
|
transport.stubs(:send_request).returns(input_required_response)
|
|
|
|
client = Client.new(transport: transport, input_required_max_rounds: 2)
|
|
client.on_elicitation { |_params| { action: "decline" } }
|
|
|
|
error = assert_raises(Client::InputRequiredError) { client.call_tool(name: "my_tool") }
|
|
|
|
assert_includes(error.message, "after 2 rounds")
|
|
assert_equal("state-1", error.request_state)
|
|
end
|
|
|
|
def test_input_required_loop_falls_back_to_the_error_for_unhandled_request_kinds
|
|
transport = mock
|
|
input_required_response = {
|
|
"result" => {
|
|
"resultType" => "input_required",
|
|
"inputRequests" => { "llm" => { "method" => "sampling/createMessage", "params" => {} } },
|
|
"requestState" => "state-1",
|
|
},
|
|
}
|
|
transport.expects(:send_request).returns(input_required_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
client.on_elicitation { |_params| {} }
|
|
|
|
error = assert_raises(Client::InputRequiredError) { client.call_tool(name: "my_tool") }
|
|
|
|
assert_includes(error.message, "sampling/createMessage")
|
|
assert_equal("state-1", error.request_state)
|
|
end
|
|
|
|
def test_input_required_loop_runs_on_a_transport_without_server_request_support
|
|
# The modern lifecycle forbids server-to-client requests, so an `input_required` result is the only
|
|
# way a server can ask. A transport with no `on_server_request` must still drive the loop.
|
|
transport = mock
|
|
transport.stubs(:respond_to?).with(:on_server_request).returns(false)
|
|
input_required_response = {
|
|
"result" => {
|
|
"resultType" => "input_required",
|
|
"inputRequests" => { "q" => { "method" => "elicitation/create", "params" => { "message" => "Region?" } } },
|
|
"requestState" => "state-1",
|
|
},
|
|
}
|
|
final_response = { "result" => { "content" => [{ "text" => "done" }] } }
|
|
transport.expects(:send_request).twice.returns(input_required_response, final_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
client.on_elicitation { |_params| { action: "accept", content: { value: "us-east-1" } } }
|
|
|
|
response = client.call_tool(name: "my_tool")
|
|
|
|
assert_equal("done", response.dig("result", "content", 0, "text"))
|
|
end
|
|
|
|
def test_input_required_loop_uses_a_roots_handler_registered_with_on_roots
|
|
transport = mock
|
|
input_required_response = {
|
|
"result" => {
|
|
"resultType" => "input_required",
|
|
"inputRequests" => { "r" => { "method" => "roots/list" } },
|
|
"requestState" => "state-1",
|
|
},
|
|
}
|
|
final_response = { "result" => { "content" => [{ "text" => "done" }] } }
|
|
transport.expects(:on_server_request).with("roots/list")
|
|
transport.expects(:send_request).twice.returns(input_required_response, final_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
client.on_roots { |_params| { roots: [{ uri: "file:///project", name: "Project" }] } }
|
|
|
|
response = client.call_tool(name: "my_tool")
|
|
|
|
assert_equal("done", response.dig("result", "content", 0, "text"))
|
|
end
|
|
|
|
def test_call_tool_sends_manual_retry_fields
|
|
transport = mock
|
|
transport.expects(:send_request).with do |args|
|
|
params = args[:request][:params]
|
|
params[:inputResponses] == { "region" => { action: "accept" } } && params[:requestState] == "state-1" && params[:name] == "my_tool"
|
|
end.returns({ "result" => { "content" => [] } }).once
|
|
|
|
client = Client.new(transport: transport)
|
|
client.call_tool(name: "my_tool", input_responses: { "region" => { action: "accept" } }, request_state: "state-1")
|
|
end
|
|
|
|
def test_get_prompt_drives_the_input_required_loop
|
|
transport = mock
|
|
input_required_response = {
|
|
"result" => {
|
|
"resultType" => "input_required",
|
|
"inputRequests" => { "q" => { "method" => "elicitation/create", "params" => { "message" => "?" } } },
|
|
"requestState" => "prompt-state",
|
|
},
|
|
}
|
|
final_response = { "result" => { "messages" => [] } }
|
|
sent_requests = []
|
|
transport.expects(:send_request).twice.with do |args|
|
|
sent_requests << args[:request]
|
|
true
|
|
end.returns(input_required_response, final_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
client.on_elicitation { |_params| { action: "accept", content: {} } }
|
|
|
|
result = client.get_prompt(name: "my_prompt")
|
|
|
|
assert_equal({ "messages" => [] }, result)
|
|
assert_equal("prompt-state", sent_requests[1].dig(:params, :requestState))
|
|
end
|
|
|
|
def test_call_tool_raises_when_no_name_or_tool
|
|
client = Client.new(transport: mock)
|
|
|
|
error = assert_raises(ArgumentError) { client.call_tool(arguments: { foo: "bar" }) }
|
|
assert_equal("Either `name:` or `tool:` must be provided.", error.message)
|
|
end
|
|
|
|
def test_resources_sends_request_to_transport_and_returns_resources_array
|
|
transport = mock
|
|
mock_response = {
|
|
"result" => {
|
|
"resources" => [
|
|
{ "name" => "resource1", "uri" => "file:///path/to/resource1", "description" => "First resource" },
|
|
{ "name" => "resource2", "uri" => "file:///path/to/resource2", "description" => "Second resource" },
|
|
],
|
|
},
|
|
}
|
|
|
|
# Only checking for the essential parts of the request
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "resources/list" && args.dig(:request, :jsonrpc) == "2.0"
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
resources = client.resources
|
|
|
|
assert_equal(2, resources.size)
|
|
assert_equal("resource1", resources.first["name"])
|
|
assert_equal("file:///path/to/resource1", resources.first["uri"])
|
|
assert_equal("resource2", resources.last["name"])
|
|
assert_equal("file:///path/to/resource2", resources.last["uri"])
|
|
end
|
|
|
|
def test_resources_returns_empty_array_when_no_resources
|
|
transport = mock
|
|
mock_response = { "result" => { "resources" => [] } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
resources = client.resources
|
|
|
|
assert_equal([], resources)
|
|
end
|
|
|
|
def test_read_resource_sends_request_to_transport_and_returns_contents
|
|
transport = mock
|
|
uri = "file:///path/to/resource.txt"
|
|
mock_response = {
|
|
"result" => {
|
|
"contents" => [
|
|
{ "uri" => uri, "mimeType" => "text/plain", "text" => "Hello, world!" },
|
|
],
|
|
},
|
|
}
|
|
|
|
# Only checking for the essential parts of the request
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "resources/read" &&
|
|
args.dig(:request, :jsonrpc) == "2.0" &&
|
|
args.dig(:request, :params, :uri) == uri
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
contents = client.read_resource(uri: uri)
|
|
|
|
assert_equal(1, contents.size)
|
|
assert_equal(uri, contents.first["uri"])
|
|
assert_equal("text/plain", contents.first["mimeType"])
|
|
assert_equal("Hello, world!", contents.first["text"])
|
|
end
|
|
|
|
def test_read_resource_returns_empty_array_when_no_contents
|
|
transport = mock
|
|
uri = "file:///path/to/nonexistent.txt"
|
|
mock_response = { "result" => {} }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
contents = client.read_resource(uri: uri)
|
|
|
|
assert_equal([], contents)
|
|
end
|
|
|
|
def test_resource_templates_sends_request_to_transport_and_returns_resource_templates_array
|
|
transport = mock
|
|
mock_response = {
|
|
"result" => {
|
|
"resourceTemplates" => [
|
|
{ "name" => "template1", "uriTemplate" => "file:///path/{filename}", "description" => "First template" },
|
|
{ "name" => "template2", "uriTemplate" => "http://example.com/{id}", "description" => "Second template" },
|
|
],
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "resources/templates/list" && args.dig(:request, :jsonrpc) == "2.0"
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
resource_templates = client.resource_templates
|
|
|
|
assert_equal(2, resource_templates.size)
|
|
assert_equal("template1", resource_templates.first["name"])
|
|
assert_equal("file:///path/{filename}", resource_templates.first["uriTemplate"])
|
|
assert_equal("template2", resource_templates.last["name"])
|
|
assert_equal("http://example.com/{id}", resource_templates.last["uriTemplate"])
|
|
end
|
|
|
|
def test_resource_templates_returns_empty_array_when_no_resource_templates
|
|
transport = mock
|
|
mock_response = { "result" => { "resourceTemplates" => [] } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
resource_templates = client.resource_templates
|
|
|
|
assert_equal([], resource_templates)
|
|
end
|
|
|
|
def test_prompts_sends_request_to_transport_and_returns_prompts_array
|
|
transport = mock
|
|
mock_response = {
|
|
"result" => {
|
|
"prompts" => [
|
|
{
|
|
"name" => "prompt_1",
|
|
"description" => "First prompt",
|
|
"arguments" => [
|
|
{
|
|
"name" => "code_1",
|
|
"description" => "The code_1 to review",
|
|
"required" => true,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
"name" => "prompt_2",
|
|
"description" => "Second prompt",
|
|
"arguments" => [
|
|
{
|
|
"name" => "code_2",
|
|
"description" => "The code_2 to review",
|
|
"required" => true,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
}
|
|
|
|
# Only checking for the essential parts of the request
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "prompts/list" && args.dig(:request, :jsonrpc) == "2.0"
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
prompts = client.prompts
|
|
|
|
assert_equal(2, prompts.size)
|
|
assert_equal("prompt_1", prompts.first["name"])
|
|
assert_equal("First prompt", prompts.first["description"])
|
|
assert_equal("code_1", prompts.first["arguments"].first["name"])
|
|
assert_equal("The code_1 to review", prompts.first["arguments"].first["description"])
|
|
assert(prompts.first["arguments"].first["required"])
|
|
|
|
assert_equal("prompt_2", prompts.last["name"])
|
|
assert_equal("Second prompt", prompts.last["description"])
|
|
assert_equal("code_2", prompts.last["arguments"].first["name"])
|
|
assert_equal("The code_2 to review", prompts.last["arguments"].first["description"])
|
|
assert(prompts.last["arguments"].first["required"])
|
|
end
|
|
|
|
def test_prompts_returns_empty_array_when_no_prompts
|
|
transport = mock
|
|
mock_response = { "result" => { "prompts" => [] } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
prompts = client.prompts
|
|
|
|
assert_equal([], prompts)
|
|
end
|
|
|
|
def test_get_prompt_sends_request_to_transport_and_returns_contents
|
|
transport = mock
|
|
name = "first_prompt"
|
|
mock_response = {
|
|
"result" => {
|
|
"description" => "First prompt",
|
|
"messages" => [
|
|
{
|
|
"role" => "user",
|
|
"content" => {
|
|
"text" => "First prompt content",
|
|
"type" => "text",
|
|
},
|
|
},
|
|
],
|
|
},
|
|
}
|
|
|
|
# Only checking for the essential parts of the request
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "prompts/get" &&
|
|
args.dig(:request, :jsonrpc) == "2.0" &&
|
|
args.dig(:request, :params, :name) == name
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
contents = client.get_prompt(name: name)
|
|
|
|
assert_equal("First prompt", contents["description"])
|
|
assert_equal("user", contents["messages"].first["role"])
|
|
assert_equal("First prompt content", contents["messages"].first["content"]["text"])
|
|
end
|
|
|
|
def test_get_prompt_returns_empty_hash_when_no_contents
|
|
transport = mock
|
|
name = "nonexistent_prompt"
|
|
mock_response = { "result" => {} }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
contents = client.get_prompt(name: name)
|
|
|
|
assert_equal({}, contents)
|
|
end
|
|
|
|
def test_get_prompt_returns_empty_hash
|
|
transport = mock
|
|
name = "nonexistent_prompt"
|
|
mock_response = {}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
contents = client.get_prompt(name: name)
|
|
|
|
assert_equal({}, contents)
|
|
end
|
|
|
|
def test_call_tool_includes_meta_progress_token_when_provided
|
|
transport = mock
|
|
tool = MCP::Client::Tool.new(name: "tool1", description: "tool1", input_schema: {})
|
|
arguments = { foo: "bar" }
|
|
progress_token = "my-progress-token"
|
|
mock_response = {
|
|
"result" => { "content" => [{ "type": "text", "text": "Hello, world!" }] },
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "tools/call" &&
|
|
args.dig(:request, :params, :_meta, :progressToken) == progress_token &&
|
|
args.dig(:request, :params, :name) == "tool1" &&
|
|
args.dig(:request, :params, :arguments) == arguments
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
client.call_tool(tool: tool, arguments: arguments, progress_token: progress_token)
|
|
end
|
|
|
|
def test_call_tool_sends_trace_context_meta_entries
|
|
transport = mock
|
|
tool = MCP::Client::Tool.new(name: "tool1", description: "tool1", input_schema: {})
|
|
meta = {
|
|
MCP::TraceContext::TRACEPARENT_META_KEY => "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01",
|
|
MCP::TraceContext::TRACESTATE_META_KEY => "vendor=value",
|
|
MCP::TraceContext::BAGGAGE_META_KEY => "userId=alice",
|
|
}
|
|
mock_response = {
|
|
"result" => { "content" => [{ "type": "text", "text": "Hello, world!" }] },
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
sent_meta = args.dig(:request, :params, :_meta)
|
|
sent_meta["traceparent"] == meta["traceparent"] &&
|
|
sent_meta["tracestate"] == meta["tracestate"] &&
|
|
sent_meta["baggage"] == meta["baggage"]
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
client.call_tool(tool: tool, arguments: {}, meta: meta)
|
|
end
|
|
|
|
def test_call_tool_merges_meta_with_progress_token_taking_precedence
|
|
transport = mock
|
|
tool = MCP::Client::Tool.new(name: "tool1", description: "tool1", input_schema: {})
|
|
meta = { "traceparent" => "00-trace-span-01", "progressToken" => "from-meta" }
|
|
mock_response = {
|
|
"result" => { "content" => [{ "type": "text", "text": "Hello, world!" }] },
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
sent_meta = args.dig(:request, :params, :_meta)
|
|
sent_meta["traceparent"] == "00-trace-span-01" &&
|
|
sent_meta[:progressToken] == "explicit-token" &&
|
|
!sent_meta.key?("progressToken")
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
client.call_tool(tool: tool, arguments: {}, progress_token: "explicit-token", meta: meta)
|
|
end
|
|
|
|
def test_call_tool_omits_meta_when_empty_meta_hash_given
|
|
transport = mock
|
|
tool = MCP::Client::Tool.new(name: "tool1", description: "tool1", input_schema: {})
|
|
mock_response = {
|
|
"result" => { "content" => [{ "type": "text", "text": "Hello, world!" }] },
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :params).key?(:_meta) == false
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
client.call_tool(tool: tool, arguments: {}, meta: {})
|
|
end
|
|
|
|
def test_call_tool_does_not_mutate_caller_meta
|
|
transport = mock
|
|
tool = MCP::Client::Tool.new(name: "tool1", description: "tool1", input_schema: {})
|
|
meta = { "traceparent" => "00-0af7651916cd43dd8448eb211c80319c-00f067aa0ba902b7-01" }
|
|
mock_response = {
|
|
"result" => { "content" => [{ "type": "text", "text": "Hello, world!" }] },
|
|
}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
client.call_tool(tool: tool, arguments: {}, progress_token: "t", meta: meta)
|
|
|
|
assert_equal({ "traceparent" => "00-0af7651916cd43dd8448eb211c80319c-00f067aa0ba902b7-01" }, meta)
|
|
end
|
|
|
|
def test_read_resource_sends_meta_when_provided
|
|
transport = mock
|
|
traceparent = "00-0af7651916cd43dd8448eb211c80319c-00f067aa0ba902b7-01"
|
|
mock_response = { "result" => { "contents" => [] } }
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "resources/read" &&
|
|
args.dig(:request, :params, :uri) == "file:///foo" &&
|
|
args.dig(:request, :params, :_meta, :traceparent) == traceparent
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
client.read_resource(uri: "file:///foo", meta: { traceparent: traceparent })
|
|
end
|
|
|
|
def test_request_methods_send_meta_when_provided
|
|
# Per SEP-414, trace context should flow on every request, so the `meta:` keyword
|
|
# is available on all client request methods.
|
|
traceparent = "00-0af7651916cd43dd8448eb211c80319c-00f067aa0ba902b7-01"
|
|
meta = { traceparent: traceparent }
|
|
|
|
[
|
|
["tools/list", { "tools" => [] }, ->(client) { client.list_tools(meta: meta) }],
|
|
["resources/list", { "resources" => [] }, ->(client) { client.list_resources(meta: meta) }],
|
|
["resources/templates/list", { "resourceTemplates" => [] }, ->(client) { client.list_resource_templates(meta: meta) }],
|
|
["prompts/list", { "prompts" => [] }, ->(client) { client.list_prompts(meta: meta) }],
|
|
["prompts/get", {}, ->(client) { client.get_prompt(name: "p", meta: meta) }],
|
|
[
|
|
"completion/complete",
|
|
{ "completion" => { "values" => [] } },
|
|
->(client) {
|
|
client.complete(ref: { type: "ref/prompt", name: "p" }, argument: { name: "a", value: "v" }, meta: meta)
|
|
},
|
|
],
|
|
["ping", {}, ->(client) { client.ping(meta: meta) }],
|
|
].each do |method, result, invoke|
|
|
transport = mock
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == method &&
|
|
args.dig(:request, :params, :_meta, :traceparent) == traceparent
|
|
end.returns({ "result" => result }).once
|
|
|
|
invoke.call(Client.new(transport: transport))
|
|
end
|
|
end
|
|
|
|
def test_request_methods_omit_meta_when_not_provided
|
|
# Wire-format regression: without `meta:`, list requests keep sending no `params` at all.
|
|
transport = mock
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "tools/list" && !args[:request].key?(:params)
|
|
end.returns({ "result" => { "tools" => [] } }).once
|
|
|
|
Client.new(transport: transport).list_tools
|
|
end
|
|
|
|
def test_call_tool_omits_meta_when_no_progress_token
|
|
transport = mock
|
|
tool = MCP::Client::Tool.new(name: "tool1", description: "tool1", input_schema: {})
|
|
arguments = { foo: "bar" }
|
|
mock_response = {
|
|
"result" => { "content" => [{ "type": "text", "text": "Hello, world!" }] },
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "tools/call" &&
|
|
args.dig(:request, :params, :name) == "tool1" &&
|
|
args.dig(:request, :params).key?(:_meta) == false
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
client.call_tool(tool: tool, arguments: arguments)
|
|
end
|
|
|
|
def test_tools_raises_server_error_on_error_response
|
|
transport = mock
|
|
mock_response = { "error" => { "code" => -32_601, "message" => "Method not found" } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(Client::ServerError) { client.tools }
|
|
assert_equal(-32_601, error.code)
|
|
assert_equal("Method not found", error.message)
|
|
end
|
|
|
|
def test_resources_raises_server_error_on_error_response
|
|
transport = mock
|
|
mock_response = { "error" => { "code" => -32_602, "message" => "Invalid params" } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(Client::ServerError) { client.resources }
|
|
assert_equal(-32_602, error.code)
|
|
end
|
|
|
|
def test_read_resource_raises_server_error_on_error_response
|
|
transport = mock
|
|
mock_response = { "error" => { "code" => -32_602, "message" => "Resource not found" } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
assert_raises(Client::ServerError) { client.read_resource(uri: "file:///missing") }
|
|
end
|
|
|
|
def test_read_resource_surfaces_resource_not_found_code_and_data
|
|
# Per SEP-2164, servers report unknown resource URIs with -32602 and
|
|
# the URI in the error `data`; the client must expose both unmodified.
|
|
transport = mock
|
|
mock_response = {
|
|
"error" => {
|
|
"code" => -32_602,
|
|
"message" => "Resource not found: file:///missing.txt",
|
|
"data" => { "uri" => "file:///missing.txt" },
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(Client::ServerError) { client.read_resource(uri: "file:///missing.txt") }
|
|
|
|
assert_equal(-32_602, error.code)
|
|
assert_equal({ "uri" => "file:///missing.txt" }, error.data)
|
|
end
|
|
|
|
def test_get_prompt_raises_server_error_on_error_response
|
|
transport = mock
|
|
mock_response = { "error" => { "code" => -32_602, "message" => "Prompt not found" } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
assert_raises(Client::ServerError) { client.get_prompt(name: "missing") }
|
|
end
|
|
|
|
def test_prompts_raises_server_error_on_error_response
|
|
transport = mock
|
|
mock_response = { "error" => { "code" => -32_601, "message" => "Method not found" } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
assert_raises(Client::ServerError) { client.prompts }
|
|
end
|
|
|
|
def test_resource_templates_raises_server_error_on_error_response
|
|
transport = mock
|
|
mock_response = { "error" => { "code" => -32_601, "message" => "Method not found" } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
assert_raises(Client::ServerError) { client.resource_templates }
|
|
end
|
|
|
|
def test_call_tool_raises_server_error_on_error_response
|
|
transport = mock
|
|
mock_response = { "error" => { "code" => -32_602, "message" => "Tool not found" } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(Client::ServerError) { client.call_tool(name: "missing") }
|
|
assert_equal(-32_602, error.code)
|
|
end
|
|
|
|
def test_server_error_includes_data_field
|
|
transport = mock
|
|
mock_response = {
|
|
"error" => { "code" => -32_603, "message" => "Internal error", "data" => "extra details" },
|
|
}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(Client::ServerError) { client.tools }
|
|
assert_equal("extra details", error.data)
|
|
end
|
|
|
|
def test_complete_raises_server_error_on_error_response
|
|
transport = mock
|
|
mock_response = { "error" => { "code" => -32_602, "message" => "Invalid params" } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(Client::ServerError) { client.complete(ref: { type: "ref/prompt", name: "missing" }, argument: { name: "arg", value: "" }) }
|
|
assert_equal(-32_602, error.code)
|
|
end
|
|
|
|
def test_complete_sends_request_and_returns_completion_result
|
|
transport = mock
|
|
mock_response = {
|
|
"result" => {
|
|
"completion" => {
|
|
"values" => ["python", "pytorch"],
|
|
"hasMore" => false,
|
|
},
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "completion/complete" &&
|
|
args.dig(:request, :jsonrpc) == "2.0" &&
|
|
args.dig(:request, :params, :ref) == { type: "ref/prompt", name: "code_review" } &&
|
|
args.dig(:request, :params, :argument) == { name: "language", value: "py" } &&
|
|
!args.dig(:request, :params).key?(:context)
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.complete(
|
|
ref: { type: "ref/prompt", name: "code_review" },
|
|
argument: { name: "language", value: "py" },
|
|
)
|
|
|
|
assert_equal(["python", "pytorch"], result["values"])
|
|
refute(result["hasMore"])
|
|
end
|
|
|
|
def test_complete_includes_context_when_provided
|
|
transport = mock
|
|
mock_response = {
|
|
"result" => {
|
|
"completion" => {
|
|
"values" => ["flask"],
|
|
"hasMore" => false,
|
|
},
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :params, :context) == { arguments: { language: "python" } }
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.complete(
|
|
ref: { type: "ref/prompt", name: "code_review" },
|
|
argument: { name: "framework", value: "fla" },
|
|
context: { arguments: { language: "python" } },
|
|
)
|
|
|
|
assert_equal(["flask"], result["values"])
|
|
end
|
|
|
|
def test_complete_returns_default_when_result_is_missing
|
|
transport = mock
|
|
mock_response = { "result" => {} }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.complete(
|
|
ref: { type: "ref/prompt", name: "test" },
|
|
argument: { name: "arg", value: "" },
|
|
)
|
|
|
|
assert_equal([], result["values"])
|
|
refute(result["hasMore"])
|
|
end
|
|
|
|
def test_ping_sends_request_and_returns_empty_hash
|
|
transport = mock
|
|
mock_response = { "result" => {} }
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
req = args[:request]
|
|
req[:method] == "ping" &&
|
|
req[:jsonrpc] == "2.0" &&
|
|
!req.key?(:params)
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.ping
|
|
|
|
assert_equal({}, result)
|
|
end
|
|
|
|
def test_ping_raises_server_error_on_error_response
|
|
transport = mock
|
|
mock_response = { "error" => { "code" => -32_603, "message" => "Internal error" } }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(Client::ServerError) { client.ping }
|
|
assert_equal(-32_603, error.code)
|
|
assert_equal("Internal error", error.message)
|
|
end
|
|
|
|
def test_ping_raises_validation_error_when_result_is_missing
|
|
transport = mock
|
|
mock_response = {}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(Client::ValidationError) { client.ping }
|
|
assert_equal("Response validation failed: missing or invalid `result`", error.message)
|
|
end
|
|
|
|
def test_ping_raises_validation_error_when_result_is_wrong_type
|
|
transport = mock
|
|
mock_response = { "result" => "ok" }
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(Client::ValidationError) { client.ping }
|
|
assert_equal("Response validation failed: missing or invalid `result`", error.message)
|
|
end
|
|
|
|
def test_ping_propagates_transport_errors
|
|
transport = mock
|
|
transport_error = StandardError.new("read timeout")
|
|
transport.expects(:send_request).raises(transport_error).once
|
|
|
|
client = Client.new(transport: transport)
|
|
error = assert_raises(StandardError) { client.ping }
|
|
assert_equal("read timeout", error.message)
|
|
end
|
|
|
|
def test_tools_auto_paginates_across_multiple_pages
|
|
transport = mock
|
|
|
|
page1_response = {
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool1", "description" => "tool1", "inputSchema" => {} }],
|
|
"nextCursor" => "cursor1",
|
|
},
|
|
}
|
|
page2_response = {
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool2", "description" => "tool2", "inputSchema" => {} }],
|
|
},
|
|
}
|
|
|
|
call_count = 0
|
|
transport.expects(:send_request).twice.with do |args|
|
|
call_count += 1
|
|
req = args[:request]
|
|
if call_count == 1
|
|
req[:method] == "tools/list" && req[:params].nil?
|
|
else
|
|
req[:method] == "tools/list" && req[:params] == { cursor: "cursor1" }
|
|
end
|
|
end.returns(page1_response).then.returns(page2_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
tools = client.tools
|
|
|
|
assert_equal(2, tools.size)
|
|
assert_equal("tool1", tools[0].name)
|
|
assert_equal("tool2", tools[1].name)
|
|
end
|
|
|
|
def test_list_tools_returns_single_page_with_cursor
|
|
transport = mock
|
|
|
|
mock_response = {
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool1", "description" => "tool1", "inputSchema" => {} }],
|
|
"nextCursor" => "cursor1",
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == "tools/list"
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.list_tools
|
|
|
|
assert_equal(1, result.tools.size)
|
|
assert_equal("tool1", result.tools[0].name)
|
|
assert_equal("cursor1", result.next_cursor)
|
|
end
|
|
|
|
def test_list_results_expose_ttl_ms_and_cache_scope
|
|
# SEP-2549 cache hints are surfaced on every paginated result struct.
|
|
[
|
|
["tools/list", "tools", :list_tools],
|
|
["prompts/list", "prompts", :list_prompts],
|
|
["resources/list", "resources", :list_resources],
|
|
["resources/templates/list", "resourceTemplates", :list_resource_templates],
|
|
].each do |method, items_key, client_method|
|
|
transport = mock
|
|
mock_response = {
|
|
"result" => { items_key => [], "ttlMs" => 5000, "cacheScope" => "private" },
|
|
}
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :method) == method
|
|
end.returns(mock_response).once
|
|
|
|
result = Client.new(transport: transport).public_send(client_method)
|
|
|
|
assert_equal(5000, result.ttl_ms, "#{method} missing ttl_ms")
|
|
assert_equal("private", result.cache_scope, "#{method} missing cache_scope")
|
|
end
|
|
end
|
|
|
|
def test_list_results_have_nil_cache_hints_when_server_omits_them
|
|
transport = mock
|
|
mock_response = { "result" => { "tools" => [] } }
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
result = Client.new(transport: transport).list_tools
|
|
|
|
assert_nil(result.ttl_ms)
|
|
assert_nil(result.cache_scope)
|
|
end
|
|
|
|
def test_list_tools_with_cursor_param
|
|
transport = mock
|
|
|
|
mock_response = {
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool2", "description" => "tool2", "inputSchema" => {} }],
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).with do |args|
|
|
args.dig(:request, :params) == { cursor: "cursor1" }
|
|
end.returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.list_tools(cursor: "cursor1")
|
|
|
|
assert_equal(1, result.tools.size)
|
|
assert_equal("tool2", result.tools[0].name)
|
|
assert_nil(result.next_cursor)
|
|
end
|
|
|
|
def test_resources_auto_paginates_across_multiple_pages
|
|
transport = mock
|
|
|
|
page1_response = {
|
|
"result" => {
|
|
"resources" => [{ "uri" => "https://a.invalid", "name" => "a" }],
|
|
"nextCursor" => "cursor1",
|
|
},
|
|
}
|
|
page2_response = {
|
|
"result" => {
|
|
"resources" => [{ "uri" => "https://b.invalid", "name" => "b" }],
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).twice.returns(page1_response).then.returns(page2_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
resources = client.resources
|
|
|
|
assert_equal(2, resources.size)
|
|
assert_equal("a", resources[0]["name"])
|
|
assert_equal("b", resources[1]["name"])
|
|
end
|
|
|
|
def test_list_resources_returns_single_page_with_cursor
|
|
transport = mock
|
|
|
|
mock_response = {
|
|
"result" => {
|
|
"resources" => [{ "uri" => "https://a.invalid", "name" => "a" }],
|
|
"nextCursor" => "cursor1",
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.list_resources
|
|
|
|
assert_equal(1, result.resources.size)
|
|
assert_equal("cursor1", result.next_cursor)
|
|
end
|
|
|
|
def test_resource_templates_auto_paginates_across_multiple_pages
|
|
transport = mock
|
|
|
|
page1_response = {
|
|
"result" => {
|
|
"resourceTemplates" => [{ "uriTemplate" => "https://a.invalid/{id}", "name" => "a" }],
|
|
"nextCursor" => "cursor1",
|
|
},
|
|
}
|
|
page2_response = {
|
|
"result" => {
|
|
"resourceTemplates" => [{ "uriTemplate" => "https://b.invalid/{id}", "name" => "b" }],
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).twice.returns(page1_response).then.returns(page2_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
templates = client.resource_templates
|
|
|
|
assert_equal(2, templates.size)
|
|
assert_equal("a", templates[0]["name"])
|
|
assert_equal("b", templates[1]["name"])
|
|
end
|
|
|
|
def test_list_resource_templates_returns_single_page_with_cursor
|
|
transport = mock
|
|
|
|
mock_response = {
|
|
"result" => {
|
|
"resourceTemplates" => [{ "uriTemplate" => "https://a.invalid/{id}", "name" => "a" }],
|
|
"nextCursor" => "cursor1",
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.list_resource_templates
|
|
|
|
assert_equal(1, result.resource_templates.size)
|
|
assert_equal("cursor1", result.next_cursor)
|
|
end
|
|
|
|
def test_prompts_auto_paginates_across_multiple_pages
|
|
transport = mock
|
|
|
|
page1_response = {
|
|
"result" => {
|
|
"prompts" => [{ "name" => "prompt_a", "description" => "A" }],
|
|
"nextCursor" => "cursor1",
|
|
},
|
|
}
|
|
page2_response = {
|
|
"result" => {
|
|
"prompts" => [{ "name" => "prompt_b", "description" => "B" }],
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).twice.returns(page1_response).then.returns(page2_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
prompts = client.prompts
|
|
|
|
assert_equal(2, prompts.size)
|
|
assert_equal("prompt_a", prompts[0]["name"])
|
|
assert_equal("prompt_b", prompts[1]["name"])
|
|
end
|
|
|
|
def test_tools_breaks_when_server_returns_same_cursor_repeatedly
|
|
transport = mock
|
|
|
|
stuck_response = {
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool1", "description" => "tool1", "inputSchema" => {} }],
|
|
"nextCursor" => "stuck_cursor",
|
|
},
|
|
}
|
|
|
|
# If the server keeps returning the same cursor, the client must not loop forever.
|
|
# Expect at most 2 calls: the initial request (cursor=nil) and one retry (cursor="stuck_cursor")
|
|
# that detects the repeat and breaks out.
|
|
transport.expects(:send_request).twice.returns(stuck_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
tools = client.tools
|
|
|
|
assert_equal(2, tools.size)
|
|
end
|
|
|
|
def test_tools_raises_when_the_server_offers_more_pages_than_max_pages
|
|
transport = mock
|
|
|
|
pages = (1..3).map do |n|
|
|
{
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool#{n}", "description" => "tool#{n}", "inputSchema" => {} }],
|
|
"nextCursor" => "cursor#{n}",
|
|
},
|
|
}
|
|
end
|
|
|
|
# A fresh cursor on every response defeats the repeat guard, so only `max_pages` stops the walk.
|
|
transport.expects(:send_request).times(3).returns(*pages)
|
|
|
|
client = Client.new(transport: transport, max_pages: 3)
|
|
|
|
error = assert_raises(Client::PaginationLimitError) { client.tools }
|
|
assert_equal(
|
|
"Server returned more than 3 pages; pass a larger `max_pages:` to `MCP::Client.new` if this is expected.",
|
|
error.message,
|
|
)
|
|
end
|
|
|
|
def test_tools_returns_every_page_when_the_server_stops_exactly_at_max_pages
|
|
transport = mock
|
|
|
|
page1 = {
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool1", "description" => "tool1", "inputSchema" => {} }],
|
|
"nextCursor" => "cursor1",
|
|
},
|
|
}
|
|
page2 = {
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool2", "description" => "tool2", "inputSchema" => {} }],
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).twice.returns(page1, page2)
|
|
|
|
client = Client.new(transport: transport, max_pages: 2)
|
|
tools = client.tools
|
|
|
|
assert_equal(["tool1", "tool2"], tools.map(&:name))
|
|
end
|
|
|
|
def test_raises_argument_error_when_max_pages_is_not_positive
|
|
error = assert_raises(ArgumentError) { Client.new(transport: mock, max_pages: 0) }
|
|
|
|
assert_equal("max_pages must be a positive Integer", error.message)
|
|
end
|
|
|
|
def test_tools_breaks_when_server_cycles_between_cursors
|
|
transport = mock
|
|
|
|
page_a = {
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool1", "description" => "tool1", "inputSchema" => {} }],
|
|
"nextCursor" => "A",
|
|
},
|
|
}
|
|
page_b = {
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool2", "description" => "tool2", "inputSchema" => {} }],
|
|
"nextCursor" => "B",
|
|
},
|
|
}
|
|
# Server cycles A -> B -> A. Client must detect the revisited cursor and break.
|
|
page_a_again = {
|
|
"result" => {
|
|
"tools" => [{ "name" => "tool3", "description" => "tool3", "inputSchema" => {} }],
|
|
"nextCursor" => "A",
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).times(3).returns(page_a, page_b, page_a_again)
|
|
|
|
client = Client.new(transport: transport)
|
|
tools = client.tools
|
|
|
|
assert_equal(3, tools.size)
|
|
assert_equal(["tool1", "tool2", "tool3"], tools.map(&:name))
|
|
end
|
|
|
|
def test_resources_breaks_when_server_returns_same_cursor_repeatedly
|
|
transport = mock
|
|
|
|
stuck_response = {
|
|
"result" => {
|
|
"resources" => [{ "uri" => "https://a.invalid", "name" => "a" }],
|
|
"nextCursor" => "stuck_cursor",
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).twice.returns(stuck_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
resources = client.resources
|
|
|
|
assert_equal(2, resources.size)
|
|
end
|
|
|
|
def test_resource_templates_breaks_when_server_returns_same_cursor_repeatedly
|
|
transport = mock
|
|
|
|
stuck_response = {
|
|
"result" => {
|
|
"resourceTemplates" => [{ "uriTemplate" => "https://a.invalid/{id}", "name" => "a" }],
|
|
"nextCursor" => "stuck_cursor",
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).twice.returns(stuck_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
templates = client.resource_templates
|
|
|
|
assert_equal(2, templates.size)
|
|
end
|
|
|
|
def test_prompts_breaks_when_server_returns_same_cursor_repeatedly
|
|
transport = mock
|
|
|
|
stuck_response = {
|
|
"result" => {
|
|
"prompts" => [{ "name" => "prompt_a", "description" => "A" }],
|
|
"nextCursor" => "stuck_cursor",
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).twice.returns(stuck_response)
|
|
|
|
client = Client.new(transport: transport)
|
|
prompts = client.prompts
|
|
|
|
assert_equal(2, prompts.size)
|
|
end
|
|
|
|
def test_list_prompts_returns_single_page_with_cursor
|
|
transport = mock
|
|
|
|
mock_response = {
|
|
"result" => {
|
|
"prompts" => [{ "name" => "prompt_a", "description" => "A" }],
|
|
"nextCursor" => "cursor1",
|
|
},
|
|
}
|
|
|
|
transport.expects(:send_request).returns(mock_response).once
|
|
|
|
client = Client.new(transport: transport)
|
|
result = client.list_prompts
|
|
|
|
assert_equal(1, result.prompts.size)
|
|
assert_equal("cursor1", result.next_cursor)
|
|
end
|
|
|
|
def test_cancellation_without_reason_omits_reason_in_notification
|
|
# The token-driven cancel path must omit `reason` from the `notifications/cancelled` params
|
|
# when the token is cancelled without one.
|
|
sent = Queue.new
|
|
cancellation = MCP::Cancellation.new
|
|
|
|
transport = Object.new
|
|
transport.define_singleton_method(:send_request) do |**|
|
|
cancellation.cancel # no reason
|
|
{ "result" => {} }
|
|
end
|
|
transport.define_singleton_method(:send_notification) do |notification:|
|
|
sent.push(notification)
|
|
nil
|
|
end
|
|
|
|
client = Client.new(transport: transport)
|
|
|
|
assert_raises(MCP::CancelledError) do
|
|
client.call_tool(name: "slow", arguments: {}, cancellation: cancellation)
|
|
end
|
|
|
|
notification = sent.pop
|
|
assert_equal(Methods::NOTIFICATIONS_CANCELLED, notification[:method])
|
|
refute(notification[:params].key?(:reason))
|
|
end
|
|
|
|
def test_call_tool_with_cancellation_returns_response_when_no_cancel
|
|
transport = mock
|
|
transport.expects(:send_request).returns({ "result" => { "content" => [{ "type" => "text", "text" => "ok" }] } }).once
|
|
transport.stubs(:send_notification) # required for `cancellation:` capability check
|
|
|
|
cancellation = MCP::Cancellation.new
|
|
client = Client.new(transport: transport)
|
|
|
|
response = client.call_tool(name: "noop", arguments: {}, cancellation: cancellation)
|
|
|
|
assert_equal("ok", response.dig("result", "content", 0, "text"))
|
|
end
|
|
|
|
def test_call_tool_with_cancellation_already_cancelled_raises_without_sending
|
|
transport = mock
|
|
transport.expects(:send_request).never
|
|
transport.expects(:send_notification).never
|
|
|
|
cancellation = MCP::Cancellation.new
|
|
cancellation.cancel(reason: "pre-cancelled")
|
|
|
|
client = Client.new(transport: transport)
|
|
|
|
assert_raises(MCP::CancelledError) do
|
|
client.call_tool(name: "noop", arguments: {}, cancellation: cancellation)
|
|
end
|
|
end
|
|
|
|
def test_call_tool_with_cancellation_mid_flight_raises_and_sends_notification
|
|
cancellation = MCP::Cancellation.new
|
|
notification_queue = Queue.new
|
|
|
|
transport = Object.new
|
|
transport.define_singleton_method(:send_request) do |**|
|
|
# Cancel while the request is "in flight".
|
|
cancellation.cancel(reason: "user abort")
|
|
sleep(0.05)
|
|
{ "result" => {} }
|
|
end
|
|
transport.define_singleton_method(:send_notification) do |notification:|
|
|
notification_queue.push(notification)
|
|
nil
|
|
end
|
|
|
|
client = Client.new(transport: transport)
|
|
|
|
error = assert_raises(MCP::CancelledError) do
|
|
client.call_tool(name: "slow", arguments: {}, cancellation: cancellation)
|
|
end
|
|
|
|
assert_equal("user abort", error.reason)
|
|
|
|
# Cancel notification is dispatched fire-and-forget on a separate thread;
|
|
# block here until it reaches the transport.
|
|
notification = notification_queue.pop
|
|
assert_equal(Methods::NOTIFICATIONS_CANCELLED, notification[:method])
|
|
assert_equal("user abort", notification[:params][:reason])
|
|
end
|
|
|
|
def test_loop_methods_accept_cancellation_keyword
|
|
# Regression: `tools` / `resources` / `resource_templates` / `prompts` are the high-level pagination loops.
|
|
# They must accept `cancellation:` so the README's "all request methods accept the cancellation: keyword"
|
|
# claim holds. The token is propagated to each underlying `list_*` page.
|
|
cancellation = MCP::Cancellation.new
|
|
|
|
transport = mock
|
|
transport.stubs(:send_request).returns({ "result" => { "tools" => [] } })
|
|
transport.stubs(:send_notification) # required for `cancellation:` capability check
|
|
|
|
client = Client.new(transport: transport)
|
|
|
|
[
|
|
-> { client.tools(cancellation: cancellation) },
|
|
-> { client.resources(cancellation: cancellation) },
|
|
-> { client.resource_templates(cancellation: cancellation) },
|
|
-> { client.prompts(cancellation: cancellation) },
|
|
].each do |loop_call|
|
|
transport.stubs(:send_request).returns({ "result" => {} })
|
|
loop_call.call
|
|
end
|
|
end
|
|
|
|
def test_cancel_callback_does_not_deadlock_when_transport_holds_a_mutex
|
|
# Regression: when the cancellation callback fires on the same thread that is currently inside
|
|
# `transport.send_request` (and therefore holds a transport-level mutex), a synchronous `send_notification`
|
|
# from the callback would deadlock by re-entering the same mutex. The fix wakes the calling thread first
|
|
# and dispatches the notification on a separate thread.
|
|
transport_mutex = Mutex.new
|
|
cancellation = MCP::Cancellation.new
|
|
|
|
# Custom transport class so we can model a mutex held during send_request.
|
|
transport = Object.new
|
|
transport.define_singleton_method(:send_request) do |**|
|
|
transport_mutex.synchronize do
|
|
# Trigger cancel while we hold the mutex. The callback must NOT try to synchronously acquire
|
|
# the same mutex via send_notification.
|
|
cancellation.cancel(reason: "mid-flight")
|
|
# Hold the mutex briefly to give the callback time to (incorrectly) try to re-enter.
|
|
sleep(0.05)
|
|
{ "result" => {} }
|
|
end
|
|
end
|
|
|
|
# send_notification also needs the mutex - this is the path that would deadlock under synchronous dispatch.
|
|
send_notification_called = Queue.new
|
|
transport.define_singleton_method(:send_notification) do |notification:|
|
|
transport_mutex.synchronize do
|
|
send_notification_called.push(notification)
|
|
end
|
|
end
|
|
|
|
client = Client.new(transport: transport)
|
|
|
|
assert_raises(MCP::CancelledError) do
|
|
client.call_tool(name: "noop", arguments: {}, cancellation: cancellation)
|
|
end
|
|
|
|
# The notification must reach the transport eventually (after the mutex is released by the now-finished send_request).
|
|
notification = send_notification_called.pop
|
|
assert_equal(Methods::NOTIFICATIONS_CANCELLED, notification[:method])
|
|
assert_equal("mid-flight", notification[:params][:reason])
|
|
end
|
|
|
|
def test_late_cancel_after_response_does_not_send_stray_notification
|
|
# Regression: between the worker thread pushing `:response` and the main thread leaving `dispatch_with_cancellation`,
|
|
# a cancellation firing in that gap must not emit a stray `notifications/cancelled` for the already-completed request.
|
|
# The completion-mutex gate makes the worker and the on_cancel callback fight for a single slot; whichever sets
|
|
# `completed` first wins, the loser bails.
|
|
cancellation = MCP::Cancellation.new
|
|
notification_count = 0
|
|
notification_count_mutex = Mutex.new
|
|
|
|
transport = Object.new
|
|
transport.define_singleton_method(:send_request) do |**, &on_sent|
|
|
on_sent&.call
|
|
{ "result" => {} }
|
|
end
|
|
transport.define_singleton_method(:send_notification) do |**|
|
|
notification_count_mutex.synchronize { notification_count += 1 }
|
|
nil
|
|
end
|
|
|
|
client = Client.new(transport: transport)
|
|
response = client.call_tool(name: "noop", arguments: {}, cancellation: cancellation)
|
|
|
|
assert_equal({}, response["result"])
|
|
|
|
# Cancel after the call returned. The on_cancel hook was deregistered in the `ensure` block;
|
|
# even if a callback raced with the response handoff, `completed` would already be true and
|
|
# `queue.push :cancelled` plus the cancel-dispatch thread would not run.
|
|
cancellation.cancel(reason: "late")
|
|
|
|
sleep(0.05) # let any erroneous cancel-dispatch thread complete.
|
|
|
|
count = notification_count_mutex.synchronize { notification_count }
|
|
assert_equal(0, count, "no stray notifications/cancelled for an already-completed request")
|
|
end
|
|
|
|
def test_call_tool_with_cancellation_raises_NoMethodError_when_transport_lacks_send_notification
|
|
# Regression: a transport that only implements `send_request` cannot deliver `notifications/cancelled`.
|
|
# We must surface this upfront with a clear `NoMethodError` rather than silently swallow
|
|
# the failure inside the cancel-dispatch thread - otherwise the user sees `CancelledError` but
|
|
# the server never receives the notification.
|
|
transport = Object.new
|
|
transport.define_singleton_method(:send_request) do |**|
|
|
{ "result" => {} }
|
|
end
|
|
# NOTE: no send_notification.
|
|
|
|
cancellation = MCP::Cancellation.new
|
|
client = Client.new(transport: transport)
|
|
|
|
error = assert_raises(NoMethodError) do
|
|
client.call_tool(name: "noop", arguments: {}, cancellation: cancellation)
|
|
end
|
|
|
|
assert_match(/send_notification/, error.message)
|
|
end
|
|
|
|
def test_cancel_notification_is_dispatched_after_request_write_via_on_sent_block
|
|
# Regression for the wire-order race: a transport that yields from `send_request` after writing
|
|
# the request must see `:request` recorded before `:cancel` even when the cancel signal arrives concurrently.
|
|
recorded = []
|
|
recorded_mutex = Mutex.new
|
|
cancellation = MCP::Cancellation.new
|
|
cancel_complete = Queue.new
|
|
|
|
transport = Object.new
|
|
transport.define_singleton_method(:send_request) do |request:, &on_sent|
|
|
# Trigger cancel BEFORE the simulated wire-write so the cancel-dispatch thread starts racing immediately.
|
|
# The `on_sent` block is yielded only after we have recorded the request - so any cancel-write that obeys
|
|
# the block must land afterwards.
|
|
cancellation.cancel(reason: "race")
|
|
sleep(0.02) # give cancel-dispatch thread time to spawn and start waiting
|
|
recorded_mutex.synchronize { recorded << [:request, request[:id]] }
|
|
on_sent&.call
|
|
{ "result" => {} }
|
|
end
|
|
transport.define_singleton_method(:send_notification) do |notification:|
|
|
recorded_mutex.synchronize { recorded << [:cancel, notification[:params][:requestId]] }
|
|
cancel_complete.push(:done)
|
|
nil
|
|
end
|
|
|
|
client = Client.new(transport: transport)
|
|
client.stubs(:generate_request_id).returns("req-A")
|
|
|
|
assert_raises(MCP::CancelledError) do
|
|
client.call_tool(name: "slow", arguments: {}, cancellation: cancellation)
|
|
end
|
|
|
|
cancel_complete.pop # wait for the fire-and-forget cancel dispatch
|
|
|
|
# Wire-order must be: request first, then cancel.
|
|
assert_equal([[:request, "req-A"], [:cancel, "req-A"]], recorded)
|
|
end
|
|
|
|
def test_cancel_notification_waits_for_delayed_on_sent_signal
|
|
# Regression: the cancel-dispatch thread must wait for `&on_sent` no matter how long it takes -
|
|
# it cannot fall back to wall-clock-based timeout. An earlier 100 ms fixed-duration fallback
|
|
# could release the cancel thread before the worker reached its send-boundary at all, allowing
|
|
# the cancel to be issued without any prior request commitment - which the spec only covers under
|
|
# the receiver's MAY-ignore-unknown-id clause. The wait is now bounded by worker termination
|
|
# (via `ensure -> signal_sent.call`), not by elapsed time.
|
|
recorded = []
|
|
recorded_mutex = Mutex.new
|
|
cancellation = MCP::Cancellation.new
|
|
cancel_complete = Queue.new
|
|
|
|
transport = Object.new
|
|
transport.define_singleton_method(:send_request) do |request:, &on_sent|
|
|
cancellation.cancel(reason: "race")
|
|
# Delay well beyond any plausible fixed-duration fallback (200 ms).
|
|
# If cancel-dispatch fires on a timer rather than waiting for on_sent,
|
|
# the recorded order will be [:cancel, :request] and the assertion below will fail.
|
|
sleep(0.2)
|
|
recorded_mutex.synchronize { recorded << [:request, request[:id]] }
|
|
on_sent&.call
|
|
{ "result" => {} }
|
|
end
|
|
transport.define_singleton_method(:send_notification) do |notification:|
|
|
recorded_mutex.synchronize { recorded << [:cancel, notification[:params][:requestId]] }
|
|
cancel_complete.push(:done)
|
|
nil
|
|
end
|
|
|
|
client = Client.new(transport: transport)
|
|
client.stubs(:generate_request_id).returns("req-D")
|
|
|
|
assert_raises(MCP::CancelledError) do
|
|
client.call_tool(name: "slow", arguments: {}, cancellation: cancellation)
|
|
end
|
|
|
|
cancel_complete.pop
|
|
|
|
assert_equal([[:request, "req-D"], [:cancel, "req-D"]], recorded)
|
|
end
|
|
|
|
def test_cancel_notification_dispatches_when_worker_raises_before_on_sent
|
|
# Regression: if the worker raises before `&on_sent` is called - which can happen if a transport rejects
|
|
# a malformed request synchronously - the cancel-dispatch thread must still terminate AND deliver the notification.
|
|
# The worker's `ensure` block invokes `signal_sent.call`, which broadcasts to the condition variable and unblocks
|
|
# the `until request_sent` wait. Without the ensure-driven unblock, the dispatch thread would leak.
|
|
cancellation = MCP::Cancellation.new
|
|
send_notification_called = Queue.new
|
|
|
|
transport = Object.new
|
|
transport.define_singleton_method(:send_request) do |**|
|
|
# Trigger cancel before raising so the cancel hook fires while the worker is mid-flight,
|
|
# then bail out without ever calling on_sent.
|
|
cancellation.cancel(reason: "race")
|
|
raise StandardError, "transport boom"
|
|
end
|
|
transport.define_singleton_method(:send_notification) do |notification:|
|
|
send_notification_called.push(notification)
|
|
nil
|
|
end
|
|
|
|
client = Client.new(transport: transport)
|
|
client.stubs(:generate_request_id).returns("req-E")
|
|
|
|
assert_raises(MCP::CancelledError) do
|
|
client.call_tool(name: "slow", arguments: {}, cancellation: cancellation)
|
|
end
|
|
|
|
# The cancel-dispatch thread should still send the notification because the worker's `ensure` triggers `signal_sent.call`.
|
|
notification = send_notification_called.pop
|
|
assert_equal("req-E", notification[:params][:requestId])
|
|
end
|
|
|
|
def test_call_tool_with_cancellation_normal_completion_does_not_send_notification
|
|
transport = mock
|
|
transport.expects(:send_request).returns({ "result" => {} }).once
|
|
transport.expects(:send_notification).never
|
|
|
|
cancellation = MCP::Cancellation.new
|
|
client = Client.new(transport: transport)
|
|
|
|
client.call_tool(name: "noop", arguments: {}, cancellation: cancellation)
|
|
|
|
# Late cancel after normal completion: hook should already be deregistered.
|
|
cancellation.cancel(reason: "late")
|
|
end
|
|
end
|
|
end
|