diff --git a/docs/advanced/low-level-server.md b/docs/advanced/low-level-server.md index 859e82fb78..21e47554ea 100644 --- a/docs/advanced/low-level-server.md +++ b/docs/advanced/low-level-server.md @@ -115,7 +115,7 @@ Call it and the result carries both representations: The `_meta` block is the server's identity stamp: the SDK adds it to every 2026-era result, with the `version` from the constructor (a server that sets none reports an empty string). A server that must not identify itself can strip the key with a middleware, which owns the results it returns. -The server never compares the two fields. This SDK's `Client` does: return `structured_content` that doesn't satisfy the `output_schema` you declared and `call_tool` raises a `RuntimeError` that starts with `Invalid structured content returned by tool search_books` and goes on to quote the `jsonschema` failure. Promising a schema is cheap; keeping it is on you. The whole ladder of return types and schemas is in **[Structured Output](../servers/structured-output.md)**. +The server never compares the two fields, and neither does this SDK's `Client`: `call_tool` hands back `structured_content` exactly as the server sent it. Promising a schema is cheap; keeping it is on you. The whole ladder of return types and schemas is in **[Structured Output](../servers/structured-output.md)**. ## The dialect is JSON Schema 2020-12 @@ -126,7 +126,7 @@ The server never compares the two fields. This SDK's `Client` does: return `stru ``` * The root of `input_schema` must be `"type": "object"`. Beside it, `oneOf`, `additionalProperties`, `anyOf`, `if`/`then`/`else`, `prefixItems`, `$defs` with local `$ref`s and the rest of the 2020-12 keywords reach the client exactly as written. -* No `$schema` key is needed. Add one only to opt into an older draft: this SDK's `Client`, which validates `structured_content` against a tool's `output_schema`, picks its validator from `$schema` and uses 2020-12 when there is none. +* No `$schema` key is needed. Add one only to opt into an older draft. ## `_meta`: for the application, not the model diff --git a/docs/client/index.md b/docs/client/index.md index c4c392bf5c..d44e1bce9c 100644 --- a/docs/client/index.md +++ b/docs/client/index.md @@ -114,7 +114,22 @@ That is why `main` narrows with `isinstance(block, TextContent)` before touching ### `structured_content`: what your application reads -`structured_content` is the tool's return value as JSON, matching the tool's declared `output_schema`. No string parsing, no guessing. +`structured_content` is the tool's return value as JSON, shaped by the tool's declared `output_schema`. No string parsing, no guessing. + +The client hands it to you exactly as the server sent it; it does not check it against the `output_schema`. The server writes both, so only a model you own says what your code can rely on: + +```python +from pydantic import BaseModel + + +class Book(BaseModel): + title: str + author: str + year: int + + +book = Book.model_validate(result.structured_content) +``` When both are present they say the same thing twice on purpose: `content` is for a model, `structured_content` is for code. Where the structured half comes from, and how to control it, is the **[Structured Output](../servers/structured-output.md)** page. diff --git a/docs/deprecated.md b/docs/deprecated.md index f48f07ac11..a0eae24ac8 100644 --- a/docs/deprecated.md +++ b/docs/deprecated.md @@ -135,6 +135,7 @@ These are not spec changes, only SDK usage with a better replacement. They warn | Deprecated | What you do instead | |---|---| +| `ClientSession.validate_tool_result()` | Nothing: it no longer does anything. Validate `result.structured_content` against a model you own, such as `Book.model_validate(result.structured_content)` (see **[Clients](client/index.md#structured_content-what-your-application-reads)**). | | `FuncMetadata.call_fn_with_arg_validation()` | `FuncMetadata.validate_arguments()` and then `FuncMetadata.call_fn()`. Only code that drives `FuncMetadata` directly (a custom `Tool` subclass, say) ever called it. | | `AuthSettings(resource_server_url=...)` without `validate_token_resource=` | Set it: `True` has the server refuse bearer tokens your verifier does not report as issued for `resource_server_url`, `False` says your verifier checks the token's audience itself (see **[Authorization](run/authorization.md#a-token-verifier)**). Unset behaves as `False`; 3.0 makes `True` the default whenever `resource_server_url` is set. | | `ClientCredentialsOAuthProvider(...)` or `PrivateKeyJWTOAuthProvider(...)` without `issuer=` | Pass `issuer=` naming the authorization server that issued the credentials (see **[Writing OAuth clients](client/oauth-clients.md#machine-to-machine)**). Without it the MCP server decides which authorization server receives them; 3.0 makes the keyword required. | diff --git a/docs/get-started/installation.md b/docs/get-started/installation.md index 4c3668cf68..b9bb617bd0 100644 --- a/docs/get-started/installation.md +++ b/docs/get-started/installation.md @@ -30,7 +30,6 @@ You don't need to know any of this to use the SDK, but if you're wondering what * [`pydantic`](https://docs.pydantic.dev/): what every `mcp.types` model is built on, plus all schema generation and validation. * [`httpx2`](https://pypi.org/project/httpx2/): the HTTP client behind the Streamable HTTP and SSE *client* transports, with server-sent events support built in. * [`starlette`](https://www.starlette.io/), [`uvicorn`](https://www.uvicorn.org/), [`sse-starlette`](https://pypi.org/project/sse-starlette/), and [`python-multipart`](https://pypi.org/project/python-multipart/): the HTTP *server* transports. -* [`jsonschema`](https://pypi.org/project/jsonschema/): validates a tool's structured output against its declared output schema. * [`pyjwt[crypto]`](https://pyjwt.readthedocs.io/): OAuth token handling for authorization. * [`opentelemetry-api`](https://opentelemetry-python.readthedocs.io/): just the lightweight API, so the SDK's tracing middleware costs nothing unless you install an OpenTelemetry SDK and exporter yourself. * [`typing-extensions`](https://typing-extensions.readthedocs.io/) and [`typing-inspection`](https://pypi.org/project/typing-inspection/): modern typing features on Python 3.11. diff --git a/pyproject.toml b/pyproject.toml index 6d7626d79b..aad4a028bf 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -141,7 +141,6 @@ dependencies = [ "python-multipart>=0.0.9", "sse-starlette>=3.0.0", "uvicorn>=0.31.1; sys_platform != 'emscripten'", - "jsonschema>=4.20.0", "pywin32>=312; sys_platform == 'win32' and python_version >= '3.15'", "pywin32>=311; sys_platform == 'win32' and python_version < '3.15'", "pyjwt[crypto]>=2.10.1", diff --git a/src/mcp/client/client.py b/src/mcp/client/client.py index 099dcbb874..e0103bdec0 100644 --- a/src/mcp/client/client.py +++ b/src/mcp/client/client.py @@ -857,14 +857,10 @@ async def retry(r: InputResponses | None, s: str | None) -> CallToolResult | Inp return result # Only claimed shapes reach this point, so the lookup is total. claim = self._folded_extensions.by_model[type(result)] - final = await claim.resolve( + return await claim.resolve( result, ClaimContext(session=self.session, tool_name=name, read_timeout_seconds=read_timeout_seconds), ) - if not final.is_error: - # Match the direct path: revalidate the output schema, but never for isError results. - await self.session.validate_tool_result(name, final) - return final async def list_prompts( self, diff --git a/src/mcp/client/session.py b/src/mcp/client/session.py index 35cae2d314..12e531b3b5 100644 --- a/src/mcp/client/session.py +++ b/src/mcp/client/session.py @@ -1,13 +1,12 @@ from __future__ import annotations -import json import logging from collections.abc import Callable, Mapping, Sequence from dataclasses import dataclass from functools import cache, reduce from operator import or_ from types import TracebackType, UnionType -from typing import TYPE_CHECKING, Annotated, Any, Final, Literal, Protocol, Self, TypeAlias, cast, get_args, overload +from typing import Annotated, Any, Final, Literal, Protocol, Self, TypeAlias, cast, get_args, overload import anyio import anyio.abc @@ -59,11 +58,6 @@ from mcp.shared.subscriptions import SUBSCRIPTION_ID_META_KEY, event_from_wire from mcp.shared.transport_context import TransportContext -if TYPE_CHECKING: - # `jsonschema` is imported lazily inside `validate_tool_result`: pulling it (and its - # `attrs`/`referencing` tree) in at module scope costs every client that never validates. - from jsonschema.protocols import Validator - DEFAULT_CLIENT_INFO = types.Implementation(name="mcp", version="0.1.0") DISCOVER_TIMEOUT_SECONDS = 10.0 _NOTIFICATION_QUEUE_SIZE: Final = 256 @@ -110,17 +104,6 @@ def _later_revision_fields(method: str, version: str) -> frozenset[str]: return frozenset(later) - _wire_fields(current) -def _same_schema(a: dict[str, Any] | None, b: dict[str, Any] | None) -> bool: - """JSON equality for two output schemas. - - Python `==` is not JSON equality: it conflates `True`/`1` and `False`/`0`, which JSON - Schema keeps distinct (`const: true` vs `const: 1`). Canonical serialization compares as - JSON does; where it is stricter (`1` vs `1.0`), erring toward "changed" only costs a - recompile, never a stale validator. - """ - return json.dumps(a, sort_keys=True) == json.dumps(b, sort_keys=True) - - def _preconnect_stamp(data: dict[str, Any], opts: CallOptions) -> None: # initialize/discover forbid cancellation; other pre-handshake requests (lowlevel # ClientSession callers may skip the handshake entirely) keep the courtesy cancel. @@ -437,10 +420,8 @@ def __init__( self._logging_callback = logging_callback or _default_logging_callback self._log_level: types.LoggingLevel | None = log_level self._message_handler = message_handler or _default_message_handler + # Unused here; downstream clients such as FastMCP read it to build typed tool results. self._tool_output_schemas: dict[str, dict[str, Any] | None] = {} - # Compiled output-schema validators, derived from `_tool_output_schemas` and owned by - # `_absorb_tool_listing`, which evicts a tool's entry whenever its schema changes. - self._tool_output_validators: dict[str, Validator] = {} self._x_mcp_header_maps: dict[str, dict[tuple[str, ...], str]] = {} self._initialize_result: types.InitializeResult | None = None self._discover_result: types.DiscoverResult | None = None @@ -1098,9 +1079,6 @@ async def call_tool( progress_callback=progress_callback, ) - if isinstance(result, types.CallToolResult) and not result.is_error: - await self.validate_tool_result(name, result) - # The input_required arm stays first; a claimed shape is terminal for the multi-round-trip driver. if isinstance(result, types.InputRequiredResult) and not allow_input_required: raise _input_required_unexpected("call_tool") @@ -1115,72 +1093,13 @@ def _resolve_param_headers(self, name: str, arguments: Mapping[str, Any]) -> dic return {} return mcp_param_headers(header_map, arguments) + @deprecated( + "The client no longer validates tool results against the server's output schema; " + "validate `structured_content` against your own model instead.", + category=MCPDeprecationWarning, + ) async def validate_tool_result(self, name: str, result: types.CallToolResult) -> None: - """Revalidate a `CallToolResult` against the tool's declared output schema. - - Raises: - RuntimeError: Structured content is missing or does not conform to the schema, or the - schema is invalid or has a `$ref` that does not resolve within the schema document. - """ - if name not in self._tool_output_schemas: - # refresh output schema cache - await self.list_tools() - - output_schema = None - if name in self._tool_output_schemas: - output_schema = self._tool_output_schemas.get(name) - else: - logger.warning(f"Tool {name} not listed by server, cannot validate any structured content") - - if output_schema is not None: - from jsonschema import exceptions as jsonschema_exceptions - from referencing.exceptions import Unresolvable - - if result.structured_content is None and "structured_content" not in result.model_fields_set: - raise RuntimeError(f"Tool {name} has an output schema but did not return structured content") - validator = self._output_schema_validator(name, output_schema) - # `best_match` picks the same error the previous `jsonschema.validate()` call raised, - # so the message a caller sees is unchanged. It is untyped upstream. - errors = validator.iter_errors(result.structured_content) - try: - error = cast( - "Exception | None", - jsonschema_exceptions.best_match(errors), # pyright: ignore[reportUnknownMemberType] - ) - except Unresolvable as e: - # A `$ref` did not resolve within the schema document. - raise RuntimeError(f"Invalid schema for tool {name}: {e}") from e - if error is not None: - raise RuntimeError(f"Invalid structured content returned by tool {name}: {error}") from error - - def _output_schema_validator(self, name: str, output_schema: dict[str, Any]) -> Validator: - """Compiled validator for the tool's cached output schema, built once per schema value. - - Compiling is ~60x the cost of validating, so a one-shot `jsonschema.validate()` per - result dominates `call_tool`; the compiled validator is cached instead. It stays valid - because `_absorb_tool_listing` evicts a tool's validator whenever it absorbs a different - schema for that tool, so a cached entry always matches `output_schema`. - - Raises: - RuntimeError: The schema is not a valid JSON Schema. Raised on every call, since a - failed compile is never cached. - """ - from jsonschema import SchemaError - from jsonschema.validators import validator_for - from referencing import Registry - - if (validator := self._tool_output_validators.get(name)) is not None: - return validator - - validator_cls = validator_for(output_schema) - try: - validator_cls.check_schema(output_schema) - except SchemaError as e: - raise RuntimeError(f"Invalid schema for tool {name}: {e}") - # An explicit empty registry: `$ref`s resolve within the schema document and the bundled metaschemas. - validator = validator_cls(output_schema, registry=Registry()) - self._tool_output_validators[name] = validator - return validator + """Does nothing. The client no longer validates tool results against the server's output schema.""" async def list_prompts(self, *, params: types.PaginatedRequestParams | None = None) -> types.ListPromptsResult: """Send a prompts/list request. @@ -1309,14 +1228,8 @@ def _absorb_tool_listing(self, result: types.ListToolsResult, *, complete: bool) kept.append(tool) result.tools = kept - # Cache tool output schemas for future validation; cursor pages only ever add. A - # changed schema evicts its compiled validator; an unchanged one (a re-listing, or the - # response cache re-absorbing a served hit) keeps it. Only validated tools pay the check. + # Cursor pages only ever add. for tool in result.tools: - if tool.name in self._tool_output_validators and not _same_schema( - self._tool_output_schemas.get(tool.name), tool.output_schema - ): - del self._tool_output_validators[tool.name] self._tool_output_schemas[tool.name] = tool.output_schema if complete: @@ -1325,7 +1238,6 @@ def _absorb_tool_listing(self, result: types.ListToolsResult, *, complete: bool) names = {tool.name for tool in result.tools} self._x_mcp_header_maps = {k: v for k, v in self._x_mcp_header_maps.items() if k in names} self._tool_output_schemas = {k: v for k, v in self._tool_output_schemas.items() if k in names} - self._tool_output_validators = {k: v for k, v in self._tool_output_validators.items() if k in names} return result diff --git a/tests/client/test_client.py b/tests/client/test_client.py index c63248798e..87af510b1a 100644 --- a/tests/client/test_client.py +++ b/tests/client/test_client.py @@ -673,16 +673,12 @@ async def test_a_complete_listing_prunes_per_tool_state_for_tools_it_no_longer_c with anyio.fail_after(5): async with Client(server) as client: await client.session.list_tools() - # Compile the retired tool's output-schema validator so its eviction is observable. - await client.session.validate_tool_result("retired", CallToolResult(content=[], structured_content={})) assert set(client.session._x_mcp_header_maps) == {"retired", "survivor"} assert set(client.session._tool_output_schemas) == {"retired", "survivor"} - assert set(client.session._tool_output_validators) == {"retired"} await client.session.list_tools() assert set(client.session._x_mcp_header_maps) == {"survivor"} assert set(client.session._tool_output_schemas) == {"survivor"} - assert client.session._tool_output_validators == {} async def test_a_complete_listing_prunes_output_schemas_on_a_legacy_session_too() -> None: diff --git a/tests/client/test_client_caching.py b/tests/client/test_client_caching.py index 30f752eb6c..9cb6ea13cb 100644 --- a/tests/client/test_client_caching.py +++ b/tests/client/test_client_caching.py @@ -93,15 +93,12 @@ def _list_changed_server() -> Server[Any]: """Server whose `touch` tool emits tools/list_changed; connect with `mode="legacy"` because the modern in-process path drops standalone server notifications.""" - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[types.Tool(name="touch", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "touch" await ctx.session.send_tool_list_changed() return CallToolResult(content=[TextContent(text="touched")]) - return Server("notifier", on_list_tools=list_tools, on_call_tool=call_tool) + return Server("notifier", on_call_tool=call_tool) async def _warm_tools_list_entry(client: Client) -> CacheKey: @@ -754,67 +751,6 @@ def text(result: ReadResourceResult) -> str: assert reads == 5 -def _output_schema_server(call_result: CallToolResult) -> tuple[Server[Any], list[str | None]]: - """One tool declaring an output schema; `call_tool` returns the canned `call_result`.""" - fetches: list[str | None] = [] - tool = Tool( - name="run", - input_schema={"type": "object"}, - output_schema={"type": "object", "properties": {"n": {"type": "integer"}}, "required": ["n"]}, - ) - - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - fetches.append(params.cursor if params is not None else None) - return ListToolsResult(tools=[tool]) - - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: - assert params.name == "run" - return call_result - - server = Server( - "schemas", - on_list_tools=list_tools, - on_call_tool=call_tool, - cache_hints={"tools/list": CacheHint(ttl_ms=60_000)}, - ) - return server, fetches - - -async def test_a_listing_served_from_a_shared_store_rebuilds_output_schemas() -> None: - """A served listing is absorbed into the session: output validation works without a wire fetch.""" - call_result = CallToolResult(content=[TextContent(text="ok")], structured_content={"n": 1}) - server, fetches = _output_schema_server(call_result) - config = CacheConfig(store=InMemoryResponseCacheStore(), partition="p", target_id="svc", clock=_ManualClock()) - - async with Client(server, cache=config) as warming: - listing = await warming.list_tools() - - async with Client(server, cache=config) as fresh: - assert await fresh.list_tools() == listing # served from the shared store - result = await fresh.call_tool("run", {}) - - assert result.structured_content == {"n": 1} - # A starved schema cache would have re-listed here. - assert fetches == [None] - - -async def test_validation_from_a_served_listing_rejects_missing_structured_content() -> None: - """The schema absorbed from a served listing is enforced, not just present.""" - server, fetches = _output_schema_server(CallToolResult(content=[TextContent(text="ok")])) - config = CacheConfig(store=InMemoryResponseCacheStore(), partition="p", target_id="svc", clock=_ManualClock()) - - async with Client(server, cache=config) as warming: - await warming.list_tools() - - async with Client(server, cache=config) as fresh: - await fresh.list_tools() - with pytest.raises(RuntimeError) as exc_info: - await fresh.call_tool("run", {}) - - assert str(exc_info.value) == snapshot("Tool run has an output schema but did not return structured content") - assert fetches == [None] - - async def test_a_cache_hit_listing_still_mirrors_x_mcp_headers_on_tools_call() -> None: """The arg-to-header maps are rebuilt from a served listing. Asserted at the wire because the client never surfaces outgoing headers.""" @@ -941,15 +877,12 @@ async def read(ctx: ServerRequestContext, params: types.ReadResourceRequestParam reads.append(params.uri) return ReadResourceResult(contents=[TextResourceContents(uri=params.uri, text=f"v{len(reads)}")]) - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[Tool(name="poke", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "poke" await ctx.session.send_resource_updated(uri) return CallToolResult(content=[TextContent(text="ok")]) - server = Server("updates", on_read_resource=read, on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("updates", on_read_resource=read, on_call_tool=call_tool) delivered: list[str] = [] seen = anyio.Event() diff --git a/tests/client/test_client_extensions.py b/tests/client/test_client_extensions.py index e21ae6b5c4..447375d831 100644 --- a/tests/client/test_client_extensions.py +++ b/tests/client/test_client_extensions.py @@ -364,12 +364,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara observed.append(ctx.session.client_params.capabilities.extensions) return CallToolResult(content=[]) - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="probe", input_schema={"type": "object"})]) - - server = Server("probe", on_call_tool=call_tool, on_list_tools=list_tools) + server = Server("probe", on_call_tool=call_tool) settings = {"tier": "bronze"} client = Client(server, extensions=[advertise("com.example/loyalty", settings)]) settings["tier"] = "gold" @@ -438,21 +433,8 @@ async def resolve(claimed: VoucherResult, ctx: ClaimContext) -> CallToolResult: assert result.content == [TextContent(text="routed")] -async def test_resolver_product_gets_the_direct_paths_output_schema_revalidation() -> None: - """The resolver's product is revalidated against the tool's output schema exactly like a direct result.""" - - async def resolve(claimed: VoucherResult, ctx: ClaimContext) -> CallToolResult: - return CallToolResult(content=[TextContent(text="unstructured")]) - - async with Client(_structured_voucher_server(), extensions=[_VoucherExtension(resolve)]) as client: - with anyio.fail_after(5), pytest.raises(RuntimeError) as exc_info: - await client.call_tool("issue", {}) - - assert str(exc_info.value) == snapshot("Tool issue has an output schema but did not return structured content") - - async def test_resolver_error_result_is_returned_not_raised() -> None: - """An `isError` resolver product skips output-schema revalidation and comes back as-is.""" + """An `isError` resolver product comes back as-is.""" async def resolve(claimed: VoucherResult, ctx: ClaimContext) -> CallToolResult: return CallToolResult(content=[TextContent(text="voucher printer on fire")], is_error=True) diff --git a/tests/client/test_output_schema_validation.py b/tests/client/test_output_schema_validation.py deleted file mode 100644 index 10715e6352..0000000000 --- a/tests/client/test_output_schema_validation.py +++ /dev/null @@ -1,190 +0,0 @@ -import logging -from pathlib import Path -from typing import Any - -import pytest -from mcp_types import ( - CallToolRequestParams, - CallToolResult, - ListToolsResult, - PaginatedRequestParams, - TextContent, - Tool, -) -from referencing.exceptions import Unresolvable - -from mcp import Client -from mcp.server import Server, ServerRequestContext - - -def _make_server( - tools: list[Tool], - structured_content: dict[str, Any], -) -> Server: - """Create a low-level server that returns the given structured_content for any tool call.""" - - async def on_list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=tools) - - async def on_call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult: - return CallToolResult( - content=[TextContent(type="text", text="result")], - structured_content=structured_content, - ) - - return Server("test-server", on_list_tools=on_list_tools, on_call_tool=on_call_tool) - - -@pytest.mark.anyio -async def test_tool_structured_output_client_side_validation_basemodel(): - """Test that client validates structured content against schema for BaseModel outputs""" - output_schema = { - "type": "object", - "properties": {"name": {"type": "string", "title": "Name"}, "age": {"type": "integer", "title": "Age"}}, - "required": ["name", "age"], - "title": "UserOutput", - } - - server = _make_server( - tools=[ - Tool( - name="get_user", - description="Get user data", - input_schema={"type": "object"}, - output_schema=output_schema, - ) - ], - structured_content={"name": "John", "age": "invalid"}, # Invalid: age should be int - ) - - async with Client(server) as client: - with pytest.raises(RuntimeError) as exc_info: - await client.call_tool("get_user", {}) - assert "Invalid structured content returned by tool get_user" in str(exc_info.value) - - -@pytest.mark.anyio -async def test_tool_structured_output_client_side_validation_primitive(): - """Test that client validates structured content for primitive outputs""" - output_schema = { - "type": "object", - "properties": {"result": {"type": "integer", "title": "Result"}}, - "required": ["result"], - "title": "calculate_Output", - } - - server = _make_server( - tools=[ - Tool( - name="calculate", - description="Calculate something", - input_schema={"type": "object"}, - output_schema=output_schema, - ) - ], - structured_content={"result": "not_a_number"}, # Invalid: should be int - ) - - async with Client(server) as client: - with pytest.raises(RuntimeError) as exc_info: - await client.call_tool("calculate", {}) - assert "Invalid structured content returned by tool calculate" in str(exc_info.value) - - -@pytest.mark.anyio -async def test_tool_structured_output_client_side_validation_dict_typed(): - """Test that client validates dict[str, T] structured content""" - output_schema = {"type": "object", "additionalProperties": {"type": "integer"}, "title": "get_scores_Output"} - - server = _make_server( - tools=[ - Tool( - name="get_scores", - description="Get scores", - input_schema={"type": "object"}, - output_schema=output_schema, - ) - ], - structured_content={"alice": "100", "bob": "85"}, # Invalid: values should be int - ) - - async with Client(server) as client: - with pytest.raises(RuntimeError) as exc_info: - await client.call_tool("get_scores", {}) - assert "Invalid structured content returned by tool get_scores" in str(exc_info.value) - - -@pytest.mark.anyio -async def test_tool_structured_output_client_side_validation_missing_required(): - """Test that client validates missing required fields""" - output_schema = { - "type": "object", - "properties": {"name": {"type": "string"}, "age": {"type": "integer"}, "email": {"type": "string"}}, - "required": ["name", "age", "email"], - "title": "PersonOutput", - } - - server = _make_server( - tools=[ - Tool( - name="get_person", - description="Get person data", - input_schema={"type": "object"}, - output_schema=output_schema, - ) - ], - structured_content={"name": "John", "age": 30}, # Missing required 'email' - ) - - async with Client(server) as client: - with pytest.raises(RuntimeError) as exc_info: - await client.call_tool("get_person", {}) - assert "Invalid structured content returned by tool get_person" in str(exc_info.value) - - -@pytest.mark.anyio -async def test_tool_not_listed_warning(caplog: pytest.LogCaptureFixture): - """Test that client logs warning when tool is not in list_tools but has output_schema""" - - async def on_list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[]) - - async def on_call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult: - return CallToolResult( - content=[TextContent(type="text", text="result")], - structured_content={"result": 42}, - ) - - server = Server("test-server", on_list_tools=on_list_tools, on_call_tool=on_call_tool) - - caplog.set_level(logging.WARNING) - - async with Client(server) as client: - result = await client.call_tool("mystery_tool", {}) - assert result.structured_content == {"result": 42} - assert result.is_error is False - - assert "Tool mystery_tool not listed" in caplog.text - - -# jsonschema's fallback retriever emits this DeprecationWarning; keep it a plain warning so the -# assertions below decide the outcome rather than the suite's warnings-as-errors filter. -@pytest.mark.filterwarnings("default:Automatically retrieving remote references:DeprecationWarning") -@pytest.mark.anyio -async def test_output_schema_ref_outside_the_document_is_rejected(tmp_path: Path): - """A `$ref` to a URI outside the output schema is not resolved, and a result whose validation - reaches one fails as an invalid schema (spec `$ref` resolution; applying it to `file:` URIs too - is SDK-defined).""" - target = tmp_path / "schema.json" - target.write_text("{}", encoding="utf-8") - server = _make_server( - tools=[Tool(name="probe", input_schema={"type": "object"}, output_schema={"$ref": target.as_uri()})], - structured_content={"v": 1}, - ) - - async with Client(server) as client: - with pytest.raises(RuntimeError) as exc_info: - await client.call_tool("probe", {}) - # SDK-authored prefix only; the tail is `referencing`'s text. - assert str(exc_info.value).startswith("Invalid schema for tool probe: ") - assert isinstance(exc_info.value.__cause__, Unresolvable) diff --git a/tests/client/test_send_request_mcp_name.py b/tests/client/test_send_request_mcp_name.py index 27c41e6614..f023d3f059 100644 --- a/tests/client/test_send_request_mcp_name.py +++ b/tests/client/test_send_request_mcp_name.py @@ -13,11 +13,9 @@ from mcp_types import ( CallToolResult, Implementation, - ListToolsResult, Request, ServerCapabilities, TextContent, - Tool, ) from mcp_types.version import LATEST_HANDSHAKE_VERSION, LATEST_MODERN_VERSION @@ -51,10 +49,6 @@ async def send_raw_request( return CallToolResult(content=[TextContent(type="text", text="ok")]).model_dump( by_alias=True, mode="json", exclude_none=True ) - if method == "tools/list": - return ListToolsResult(tools=[Tool(name="my-tool", input_schema={"type": "object"})]).model_dump( - by_alias=True, mode="json", exclude_none=True - ) return {} async def notify(self, method: str, params: Mapping[str, Any] | None, opts: CallOptions | None = None) -> None: diff --git a/tests/client/test_session.py b/tests/client/test_session.py index 7acbe01ce3..d721e103ac 100644 --- a/tests/client/test_session.py +++ b/tests/client/test_session.py @@ -9,7 +9,6 @@ import anyio.streams.memory import mcp_types as types import pytest -from inline_snapshot import snapshot from mcp_types import ( CONNECTION_CLOSED, INTERNAL_ERROR, @@ -720,26 +719,6 @@ async def mock_server(): ) ) - # Wait for the tools/list request from the client - # The client requires this step to validate the tool output schema - session_message = await client_to_server_receive.receive() - jsonrpc_request = session_message.message - assert isinstance(jsonrpc_request, JSONRPCRequest) - - assert jsonrpc_request.method == "tools/list" - - result = types.ListToolsResult(tools=[mocked_tool]) - - await server_to_client_send.send( - SessionMessage( - JSONRPCResponse( - jsonrpc="2.0", - id=jsonrpc_request.id, - result=result.model_dump(by_alias=True, mode="json", exclude_none=True), - ) - ) - ) - server_to_client_send.close() async with ( @@ -1857,40 +1836,26 @@ async def test_call_tool_accepts_a_null_structured_content_the_output_schema_per @pytest.mark.anyio -async def test_call_tool_rejects_a_null_structured_content_the_output_schema_forbids() -> None: - """A null `structuredContent` is validated like any other value: against a schema that does - not permit null it fails as a schema mismatch, not as missing structured content.""" - dispatcher = _ScriptedDispatcher( - _discover_result_dict(), - _listing_with_output_schema({"type": "object"}), - {"resultType": "complete", "content": [], "structuredContent": None}, - ) - with anyio.fail_after(5): - async with ClientSession(dispatcher=dispatcher) as session: - await session.discover() - await session.list_tools() - with pytest.raises(RuntimeError) as exc_info: - await session.call_tool("t", {}) - # Stable SDK prefix only: the message tail is jsonschema text that shifts with the dependency. - assert str(exc_info.value).startswith("Invalid structured content returned by tool t") - - -@pytest.mark.anyio -async def test_call_tool_reports_an_absent_structured_content_as_missing_even_when_null_is_permitted() -> None: - """SDK-defined: only a result with no `structuredContent` field at all is reported as - missing structured content, and it is so even when the output schema would accept null.""" +@pytest.mark.parametrize( + "structured", + [{"structuredContent": {"x": "not an integer"}}, {}], + ids=["mismatched", "absent"], +) +async def test_call_tool_returns_structured_content_as_the_server_sent_it(structured: dict[str, Any]) -> None: + """SDK-defined: the client does not check results against the tool's output schema, so content + that breaks the schema, or no content at all, reaches the caller unchanged.""" dispatcher = _ScriptedDispatcher( _discover_result_dict(), - _listing_with_output_schema({"type": ["object", "null"]}), - {"resultType": "complete", "content": []}, + _listing_with_output_schema({"type": "object", "properties": {"x": {"type": "integer"}}, "required": ["x"]}), + {"resultType": "complete", "content": [], **structured}, ) with anyio.fail_after(5): async with ClientSession(dispatcher=dispatcher) as session: await session.discover() await session.list_tools() - with pytest.raises(RuntimeError) as exc_info: - await session.call_tool("t", {}) - assert str(exc_info.value) == snapshot("Tool t has an output schema but did not return structured content") + result = await session.call_tool("t", {}) + assert isinstance(result, CallToolResult) + assert result.structured_content == structured.get("structuredContent") @pytest.mark.anyio @@ -1920,12 +1885,7 @@ async def on_call_tool(ctx: ServerRequestContext, params: types.CallToolRequestP captured.append(params) return CallToolResult(content=[]) - async def on_list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[]) - - server = Server("test", on_call_tool=on_call_tool, on_list_tools=on_list_tools) + server = Server("test", on_call_tool=on_call_tool) with anyio.fail_after(5): async with Client(server, mode="2026-07-28") as client: await client.call_tool( diff --git a/tests/client/test_session_claims.py b/tests/client/test_session_claims.py index e6495aa31e..14f4ad0436 100644 --- a/tests/client/test_session_claims.py +++ b/tests/client/test_session_claims.py @@ -15,11 +15,9 @@ CallToolResult, Implementation, InputRequiredResult, - ListToolsResult, Result, ServerCapabilities, TextContent, - Tool, ) from mcp_types.methods import validate_server_result from mcp_types.version import LATEST_HANDSHAKE_VERSION, LATEST_MODERN_VERSION @@ -52,9 +50,6 @@ def _task_claim(**kwargs: Any) -> ResultClaim[_TaskResult]: by_alias=True, mode="json", exclude_none=True ) _CLAIMED_TASK_RESULT = {"resultType": "task", "taskId": "t-1"} -_TOOL_LISTING = ListToolsResult(tools=[Tool(name="t", input_schema={"type": "object"})]).model_dump( - by_alias=True, mode="json", exclude_none=True -) _INITIALIZE_RESULT = types.InitializeResult( protocol_version=LATEST_HANDSHAKE_VERSION, capabilities=ServerCapabilities(), @@ -87,8 +82,6 @@ async def send_raw_request( self.calls.append((method, params, opts or {})) if method == "tools/call": return self._tool_result - if method == "tools/list": - return _TOOL_LISTING if method == "initialize": return _INITIALIZE_RESULT return {} diff --git a/tests/client/test_session_promotions.py b/tests/client/test_session_promotions.py index 6d6b6bc8dc..babebb0fc3 100644 --- a/tests/client/test_session_promotions.py +++ b/tests/client/test_session_promotions.py @@ -1,19 +1,11 @@ -"""`dispatch_input_request` and `validate_tool_result` are public `ClientSession` API.""" +"""`dispatch_input_request` and the deprecated `validate_tool_result` are public `ClientSession` API.""" import mcp_types as types import pytest -from mcp_types import ( - CallToolResult, - ErrorData, - ListRootsResult, - ListToolsResult, - PaginatedRequestParams, - Tool, -) +from mcp_types import CallToolResult, ErrorData, ListRootsResult -from mcp.client.client import Client +from mcp import MCPDeprecationWarning from mcp.client.session import ClientRequestContext, ClientSession -from mcp.server import Server, ServerRequestContext from mcp.shared.direct_dispatcher import create_direct_dispatcher_pair @@ -42,86 +34,12 @@ async def test_dispatch_input_request_returns_error_data_on_refusal() -> None: assert response.code == types.INVALID_REQUEST -def _make_server(output_schema: dict[str, object]) -> Server: - async def on_list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[Tool(name="t", input_schema={"type": "object"}, output_schema=output_schema)]) - - return Server("test-server", on_list_tools=on_list_tools) - - -@pytest.mark.anyio -async def test_validate_tool_result_passes_a_conforming_result() -> None: - server = _make_server({"type": "object", "properties": {"x": {"type": "integer"}}, "required": ["x"]}) - async with Client(server) as client: - # The session fetches the listing itself when the tool isn't cached yet. - await client.session.validate_tool_result("t", CallToolResult(content=[], structured_content={"x": 1})) - - -@pytest.mark.anyio -async def test_validate_tool_result_raises_on_schema_mismatch() -> None: - server = _make_server({"type": "object", "properties": {"x": {"type": "integer"}}, "required": ["x"]}) - async with Client(server) as client: - # Stable SDK prefix only: the message tail is jsonschema text that shifts with the dependency. - with pytest.raises(RuntimeError, match="Invalid structured content returned by tool t"): - await client.session.validate_tool_result("t", CallToolResult(content=[], structured_content={"x": "no"})) - - -@pytest.mark.anyio -async def test_validate_tool_result_raises_on_an_unusable_output_schema() -> None: - """A schema that isn't valid JSON Schema is reported as such, on every call.""" - server = _make_server({"type": "not-a-json-schema-type"}) - async with Client(server) as client: - result = CallToolResult(content=[], structured_content={"x": 1}) - for _ in range(2): - # Compiling is never cached on failure, so the second call raises like the first. - # Stable SDK prefix only: the message tail is jsonschema text that shifts with the dependency. - with pytest.raises(RuntimeError, match="Invalid schema for tool t"): - await client.session.validate_tool_result("t", result) - - @pytest.mark.anyio -async def test_validate_tool_result_compiles_the_output_schema_once_per_tool() -> None: - """Regression guard: compiling dominates validating, so the validator must outlive one call.""" - server = _make_server({"type": "object", "properties": {"x": {"type": "integer"}}, "required": ["x"]}) - async with Client(server) as client: - result = CallToolResult(content=[], structured_content={"x": 1}) - await client.session.validate_tool_result("t", result) - compiled = client.session._tool_output_validators["t"] - await client.session.validate_tool_result("t", result) - assert client.session._tool_output_validators["t"] is compiled - - -@pytest.mark.anyio -async def test_validate_tool_result_keeps_the_validator_across_a_relisting_of_the_same_schema() -> None: - """SDK-defined: an unchanged schema on a re-listing (or a re-absorbed cache hit) keeps its - compiled validator, so relisting between calls doesn't reintroduce the per-call compile.""" - server = _make_server({"type": "object", "properties": {"x": {"type": "integer"}}, "required": ["x"]}) - async with Client(server) as client: - result = CallToolResult(content=[], structured_content={"x": 1}) - await client.session.validate_tool_result("t", result) - compiled = client.session._tool_output_validators["t"] - - await client.session.list_tools() # a second listing carrying an equal schema - await client.session.validate_tool_result("t", result) - assert client.session._tool_output_validators["t"] is compiled - - -@pytest.mark.anyio -async def test_validate_tool_result_recompiles_when_the_server_changes_the_schema() -> None: - """A relisted tool must not be validated against the schema it used to declare.""" - schemas = [ - {"type": "object", "properties": {"x": {"type": "integer"}}, "required": ["x"]}, - {"type": "object", "properties": {"x": {"type": "string"}}, "required": ["x"]}, - ] - - async def on_list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[Tool(name="t", input_schema={"type": "object"}, output_schema=schemas.pop(0))]) - - server = Server("test-server", on_list_tools=on_list_tools) - async with Client(server) as client: - integer_result = CallToolResult(content=[], structured_content={"x": 1}) - await client.session.validate_tool_result("t", integer_result) - - await client.session.list_tools() - with pytest.raises(RuntimeError, match="Invalid structured content returned by tool t"): - await client.session.validate_tool_result("t", integer_result) +async def test_validate_tool_result_is_a_deprecated_no_op() -> None: + """SDK-defined: the client no longer checks a result against the server's output schema.""" + client_side, _server_side = create_direct_dispatcher_pair() + session = ClientSession(dispatcher=client_side) + with pytest.warns(MCPDeprecationWarning, match="no longer validates tool results"): + await session.validate_tool_result( # pyright: ignore[reportDeprecated] + "t", CallToolResult(content=[], structured_content={"x": "no"}) + ) diff --git a/tests/client/test_streamable_http.py b/tests/client/test_streamable_http.py index 9087394cd6..d27d623ccc 100644 --- a/tests/client/test_streamable_http.py +++ b/tests/client/test_streamable_http.py @@ -30,7 +30,6 @@ ListToolsResult, PaginatedRequestParams, TextContent, - Tool, ) from mcp_types.version import LATEST_MODERN_VERSION from starlette.applications import Starlette @@ -63,14 +62,11 @@ async def test_configured_sse_limit_accepts_a_tool_result_larger_than_one_mebiby """SDK-defined: a larger SSE limit accepts a large tool result sent as one POST SSE event.""" payload = "x" * (2 * 1024 * 1024) - async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[Tool(name="large", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult: assert params.name == "large" return CallToolResult(content=[TextContent(text=payload)]) - manager = StreamableHTTPSessionManager(app=Server("large-result", on_list_tools=list_tools, on_call_tool=call_tool)) + manager = StreamableHTTPSessionManager(app=Server("large-result", on_call_tool=call_tool)) app = Starlette(routes=[Mount("/mcp", app=manager.handle_request)]) with anyio.fail_after(5): @@ -92,16 +88,11 @@ async def test_default_sse_limit_fails_one_large_tool_call_and_keeps_the_session """SDK-defined: the 1 MiB default rejects one oversized tool result without poisoning the session.""" calls: list[str] = [] - async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[Tool(name=name, input_schema={"type": "object"}) for name in ("large", "small")]) - async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult: calls.append(params.name) return CallToolResult(content=[TextContent(text="x" * (2 * 1024 * 1024) if params.name == "large" else "ok")]) - manager = StreamableHTTPSessionManager( - app=Server("bounded-result", on_list_tools=list_tools, on_call_tool=call_tool) - ) + manager = StreamableHTTPSessionManager(app=Server("bounded-result", on_call_tool=call_tool)) app = Starlette(routes=[Mount("/mcp", app=manager.handle_request)]) with anyio.fail_after(5): diff --git a/tests/conftest.py b/tests/conftest.py index 2b6989dd31..81dc2249ee 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -34,10 +34,6 @@ def blockbuster() -> Iterator[None]: # Coverage reads source files while collecting data. bb.functions["os.stat"].can_block_in("coverage/python.py", "get_python_source") bb.functions["io.BufferedReader.read"].can_block_in("coverage/python.py", "read_python_source") - # jsonschema discovers its bundled schemas during its first import. - for name in bb.functions.keys() & {"os.listdir", "os.scandir"}: - bb.functions[name].can_block_in("/jsonschema_specifications/_core.py", "_schemas") - bb.functions["io.TextIOWrapper.read"].can_block_in("/jsonschema_specifications/_core.py", "_schemas") # These public synchronous conversions read the media file by design. bb.functions["io.BufferedReader.read"].can_block_in( "mcp/server/mcpserver/utilities/types.py", ("to_image_content", "to_audio_content") diff --git a/tests/docs_src/test_identity_assertion.py b/tests/docs_src/test_identity_assertion.py index 3a15ef94ec..25977b4721 100644 --- a/tests/docs_src/test_identity_assertion.py +++ b/tests/docs_src/test_identity_assertion.py @@ -181,7 +181,6 @@ def whoami() -> str: ("POST", "/token"), ("POST", "/mcp"), ("POST", "/mcp"), - ("POST", "/mcp"), ] ) token_request = dict(parse_qsl(log[2][2].decode())) diff --git a/tests/docs_src/test_lowlevel.py b/tests/docs_src/test_lowlevel.py index 8a89aa014d..862a4d61bd 100644 --- a/tests/docs_src/test_lowlevel.py +++ b/tests/docs_src/test_lowlevel.py @@ -108,16 +108,16 @@ async def test_output_schema_and_structured_content_are_both_yours_to_build() -> ) -async def test_the_client_checks_the_schema_you_promised() -> None: - """The page's warning: a `structured_content` that violates your `output_schema` fails in `call_tool`.""" +async def test_the_client_does_not_check_the_schema_you_promised() -> None: + """The page's warning: a `structured_content` that violates your `output_schema` still reaches the caller.""" async def promise_breaker(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult: return CallToolResult(content=[TextContent(type="text", text="oops")], structured_content={"matches": "three"}) lying = Server("Bookshop", on_list_tools=tutorial003.list_tools, on_call_tool=promise_breaker) async with Client(lying) as client: - with pytest.raises(RuntimeError, match="Invalid structured content returned by tool search_books"): - await client.call_tool("search_books", {"query": "dune", "limit": 5}) + result = await client.call_tool("search_books", {"query": "dune", "limit": 5}) + assert result.structured_content == {"matches": "three"} async def test_meta_reaches_the_client_application() -> None: diff --git a/tests/interaction/_requirements.py b/tests/interaction/_requirements.py index 1d9033b307..81ce1d3448 100644 --- a/tests/interaction/_requirements.py +++ b/tests/interaction/_requirements.py @@ -956,35 +956,24 @@ def __post_init__(self) -> None: # ═══════════════════════════════════════════════════════════════════════════ # Tools: SDK guarantees # ═══════════════════════════════════════════════════════════════════════════ - "client:output-schema:skip-on-error": Requirement( - source="sdk", - behavior="The client skips structured-content validation when the tool result has isError true.", - ), - "client:output-schema:validate": Requirement( + "client:output-schema:returned-as-sent": Requirement( source=f"{SPEC_BASE_URL}/server/tools#output-schema", behavior=( "A tool result whose structuredContent does not conform to the tool's declared outputSchema " - "is rejected by the client: the call raises instead of returning the invalid result." - ), - ), - "client:output-schema:missing-structured": Requirement( - source="sdk", - behavior="A tool that declares an output schema but returns no structuredContent fails client-side validation.", - ), - "client:output-schema:auto-list": Requirement( - source="sdk", - behavior=( - "Calling a tool whose output schema is not yet cached issues an implicit tools/list to " - "populate the cache; subsequent calls of the same tool do not." + "is returned to the caller unchanged; the client does not validate it." ), divergence=Divergence( note=( - "Design concern rather than spec violation: the implicit request is invisible to the " - "caller, and against a server that registers only on_call_tool a successful call surfaces " - "as METHOD_NOT_FOUND from a tools/list the caller never asked for." + "The spec says clients SHOULD validate structured results against the output schema. The " + "server supplies both, so the SDK leaves the check to the caller, who can validate " + "structuredContent against a model of their own." ), ), ), + "client:call-tool:no-implicit-list": Requirement( + source="sdk", + behavior="call_tool sends only tools/call; it never issues a tools/list the caller did not ask for.", + ), "mcpserver:output-schema:missing-structured": Requirement( source=f"{SPEC_BASE_URL}/server/tools#output-schema", behavior="A tool with an output schema whose function returns no structured content produces a server error.", diff --git a/tests/interaction/lowlevel/test_cancellation.py b/tests/interaction/lowlevel/test_cancellation.py index 74c32e304b..0e70eb2f2f 100644 --- a/tests/interaction/lowlevel/test_cancellation.py +++ b/tests/interaction/lowlevel/test_cancellation.py @@ -21,11 +21,9 @@ JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, - ListToolsResult, PingRequest, ServerCapabilities, TextContent, - Tool, ) from mcp import Client, MCPError @@ -112,16 +110,6 @@ async def test_session_serves_requests_after_cancellation(connect: Connect) -> N handler_cancelled = anyio.Event() request_ids: list[types.RequestId] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[ - types.Tool(name="block", input_schema={"type": "object"}), - types.Tool(name="echo", input_schema={"type": "object"}), - ] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: if params.name == "echo": return CallToolResult(content=[TextContent(text="still alive")]) @@ -135,7 +123,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara raise raise NotImplementedError # unreachable - server = Server("blocker", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("blocker", on_call_tool=call_tool) async with connect(server) as client: with anyio.fail_after(5): @@ -157,16 +145,11 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara async def test_cancellation_for_unknown_request_is_ignored(connect: Connect, unstamped: Unstamp) -> None: """A cancellation referencing a request id that is not in flight is ignored without error.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="echo", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "echo" return CallToolResult(content=[TextContent(text="unbothered")]) - server = Server("calm", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("calm", on_call_tool=call_tool) async with connect(server) as client: await client.session.send_notification( @@ -194,11 +177,6 @@ async def sampling_callback( raise raise NotImplementedError # unreachable - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="impatient", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "impatient" request = types.CreateMessageRequest( @@ -221,7 +199,7 @@ async def sample() -> None: await callback_cancelled.wait() return CallToolResult(content=[TextContent(text="abandoned")]) - server = Server("abandoner", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("abandoner", on_call_tool=call_tool) async with connect(server, sampling_callback=sampling_callback) as client: result = await client.call_tool("impatient", {}) @@ -388,10 +366,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara assert params.name == "echo" return CallToolResult(content=[TextContent(text="ok")]) - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[Tool(name=name, input_schema={"type": "object"}) for name in ("block", "echo")]) - - server = Server("blocker", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("blocker", on_call_tool=call_tool) async with connect(server) as client: abandon = anyio.CancelScope() @@ -447,12 +422,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara await release_survivor.wait() return CallToolResult(content=[TextContent(text="survived")]) - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult( - tools=[Tool(name=name, input_schema={"type": "object"}) for name in ("doomed", "survivor")] - ) - - server = Server("pair", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("pair", on_call_tool=call_tool) async with connect(server) as client: abandon = anyio.CancelScope() diff --git a/tests/interaction/lowlevel/test_elicitation.py b/tests/interaction/lowlevel/test_elicitation.py index d9893cdc08..a35de45720 100644 --- a/tests/interaction/lowlevel/test_elicitation.py +++ b/tests/interaction/lowlevel/test_elicitation.py @@ -58,19 +58,12 @@ async def test_elicit_form_accepted_content_returns_to_handler(connect: Connect) """ received: list[types.ElicitRequestParams] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="signup", description="Register the user.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "signup" answer = await ctx.session.elicit_form("Choose a username.", REQUESTED_SCHEMA) return CallToolResult(content=[TextContent(text=answer.action)], structured_content=answer.content) - server = Server("registrar", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("registrar", on_call_tool=call_tool) async def answer_form(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult: received.append(params) @@ -106,19 +99,12 @@ async def answer_form(context: ClientRequestContext, params: types.ElicitRequest async def test_elicit_form_decline_returns_no_content(connect: Connect) -> None: """A declined form elicitation returns the decline action to the handler with no content.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="confirm", description="Ask for confirmation.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "confirm" answer = await ctx.session.elicit_form("Proceed?", {"type": "object", "properties": {}}) return CallToolResult(content=[TextContent(text=f"{answer.action} content={answer.content}")]) - server = Server("confirmer", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("confirmer", on_call_tool=call_tool) async def answer_form(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult: return ElicitResult(action="decline") @@ -133,19 +119,12 @@ async def answer_form(context: ClientRequestContext, params: types.ElicitRequest async def test_elicit_form_cancel_returns_no_content(connect: Connect) -> None: """A cancelled form elicitation returns the cancel action to the handler with no content.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="confirm", description="Ask for confirmation.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "confirm" answer = await ctx.session.elicit_form("Proceed?", {"type": "object", "properties": {}}) return CallToolResult(content=[TextContent(text=f"{answer.action} content={answer.content}")]) - server = Server("confirmer", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("confirmer", on_call_tool=call_tool) async def answer_form(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult: return ElicitResult(action="cancel") @@ -168,13 +147,6 @@ async def test_elicit_form_without_callback_is_error(connect: Connect) -> None: elicitation capability before sending (see the divergence on `server-respects-mode`). """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="ask", description="Ask the user.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "ask" try: @@ -183,7 +155,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara return CallToolResult(content=[TextContent(text=f"{exc.error.code}: {exc.error.message}")]) raise NotImplementedError # elicit_form cannot succeed without a client callback - server = Server("asker", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("asker", on_call_tool=call_tool) async with connect(server) as client: result = await client.call_tool("ask", {}) @@ -202,13 +174,6 @@ async def test_elicit_url_delivers_url_and_returns_accept_without_content(connec """ received: list[types.ElicitRequestParams] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="authorize", description="Link an account.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "authorize" answer = await ctx.session.elicit_url( @@ -216,7 +181,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara ) return CallToolResult(content=[TextContent(text=f"{answer.action} content={answer.content}")]) - server = Server("authorizer", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("authorizer", on_call_tool=call_tool) async def answer_url(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult: received.append(params) @@ -241,13 +206,6 @@ async def answer_url(context: ClientRequestContext, params: types.ElicitRequestP async def test_elicit_url_decline_returns_no_content(connect: Connect) -> None: """A declined URL elicitation returns the decline action to the handler with no content.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="authorize", description="Link an account.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "authorize" answer = await ctx.session.elicit_url( @@ -255,7 +213,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara ) return CallToolResult(content=[TextContent(text=f"{answer.action} content={answer.content}")]) - server = Server("authorizer", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("authorizer", on_call_tool=call_tool) async def answer_url(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult: return ElicitResult(action="decline") @@ -270,13 +228,6 @@ async def answer_url(context: ClientRequestContext, params: types.ElicitRequestP async def test_elicit_url_cancel_returns_no_content(connect: Connect) -> None: """A cancelled URL elicitation returns the cancel action to the handler with no content.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="authorize", description="Link an account.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "authorize" answer = await ctx.session.elicit_url( @@ -284,7 +235,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara ) return CallToolResult(content=[TextContent(text=f"{answer.action} content={answer.content}")]) - server = Server("authorizer", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("authorizer", on_call_tool=call_tool) async def answer_url(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult: return ElicitResult(action="cancel") @@ -313,13 +264,6 @@ async def test_elicitation_complete_notification_carries_the_elicited_id_back_to async def collect(message: IncomingMessage) -> None: received.append(message) - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="link_account", description="Link an account.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "link_account" answer = await ctx.session.elicit_url( @@ -329,7 +273,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara await ctx.session.send_elicit_complete(elicitation_id, related_request_id=ctx.request_id) return CallToolResult(content=[TextContent(text="linked")]) - server = Server("authorizer", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("authorizer", on_call_tool=call_tool) async def answer_url(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult: assert isinstance(params, ElicitRequestURLParams) @@ -424,19 +368,12 @@ async def test_elicit_form_schema_with_every_primitive_and_enum_type_reaches_the "required": ["email"], } - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="onboard", description="Onboard the user.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "onboard" answer = await ctx.session.elicit_form("Tell us about yourself.", schema) return CallToolResult(content=[TextContent(text=answer.action)]) - server = Server("onboarder", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("onboarder", on_call_tool=call_tool) received: list[types.ElicitRequestParams] = [] @@ -475,19 +412,12 @@ async def test_elicit_form_with_a_nested_schema_is_forwarded_unchanged(connect: }, } - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="profile", description="Collect a profile.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "profile" answer = await ctx.session.elicit_form("Profile details.", schema) return CallToolResult(content=[TextContent(text=answer.action)]) - server = Server("profiler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("profiler", on_call_tool=call_tool) received: list[types.ElicitRequestParams] = [] @@ -514,13 +444,6 @@ async def test_accepted_elicitation_content_that_violates_the_schema_reaches_the the requirement), so the handler observes exactly what the callback sent. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="signup", description="Register the user.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "signup" answer = await ctx.session.elicit_form( @@ -529,7 +452,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara ) return CallToolResult(content=[TextContent(text=answer.action)], structured_content=answer.content) - server = Server("registrar", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("registrar", on_call_tool=call_tool) async def answer_form(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult: return ElicitResult(action="accept", content={"name": 42, "extra": "field"}) @@ -551,19 +474,12 @@ async def test_elicitation_complete_for_an_unknown_id_is_received_without_error( notification as-is. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="noop", description="Send a stray complete.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "noop" await ctx.session.send_elicit_complete("never-elicited", related_request_id=ctx.request_id) return CallToolResult(content=[TextContent(text="ok")]) - server = Server("notifier", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("notifier", on_call_tool=call_tool) received: list[IncomingMessage] = [] diff --git a/tests/interaction/lowlevel/test_flows.py b/tests/interaction/lowlevel/test_flows.py index 78ca716021..83ef9c020f 100644 --- a/tests/interaction/lowlevel/test_flows.py +++ b/tests/interaction/lowlevel/test_flows.py @@ -6,8 +6,6 @@ individual features are pinned by their own tests; these prove they compose. """ -from collections.abc import Awaitable, Callable - import anyio import mcp_types as types import pytest @@ -20,12 +18,10 @@ ElicitRequestURLParams, ElicitResult, EmptyResult, - ListToolsResult, ReadResourceResult, ResourceLink, TextContent, TextResourceContents, - Tool, ) from mcp import MCPError, UrlElicitationRequiredError @@ -38,19 +34,6 @@ pytestmark = pytest.mark.anyio -ListToolsHandler = Callable[ - [ServerRequestContext, types.PaginatedRequestParams | None], Awaitable[types.ListToolsResult] -] - - -def _list_tools(*names: str) -> ListToolsHandler: - """A list_tools handler advertising the named tools, so call_tool's implicit list succeeds.""" - - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[Tool(name=name, input_schema={"type": "object"}) for name in names]) - - return list_tools - @requirement("flow:tool-result:resource-link-follow") async def test_a_resource_link_returned_by_a_tool_can_be_followed_with_read( @@ -70,9 +53,7 @@ async def read_resource(ctx: ServerRequestContext, params: types.ReadResourceReq assert str(params.uri) == "file:///report.txt" return ReadResourceResult(contents=[TextResourceContents(uri="file:///report.txt", text="generated")]) - server = Server( - "linker", on_list_tools=_list_tools("generate"), on_call_tool=call_tool, on_read_resource=read_resource - ) + server = Server("linker", on_call_tool=call_tool, on_read_resource=read_resource) async with connect(server) as client: called = await client.call_tool("generate", {}) @@ -115,7 +96,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara assert second.action == "accept" and second.content is not None return CallToolResult(content=[TextContent(text=f"{first.content['name']} is {second.content['age']}")]) - server = Server("onboarder", on_list_tools=_list_tools("onboard"), on_call_tool=call_tool) + server = Server("onboarder", on_call_tool=call_tool) async def answer(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult: assert isinstance(params, ElicitRequestFormParams) @@ -179,7 +160,6 @@ async def set_logging_level(ctx: ServerRequestContext, params: types.SetLevelReq server = Server( # pyright: ignore[reportDeprecated] "gatekeeper", - on_list_tools=_list_tools("read_files"), on_call_tool=call_tool, on_set_logging_level=set_logging_level, ) diff --git a/tests/interaction/lowlevel/test_initialize.py b/tests/interaction/lowlevel/test_initialize.py index 1ebc9e2681..3f82ee8d89 100644 --- a/tests/interaction/lowlevel/test_initialize.py +++ b/tests/interaction/lowlevel/test_initialize.py @@ -164,20 +164,13 @@ async def test_initialize_minimal_server_advertises_no_capabilities(connect: Con async def test_initialize_server_sees_client_info(connect: Connect) -> None: """The client identity supplied to Client is visible to server handlers after initialization.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="whoami", description="Report the caller.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "whoami" assert ctx.session.client_params is not None client_info = ctx.session.client_params.client_info return CallToolResult(content=[TextContent(text=f"{client_info.name} {client_info.version}")]) - server = Server("introspector", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("introspector", on_call_tool=call_tool) async with connect(server, client_info=Implementation(name="acme-agent", version="9.9.9")) as client: result = await client.call_tool("whoami", {}) @@ -188,13 +181,6 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara async def test_initialize_server_sees_client_capabilities(connect: Connect) -> None: """The client capabilities visible to the server reflect which callbacks the client configured.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="abilities", description="Report capabilities.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "abilities" assert ctx.session.client_params is not None @@ -215,7 +201,7 @@ async def list_roots(context: ClientRequestContext) -> types.ListRootsResult: """Registered only so the client declares the roots capability; never called.""" raise NotImplementedError - server = Server("introspector", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("introspector", on_call_tool=call_tool) async with connect(server) as client: result = await client.call_tool("abilities", {}) diff --git a/tests/interaction/lowlevel/test_list_changed.py b/tests/interaction/lowlevel/test_list_changed.py index d978c0db51..fbd445a4ba 100644 --- a/tests/interaction/lowlevel/test_list_changed.py +++ b/tests/interaction/lowlevel/test_list_changed.py @@ -44,17 +44,12 @@ async def collect(message: IncomingMessage) -> None: received.append(message) seen.set() - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="install", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "install" await ctx.session.send_tool_list_changed() return CallToolResult(content=[TextContent(text="installed")]) - server = Server("registry", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("registry", on_call_tool=call_tool) async with connect(server, message_handler=collect) as client: await client.call_tool("install", {}) @@ -74,11 +69,6 @@ async def collect(message: IncomingMessage) -> None: received.append(message) seen.set() - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="mount", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "mount" await ctx.session.send_resource_list_changed() @@ -90,7 +80,7 @@ async def list_resources( """Registered so the resources capability is advertised; the client never lists resources.""" raise NotImplementedError - server = Server("registry", on_list_tools=list_tools, on_call_tool=call_tool, on_list_resources=list_resources) + server = Server("registry", on_call_tool=call_tool, on_list_resources=list_resources) async with connect(server, message_handler=collect) as client: await client.call_tool("mount", {}) @@ -110,11 +100,6 @@ async def collect(message: IncomingMessage) -> None: received.append(message) seen.set() - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="learn", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "learn" await ctx.session.send_prompt_list_changed() @@ -126,7 +111,7 @@ async def list_prompts( """Registered so the prompts capability is advertised; the client never lists prompts.""" raise NotImplementedError - server = Server("registry", on_list_tools=list_tools, on_call_tool=call_tool, on_list_prompts=list_prompts) + server = Server("registry", on_call_tool=call_tool, on_list_prompts=list_prompts) async with connect(server, message_handler=collect) as client: await client.call_tool("learn", {}) diff --git a/tests/interaction/lowlevel/test_logging.py b/tests/interaction/lowlevel/test_logging.py index f827650e73..4881b8c12f 100644 --- a/tests/interaction/lowlevel/test_logging.py +++ b/tests/interaction/lowlevel/test_logging.py @@ -66,11 +66,6 @@ async def test_log_messages_reach_logging_callback_in_order(connect: Connect, un async def collect(params: LoggingMessageNotificationParams) -> None: received.append(params) - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="chatty", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "chatty" await ctx.session.send_log_message( # pyright: ignore[reportDeprecated] @@ -86,7 +81,7 @@ async def set_logging_level(ctx: ServerRequestContext, params: types.SetLevelReq raise NotImplementedError server = Server( # pyright: ignore[reportDeprecated] - "logger", on_list_tools=list_tools, on_call_tool=call_tool, on_set_logging_level=set_logging_level + "logger", on_call_tool=call_tool, on_set_logging_level=set_logging_level ) async with connect(server, logging_callback=collect, log_level="debug") as client: @@ -109,11 +104,6 @@ async def test_log_messages_at_every_severity_level(connect: Connect) -> None: async def collect(params: LoggingMessageNotificationParams) -> None: received.append(params) - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="siren", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "siren" for level in ALL_LEVELS: @@ -127,7 +117,7 @@ async def set_logging_level(ctx: ServerRequestContext, params: types.SetLevelReq raise NotImplementedError server = Server( # pyright: ignore[reportDeprecated] - "logger", on_list_tools=list_tools, on_call_tool=call_tool, on_set_logging_level=set_logging_level + "logger", on_call_tool=call_tool, on_set_logging_level=set_logging_level ) async with connect(server, logging_callback=collect, log_level="debug") as client: @@ -143,18 +133,13 @@ def _siren_server() -> Server: request-scoped by construction, so they still ride the requesting stream on every leg. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="siren", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "siren" for level in ALL_LEVELS: await ctx.session.send_log_message(level=level, data=f"a {level} message") # pyright: ignore[reportDeprecated] return CallToolResult(content=[TextContent(text="logged")]) - return Server("logger", on_list_tools=list_tools, on_call_tool=call_tool) + return Server("logger", on_call_tool=call_tool) @requirement("logging:per-request:opt-in") diff --git a/tests/interaction/lowlevel/test_meta.py b/tests/interaction/lowlevel/test_meta.py index 6e1403fea4..46dd9f3bee 100644 --- a/tests/interaction/lowlevel/test_meta.py +++ b/tests/interaction/lowlevel/test_meta.py @@ -24,18 +24,13 @@ async def test_request_meta_reaches_handler(connect: Connect) -> None: request_meta: RequestParamsMeta = {"example.com/trace": "abc-123"} observed_metas: list[dict[str, object]] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="traced", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "traced" assert ctx.meta is not None observed_metas.append(dict(ctx.meta)) return CallToolResult(content=[TextContent(text="traced")]) - server = Server("observability", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("observability", on_call_tool=call_tool) async with connect(server) as client: await client.call_tool("traced", {}, meta=request_meta) @@ -48,16 +43,11 @@ async def test_result_meta_reaches_client(connect: Connect, unstamped: Unstamp) """The _meta object a handler attaches to its result is delivered to the client unchanged.""" result_meta = {"example.com/cost": 3} - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="metered", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "metered" return CallToolResult(content=[TextContent(text="done")], _meta=result_meta) - server = Server("observability", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("observability", on_call_tool=call_tool) async with connect(server) as client: result = await client.call_tool("metered", {}) diff --git a/tests/interaction/lowlevel/test_ping.py b/tests/interaction/lowlevel/test_ping.py index 4ccf800e2f..617a615943 100644 --- a/tests/interaction/lowlevel/test_ping.py +++ b/tests/interaction/lowlevel/test_ping.py @@ -33,19 +33,12 @@ async def test_server_ping_returns_empty_result(connect: Connect) -> None: the handler before the tool result was produced. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[types.Tool(name="ping_back", description="Ping the client.", input_schema={"type": "object"})] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "ping_back" pong = await ctx.session.send_ping() return CallToolResult(content=[TextContent(text=type(pong).__name__)]) - server = Server("pinger", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("pinger", on_call_tool=call_tool) async with connect(server) as client: result = await client.call_tool("ping_back", {}) diff --git a/tests/interaction/lowlevel/test_progress.py b/tests/interaction/lowlevel/test_progress.py index ed98764622..31d1391d96 100644 --- a/tests/interaction/lowlevel/test_progress.py +++ b/tests/interaction/lowlevel/test_progress.py @@ -35,11 +35,6 @@ async def test_progress_during_tool_call_reaches_callback_in_order(connect: Conn async def collect(progress: float, total: float | None, message: str | None) -> None: received.append((progress, total, message)) - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="download", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "download" await ctx.session.report_progress(1.0, total=3.0, message="first chunk") @@ -47,7 +42,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara await ctx.session.report_progress(3.0, total=3.0, message="done") return CallToolResult(content=[TextContent(text="downloaded")]) - server = Server("downloader", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("downloader", on_call_tool=call_tool) async with connect(server) as client: result = await client.call_tool("download", {}, progress_callback=collect) @@ -60,17 +55,12 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara async def test_progress_token_visible_to_handler(connect: Connect) -> None: """Supplying a progress callback attaches a progress token that the handler can read from the request meta.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="inspect", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "inspect" assert ctx.meta is not None return CallToolResult(content=[TextContent(text=str(ctx.meta.get("progress_token")))]) - server = Server("introspector", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("introspector", on_call_tool=call_tool) async def ignore(progress: float, total: float | None, message: str | None) -> None: """A progress callback that is never invoked; the tool only inspects the token.""" @@ -91,16 +81,11 @@ async def test_no_progress_callback_means_no_token(connect: Connect, unstamped: that sees no token has nothing to send progress against. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="inspect", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "inspect" return CallToolResult(content=[TextContent(text=str((ctx.meta or {}).get("progress_token")))]) - server = Server("introspector", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("introspector", on_call_tool=call_tool) async with connect(server) as client: result = await client.call_tool("inspect", {}) @@ -209,11 +194,6 @@ async def test_progress_sent_after_the_response_is_not_delivered_to_the_callback """ captured: list[tuple[ServerSession, ProgressToken]] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="report", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "report" assert ctx.meta is not None @@ -223,7 +203,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara await ctx.session.send_progress_notification(token, 0.5, related_request_id=str(ctx.request_id)) return CallToolResult(content=[TextContent(text="done")]) - server = Server("reporter", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("reporter", on_call_tool=call_tool) received: list[float] = [] late_progress_arrived = anyio.Event() @@ -259,11 +239,6 @@ async def test_non_increasing_progress_values_are_forwarded_unchanged(connect: C async def collect(progress: float, total: float | None, message: str | None) -> None: received.append(progress) - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="zigzag", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "zigzag" await ctx.session.report_progress(0.5) @@ -271,7 +246,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara await ctx.session.report_progress(0.9) return CallToolResult(content=[TextContent(text="done")]) - server = Server("zigzagger", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("zigzagger", on_call_tool=call_tool) async with connect(server) as client: await client.call_tool("zigzag", {}, progress_callback=collect) diff --git a/tests/interaction/lowlevel/test_resources.py b/tests/interaction/lowlevel/test_resources.py index 9e18393707..3b49a0254f 100644 --- a/tests/interaction/lowlevel/test_resources.py +++ b/tests/interaction/lowlevel/test_resources.py @@ -280,11 +280,6 @@ async def collect(message: IncomingMessage) -> None: received.append(message) seen.set() - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="touch", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "touch" await ctx.session.send_resource_updated("file:///watched.txt") @@ -302,7 +297,6 @@ async def subscribe_resource(ctx: ServerRequestContext, params: types.SubscribeR server = Server( "library", - on_list_tools=list_tools, on_call_tool=call_tool, on_list_resources=list_resources, on_subscribe_resource=subscribe_resource, diff --git a/tests/interaction/lowlevel/test_roots.py b/tests/interaction/lowlevel/test_roots.py index bfd6cc90a0..e94377345b 100644 --- a/tests/interaction/lowlevel/test_roots.py +++ b/tests/interaction/lowlevel/test_roots.py @@ -23,18 +23,13 @@ async def test_list_roots_round_trip(connect: Connect) -> None: The tool reports the URIs and names it received, proving the client's roots reached the server. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="show_roots", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "show_roots" result = await ctx.session.list_roots() # pyright: ignore[reportDeprecated] lines = [f"{root.uri} name={root.name}" for root in result.roots] return CallToolResult(content=[TextContent(text="\n".join(lines))]) - server = Server("rooted", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("rooted", on_call_tool=call_tool) async def list_roots(context: ClientRequestContext) -> ListRootsResult: return ListRootsResult( @@ -58,17 +53,12 @@ async def list_roots(context: ClientRequestContext) -> ListRootsResult: async def test_list_roots_empty(connect: Connect) -> None: """A client with no roots to offer answers roots/list with an empty list, not an error.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="count_roots", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "count_roots" result = await ctx.session.list_roots() # pyright: ignore[reportDeprecated] return CallToolResult(content=[TextContent(text=str(len(result.roots)))]) - server = Server("rooted", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("rooted", on_call_tool=call_tool) async def list_roots(context: ClientRequestContext) -> ListRootsResult: return ListRootsResult(roots=[]) @@ -87,11 +77,6 @@ async def test_list_roots_without_callback_is_error(connect: Connect) -> None: hanging; the spec names -32601 for this case (see the divergence note on the requirement). """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="show_roots", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "show_roots" try: @@ -100,7 +85,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara return CallToolResult(content=[TextContent(text=f"{exc.error.code}: {exc.error.message}")]) raise NotImplementedError # list_roots cannot succeed without a client callback - server = Server("rooted", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("rooted", on_call_tool=call_tool) async with connect(server) as client: result = await client.call_tool("show_roots", {}) @@ -115,11 +100,6 @@ async def test_list_roots_callback_error_surfaces_to_the_handler(connect: Connec The callback's code and message reach the requesting handler verbatim as an MCPError. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="show_roots", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "show_roots" try: @@ -128,7 +108,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara return CallToolResult(content=[TextContent(text=f"{exc.error.code}: {exc.error.message}")]) raise NotImplementedError # the callback always answers with an error - server = Server("rooted", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("rooted", on_call_tool=call_tool) async def list_roots(context: ClientRequestContext) -> ErrorData: return ErrorData(code=INTERNAL_ERROR, message="roots provider crashed") diff --git a/tests/interaction/lowlevel/test_sampling.py b/tests/interaction/lowlevel/test_sampling.py index 522a2db980..7979f951f9 100644 --- a/tests/interaction/lowlevel/test_sampling.py +++ b/tests/interaction/lowlevel/test_sampling.py @@ -43,11 +43,6 @@ async def test_create_message_round_trip(connect: Connect) -> None: """ received: list[CreateMessageRequestParams] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="ask_model", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "ask_model" result = await ctx.session.create_message( # pyright: ignore[reportDeprecated] @@ -57,7 +52,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara assert isinstance(result.content, TextContent) return CallToolResult(content=[TextContent(text=f"{result.model}/{result.stop_reason}: {result.content.text}")]) - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -97,11 +92,6 @@ async def test_create_message_params_reach_callback(connect: Connect) -> None: """ received: list[CreateMessageRequestParams] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="ask_model", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "ask_model" result = await ctx.session.create_message( # pyright: ignore[reportDeprecated] @@ -121,7 +111,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara assert isinstance(result.content, TextContent) return CallToolResult(content=[TextContent(text=result.content.text)]) - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -162,11 +152,6 @@ async def test_create_message_request_with_image_content_reaches_callback(connec """ received: list[CreateMessageRequestParams] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="describe_image", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "describe_image" result = await ctx.session.create_message( # pyright: ignore[reportDeprecated] @@ -176,7 +161,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara assert isinstance(result.content, TextContent) return CallToolResult(content=[TextContent(text=result.content.text)]) - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -211,11 +196,6 @@ async def test_create_message_result_with_image_content_returns_to_handler(conne This is the client-to-server direction: the model's response is an image rather than text. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="draw", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "draw" result = await ctx.session.create_message( # pyright: ignore[reportDeprecated] @@ -226,7 +206,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara assert isinstance(image, ImageContent) return CallToolResult(content=[TextContent(text=f"{result.model}: {image.mime_type} {image.data}")]) - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -251,11 +231,6 @@ async def test_create_message_callback_error(connect: Connect) -> None: the callback's code and message reach the handler verbatim, whatever they are. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="ask_model", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "ask_model" try: @@ -267,7 +242,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara return CallToolResult(content=[TextContent(text=f"{exc.error.code}: {exc.error.message}")]) raise NotImplementedError # the callback always answers with an error - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback(context: ClientRequestContext, params: CreateMessageRequestParams) -> ErrorData: return ErrorData(code=-1, message="User rejected sampling request") @@ -282,11 +257,6 @@ async def sampling_callback(context: ClientRequestContext, params: CreateMessage async def test_create_message_without_callback_is_error(connect: Connect) -> None: """A sampling request to a client with no sampling callback fails with the SDK's default error.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="ask_model", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "ask_model" try: @@ -298,7 +268,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara return CallToolResult(content=[TextContent(text=f"{exc.error.code}: {exc.error.message}")]) raise NotImplementedError # create_message cannot succeed without a client callback - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async with connect(server) as client: result = await client.call_tool("ask_model", {}) @@ -314,11 +284,6 @@ async def test_create_message_with_tools_is_rejected_for_unsupporting_client(con expose it), so the server-side validator rejects the request before anything reaches the wire. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="ask_model", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "ask_model" try: @@ -331,7 +296,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara return CallToolResult(content=[TextContent(text=f"{exc.error.code}: {exc.error.message}")]) raise NotImplementedError # the validator rejects every tool-enabled request - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -356,11 +321,6 @@ async def test_create_message_with_mixed_tool_result_content_is_rejected(connect ValueError directly. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="summarise_tools", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "summarise_tools" try: @@ -380,7 +340,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara return CallToolResult(content=[TextContent(text=f"{type(exc).__name__}: {exc}")]) raise NotImplementedError # the validator rejects the malformed messages before sending - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -409,18 +369,13 @@ async def test_a_client_with_a_sampling_callback_declares_the_sampling_capabilit """ captured: list[SamplingCapability | None] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="capabilities", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "capabilities" assert ctx.session.client_params is not None captured.append(ctx.session.client_params.capabilities.sampling) return CallToolResult(content=[TextContent(text="ok")]) - server = Server("introspector", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("introspector", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -443,11 +398,6 @@ async def test_create_message_request_with_audio_content_reaches_callback(connec """ received: list[CreateMessageRequestParams] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="transcribe", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "transcribe" result = await ctx.session.create_message( # pyright: ignore[reportDeprecated] @@ -457,7 +407,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara assert isinstance(result.content, TextContent) return CallToolResult(content=[TextContent(text=result.content.text)]) - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -492,11 +442,6 @@ async def test_create_message_result_with_audio_content_returns_to_handler(conne This is the client-to-server direction: the model's response is audio rather than text. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="speak", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "speak" result = await ctx.session.create_message( # pyright: ignore[reportDeprecated] @@ -507,7 +452,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara assert isinstance(audio, AudioContent) return CallToolResult(content=[TextContent(text=f"{result.model}: {audio.mime_type} {audio.data}")]) - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -529,11 +474,6 @@ async def test_create_message_with_list_valued_message_content_reaches_callback( """A sampling message whose content is a list of blocks arrives at the client callback as a list.""" received: list[CreateMessageRequestParams] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="caption", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "caption" result = await ctx.session.create_message( # pyright: ignore[reportDeprecated] @@ -551,7 +491,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara assert isinstance(result.content, TextContent) return CallToolResult(content=[TextContent(text=result.content.text)]) - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -594,11 +534,6 @@ async def test_create_message_with_mismatched_tool_use_and_result_ids_is_rejecte client-side -32602 check is tracked separately at sampling:tool-use:result-balance. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="continue_tools", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "continue_tools" try: @@ -619,7 +554,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara return CallToolResult(content=[TextContent(text=f"{type(exc).__name__}: {exc}")]) raise NotImplementedError # the validator rejects the malformed messages before sending - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams @@ -650,11 +585,6 @@ async def test_array_content_result_for_a_tool_free_request_surfaces_as_a_valida the result; instead the client accepts it and the server's response parsing raises. """ - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="ask_model", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "ask_model" try: @@ -666,7 +596,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara return CallToolResult(content=[TextContent(text=type(exc).__name__)]) raise NotImplementedError # the array-content result fails server-side parsing every time - server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("sampler", on_call_tool=call_tool) async def sampling_callback( context: ClientRequestContext, params: CreateMessageRequestParams diff --git a/tests/interaction/lowlevel/test_timeouts.py b/tests/interaction/lowlevel/test_timeouts.py index 0c20fd7c6e..638bba6764 100644 --- a/tests/interaction/lowlevel/test_timeouts.py +++ b/tests/interaction/lowlevel/test_timeouts.py @@ -82,11 +82,6 @@ async def test_server_request_timeout_sends_cancellation_to_the_client() -> None callback_started = anyio.Event() errors: list[ErrorData] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="impatient", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "impatient" request = types.CreateMessageRequest( @@ -101,7 +96,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara release.set() return CallToolResult(content=[TextContent(text="gave up")]) - server = Server("impatient", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("impatient", on_call_tool=call_tool) recording = RecordingTransport(InMemoryTransport(server)) async def sampling_callback( @@ -135,23 +130,13 @@ async def sampling_callback( async def test_session_serves_requests_after_timeout() -> None: """A timed-out request does not poison the session: the next request succeeds.""" - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult( - tools=[ - types.Tool(name="block", input_schema={"type": "object"}), - types.Tool(name="echo", input_schema={"type": "object"}), - ] - ) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: if params.name == "echo": return CallToolResult(content=[TextContent(text="still alive")]) await anyio.Event().wait() # blocks until the courtesy cancellation interrupts it raise NotImplementedError # unreachable - server = Server("blocker", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("blocker", on_call_tool=call_tool) async with Client(server, mode="legacy") as client: with pytest.raises(MCPError): diff --git a/tests/interaction/lowlevel/test_tools.py b/tests/interaction/lowlevel/test_tools.py index 86fec356bc..042cf508c1 100644 --- a/tests/interaction/lowlevel/test_tools.py +++ b/tests/interaction/lowlevel/test_tools.py @@ -259,9 +259,6 @@ async def test_call_tool_multiple_content_block_types(connect: Connect, unstampe snapshot pins the exact bytes the client receives. """ - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[Tool(name="render", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "render" return CallToolResult( @@ -276,7 +273,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara ] ) - server = Server("renderer", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("renderer", on_call_tool=call_tool) async with connect(server) as client: result = await client.call_tool("render", {}) @@ -300,14 +297,11 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara async def test_call_tool_structured_content(connect: Connect, unstamped: Unstamp) -> None: """A tool result carrying structured content alongside content delivers both to the client.""" - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[Tool(name="sum", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "sum" return CallToolResult(content=[TextContent(text="the sum is 5")], structured_content={"sum": 5}) - server = Server("calculator", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("calculator", on_call_tool=call_tool) async with connect(server) as client: result = await client.call_tool("sum", {}) @@ -369,48 +363,13 @@ async def call_and_record(tag: str) -> None: ) -@requirement("client:output-schema:validate") -async def test_call_tool_structured_content_violating_output_schema_is_rejected_by_the_client(connect: Connect) -> None: - """A result whose structured content does not conform to the tool's declared output schema never - reaches the caller: the client validates it against the schema cached from tools/list and raises. - """ - - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult( - tools=[ - Tool( - name="forecast", - input_schema={"type": "object"}, - output_schema={ - "type": "object", - "properties": {"temperature": {"type": "number"}}, - "required": ["temperature"], - }, - ) - ] - ) - - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: - assert params.name == "forecast" - return CallToolResult(content=[TextContent(text="warm")], structured_content={"temperature": "warm"}) - - server = Server("weather", on_list_tools=list_tools, on_call_tool=call_tool) - - async with connect(server) as client: - await client.list_tools() - with pytest.raises(RuntimeError) as exc_info: - await client.call_tool("forecast", {}) - - # The message embeds the jsonschema validation error, so only the SDK-authored prefix is pinned. - assert str(exc_info.value).startswith("Invalid structured content returned by tool forecast") - - -@requirement("client:output-schema:skip-on-error") -async def test_is_error_result_bypasses_client_output_schema_validation(connect: Connect, unstamped: Unstamp) -> None: - """A tool result with isError true is returned as-is even when its structured content violates the schema. +@requirement("client:output-schema:returned-as-sent") +async def test_call_tool_structured_content_violating_output_schema_reaches_the_caller( + connect: Connect, unstamped: Unstamp +) -> None: + """A result whose structured content breaks the tool's declared output schema is returned unchanged. - The schema is cached up front so the client could validate, proving the bypass is specifically the - isError flag and not an empty cache. + The schema is cached up front, so the result is returned as sent even though the client could check it. """ async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: @@ -430,9 +389,7 @@ async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestPa async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "forecast" - return CallToolResult( - content=[TextContent(text="boom")], structured_content={"temperature": "warm"}, is_error=True - ) + return CallToolResult(content=[TextContent(text="warm")], structured_content={"temperature": "warm"}) server = Server("weather", on_list_tools=list_tools, on_call_tool=call_tool) @@ -441,80 +398,21 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara result = await client.call_tool("forecast", {}) assert unstamped(result) == snapshot( - CallToolResult(content=[TextContent(text="boom")], structured_content={"temperature": "warm"}, is_error=True) + CallToolResult(content=[TextContent(text="warm")], structured_content={"temperature": "warm"}) ) -@requirement("client:output-schema:missing-structured") -async def test_declared_output_schema_with_no_structured_content_is_rejected_by_the_client(connect: Connect) -> None: - """A tool that declared an output schema but returned no structuredContent fails the client-side check. - - The error is the SDK's own message, so the full text is snapshotted. - """ - - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult( - tools=[ - Tool( - name="forecast", - input_schema={"type": "object"}, - output_schema={"type": "object", "properties": {"temperature": {"type": "number"}}}, - ) - ] - ) - - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: - assert params.name == "forecast" - return CallToolResult(content=[TextContent(text="warm")]) - - server = Server("weather", on_list_tools=list_tools, on_call_tool=call_tool) - - async with connect(server) as client: - await client.list_tools() - with pytest.raises(RuntimeError) as exc_info: - await client.call_tool("forecast", {}) - - assert str(exc_info.value) == snapshot("Tool forecast has an output schema but did not return structured content") - - -@requirement("client:output-schema:auto-list") -async def test_call_tool_populates_the_output_schema_cache_via_an_implicit_tools_list( - connect: Connect, unstamped: Unstamp -) -> None: - """Calling a tool whose schema is not cached issues exactly one implicit tools/list to populate it. - - The first call_tool of an uncached tool triggers a tools/list the caller never asked for; the - second call hits the cache and does not. This is the SDK's chosen cache strategy and the cause of - the surprising behaviour where a server with only on_call_tool sees a successful call answered - with METHOD_NOT_FOUND from a request the caller never made; see the divergence on the requirement. - """ - list_calls: list[str] = [] - - async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult: - list_calls.append("called") - return ListToolsResult( - tools=[ - Tool( - name="forecast", - input_schema={"type": "object"}, - output_schema={"type": "object", "properties": {"temperature": {"type": "number"}}}, - ) - ] - ) +@requirement("client:call-tool:no-implicit-list") +async def test_call_tool_sends_no_tools_list_the_caller_did_not_ask_for(connect: Connect) -> None: + """A server that only handles tools/call answers a call: the client sends no tools/list of its own.""" async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "forecast" return CallToolResult(content=[TextContent(text="21 C")], structured_content={"temperature": 21}) - server = Server("weather", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("weather", on_call_tool=call_tool) async with connect(server) as client: - first = await client.call_tool("forecast", {}) - assert list_calls == ["called"] - second = await client.call_tool("forecast", {}) + result = await client.call_tool("forecast", {}) - assert list_calls == ["called"] - assert unstamped(first) == snapshot( - CallToolResult(content=[TextContent(text="21 C")], structured_content={"temperature": 21}) - ) - assert unstamped(second) == first + assert result.structured_content == {"temperature": 21} diff --git a/tests/interaction/transports/_stdio_server.py b/tests/interaction/transports/_stdio_server.py index 2bc383255e..e82ecdc4af 100644 --- a/tests/interaction/transports/_stdio_server.py +++ b/tests/interaction/transports/_stdio_server.py @@ -9,11 +9,8 @@ CallToolRequestParams, CallToolResult, EmptyResult, - ListToolsResult, - PaginatedRequestParams, SetLevelRequestParams, TextContent, - Tool, ) from mcp.server import Server, ServerRequestContext @@ -21,17 +18,6 @@ from mcp.shared.exceptions import MCPDeprecationWarning -async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult( - tools=[ - Tool( - name="echo", - input_schema={"type": "object", "properties": {"text": {"type": "string"}}, "required": ["text"]}, - ) - ] - ) - - async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult: assert params.name == "echo" assert params.arguments is not None @@ -50,7 +36,7 @@ async def set_logging_level(ctx: ServerRequestContext, params: SetLevelRequestPa with warnings.catch_warnings(): warnings.simplefilter("ignore", MCPDeprecationWarning) server = Server( # pyright: ignore[reportDeprecated] - "stdio-echo", on_list_tools=list_tools, on_call_tool=call_tool, on_set_logging_level=set_logging_level + "stdio-echo", on_call_tool=call_tool, on_set_logging_level=set_logging_level ) diff --git a/tests/interaction/transports/test_hosting_http_modern.py b/tests/interaction/transports/test_hosting_http_modern.py index d4cee2817f..b48b945d54 100644 --- a/tests/interaction/transports/test_hosting_http_modern.py +++ b/tests/interaction/transports/test_hosting_http_modern.py @@ -369,9 +369,8 @@ async def test_pinned_client_stateless_tools_call_round_trips_against_the_modern proving the envelope merge is additive: the caller's key sits alongside the three envelope keys on the wire and inside the handler. Asserted at the wire via the ``mounted_app`` httpx2 event hooks because none of the headers, the envelope, or the handshake-absence is observable through - the public client API. The recorded log shows two POSTs: the ``tools/call`` itself and the - client's implicit ``tools/list`` output-schema fetch (see ``client:output-schema:auto-list``), - both of which must satisfy the stateless contract. + the public client API. The recorded log shows two POSTs, the ``tools/call`` and a following + ``tools/list``, both of which must satisfy the stateless contract. """ observed_metas: list[dict[str, Any]] = [] server = _server(on_meta=observed_metas.append) @@ -403,6 +402,7 @@ async def on_response(response: httpx2.Response) -> None: {"a": 2, "b": 3}, meta={"custom-key": "x", "io.modelcontextprotocol/protocolVersion": "evil"}, ) + await session.list_tools() assert result.model_dump(by_alias=True, mode="json", exclude_none=True) == snapshot( { @@ -413,7 +413,7 @@ async def on_response(response: httpx2.Response) -> None: } ) - # Exactly the tools/call POST and the implicit tools/list POST -- no initialize, no + # Exactly the tools/call POST and the tools/list POST -- no initialize, no # notifications/initialized, no standalone GET stream, no closing DELETE. bodies = [json.loads(r.content) for r in requests] assert [(r.method, body["method"]) for r, body in zip(requests, bodies, strict=True)] == snapshot( @@ -435,7 +435,7 @@ async def on_response(response: httpx2.Response) -> None: "io.modelcontextprotocol/clientCapabilities": {}, } ) - # The implicit tools/list carries the envelope but no caller meta: proves the envelope is + # The tools/list carries the envelope but no caller meta: proves the envelope is # stamped on every request, not just on requests where the caller passed meta=. assert bodies[1]["params"]["_meta"] == snapshot( { diff --git a/tests/interaction/transports/test_legacy_wire.py b/tests/interaction/transports/test_legacy_wire.py index 4653696cf9..47d31a483b 100644 --- a/tests/interaction/transports/test_legacy_wire.py +++ b/tests/interaction/transports/test_legacy_wire.py @@ -13,10 +13,7 @@ from mcp_types import ( CallToolRequestParams, CallToolResult, - ListToolsResult, - PaginatedRequestParams, TextContent, - Tool, ) from mcp.client.client import Client @@ -34,15 +31,12 @@ def _server() -> Server: """A low-level server with one echo tool, so the recorded exchange covers tools/list and tools/call.""" - async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult(tools=[Tool(name="echo", description="Echo text.", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult: assert params.name == "echo" assert params.arguments is not None return CallToolResult(content=[TextContent(text=str(params.arguments["text"]))]) - return Server("legacy", on_list_tools=list_tools, on_call_tool=call_tool) + return Server("legacy", on_call_tool=call_tool) @requirement("hosting:http:legacy-no-modern-vocabulary") @@ -74,12 +68,12 @@ async def on_response(response: httpx2.Response) -> None: recorded.frames.extend(m.message for m in recording.sent) recorded.frames.extend(m.message for m in recording.received if isinstance(m, SessionMessage)) - # The handshake, the implicit tools/list (output-schema cache), tools/call, the standalone GET - # stream, and the closing DELETE all crossed the HTTP seam; the transport seam saw a JSON-RPC + # The handshake, tools/call, the standalone GET stream, and the closing DELETE all crossed + # the HTTP seam; the transport seam saw a JSON-RPC # frame for each direction of each. Asserting non-empty so the vocabulary scan cannot pass on # nothing recorded. assert {r.method for r in recorded.requests} == snapshot({"POST", "GET", "DELETE"}) assert len(recorded.responses) == len(recorded.requests) - assert len(recorded.frames) >= 6 + assert len(recorded.frames) >= 5 assert_no_modern_vocabulary(recorded) diff --git a/tests/issues/test_88_random_error.py b/tests/issues/test_88_random_error.py index 409ac96a2f..9c778cb47e 100644 --- a/tests/issues/test_88_random_error.py +++ b/tests/issues/test_88_random_error.py @@ -3,7 +3,6 @@ from pathlib import Path import anyio -import mcp_types as types import pytest from anyio.abc import TaskStatus from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream @@ -11,8 +10,6 @@ REQUEST_TIMEOUT, CallToolRequestParams, CallToolResult, - ListToolsResult, - PaginatedRequestParams, TextContent, ) @@ -40,22 +37,6 @@ async def test_notification_validation_error(tmp_path: Path): request_count = 0 slow_request_lock = anyio.Event() - async def handle_list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult( - tools=[ - types.Tool( - name="slow", - description="A slow tool", - input_schema={"type": "object"}, - ), - types.Tool( - name="fast", - description="A fast tool", - input_schema={"type": "object"}, - ), - ] - ) - async def handle_call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult: nonlocal request_count request_count += 1 @@ -69,7 +50,7 @@ async def handle_call_tool(ctx: ServerRequestContext, params: CallToolRequestPar text = f"fast {request_count}" return CallToolResult(content=[TextContent(type="text", text=text)]) - server = Server(name="test", on_list_tools=handle_list_tools, on_call_tool=handle_call_tool) + server = Server(name="test", on_call_tool=handle_call_tool) async def server_handler( read_stream: MemoryObjectReceiveStream[SessionMessage | Exception], diff --git a/tests/server/test_apps.py b/tests/server/test_apps.py index 2ad5410f8b..304ac06ebe 100644 --- a/tests/server/test_apps.py +++ b/tests/server/test_apps.py @@ -113,17 +113,12 @@ async def _observed_client_supports_apps(ui_settings: dict[str, Any] | None) -> """ observed: list[bool] = [] - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="probe", input_schema={"type": "object"})]) - async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult: assert params.name == "probe" observed.append(client_supports_apps(ctx)) return CallToolResult(content=[TextContent(text="ok")]) - server = Server("probe", on_list_tools=list_tools, on_call_tool=call_tool) + server = Server("probe", on_call_tool=call_tool) extensions = None if ui_settings is None else [advertise(EXTENSION_ID, ui_settings)] async with Client(server, extensions=extensions) as client: await client.call_tool("probe", {}) diff --git a/tests/server/test_cancel_handling.py b/tests/server/test_cancel_handling.py index fd0e4b28af..a524af837e 100644 --- a/tests/server/test_cancel_handling.py +++ b/tests/server/test_cancel_handling.py @@ -13,10 +13,7 @@ InitializeRequestParams, JSONRPCNotification, JSONRPCRequest, - ListToolsResult, - PaginatedRequestParams, TextContent, - Tool, ) from mcp_types.version import LATEST_HANDSHAKE_VERSION @@ -35,17 +32,6 @@ async def test_server_remains_functional_after_cancel(): ev_first_call_cancelled = anyio.Event() first_request_id = None - async def handle_list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult: - return ListToolsResult( - tools=[ - Tool( - name="test_tool", - description="Tool for testing", - input_schema={"type": "object"}, - ) - ] - ) - async def handle_call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult: nonlocal call_count, first_request_id if params.name == "test_tool": @@ -61,7 +47,7 @@ async def handle_call_tool(ctx: ServerRequestContext, params: CallToolRequestPar return CallToolResult(content=[TextContent(type="text", text=f"Call number: {call_count}")]) raise ValueError(f"Unknown tool: {params.name}") # pragma: no cover - server = Server("test-server", on_list_tools=handle_list_tools, on_call_tool=handle_call_tool) + server = Server("test-server", on_call_tool=handle_call_tool) async with Client(server, mode="legacy") as client: # First request (will be cancelled server-side, then abandoned here: a diff --git a/tests/server/test_extensions_capability.py b/tests/server/test_extensions_capability.py index 017ac517e6..e681e18219 100644 --- a/tests/server/test_extensions_capability.py +++ b/tests/server/test_extensions_capability.py @@ -76,12 +76,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara supported.append(ctx.session.check_client_capability(queried)) return types.CallToolResult(content=[]) - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="probe", input_schema={"type": "object"})]) - - server = Server("checker", on_call_tool=call_tool, on_list_tools=list_tools) + server = Server("checker", on_call_tool=call_tool) async with Client(server, extensions=[advertise(_EXTENSION_ID, {"mimeTypes": ["text/html"]})]) as client: await client.call_tool("probe", {}) @@ -99,12 +94,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara supported.append(ctx.session.check_client_capability(queried)) return types.CallToolResult(content=[]) - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="probe", input_schema={"type": "object"})]) - - server = Server("checker", on_call_tool=call_tool, on_list_tools=list_tools) + server = Server("checker", on_call_tool=call_tool) async with Client(server, extensions=[advertise(_EXTENSION_ID, {"mimeTypes": ["text/html"]})]) as client: await client.call_tool("probe", {}) @@ -122,12 +112,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara supported.append(ctx.session.check_client_capability(queried)) return types.CallToolResult(content=[]) - async def list_tools( - ctx: ServerRequestContext, params: types.PaginatedRequestParams | None - ) -> types.ListToolsResult: - return types.ListToolsResult(tools=[types.Tool(name="probe", input_schema={"type": "object"})]) - - server = Server("checker", on_call_tool=call_tool, on_list_tools=list_tools) + server = Server("checker", on_call_tool=call_tool) async with Client(server) as client: await client.call_tool("probe", {}) diff --git a/tests/server/test_request_state_boundary.py b/tests/server/test_request_state_boundary.py index ed4e5b0662..89701d6be4 100644 --- a/tests/server/test_request_state_boundary.py +++ b/tests/server/test_request_state_boundary.py @@ -16,13 +16,10 @@ ElicitRequestFormParams, ElicitResult, InputRequiredResult, - ListToolsResult, - PaginatedRequestParams, ReadResourceResult, RequestParams, TextContent, TextResourceContents, - Tool, ) import mcp.server.request_state as request_state_module @@ -69,11 +66,6 @@ def _accept() -> ElicitResult: return ElicitResult(action="accept", content={"confirm": True}) -async def _list_tools(ctx: ServerRequestContext[Any], params: PaginatedRequestParams | None) -> ListToolsResult: - """`ClientSession.call_tool` consults tools/list, so lowlevel fixtures must answer it.""" - return ListToolsResult(tools=[Tool(name="t", input_schema={"type": "object"})]) - - class _PassthroughCodec: """Cryptography-free codec (the token IS the payload) that puts arbitrary bytes behind a successful unseal.""" @@ -187,7 +179,7 @@ async def call_tool( seen.append(params.request_state) return CallToolResult(content=[TextContent(text="done")]) - server = Server("srv", on_call_tool=call_tool, on_list_tools=_list_tools) + server = Server("srv", on_call_tool=call_tool) server.middleware.append(RequestStateBoundary(RequestStateSecurity(keys=[_KEY]), default_audience=server.name)) with anyio.fail_after(5): @@ -508,7 +500,7 @@ async def call_tool( return InputRequiredResult(input_requests={"confirm": _ask("Go?")}, request_state="round-1") return CallToolResult(content=[TextContent(text="done")]) - server = Server("srv", on_call_tool=call_tool, on_list_tools=_list_tools) + server = Server("srv", on_call_tool=call_tool) server.middleware.append(boundary) return server @@ -675,7 +667,7 @@ async def call_tool( seen.append(params.request_state) return CallToolResult(content=[TextContent(text="done")]) - server = Server("srv", on_call_tool=call_tool, on_list_tools=_list_tools) + server = Server("srv", on_call_tool=call_tool) with anyio.fail_after(5): async with Client(server) as client: @@ -751,7 +743,7 @@ async def custom(ctx: ServerRequestContext[Any], params: _CustomMethodParams) -> calls.append(params.request_state or "fresh") return {"resultType": "complete"} - server = Server("srv", on_list_tools=_list_tools) + server = Server("srv") server.add_request_handler("example/mrtr", _CustomMethodParams, custom) server.middleware.append(RequestStateBoundary(RequestStateSecurity(keys=[_KEY]), default_audience=None)) @@ -770,7 +762,7 @@ async def test_outbound_request_state_on_a_non_carrier_method_is_not_sealed() -> async def custom(ctx: ServerRequestContext[Any], params: _CustomMethodParams) -> InputRequiredResult: return InputRequiredResult(input_requests={"confirm": _ask("?")}, request_state="ext-handler-plaintext") - server = Server("srv", on_list_tools=_list_tools) + server = Server("srv") server.add_request_handler("example/mrtr", _CustomMethodParams, custom) server.middleware.append(RequestStateBoundary(RequestStateSecurity(keys=[_KEY]), default_audience=None)) @@ -787,7 +779,7 @@ async def test_an_off_set_input_required_result_without_state_passes_through_unt async def custom(ctx: ServerRequestContext[Any], params: _CustomMethodParams) -> InputRequiredResult: return InputRequiredResult(input_requests={"confirm": _ask("?")}) - server = Server("srv", on_list_tools=_list_tools) + server = Server("srv") server.add_request_handler("example/mrtr", _CustomMethodParams, custom) server.middleware.append(RequestStateBoundary(RequestStateSecurity(keys=[_KEY]), default_audience=None)) diff --git a/tests/shared/test_sse.py b/tests/shared/test_sse.py index 77d1b28a0a..e9d55a0f03 100644 --- a/tests/shared/test_sse.py +++ b/tests/shared/test_sse.py @@ -18,14 +18,11 @@ Implementation, InitializeResult, JSONRPCResponse, - ListToolsResult, - PaginatedRequestParams, ReadResourceRequestParams, ReadResourceResult, ServerCapabilities, TextContent, TextResourceContents, - Tool, ) from starlette.applications import Starlette from starlette.requests import Request @@ -254,35 +251,11 @@ async def _handle_context_call_tool(ctx: ServerRequestContext, params: CallToolR return CallToolResult(content=[TextContent(type="text", text=json.dumps(context_data))]) -async def _handle_context_list_tools( - ctx: ServerRequestContext, params: PaginatedRequestParams | None -) -> ListToolsResult: - return ListToolsResult( - tools=[ - Tool( - name="echo_headers", - description="Echoes request headers", - input_schema={"type": "object", "properties": {}}, - ), - Tool( - name="echo_context", - description="Echoes request context", - input_schema={ - "type": "object", - "properties": {"request_id": {"type": "string"}}, - "required": ["request_id"], - }, - ), - ] - ) - - def make_context_server_app() -> Starlette: return make_app( Server( "request_context_server", on_call_tool=_handle_context_call_tool, - on_list_tools=_handle_context_list_tools, ) ) diff --git a/tests/shared/test_streamable_http.py b/tests/shared/test_streamable_http.py index 655d9941dc..75640be01b 100644 --- a/tests/shared/test_streamable_http.py +++ b/tests/shared/test_streamable_http.py @@ -1380,29 +1380,6 @@ async def sampling_callback( # Context-aware server implementation for testing request context propagation -async def _handle_context_list_tools( - ctx: ServerRequestContext, params: PaginatedRequestParams | None -) -> ListToolsResult: - return ListToolsResult( - tools=[ - Tool( - name="echo_headers", - description="Echo request headers from context", - input_schema={"type": "object", "properties": {}}, - ), - Tool( - name="echo_context", - description="Echo request context with custom data", - input_schema={ - "type": "object", - "properties": { - "request_id": {"type": "string"}, - }, - "required": ["request_id"], - }, - ), - ] - ) async def _handle_context_call_tool( @@ -1430,7 +1407,6 @@ async def _handle_context_call_tool( async def _run_context_app(*, stateless: bool) -> AsyncIterator[Starlette]: server = Server( "ContextAwareServer", - on_list_tools=_handle_context_list_tools, on_call_tool=_handle_context_call_tool, ) session_manager = StreamableHTTPSessionManager( diff --git a/tests/test_examples.py b/tests/test_examples.py index ffc0c448d0..f02cbb5be8 100644 --- a/tests/test_examples.py +++ b/tests/test_examples.py @@ -80,10 +80,6 @@ async def test_direct_call_tool_result_return(): @pytest.mark.anyio async def test_desktop(tmp_path: Path, monkeypatch: pytest.MonkeyPatch): """Test the desktop server""" - # Build a real Desktop directory under tmp_path rather than patching - # Path.iterdir — a class-level patch breaks jsonschema_specifications' - # import-time schema discovery when this test happens to be the first - # tool call in an xdist worker. desktop = tmp_path / "Desktop" desktop.mkdir() (desktop / "file1.txt").touch() diff --git a/uv.lock b/uv.lock index 3b718ff868..9ab9f2daa7 100644 --- a/uv.lock +++ b/uv.lock @@ -839,33 +839,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/78/f7/18a1afcd64f35314b68c1f23afcd9994d0bc13e65cc77517afff4e83986d/jiter-0.16.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64d613743df53199b1aa256a7d328340da6d7078aac7705a7db9d7a791e9cfd2", size = 343885, upload-time = "2026-06-29T13:05:12.087Z" }, ] -[[package]] -name = "jsonschema" -version = "4.25.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "attrs" }, - { name = "jsonschema-specifications" }, - { name = "referencing" }, - { name = "rpds-py" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload-time = "2025-08-18T17:03:48.373Z" }, -] - -[[package]] -name = "jsonschema-specifications" -version = "2025.9.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "referencing" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, -] - [[package]] name = "logfire" version = "5.3.0" @@ -976,7 +949,6 @@ default-groups = ["dev", "docs"] dependencies = [ { name = "anyio" }, { name = "httpx2" }, - { name = "jsonschema" }, { name = "mcp-types" }, { name = "opentelemetry-api" }, { name = "pydantic", version = "2.12.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.15'" }, @@ -1044,7 +1016,6 @@ requires-dist = [ { name = "anyio", marker = "python_full_version < '3.14'", specifier = ">=4.9" }, { name = "anyio", marker = "python_full_version >= '3.14'", specifier = ">=4.10" }, { name = "httpx2", specifier = ">=2.10.0" }, - { name = "jsonschema", specifier = ">=4.20.0" }, { name = "mcp-types", editable = "src/mcp-types" }, { name = "opentelemetry-api", specifier = ">=1.28.0" }, { name = "pydantic", marker = "python_full_version < '3.15'", specifier = ">=2.12.0" }, @@ -2550,20 +2521,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" }, ] -[[package]] -name = "referencing" -version = "0.36.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "attrs" }, - { name = "rpds-py" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744, upload-time = "2025-01-25T08:48:16.138Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775, upload-time = "2025-01-25T08:48:14.241Z" }, -] - [[package]] name = "requests" version = "2.33.0" @@ -2592,141 +2549,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e3/30/3c4d035596d3cf444529e0b2953ad0466f6049528a879d27534700580395/rich-14.1.0-py3-none-any.whl", hash = "sha256:536f5f1785986d6dbdea3c75205c473f970777b4a0d6c6dd1b696aa05a3fa04f", size = 243368, upload-time = "2025-07-25T07:32:56.73Z" }, ] -[[package]] -name = "rpds-py" -version = "2026.9.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/42/68/3bd46b8a5e01d3c2ebdf9c5e9497912e3fe0cde02bac21a7130ca866e403/rpds_py-2026.9.1.tar.gz", hash = "sha256:4793ef7f78268b124b73fa933440f01d258bbae01de9fa53e9080c9ab0425a12", size = 63948, upload-time = "2026-10-04T16:32:36.469Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f5/6d/ddb8dfcf41892ba9c672d27988592c038d30db61708230313831b6780a1b/rpds_py-2026.9.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:2711d29b653b3bce48a63d18b9c6b53274669e6d6c4094dddeb4d9a0e45128b2", size = 344947, upload-time = "2026-10-04T16:28:55.207Z" }, - { url = "https://files.pythonhosted.org/packages/9e/b2/632c3d034961149eff606e3e357547620a9ab37b849ae5815f67838753fd/rpds_py-2026.9.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3231c4c0e521dafa5be0c9f114ee2c2ad46650836f2d72caa86801950c3e7044", size = 346770, upload-time = "2026-10-04T16:28:56.884Z" }, - { url = "https://files.pythonhosted.org/packages/6d/45/4df346410bb873d03ec60c3b891d1fceb8cabde1971d29844bbb625cc296/rpds_py-2026.9.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e01b3c878c8641913e688edd1b3f08658c6783d29cf6b826bd3c0d1ae7a1ffaa", size = 377795, upload-time = "2026-10-04T16:28:58.193Z" }, - { url = "https://files.pythonhosted.org/packages/ba/b8/a70f302207e4f29f873c01a986fcac5def49b9c8224328cef1ad7da6b7a9/rpds_py-2026.9.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3e524c7874ac72884d28e16dd5b8d839fd09e0fe76b020d3fbca23212a7b8c52", size = 383137, upload-time = "2026-10-04T16:28:59.411Z" }, - { url = "https://files.pythonhosted.org/packages/13/e3/3aa28a48a01169d0e20728bf0e5ebbea3ae2774285b40853ae49b3ef332a/rpds_py-2026.9.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:761fdae6728ceb99ab182fad2f0cc1e262f610834dc891aea1d1a2a2e634776f", size = 496789, upload-time = "2026-10-04T16:29:01.011Z" }, - { url = "https://files.pythonhosted.org/packages/3e/a7/414e8d088602d66ad6f47c65bf07fe5090992a8574cdd4571c1a83b647ed/rpds_py-2026.9.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6b723eb406dec5bc9ec516c73ab9c3239a3284e017f7eb89ee2b3258bd504fb7", size = 395929, upload-time = "2026-10-04T16:29:02.465Z" }, - { url = "https://files.pythonhosted.org/packages/2d/5c/aac3b960fd55d37b49f77c0eebbe043eaf36762ebd48e7b46951e59c1c05/rpds_py-2026.9.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:136a1c3fe4402b7008bc81cb62ee538481795b61a7e83df88dff3b3f02b726ff", size = 375426, upload-time = "2026-10-04T16:29:03.944Z" }, - { url = "https://files.pythonhosted.org/packages/d3/80/77987a41c40be7202a78d9aed4a650bfb05792237cfd3b9e22638d990fe5/rpds_py-2026.9.1-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:839dde845559254f34885267c6878f60d61d5205180226d976fe488d45fa128e", size = 381497, upload-time = "2026-10-04T16:29:05.308Z" }, - { url = "https://files.pythonhosted.org/packages/b8/d0/640b02eb1ecd71a913c1178b6235287b31006266bca9a26862e80e497b54/rpds_py-2026.9.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:56cd8b3f77d7b6812f533b662186a1f28316931166ddc00fb893b1b0db7e9888", size = 405740, upload-time = "2026-10-04T16:29:06.578Z" }, - { url = "https://files.pythonhosted.org/packages/3e/8c/d034195d45d215625a23f2ae85dbbdb86a49a93a51272061c97c80b9d316/rpds_py-2026.9.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:074a4d198bc34d9a8ea425114fc3ded6d11ec01f6a314a8db67454a5152d8834", size = 555850, upload-time = "2026-10-04T16:29:08.115Z" }, - { url = "https://files.pythonhosted.org/packages/de/f8/532f1addfc86207bc3cf23749638bb0d457bce891595012ed8a08d0543b8/rpds_py-2026.9.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6beb738155fe8ab8091afdfa5a3226b21c2b1593f1e50ebb90eb25b44dbc0391", size = 618661, upload-time = "2026-10-04T16:29:09.554Z" }, - { url = "https://files.pythonhosted.org/packages/50/5b/b0f2c9833a36a5b1f6ac5cb0e635fabacf713266f46ceefba2102da0bf51/rpds_py-2026.9.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:57492a550a1d88d29d003247e5f78dd8cf04a701fac0e4c8db8745a6d2504e0a", size = 583530, upload-time = "2026-10-04T16:29:11.072Z" }, - { url = "https://files.pythonhosted.org/packages/bf/20/464ed4b98d3c8c6a334f3b5e24d3886de04b05658a95fc40a37e0e6e4775/rpds_py-2026.9.1-cp311-cp311-win32.whl", hash = "sha256:d95a354e02393eada6d7351184671aced9d4cce109dabf927cb7aa99624352a1", size = 208125, upload-time = "2026-10-04T16:29:12.408Z" }, - { url = "https://files.pythonhosted.org/packages/df/c9/384a9b62f8cd89c8e3e609b8c9052c140e8c01d807261e0517c904b8bf29/rpds_py-2026.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:ce4d4f52e2a4324396caddbd45a97d8d7be5f42edd25d2355282a9c34f9b2f7f", size = 226045, upload-time = "2026-10-04T16:29:13.751Z" }, - { url = "https://files.pythonhosted.org/packages/4f/3b/0a691f0dcb2301fa9c736346da2d0d4991778373283301c5c12b8f952f3d/rpds_py-2026.9.1-cp311-cp311-win_arm64.whl", hash = "sha256:fdcd198979b4ecffcc1beba366a7fbcf4eb41243691a82fe52ceb0b902f09c12", size = 222636, upload-time = "2026-10-04T16:29:14.989Z" }, - { url = "https://files.pythonhosted.org/packages/5d/34/a828586ea3329fbb50895b50e9cf98ca3d924a9f41a0b26d443bff1b3794/rpds_py-2026.9.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:50906f5aea24b5a865cbd0a589698288631d9f3a54c3a937c83aefa95a0d14af", size = 346822, upload-time = "2026-10-04T16:29:16.258Z" }, - { url = "https://files.pythonhosted.org/packages/90/81/ac6a0d064982251856ce009c9e1dd51a34110b3c055aa7d1aad18b4899a3/rpds_py-2026.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e21c1429e205828ea886a2293a4a2c8e01f4c25d9893ca330e97a6cf73f52e7b", size = 341380, upload-time = "2026-10-04T16:29:17.706Z" }, - { url = "https://files.pythonhosted.org/packages/42/ff/bf7d54f362748fd6a49277b9d6531c394074110fedf50ad791ec59133fbb/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2693b2728bbcc48d09a981a356954b0c47c53ff25b545856f28a889ea619f69a", size = 373053, upload-time = "2026-10-04T16:29:19.063Z" }, - { url = "https://files.pythonhosted.org/packages/60/de/74b0ccdbbd28687b9b5fdb34c1cabed88352182facaced9d6f5486b8b9ed/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8601470267d938bcb7f3ab1a336100af51a4fd5b6ed030ef52461bb3ef5e7e07", size = 377742, upload-time = "2026-10-04T16:29:20.543Z" }, - { url = "https://files.pythonhosted.org/packages/c2/6d/b979775a3057b2a5c26d75ecbff60a20a24ef081db6dd76836fca3f20247/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3890a6aa36e6baa53d5258a2a25d3ef8b37ad165a6ab27a892d7c3e3a432cd69", size = 487289, upload-time = "2026-10-04T16:29:21.958Z" }, - { url = "https://files.pythonhosted.org/packages/1d/5d/7c34734ce3ece943d9d6ee0122a74a21bbc75b47acb5b7053c83f6efb1ed/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6b5b393eda5ea42cca1c1a6665f2a4882b4fd5d1777e41ce0545a107fb008c9d", size = 390710, upload-time = "2026-10-04T16:29:23.378Z" }, - { url = "https://files.pythonhosted.org/packages/1d/6d/b26eb1e75395925b3a142ed351cbed2ec8212f5c9d937aee3df32c701baa/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:addeda51556dac7c1a2f14cda62db8b621cd12afba3091d03a96c72932387eab", size = 371261, upload-time = "2026-10-04T16:29:25.1Z" }, - { url = "https://files.pythonhosted.org/packages/7c/98/b2fdfe10301a9e27af21e634337fbba7baac0bc17fe44619a17c26bba2cb/rpds_py-2026.9.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d9edf30457d74eebfd76b045535e36f1cd89062566a128a0db2145ca042d787e", size = 376075, upload-time = "2026-10-04T16:29:26.748Z" }, - { url = "https://files.pythonhosted.org/packages/c5/b1/c4b8d954e49c3c69cf8063c0c9e0919c99f3d2cecc46311606a1cbe835dc/rpds_py-2026.9.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:815d26356930846a40c7bc1366e7b1b0320ab8a063e66c11298a208bed0fd237", size = 399358, upload-time = "2026-10-04T16:29:28.282Z" }, - { url = "https://files.pythonhosted.org/packages/b3/59/9559a7293c97dff0cbb293efffbd36644103883ecc27741af8ef90c84ca8/rpds_py-2026.9.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b5a6f40f0a1486b4b36c888123afc67acdbd9f33235927acf5ff295429a0ba3", size = 550267, upload-time = "2026-10-04T16:29:29.851Z" }, - { url = "https://files.pythonhosted.org/packages/6c/9d/6dc60e49511de4c8b00e74f9c1d43aed4d27f712cdb1ade92f2c199cbf64/rpds_py-2026.9.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b5b8b0753718d258fd454283fbd57e14545d3b40583fa672e27cb4f987626bcc", size = 614018, upload-time = "2026-10-04T16:29:31.54Z" }, - { url = "https://files.pythonhosted.org/packages/fb/bc/92a4ecf27301b886232a413360f6b348a81d55ffef654f2ebda5970ebc3d/rpds_py-2026.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:46d80bc76b51a6c24f9944368c28d38b8bcbcea1da4f2f8d3ebc31a67e8c6ec6", size = 578509, upload-time = "2026-10-04T16:29:33.01Z" }, - { url = "https://files.pythonhosted.org/packages/08/53/efb97f2e6589b7ab8394385a73870e0b2ab2a195281c117b21fd6d7d4855/rpds_py-2026.9.1-cp312-cp312-win32.whl", hash = "sha256:befc2d6a953e563f8a7bfd87a42c22ebf8a3e980dcb7b6a4d17b70b0e914e8a3", size = 205401, upload-time = "2026-10-04T16:29:34.451Z" }, - { url = "https://files.pythonhosted.org/packages/1c/84/1700cc748d0eaa747486e4e82882d2575224e6e9a3148df583058850c629/rpds_py-2026.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:5ce8943f79c2210f7abcc28e86367b03b28d95027fd01c46d2472373ae70c86f", size = 222923, upload-time = "2026-10-04T16:29:35.709Z" }, - { url = "https://files.pythonhosted.org/packages/c3/89/0302215373c2f8b4408b0fdfee955368cc378a98ff59508d47a7e0dc2dbf/rpds_py-2026.9.1-cp312-cp312-win_arm64.whl", hash = "sha256:501909f2e4a1e2dee528ef766fe3c469060ebc17e54a8383d404ba07a81a6f02", size = 218415, upload-time = "2026-10-04T16:29:37.263Z" }, - { url = "https://files.pythonhosted.org/packages/83/ea/ee88fd9e756ff93fb6b1182a47ec09504a242620e33ce1d20679efefe841/rpds_py-2026.9.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:a36b70596407634ca82d4b989a3729074a008537a0522e4c8046a67c729103e9", size = 346229, upload-time = "2026-10-04T16:29:38.82Z" }, - { url = "https://files.pythonhosted.org/packages/57/71/a097d6552f837500fc36e6b23d09cfb9890c3cc47531f9ca64e149799615/rpds_py-2026.9.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eba5d173f7d5708b22a93815017a4611873ed54db9f268077c0dd1ed99cfc858", size = 340514, upload-time = "2026-10-04T16:29:40.405Z" }, - { url = "https://files.pythonhosted.org/packages/bd/b7/497e85768bf4e0d8ddbaa096a4cac31d1509251dee2728a8490aa367e0b5/rpds_py-2026.9.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:457866b85daf5034296666168b84a69e0b2e89dc4f1af102b46f6448a60b9063", size = 372611, upload-time = "2026-10-04T16:29:41.778Z" }, - { url = "https://files.pythonhosted.org/packages/52/4b/74ab4108916250b6e198e0d3af05bc6835eb046315f22f7a0ceb49667c5a/rpds_py-2026.9.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a3a52a3ba86436ab3aef510fbe21512abc2ddd1993005dfe50514bd2284ef025", size = 377712, upload-time = "2026-10-04T16:29:43.242Z" }, - { url = "https://files.pythonhosted.org/packages/0c/8e/067e77d9d7b3cc793c9d909b7e97e7aadbbb1fb094093b6876902cc96d38/rpds_py-2026.9.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d7841166b7fa64c9c56404617ae4341448847482d45933b13135d26c130519e5", size = 488106, upload-time = "2026-10-04T16:29:44.692Z" }, - { url = "https://files.pythonhosted.org/packages/3c/b4/c5aae6c2dde269bf955f6b7d35065c655a57e47750d9668052ad67e74dda/rpds_py-2026.9.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:926bdd3e3b5998ddf70cc64bc8cf57209571f9044542913afb673799fec77dd0", size = 390795, upload-time = "2026-10-04T16:29:46.129Z" }, - { url = "https://files.pythonhosted.org/packages/a0/36/76fab39973ee11e7f9f357c55138197bb01c86f6502cb76487e3b4f42db0/rpds_py-2026.9.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7868b85224291c6cb6759f9b5adb9745f486d226f62b16a614dd5a2a5ab2b35b", size = 370794, upload-time = "2026-10-04T16:29:47.603Z" }, - { url = "https://files.pythonhosted.org/packages/3d/fe/cd2a80e6d7b871937a60e935c5d507aa390d143f4ff3636f640b9733d5df/rpds_py-2026.9.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:3cd182d7291d29b92c521a0069d9c01ba6193628a9a105531d11b40a6d731a33", size = 375673, upload-time = "2026-10-04T16:29:49.223Z" }, - { url = "https://files.pythonhosted.org/packages/6c/18/7464a9953724e55a3b3206062fa0ffdeaa519584c6aabf65d3956d94f131/rpds_py-2026.9.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e6ea1cda8d8c688278430e4268a42f5e5da3bdd74578dfadc0820c3f1766ce83", size = 398758, upload-time = "2026-10-04T16:29:50.601Z" }, - { url = "https://files.pythonhosted.org/packages/c0/86/1534b436700fd49ff411063b7c4d7e938adfabf90895b6cf1622d5a7d1f6/rpds_py-2026.9.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5943980471829f6de242a20b109de3111ba6b77e3af0ffc587028ac854b05e6c", size = 550370, upload-time = "2026-10-04T16:29:52.002Z" }, - { url = "https://files.pythonhosted.org/packages/57/1c/e1fa82a8a01e3c5820f3ba98a8b2673f642128eb368fa88871b01dd2c909/rpds_py-2026.9.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:76d3af9732d2dab69f28179b40ba2d87e2f1d5824b4a694780aa787d685e8f36", size = 613106, upload-time = "2026-10-04T16:29:53.655Z" }, - { url = "https://files.pythonhosted.org/packages/29/55/b20b8c4c3dde8755bfcd5b08492a02d0cd2e26929aedf6199ca2a377d42a/rpds_py-2026.9.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:78326f4cb4427a56ba4996c0762b63be45f06b85f086526420d2b3a66e40f84d", size = 578235, upload-time = "2026-10-04T16:29:55.157Z" }, - { url = "https://files.pythonhosted.org/packages/55/42/df3f7bbc3f7ab37a8a9db8d6c2ff2c985422899f1f7926afbf7ec3c0b8b4/rpds_py-2026.9.1-cp313-cp313-win32.whl", hash = "sha256:172e47169583f46ce118cbec68e6795d0da0f4606b488b6434f8276bca0a058c", size = 205293, upload-time = "2026-10-04T16:29:56.669Z" }, - { url = "https://files.pythonhosted.org/packages/31/9c/ba5a9569d719bfdd6ce863df4133ac6a1658cf1b07cc3534c31db729fbbc/rpds_py-2026.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:3e93b2cd69a9830be33e03945cd7cda940a0a8bfcfbff41d6144f0cb0d3d8bd9", size = 222409, upload-time = "2026-10-04T16:29:58.049Z" }, - { url = "https://files.pythonhosted.org/packages/35/72/f28ca566f6c23c35bbf7445f65eb0364577b25a026305995e24f78b83d94/rpds_py-2026.9.1-cp313-cp313-win_arm64.whl", hash = "sha256:d151e148117294133bf8af7eeace085e7e87432db15ab6adf640330298a47f6f", size = 217681, upload-time = "2026-10-04T16:29:59.449Z" }, - { url = "https://files.pythonhosted.org/packages/8a/f2/67b94be1532767803415c1c5a1fd88ea487643d74a673cec1ba140af77bb/rpds_py-2026.9.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c9d1aca01f49170fdcf5c92761b1fafe97f554b721ca4570c5949fff778f0d4b", size = 347178, upload-time = "2026-10-04T16:30:00.865Z" }, - { url = "https://files.pythonhosted.org/packages/04/37/b751de2b59b0197a1d92a5dd491de88e8a5e928c2e6562581974f1e85263/rpds_py-2026.9.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3f0e9ac28fc067d4d34b88ae43c48e9489455c97fee9633d851f7eeed5a05d35", size = 341878, upload-time = "2026-10-04T16:30:02.564Z" }, - { url = "https://files.pythonhosted.org/packages/72/e2/5873bc4643c250db9e05d48dc0c93763d4aa68bc3b81164cb1af3b45b284/rpds_py-2026.9.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:07deecbfce94c78473018bc7d10b337cc651d12df87a1eb2cb3e4024bc9c33d0", size = 373963, upload-time = "2026-10-04T16:30:04.026Z" }, - { url = "https://files.pythonhosted.org/packages/51/03/5acf7632158247f3f6386ff0af3a1ee48167d575037e8d0920594b76d92b/rpds_py-2026.9.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:821b2755db9194409254012f429c56643416fb96ef9be090be82ec8826b7f477", size = 377975, upload-time = "2026-10-04T16:30:05.555Z" }, - { url = "https://files.pythonhosted.org/packages/e6/00/63fda451b8bffa5808fc8bb311ee7c073b340974b09f273c7b2a145d3d62/rpds_py-2026.9.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3c91c210ae7645626c608400e3519b4a642f837cce09ca830db3beb2e9f274d4", size = 490347, upload-time = "2026-10-04T16:30:07.156Z" }, - { url = "https://files.pythonhosted.org/packages/a1/ae/c093ffd070ba0fb02f76c565d06fecc65ad6e4afdbae78f7031076d3cdac/rpds_py-2026.9.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:54ac2158a6f96cfbabff0b2eedaf94b90c5ec7ca8317fcadc61e1c2b2e0ff6ef", size = 392962, upload-time = "2026-10-04T16:30:08.77Z" }, - { url = "https://files.pythonhosted.org/packages/22/9d/d08a1128ab199b2f0cf25bfeb0639bd05119fff4b7c47bec24ef9a8ec23f/rpds_py-2026.9.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eac2f5dbafd585dfe31f86a23ebf0d3ba480a9d49ebc87947267b5608d4ea0cd", size = 371623, upload-time = "2026-10-04T16:30:10.501Z" }, - { url = "https://files.pythonhosted.org/packages/53/c7/4758ddcbb75609414bbccfcb11d612436f9b3ee821bd2f33f0f1604ee648/rpds_py-2026.9.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:8aa5dda18d39b6143eb24809d158f9252c88f402749b6f1b62a506cc7d96cc35", size = 376997, upload-time = "2026-10-04T16:30:12.124Z" }, - { url = "https://files.pythonhosted.org/packages/87/e4/947bd7f608ff60faf46dc9d389c3dffd0e3d767d78a0be19978448ef0ce7/rpds_py-2026.9.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5c90e7fa02e8f5de0d10c17595c568ada48c5302e749462c0ea1a4c362111a86", size = 400169, upload-time = "2026-10-04T16:30:13.804Z" }, - { url = "https://files.pythonhosted.org/packages/4b/35/fe93e020a0543b5670472c18d7e6af3197c08da571240ce1965c84f85c0f/rpds_py-2026.9.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e6d198bad4e49dd6732fbd636e2fc5c082f45c8cad0b4acb756b00c82c76072e", size = 551615, upload-time = "2026-10-04T16:30:15.332Z" }, - { url = "https://files.pythonhosted.org/packages/0d/4f/5d2a0136bb03b2a56a39dc6ff92d58a6e3e53a2e17079238b86228882f16/rpds_py-2026.9.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:96beca19ec79de272e8668585380ff9092c47077c1d7a1e098e00bbd921f4785", size = 614655, upload-time = "2026-10-04T16:30:16.92Z" }, - { url = "https://files.pythonhosted.org/packages/09/1c/3f1025aaf70d9bf7272cc41f8b64ee76b48bf01726248138430e16f23b38/rpds_py-2026.9.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5cf77eb04f20b720be95265a3e00eb2a14814074255cc27069c551b2db53118", size = 579602, upload-time = "2026-10-04T16:30:18.555Z" }, - { url = "https://files.pythonhosted.org/packages/53/0d/5c72e6204f76610608706da32b6b7e11ef7e10317558a7bb15a122e008dc/rpds_py-2026.9.1-cp314-cp314-win32.whl", hash = "sha256:a03d57b86d2a51d0a66c92177e2be154ad015f357791d306e714569999cdb4cc", size = 206315, upload-time = "2026-10-04T16:30:20.05Z" }, - { url = "https://files.pythonhosted.org/packages/a4/0b/489d48abbcc7d70cf3fbf662d9d22abf1f4650761c0a9ae05260800800d3/rpds_py-2026.9.1-cp314-cp314-win_amd64.whl", hash = "sha256:837c6b305e26fe0f75b15c92cf3b2ba29e0ae19dc40b1c557b026cb426347d0c", size = 222852, upload-time = "2026-10-04T16:30:21.604Z" }, - { url = "https://files.pythonhosted.org/packages/91/16/bbb05a7e6a10cf79ba639be7f799d770ee15f64175cc61d081b218dd402a/rpds_py-2026.9.1-cp314-cp314-win_arm64.whl", hash = "sha256:fce4b85234a0cbad67bf8e6e1201ee815d172c9aebad75f25645bc4d834f8e31", size = 218709, upload-time = "2026-10-04T16:30:23.036Z" }, - { url = "https://files.pythonhosted.org/packages/22/ac/ac507a0a4ec478ca470440a09583db4be5259ba7670aeba0620822f1e57a/rpds_py-2026.9.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:3a72c11530d71abfb66c8d7696a2f86c43e63fca8b948f1a784ac490f4ec688e", size = 349596, upload-time = "2026-10-04T16:30:24.558Z" }, - { url = "https://files.pythonhosted.org/packages/e9/f2/817a46b658d5070f477f722c298ee9a24525b0e4017347964146ef5fdd0e/rpds_py-2026.9.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:068c37bba854ec2fe42f7365c640af11dd9895890ccbf2df5070d0c059bd7f96", size = 343114, upload-time = "2026-10-04T16:30:26.048Z" }, - { url = "https://files.pythonhosted.org/packages/6c/42/6ade976b13ac1b4cb3bf2eb603f1be2fe74df19a29988d4c2b386be59d6f/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fca4eb6df565e2a928f1c7dad92d27db8f9df0f449e76423ed5d7e713ed445", size = 374197, upload-time = "2026-10-04T16:30:27.699Z" }, - { url = "https://files.pythonhosted.org/packages/d9/70/77cdf1d3f1a07faabe936016ae623aec7981f73108a8fe7a203ed2e21998/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c933c6678c6f116ff8af47a4c6db0868b8ace74af0343016c0ef00f00272ea69", size = 378025, upload-time = "2026-10-04T16:30:29.451Z" }, - { url = "https://files.pythonhosted.org/packages/3f/6b/18a44a3beaa9b7931acb04af7bd9539836477c630a794452d4826d6185d4/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:028ad274ea951dac64491b5d1e65712a4aeabfdbdb9fccf797b57bd899b0c495", size = 491969, upload-time = "2026-10-04T16:30:30.995Z" }, - { url = "https://files.pythonhosted.org/packages/73/27/fb39cfd6bddaf741b024f813890374578ff8ac1f1adc473659c048b03b05/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:740d0a99cf9de0b17a3943388e9294a59becf75e7c43421f387bd3c7a9901f7c", size = 393905, upload-time = "2026-10-04T16:30:32.628Z" }, - { url = "https://files.pythonhosted.org/packages/ed/71/0fa7bb77b57af0d710273964180d11b503f62b8a5c358eb2d8c3f62feff6/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0da298fb372dc192610a4b9ecbc68a0cd8b675bbbd1fc519d01b41cfd658333e", size = 374569, upload-time = "2026-10-04T16:30:34.257Z" }, - { url = "https://files.pythonhosted.org/packages/54/22/f41cfac269af3b449513ef1bc3d7f32fde52abbbd2d01c7e76b47743acd9/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:eb61be926bb81567c1f48bdc8aa22b9855048dc2efd53871f9f7e6e9a5632346", size = 377482, upload-time = "2026-10-04T16:30:35.997Z" }, - { url = "https://files.pythonhosted.org/packages/b4/fc/312b49006e7f8f9ca5f96647577b8aa6f3df30519c46bd448f5c425af0b2/rpds_py-2026.9.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:42e75466f83cd43f6026c81eab74246efb2bdadafb307b85700632d06c68f299", size = 400040, upload-time = "2026-10-04T16:30:37.76Z" }, - { url = "https://files.pythonhosted.org/packages/cf/a6/18cca7a878dc7fa95165a83343fd4d7b65643fd22e54e47340a451121d5c/rpds_py-2026.9.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:617f59cde379b4f648a09797b7f683d04b90a46344cddab85639da5aff0f5531", size = 551849, upload-time = "2026-10-04T16:30:39.443Z" }, - { url = "https://files.pythonhosted.org/packages/e4/6d/1f5685e20f39604691bdc3c05aaa6b8bd2f954e9e996477adf2376768e33/rpds_py-2026.9.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3edae8c5ddfdb6985d49ae9d150516e5076888879022f91a26c2de9276ce0bdb", size = 614842, upload-time = "2026-10-04T16:30:41.231Z" }, - { url = "https://files.pythonhosted.org/packages/c6/25/98652109fd9f7e10268dd4571aa52b81987001b806f37ef1a18260de714a/rpds_py-2026.9.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0f045bb053c9057720d72c56dffe30dffdc05997b2897a827b9325f0ab6623fa", size = 582606, upload-time = "2026-10-04T16:30:43.345Z" }, - { url = "https://files.pythonhosted.org/packages/19/03/11ca09099bab5f53373a80a334c424ec917c13d050760a59499d2af5171e/rpds_py-2026.9.1-cp314-cp314t-win32.whl", hash = "sha256:bf35d0568abda97233239ce32896d3ad53fccc537832c104e30c94aa5fb93569", size = 203341, upload-time = "2026-10-04T16:30:44.954Z" }, - { url = "https://files.pythonhosted.org/packages/6f/8a/88909e3ffd9f47f5b58211473875d8c3c09079f0058c46fb72c55a702a26/rpds_py-2026.9.1-cp314-cp314t-win_amd64.whl", hash = "sha256:1e8d4d79d828299bf44a55db22a9388ab967b49d17132c88eab0f4360b48da8e", size = 222843, upload-time = "2026-10-04T16:30:46.486Z" }, - { url = "https://files.pythonhosted.org/packages/f6/b7/a662f367d4896dd0a10cef2fc91f10b7f08af1c10858e287e019563f338d/rpds_py-2026.9.1-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:1d77b649e6f7cdf12ca5c2a98dad0ad37f9ea9b6f960408a92f0cb12bb3d04d9", size = 347463, upload-time = "2026-10-04T16:30:48.203Z" }, - { url = "https://files.pythonhosted.org/packages/ae/3f/ad45d03df4f84ebae5439577ee81f3999d182711e82235c8037b6528890e/rpds_py-2026.9.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:00ba2d8c7dd4ee537978ddf4b3fbd712bef2d8751603f7f3146b3f4287768e25", size = 342051, upload-time = "2026-10-04T16:30:49.872Z" }, - { url = "https://files.pythonhosted.org/packages/7e/31/3dcd68c13d4bcc59c1f7eb33ac8e80698f06f3eb0d8a1e06419836071c20/rpds_py-2026.9.1-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec450527cbf485e13c8d3602a54f428ab0432fdade0ede75efd74b735421c871", size = 374143, upload-time = "2026-10-04T16:30:51.508Z" }, - { url = "https://files.pythonhosted.org/packages/cf/0d/68c1f058a250fbd1380ebda9fc227cbf50117adf8ffe8161ef383ea79f68/rpds_py-2026.9.1-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:306ee1850d8105b5baf977e78d45fcadd12c1a54678d614c9baf217708446e91", size = 378604, upload-time = "2026-10-04T16:30:53.206Z" }, - { url = "https://files.pythonhosted.org/packages/d7/d6/2d4c59b85397cb4800594fadf692688ccf5ce556adc930e7a5bf21061a5e/rpds_py-2026.9.1-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ef6b65b03247c54692ad4fd9ee97cb772781927db72e3cb05e70b3db6d1ff14f", size = 490790, upload-time = "2026-10-04T16:30:54.925Z" }, - { url = "https://files.pythonhosted.org/packages/da/04/7e05dc3aebaf52f4e026766bd668fdd09a9d0e23f64a14686b36b3501892/rpds_py-2026.9.1-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a575404ebc9cf2e91edd32eaf570ec1430eb900d4f56724ba7dd4bc1fc9c176d", size = 393146, upload-time = "2026-10-04T16:30:56.625Z" }, - { url = "https://files.pythonhosted.org/packages/57/ca/e2e9a0a46a74ed51a0498ba1fe10f4ea6b2d9a155f372a2f91e51f18cf10/rpds_py-2026.9.1-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c16ab111bc27c646ba8aa005d0527754edc538ebb636f0b1bf8e244b48d1945", size = 372022, upload-time = "2026-10-04T16:30:58.295Z" }, - { url = "https://files.pythonhosted.org/packages/ba/cb/8f8774df5134e23424372838bcc5c7ed4127d723e1ff52f7bebd4dcb2563/rpds_py-2026.9.1-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:7664419f27db41d4f1c43a78dccda7dd6e8ef2428df3ee01d0c2a07a6b071297", size = 377092, upload-time = "2026-10-04T16:30:59.984Z" }, - { url = "https://files.pythonhosted.org/packages/90/02/8d7095d73bf9114219be40230baa5df00611e0a82ed9517779ff9c19f82b/rpds_py-2026.9.1-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4b26b03d9d2658ee2fa234f8f4f19f38a09773fe5261028025032e26d4d35af0", size = 400830, upload-time = "2026-10-04T16:31:01.721Z" }, - { url = "https://files.pythonhosted.org/packages/ec/02/8206856f8f363cd042a8315dc86b3912f5dcb6d3c66bbb24b69c2bfb0775/rpds_py-2026.9.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:be3e47e2d91aa3942ff9bf4077a505226005abfc39b6f7554a91c1b9393986b9", size = 551478, upload-time = "2026-10-04T16:31:03.472Z" }, - { url = "https://files.pythonhosted.org/packages/41/6b/36211f1bb1f0b0313f496d92f5905b74ea107f27cb16fa3355a82f04575e/rpds_py-2026.9.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:6307a0da524939decb8ca4a3933b8ab62525794411d6984fca6726e732804af6", size = 615173, upload-time = "2026-10-04T16:31:05.281Z" }, - { url = "https://files.pythonhosted.org/packages/35/77/cda0c4a6f055446b692f0ed5692f73707cafd3dff82672ede31b1a9b59de/rpds_py-2026.9.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:159a7aab5c5e8b112c8830f54717ce56da1252ebdbb526f5be2df2309280b9e7", size = 579653, upload-time = "2026-10-04T16:31:07.065Z" }, - { url = "https://files.pythonhosted.org/packages/74/ec/d8385f446240aed643b9e92a5055cff3015cc04a13c61f73b2883c478ed5/rpds_py-2026.9.1-cp315-cp315-win32.whl", hash = "sha256:dbc2673f9223d420c91145599b3ba45a8a50c207d1976908e5fb5ddb0c9b9429", size = 206498, upload-time = "2026-10-04T16:31:08.989Z" }, - { url = "https://files.pythonhosted.org/packages/6d/a5/71b5cd00e0521e3b6b81828baea368c62b6b700ebdd9554cd7d41ddf12fa/rpds_py-2026.9.1-cp315-cp315-win_amd64.whl", hash = "sha256:75c38c50ab9aca840225d9a9a3810bf11d04bd5c1f186cabbb8aee56db3e9b15", size = 223121, upload-time = "2026-10-04T16:31:10.84Z" }, - { url = "https://files.pythonhosted.org/packages/33/58/dba857c3bc8221b31b62eb170a3080f4f191de79f047200389b7ed1b06a7/rpds_py-2026.9.1-cp315-cp315-win_arm64.whl", hash = "sha256:a431156bb41865fc14cd5d79bb9d7bbed83110b0159e34e62ae30951f96c0009", size = 218741, upload-time = "2026-10-04T16:31:12.592Z" }, - { url = "https://files.pythonhosted.org/packages/5b/d0/320ab28ccc1415eeb509d68682b0014fb74690cd49f1c2d29a232475af50/rpds_py-2026.9.1-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:ef0d8c843e2827d6c120ab4687e9423fb1d893db1df27b7c1506615bcb9734a0", size = 349719, upload-time = "2026-10-04T16:31:14.48Z" }, - { url = "https://files.pythonhosted.org/packages/56/88/f5b12f1358f443c08b7ce3cc8391d82d335f4872580e2e097847fd36087a/rpds_py-2026.9.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:45bc6bccf78b20fd834237d18db64965d7ee68ba7f60440a26c7ab71e7b8d51a", size = 343267, upload-time = "2026-10-04T16:31:16.827Z" }, - { url = "https://files.pythonhosted.org/packages/f7/0c/c765b0059d532acb3b9c45d781ccc22f15a96dbe443d00903f643ba9df10/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d55198263bb51f557550c6ed2e6d1cb6a6fed6eb5c9120b741c5926bef8a45d", size = 374555, upload-time = "2026-10-04T16:31:18.931Z" }, - { url = "https://files.pythonhosted.org/packages/6b/8a/cafddfda77564a10cd21184640c3bffda6a2b8d20972fb5dedd5e0166328/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a8763f20692da7df39b0afdd1ba3042b004c50a45994f76c2d9a25641f7673db", size = 378346, upload-time = "2026-10-04T16:31:20.75Z" }, - { url = "https://files.pythonhosted.org/packages/b9/01/5e626016eff72c183bf6c96539240cace15d402468647a453ec08415b2fc/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e43d4a1f673e8a1cbd8533e809e02b4bf9d4f2280269bb640436556312121250", size = 492373, upload-time = "2026-10-04T16:31:22.614Z" }, - { url = "https://files.pythonhosted.org/packages/3b/9c/15a2469e9389242f46896b3f0a01d68caea8a5a35c011fcb05ef333aae73/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea394a937f17a54c51239348bdbe2e3518124c8d4a8951ba04a311d3095bd18f", size = 394371, upload-time = "2026-10-04T16:31:24.768Z" }, - { url = "https://files.pythonhosted.org/packages/63/f5/c100ff77e1e6366e947c75969c258fdfc4b7bc5bbfe7351e62ffbf2a1228/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdeaa99ce822dca76cfb1b993e9120c5ea212f2eb66d48950ad63c349668a018", size = 375132, upload-time = "2026-10-04T16:31:26.588Z" }, - { url = "https://files.pythonhosted.org/packages/dd/f4/fe0269c9de253e99c81cabc12b8971a5feaa083debdaff1221e06264d9e3/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:b4f062343e7ad3fa94f2c66e5ae667dee47ee74dd41a9057c4fbe163236a123d", size = 377642, upload-time = "2026-10-04T16:31:28.677Z" }, - { url = "https://files.pythonhosted.org/packages/05/65/b34a7b257baccff8f4a24a722933166d4941d5ebdc9c3f4bc4ffcd5ce4f4/rpds_py-2026.9.1-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:22ffd29a63d71fb1b81552c21f2c2b734949b7ac751a9be70675a939a900839b", size = 400855, upload-time = "2026-10-04T16:31:30.802Z" }, - { url = "https://files.pythonhosted.org/packages/98/32/844e54176b6071b90b38a564e6940bc6eb8f97b2890dc709c19db9dec0f4/rpds_py-2026.9.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:08dae4a4095150a7c4545a1fb40b98e1ab1744fbc2770d92c977b9dadaa49ab6", size = 552573, upload-time = "2026-10-04T16:31:32.709Z" }, - { url = "https://files.pythonhosted.org/packages/17/73/6041d20729dffbfdf155c02d65be58bc225a1c1fb548fd87c23ef306138f/rpds_py-2026.9.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:9a0460d43603d1fd9ef59c30278531e15d78581721ddb538fa560aa7817ea4ad", size = 615840, upload-time = "2026-10-04T16:31:34.565Z" }, - { url = "https://files.pythonhosted.org/packages/af/9e/418094adaee6b056ce199051b255448ed872829051e341b2294c80da0977/rpds_py-2026.9.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1c2d1f6da5128eabf34e963d7163a818846075a52568250d006c4c953b40f903", size = 582764, upload-time = "2026-10-04T16:31:36.665Z" }, - { url = "https://files.pythonhosted.org/packages/3d/9b/1698ebf6b840ddfe8b472198abbed6ace35c6e398faeecd6c47dae742a4e/rpds_py-2026.9.1-cp315-cp315t-win32.whl", hash = "sha256:5c6ee90dee3e85e055ddfd502d611643d9b0fd94c818220bda84ec3dacd9b27b", size = 203795, upload-time = "2026-10-04T16:31:38.53Z" }, - { url = "https://files.pythonhosted.org/packages/8a/e2/91f70d804c61f8eac39a417e82aa1024f655ab9e8bdd7393b196242bc41b/rpds_py-2026.9.1-cp315-cp315t-win_amd64.whl", hash = "sha256:fe5ad0664ec772b02c45859041aa17655709cced7a31005817fbbbd988c25567", size = 223037, upload-time = "2026-10-04T16:31:40.468Z" }, - { url = "https://files.pythonhosted.org/packages/f3/ad/f0eba548e297987964ef8088403db875b333963bf8189f3f563b6936b20e/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c0d2cb595a420b34d5086db0add011e26e2c09d6a024afbac4228bf8f863a30", size = 384112, upload-time = "2026-10-04T16:31:42.643Z" }, - { url = "https://files.pythonhosted.org/packages/33/89/891fa4d81f1eae7fe262ecd0aba2c51de94a116c7f3ccfb034fa75f4c537/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f3d6ed6a98cfd19155996605474982cc470d7601746a6439078f1a5a3fa8b050", size = 389662, upload-time = "2026-10-04T16:31:44.642Z" }, - { url = "https://files.pythonhosted.org/packages/4f/46/912cf623b2263f9c9c2d04e8508fc38dbe89983faeba5fb36ca4558ae550/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8171b44a054e5c67fd748ada04187f1250bf35b95f85e52ab64bcf3331a923bb", size = 504637, upload-time = "2026-10-04T16:31:46.667Z" }, - { url = "https://files.pythonhosted.org/packages/9b/5c/7f3cfa7c5f01765c9f47c8398210ed0c1eb686c0e99c223cb1c6776d3fb9/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fda1d96e542c37b6c804547dbf489c129fe7c97183a76a5ec275909ba1a063df", size = 402607, upload-time = "2026-10-04T16:31:49.068Z" }, - { url = "https://files.pythonhosted.org/packages/f0/76/2e915d4115ee453c33e6af17bc1df7e22ddc52974e178eeeb92a78c09983/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:270bdcdaac5d5b6f73c5e22e7e135c7f2a50e789f71d9e241d5be8d90026e19a", size = 382762, upload-time = "2026-10-04T16:31:51.24Z" }, - { url = "https://files.pythonhosted.org/packages/0d/e5/844382925d7b84a4074ad79fc2b9d05eb6231ea243b34f247e68e519b606/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:84a6ecc0c940169190d2c23bd969debd48c94dbc855acd60188a68d71d421608", size = 389563, upload-time = "2026-10-04T16:31:53.549Z" }, - { url = "https://files.pythonhosted.org/packages/81/82/d6e3951602dc2e24790ef9d299aa24bf5e2493df5043f2c6da00480cc447/rpds_py-2026.9.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ab4b2fda7c2b542f7f9d886cc6a838c5079d2b76f72e6081411faba11adde2c9", size = 416842, upload-time = "2026-10-04T16:31:55.76Z" }, - { url = "https://files.pythonhosted.org/packages/ea/1c/8d248e4ea671d525ab7daa0703ad81cc2175076fa0ccd7ef088facbd2b01/rpds_py-2026.9.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:44b32a7c4f0da3d28af31c259e38ddcff096f855e205ed0671d02fcf44f1ea1c", size = 562434, upload-time = "2026-10-04T16:31:57.874Z" }, - { url = "https://files.pythonhosted.org/packages/ad/38/e7ac0db898120d15dea25e3661b1242a40cb3b23d1f4db86c15a01fe0ba1/rpds_py-2026.9.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:a3dbc5ed9514908d5046107d7b1346bde71eea61de6e0e4919c19354f97e769f", size = 627909, upload-time = "2026-10-04T16:31:59.977Z" }, - { url = "https://files.pythonhosted.org/packages/03/c8/37e555514932cb1ee36c75349187aa882a98dee5d5654c761699ed8a0d27/rpds_py-2026.9.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:6eae33003518fd4cb4f83a218d5371469dd3001aa3b87128c005b07762f7fe5e", size = 593658, upload-time = "2026-10-04T16:32:02.14Z" }, - { url = "https://files.pythonhosted.org/packages/12/5c/5f69a91add94a8a33acea68a2b034a464946a654ff7296af9d957ef0d6a5/rpds_py-2026.9.1-pp311-pypy311_pp80-macosx_10_12_x86_64.whl", hash = "sha256:0483515261947e4e8b8e1375bf7463e7eb6ccfb3d86e7b554d90cd5285f20f32", size = 351769, upload-time = "2026-10-04T16:32:04.675Z" }, - { url = "https://files.pythonhosted.org/packages/41/22/35ea8bf3b2682b90ab687c74e4828418ff12298a5b0b0a0c033f61c86a30/rpds_py-2026.9.1-pp311-pypy311_pp80-macosx_11_0_arm64.whl", hash = "sha256:4cfaf02209061880210819934de2f4f6aa83dc04dafe6770276acc240a56da31", size = 351719, upload-time = "2026-10-04T16:32:06.834Z" }, - { url = "https://files.pythonhosted.org/packages/a3/90/a9ba81408369d34c1aca73319c15adc91ed45c1d21e9e8ee4832ffb7fe0b/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6cdc537c8633d7fd92a82e2e0d2ab74320a3f63d5e59fb9cf08711e08fe151c4", size = 381109, upload-time = "2026-10-04T16:32:08.994Z" }, - { url = "https://files.pythonhosted.org/packages/b3/44/5192a0bed94cec86bd2a5e1cc5a1bb8f7eec3aec907eacd2deb13e87e326/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:10e208f2425d973938afcd56e28a7c4be32e27b6a60b5d381f49fb9d8acf9759", size = 388222, upload-time = "2026-10-04T16:32:11.321Z" }, - { url = "https://files.pythonhosted.org/packages/92/cd/5356549711448f18b52f7a11ffbe90f1228774996fbf3c6cd1b18d22abaf/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c0dbbcc19735fe5f8b0a54c07659d154a9e69f47e15d0a6ab7299215daf62cb", size = 500384, upload-time = "2026-10-04T16:32:13.478Z" }, - { url = "https://files.pythonhosted.org/packages/7a/88/ddda9d28adfe33119c75b2e733d4ba7e326f41d7e1b1093951771768ca48/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:684fd492fff4fead00587544e059be2bbcb6f93454f21fa2a91b66fc7508be82", size = 401661, upload-time = "2026-10-04T16:32:15.653Z" }, - { url = "https://files.pythonhosted.org/packages/32/c3/bb59ba16a6b4a57995d15b8c04c00f28df3b938c4dcdde48fbe0f73edb0c/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d1028417bb44037eb3069c1009bd7b7277212876cda22fbe565b0bca9fab6d2c", size = 380748, upload-time = "2026-10-04T16:32:17.727Z" }, - { url = "https://files.pythonhosted.org/packages/f5/b8/0580faa1c5a32ddc160130dd7ae54d2d007272a89a40a6b5db3e50f9f585/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:492e5e428cbe126221611f47e068f01660352feec4ad18bc0f5ea9b2ae88fb14", size = 385731, upload-time = "2026-10-04T16:32:19.855Z" }, - { url = "https://files.pythonhosted.org/packages/bf/70/f73564642bbe3322c7eeef2c2f258cf040b71c41a430b532e59d04a1b838/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:88b5268892fde430d5531f95bc560b6efbbd67c929662c586afd729a96e7461c", size = 412131, upload-time = "2026-10-04T16:32:22.285Z" }, - { url = "https://files.pythonhosted.org/packages/8c/5d/17fff2e1f8f68721a2afb5cb48f7e442c751bb6b4883157c5abaf618cd08/rpds_py-2026.9.1-pp312-pypy312_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:01445c8d194aa032a08e944f16567672da1c62dbdbefd8b6d0693032e290cf68", size = 558193, upload-time = "2026-10-04T16:32:24.4Z" }, - { url = "https://files.pythonhosted.org/packages/2a/d0/869ab6fb08531f97aae4a780b4d61b4190d8aef48fe054ee28bcf7114466/rpds_py-2026.9.1-pp312-pypy312_pp73-musllinux_1_2_i686.whl", hash = "sha256:eef6a03b0b6d08d0835ccfa8ec8d1bc70525e3801387567137b50c557695e6da", size = 622448, upload-time = "2026-10-04T16:32:26.844Z" }, - { url = "https://files.pythonhosted.org/packages/ba/a5/9672e532fe02cd3b92c78cfd8743abca939d96853006c63835009a1ecb6f/rpds_py-2026.9.1-pp312-pypy312_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:6b9bf3135b4ad5981df9a73d71a35272d650a2985ae9c2746357b24d59de2448", size = 591126, upload-time = "2026-10-04T16:32:29.274Z" }, - { url = "https://files.pythonhosted.org/packages/80/ef/3a9f8e4279c7920af561deed4cb7ebebed2794a8f608cf404d5eef14a105/rpds_py-2026.9.1-pp312-pypy312_pp80-macosx_10_12_x86_64.whl", hash = "sha256:56c6952a9b15047466d0c2347c446a761d4527f89976156341e68f0ce5cc08b0", size = 357108, upload-time = "2026-10-04T16:32:31.641Z" }, - { url = "https://files.pythonhosted.org/packages/b7/55/4b2fa381a583760aea5c92841e4e928a358e1c6511b129219e9c2826a226/rpds_py-2026.9.1-pp312-pypy312_pp80-macosx_11_0_arm64.whl", hash = "sha256:b242c27c8f836305a4a72df9cdd564386ac57b807bd252a063223331c9316b37", size = 346877, upload-time = "2026-10-04T16:32:34.061Z" }, -] - [[package]] name = "ruff" version = "0.12.12" @@ -3101,13 +2923,8 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c2/d2/e126d56642a5fd437eeb5a067b7c0d1f766c08e22d6a708bb923986f1d44/zensical-0.0.50-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:26dda9dbacab84db2743726f83202798e1893fbfddecb6a845812d7a331043ad", size = 12817706, upload-time = "2026-07-09T13:51:29.624Z" }, { url = "https://files.pythonhosted.org/packages/bd/9b/e1a22fb4ea8fc3e8377d7b394ee06cf0349e7f9a64ecb4c9873dee79b102/zensical-0.0.50-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:376887def6470c57509b48519870f74e2b987e30509cf5c819fcf372771f9403", size = 12691061, upload-time = "2026-07-09T13:51:33.194Z" }, { url = "https://files.pythonhosted.org/packages/38/f5/16c087635680efb39e1d7b7aa3c2cca548305aa29ad51dee04f37b32b65f/zensical-0.0.50-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bbf3034a2cb1a9d2a72a5ee7047688717c93da0d8a90d25dd871db8d5f33a6d", size = 13129505, upload-time = "2026-07-09T13:51:36.383Z" }, - { url = "https://files.pythonhosted.org/packages/65/30/50d02402e53aa01a5c5c116a3522c7bb18d6ae4da964d8b236173b6fa086/zensical-0.0.50-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:26fe4167663d544ca385ef420a49d3b738c7606a79d7a62a6bedcbf74cd383e7", size = 13055300, upload-time = "2026-07-09T13:51:39.748Z" }, - { url = "https://files.pythonhosted.org/packages/cf/0f/45f4f3e56a6483ea9f88478b20d6b434718e7c46579239589202e5135ec1/zensical-0.0.50-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8813d1f8895b19520d4a982d6bfcfd06372d73d96e6a63f0d2cf8f3b6036d5a1", size = 13445447, upload-time = "2026-07-09T13:51:43.106Z" }, { url = "https://files.pythonhosted.org/packages/33/9b/1f5065c664afde6a63e0ada8c14eae75f9e6960df597a5ca28c07340f938/zensical-0.0.50-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a64f957f94f7d8e8847a7f1e8205509ba4b188c93c157c5e7be49bcb8556a127", size = 13098775, upload-time = "2026-07-09T13:51:46.437Z" }, { url = "https://files.pythonhosted.org/packages/46/65/1e42e18d8f9a0cb9fcc8b871852810c7fe196237b79aaa831e863325091e/zensical-0.0.50-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:781d333bcb42c6a6b92360e05eadc944e2674794e1a95537971de1bf64cb9f89", size = 13305922, upload-time = "2026-07-09T13:51:51.107Z" }, - { url = "https://files.pythonhosted.org/packages/50/36/9cace194ba13aef3bdde8ca2d327f3a05cdf5c456e94f6d896852e2cbd38/zensical-0.0.50-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:5d0f86eec76c23efb04566cd444bf025845ac8a02e75c8a6b4af13a39a2a9955", size = 13325488, upload-time = "2026-07-09T13:51:54.883Z" }, - { url = "https://files.pythonhosted.org/packages/b1/80/2891a9316e486794dae43151561b49f3313499cfb2c95c7886abad7bcf2d/zensical-0.0.50-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:392a7299a3c4d1ac7ff288bbed181d77a9fd23e6614180476e01630aaee0d67e", size = 13496866, upload-time = "2026-07-09T13:51:58.257Z" }, { url = "https://files.pythonhosted.org/packages/7e/09/fbd3af58081a0d399fa913ef1f2fd6a007f2f06f7026c8d6a6096e34b996/zensical-0.0.50-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:cac3448d8c8a76dfb43e55908b4ca9ad17596aee89a9287a184c1a0ba7dce2a2", size = 13437565, upload-time = "2026-07-09T13:52:01.766Z" }, - { url = "https://files.pythonhosted.org/packages/d3/79/709311ff202326260ff223fb6e9ddefa3100474c428e3c70a04036cefe0e/zensical-0.0.50-cp310-abi3-win32.whl", hash = "sha256:32b244f96a930f68e049b2e03d50790c120ef701b6277ddd854905a33040c75f", size = 12371966, upload-time = "2026-07-09T13:52:05.207Z" }, { url = "https://files.pythonhosted.org/packages/e3/e1/4babb30544d7465c95a6a93abc0680b1c51752411a225c2b7f2cb44e80c7/zensical-0.0.50-cp310-abi3-win_amd64.whl", hash = "sha256:2f054769bf96ae46353de3eca2463ad4db6df1da9fde515c6d7fc54c3608e615", size = 12604832, upload-time = "2026-07-09T13:52:09.013Z" }, ]