pyfect-dev 0.1.0__py3-none-any.whl

pyfect/ai/_mcp/client_transport.py

@@ -0,0 +1,412 @@
+"""The MCP client's transports: a child process on stdio, or Streamable
+HTTP. A transport sends a request and waits for its response, sends a
+notification, and says which tools it can call."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any, Literal, Never, cast
+
+from pyfect import stream
+from pyfect._core import Effect
+from pyfect.ai._mcp.client_wire import (
+    cancelled,
+    encode_message,
+    failure,
+    header_parameters,
+    is_request,
+    is_response,
+    limit_error,
+    media_type,
+    parse_message,
+    reply_to_server,
+    routing_headers,
+)
+from pyfect.ai.mcp_client_error import (
+    ClosedError,
+    ConfigurationError,
+    HttpError,
+    McpClientError,
+    ProtocolError,
+    TransportError,
+)
+from pyfect.ai.mcp_protocol import ProtocolAdapter
+from pyfect.ai.mcp_schema import JsonObject, RequestId, Tool, parse_request_id
+from pyfect.byte_size import ByteSize
+from pyfect.channel import LineTooLongError, split_lines_within
+from pyfect.deferred import Deferred
+from pyfect.duration import Seconds
+from pyfect.effect import fail, gen, succeed, suspend, sync
+from pyfect.encoding import sse
+from pyfect.errors import Done
+from pyfect.http import request as http_request
+from pyfect.http.client import HttpClient
+from pyfect.http.error import HttpClientError
+from pyfect.http.response import HttpClientResponse, is_too_large, with_body_limit
+from pyfect.process import ChildProcessSpawner, Command
+from pyfect.queue import Queue
+from pyfect.scope import Scope, add_finalizer
+
+type ClientProtocolVersion = Literal["2025-11-25", "2026-07-28"]
+type ClientProtocol = ProtocolAdapter[ClientProtocolVersion]
+
+CLOSE_TIMEOUT = Seconds(5)
+DEFAULT_MAX_MESSAGE_BYTES = 16 * 1024 * 1024
+
+_VOID: Effect[None] = succeed(None)
+
+
+@dataclass(frozen=True, slots=True)
+class TransportService:
+    """How a client reaches its server (Effect's ``McpClient.Transport``)."""
+
+    protocol: ClientProtocol
+    request: Callable[[JsonObject, Tool | None], Effect[JsonObject, McpClientError]]
+    notify: Callable[[JsonObject], Effect[None, McpClientError]]
+    is_callable: Callable[[Tool], bool]
+
+
+def message_limit(max_message_bytes: int | None) -> Effect[ByteSize, McpClientError]:
+    limit = DEFAULT_MAX_MESSAGE_BYTES if max_message_bytes is None else max_message_bytes
+    if limit <= 0:
+        return fail(failure(ConfigurationError("maxMessageBytes must be a positive safe integer")))
+    return succeed(ByteSize(limit))
+
+
+class _Closing:
+    """The first error a transport closed with, failing every later call."""
+
+    def __init__(self) -> None:
+        self.failed: McpClientError | None = None
+        self.signal = Deferred[Never, McpClientError]()
+
+    def close(self, error: McpClientError) -> Effect[None]:
+        def run() -> Effect[None]:
+            if self.failed is None:
+                self.failed = error
+            return self.signal.fail(self.failed).as_void()
+
+        return suspend(run)
+
+    def check(self) -> Effect[None, McpClientError]:
+        return _VOID if self.failed is None else fail(self.failed)
+
+
+def stdio(
+    *, command: Command, protocol: ClientProtocol, max_message_bytes: int | None = None
+) -> Effect[TransportService, McpClientError, ChildProcessSpawner | Scope]:
+    """A transport to ``command``'s process, on its standard input and
+    output. Closing the scope closes its input, then terminates it if it
+    has not exited within five seconds."""
+
+    @gen
+    def run():
+        max_bytes = yield from message_limit(max_message_bytes)
+        spawner = yield from ChildProcessSpawner()
+        process = yield from spawner.spawn(command).map_error(
+            lambda cause: failure(TransportError("Cannot spawn MCP server", cause))
+        )
+        pending: dict[RequestId, Deferred[JsonObject]] = {}
+        closing = _Closing()
+        lines = Queue[str, Done]()
+
+        def write(message: JsonObject) -> Effect[None, McpClientError]:
+            return closing.check().and_then(
+                encode_message(message, max_bytes).flat_map(
+                    lambda text: lines.offer(text + "\n").as_void()
+                )
+            )
+
+        def receive(message: JsonObject) -> Effect[None, McpClientError]:
+            if is_request(message):
+                return write(reply_to_server(message))
+            if not is_response(message):
+                return _VOID
+            id = parse_request_id(message.get("id"))
+            if id is None:
+                return fail(
+                    failure(
+                        ProtocolError(description="Server returned an uncorrelated JSON-RPC error")
+                    )
+                )
+            response = pending.get(id)
+            return _VOID if response is None else response.succeed(message).as_void()
+
+        def line(text: str) -> Effect[None, McpClientError]:
+            if not text.strip():
+                return _VOID
+            return parse_message(text, max_bytes).flat_map(receive)
+
+        def as_client_error(cause: object) -> McpClientError:
+            if isinstance(cause, McpClientError):
+                return cause
+            if isinstance(cause, LineTooLongError):
+                return limit_error("MCP message exceeds maxMessageBytes")
+            return failure(TransportError("MCP stdout failed", cause))
+
+        yield from (
+            stream.from_queue(lines)
+            .encode_text()
+            .run(process.stdin)
+            .catch_all(
+                lambda cause: closing.close(failure(TransportError("MCP stdin failed", cause)))
+            )
+            .fork_scoped()
+        )
+        yield from process.stderr.run_drain().ignore().fork_scoped()
+        drained = Deferred[None]()
+        yield from (
+            process.stdout.decode_text()
+            .pipe_through_channel(split_lines_within(max_bytes))
+            .run_for_each(line)
+            .map_error(as_client_error)
+            .and_then(fail(failure(TransportError("MCP server closed stdout"))))
+            .catch_all(closing.close)
+            .ensuring(drained.succeed(None))
+            .fork_scoped()
+        )
+        yield from (
+            process.exit_code.map(lambda code: f"MCP process exited ({code})")
+            .or_else_succeed(lambda _: "MCP process exited")
+            .tap(lambda _: drained.wait().timeout_option(CLOSE_TIMEOUT))
+            .flat_map(lambda description: closing.close(failure(TransportError(description))))
+            .fork_scoped()
+        )
+
+        @gen
+        def finalize():
+            yield from closing.close(failure(ClosedError(description="MCP transport closed")))
+            yield from lines.end()
+            exited = yield from process.exit_code.timeout_option(CLOSE_TIMEOUT).option()
+            if exited is None or exited.value is None:
+                yield from process.kill(force_kill_after=CLOSE_TIMEOUT).ignore()
+
+        yield from add_finalizer(lambda _: finalize)
+
+        def request(message: JsonObject, _tool: Tool | None) -> Effect[JsonObject, McpClientError]:
+            id = cast("RequestId", message["id"])
+            response = Deferred[JsonObject]()
+
+            def cancel() -> Effect[None]:
+                if message.get("method") == "initialize":
+                    return _VOID
+                return response.is_done().flat_map(
+                    lambda done: _VOID if done else write(cancelled(id)).ignore()
+                )
+
+            return (
+                sync(lambda: pending.__setitem__(id, response))
+                .and_then(write(message))
+                .and_then(response.wait())
+                .race_first(closing.signal.wait())
+                .on_interrupt(cancel())
+                .ensuring(sync(lambda: pending.pop(id, None)))
+            )
+
+        return TransportService(protocol, request, write, lambda _: True)
+
+    return run
+
+
+def _read_failed(cause: HttpClientError) -> McpClientError:
+    if is_too_large(cause):
+        return limit_error("MCP message exceeds maxMessageBytes")
+    return failure(TransportError("Cannot read MCP response", cause))
+
+
+def http(  # noqa: PLR0915
+    *,
+    url: str,
+    protocol: ClientProtocol,
+    headers: Mapping[str, str] | None = None,
+    max_message_bytes: int | None = None,
+) -> Effect[TransportService, McpClientError, HttpClient | Scope]:
+    """A Streamable HTTP transport to ``url``. A 2025-11-25 session is
+    deleted when the scope closes; a server forgetting it fails every
+    later call with a ``ClosedError`` whose ``session_expired`` is set."""
+
+    @gen
+    def run():  # noqa: PLR0915
+        max_bytes = yield from message_limit(max_message_bytes)
+        client = yield from HttpClient()
+        modern = protocol.protocol_version == "2026-07-28"
+        closing = _Closing()
+        session: list[str] = []
+        base_headers = {
+            **(headers or {}),
+            "accept": "application/json, text/event-stream",
+            "mcp-protocol-version": protocol.protocol_version,
+        }
+
+        def current_headers() -> dict[str, str]:
+            return {**base_headers, "mcp-session-id": session[0]} if session else dict(base_headers)
+
+        def http_error(response: HttpClientResponse) -> Effect[Never, McpClientError]:
+            def with_remote(remote: Mapping[str, Any] | None) -> Effect[Never, McpClientError]:
+                return fail(
+                    failure(
+                        HttpError(
+                            response.status,
+                            code=None if remote is None else remote.get("code"),
+                            data=None if remote is None else remote.get("data"),
+                            description=None if remote is None else remote.get("message"),
+                            www_authenticate=response.headers.get("www-authenticate"),
+                            retry_after=response.headers.get("retry-after"),
+                        )
+                    )
+                )
+
+            if media_type(response.headers) != "application/json":
+                return with_remote(None)
+            remote = (
+                with_body_limit(response, max_bytes)
+                .text.map_error(lambda _: None)
+                .flat_map(lambda text: parse_message(text, max_bytes))
+                .map(lambda message: cast("Mapping[str, Any] | None", message.get("error")))
+                .or_else_succeed(lambda _: None)
+            )
+            return remote.flat_map(with_remote)
+
+        def send(
+            message: JsonObject, tool: Tool | None
+        ) -> Effect[HttpClientResponse, McpClientError]:
+            @gen
+            def go():
+                yield from closing.check()
+                body = yield from encode_message(message, max_bytes)
+                routing = (yield from routing_headers(message, tool)) if modern else {}
+                request = (
+                    http_request.post(url)
+                    .set_headers({**current_headers(), **routing})
+                    .body_text(body, "application/json")
+                )
+                response = yield from client.execute(request).map_error(
+                    lambda cause: failure(TransportError("MCP HTTP request failed", cause))
+                )
+                if session and response.status == 404:
+                    if closing.failed is None:
+                        closing.failed = failure(ClosedError(session_expired=True))
+                    return (yield from fail(closing.failed))
+                if not 200 <= response.status < 300:
+                    return (yield from http_error(response))
+                assigned = response.headers.get("mcp-session-id")
+                if not modern and assigned is not None:
+                    session[:] = [assigned]
+                return response
+
+            return go
+
+        def exchange[A](effect: Effect[A, McpClientError]) -> Effect[A, McpClientError]:
+            return effect.race_first(closing.signal.wait())
+
+        def notify(message: JsonObject) -> Effect[None, McpClientError]:
+            return exchange(send(message, None).as_void())
+
+        def match(
+            message: JsonObject, request: JsonObject
+        ) -> Effect[JsonObject | None, McpClientError]:
+            if is_request(message):
+                return notify(reply_to_server(message)).as_(None)
+            if not is_response(message):
+                return succeed(None)
+            if message.get("id") != request["id"] and not (
+                "error" in message and message.get("id") is None
+            ):
+                return fail(
+                    failure(
+                        ProtocolError(description="HTTP MCP response id does not match its request")
+                    )
+                )
+            return succeed(message)
+
+        def read_response(
+            response: HttpClientResponse, request: JsonObject
+        ) -> Effect[JsonObject, McpClientError]:
+            ended = failure(TransportError("MCP response ended before the terminal response"))
+            kind = media_type(response.headers)
+            if kind == "application/json":
+                return (
+                    with_body_limit(response, max_bytes)
+                    .text.map_error(_read_failed)
+                    .flat_map(lambda text: parse_message(text, max_bytes))
+                    .flat_map(lambda message: match(message, request))
+                    .flat_map(lambda found: fail(ended) if found is None else succeed(found))
+                )
+            if kind == "text/event-stream":
+                events: list[str] = []
+
+                def on_event(event: object) -> None:
+                    if isinstance(event, sse.Event) and event.data:
+                        events.append(event.data)
+
+                parser = sse.make_parser(on_event, max_event_size=max_bytes)
+
+                def feed(chunk: str) -> stream.Stream[str, McpClientError]:
+                    error = parser.feed(chunk)
+                    parsed = stream.from_iterable(events[:])
+                    events.clear()
+                    if error is None:
+                        return parsed
+                    return parsed.concat(
+                        stream.fail(limit_error("MCP SSE event exceeds maxMessageBytes"))
+                    )
+
+                found = (
+                    response.stream.map_error(_read_failed)
+                    .decode_text()
+                    .flat_map(feed)
+                    .map_effect(
+                        lambda data: parse_message(data, max_bytes).flat_map(
+                            lambda message: match(message, request)
+                        )
+                    )
+                    .filter(lambda message: message is not None)
+                    .run_head()
+                )
+                return found.flat_map(
+                    lambda head: (
+                        fail(ended) if head is None else succeed(cast("JsonObject", head.value))
+                    )
+                )
+            return fail(failure(ProtocolError(description="Unsupported MCP response Content-Type")))
+
+        @gen
+        def finalize():
+            if closing.failed is None:
+                closing.failed = failure(ClosedError(description="MCP HTTP transport closed"))
+            yield from closing.signal.fail(closing.failed)
+            reason = closing.failed.reason
+            if not session or not isinstance(reason, ClosedError) or reason.session_expired:
+                return None
+            delete = http_request.delete(url).set_headers(current_headers())
+            yield from client.execute(delete).timeout_option(CLOSE_TIMEOUT).ignore()
+            return None
+
+        yield from add_finalizer(lambda _: finalize)
+
+        def request(message: JsonObject, tool: Tool | None) -> Effect[JsonObject, McpClientError]:
+            def received(response: HttpClientResponse) -> Effect[JsonObject, McpClientError]:
+                if response.status in (202, 204):
+                    return fail(
+                        failure(ProtocolError(description="MCP request received no response"))
+                    )
+                return read_response(response, message)
+
+            def cancel() -> Effect[None]:
+                if modern or message.get("method") == "initialize":
+                    return _VOID
+                return (
+                    notify(cancelled(cast("RequestId", message["id"])))
+                    .timeout_option(CLOSE_TIMEOUT)
+                    .ignore()
+                )
+
+            return exchange(send(message, tool).flat_map(received)).on_interrupt(cancel())
+
+        def is_callable(tool: Tool) -> bool:
+            return not modern or header_parameters(tool) is not None
+
+        return TransportService(protocol, request, notify, is_callable)
+
+    return run

pyfect/ai/_mcp/client_wire.py

@@ -0,0 +1,284 @@
+"""What the MCP client transports share: message encoding and parsing
+within the size limit, answers to server requests, routing headers and
+the text a tool result shows a model."""
+
+from __future__ import annotations
+
+import base64
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any, cast
+
+from pyfect import _json_text
+from pyfect._core import Effect
+from pyfect._js import text_encode
+from pyfect._json_text import parse as parse_json_text
+from pyfect.ai.mcp_client_error import (
+    AnyReason,
+    LimitError,
+    McpClientError,
+    ProtocolError,
+    TransportError,
+    UnsupportedError,
+    ValidationError,
+)
+from pyfect.ai.mcp_schema import (
+    METHOD_NOT_FOUND_ERROR_CODE,
+    CallToolResult,
+    JsonObject,
+    RequestId,
+    Tool,
+)
+from pyfect.effect import fail, succeed
+
+BASE64_PREFIX = "=?base64?"
+BASE64_SUFFIX = "?="
+_HEADER_TOKEN = re.compile(r"^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$")
+_VISIBLE_ASCII = re.compile(r"^[\x20-\x7e]*$")
+
+_SCHEMA_KEYWORDS = frozenset(
+    {
+        "additionalProperties",
+        "unevaluatedProperties",
+        "propertyNames",
+        "items",
+        "additionalItems",
+        "unevaluatedItems",
+        "contains",
+        "not",
+        "if",
+        "then",
+        "else",
+        "contentSchema",
+    }
+)
+_SCHEMA_MAP_KEYWORDS = frozenset(
+    {"properties", "patternProperties", "$defs", "definitions", "dependentSchemas", "dependencies"}
+)
+_SCHEMA_ARRAY_KEYWORDS = frozenset({"allOf", "anyOf", "oneOf", "prefixItems", "items"})
+
+
+def failure(reason: AnyReason) -> McpClientError:
+    return McpClientError(reason)
+
+
+def limit_error(description: str) -> McpClientError:
+    return failure(LimitError(description))
+
+
+def encode_message(message: Mapping[str, Any], max_bytes: int) -> Effect[str, McpClientError]:
+    try:
+        text = _json_text.stringify(message)
+    except (TypeError, ValueError) as cause:
+        return fail(failure(TransportError("Cannot encode MCP message", cause)))
+    if len(text_encode(text)) > max_bytes:
+        return fail(limit_error("MCP message exceeds maxMessageBytes"))
+    return succeed(text)
+
+
+def _is_message(value: object) -> bool:
+    if not isinstance(value, dict):
+        return False
+    body = cast("dict[str, object]", value)
+    if body.get("jsonrpc") != "2.0":
+        return False
+    if "method" in body:
+        return isinstance(body["method"], str)
+    return "result" in body or "error" in body
+
+
+def parse_message(text: str, max_bytes: int) -> Effect[JsonObject, McpClientError]:
+    if len(text_encode(text)) > max_bytes:
+        return fail(limit_error("MCP message exceeds maxMessageBytes"))
+    try:
+        parsed: object = parse_json_text(text)
+    except ValueError as cause:
+        return fail(failure(ProtocolError(description="Invalid MCP JSON", cause=cause)))
+    if not _is_message(parsed):
+        return fail(failure(ProtocolError(description="Invalid JSON-RPC message")))
+    return succeed(cast("JsonObject", parsed))
+
+
+def is_request(message: Mapping[str, Any]) -> bool:
+    return "method" in message and "id" in message
+
+
+def is_response(message: Mapping[str, Any]) -> bool:
+    return "method" not in message
+
+
+def reply_to_server(request: Mapping[str, Any]) -> JsonObject:
+    """The client advertises no capabilities: it answers pings and
+    declines every other server request."""
+    id = request.get("id")
+    if request.get("method") == "ping":
+        return {"jsonrpc": "2.0", "id": id, "result": {}}
+    return {
+        "jsonrpc": "2.0",
+        "id": id,
+        "error": {
+            "code": METHOD_NOT_FOUND_ERROR_CODE,
+            "message": f"Unsupported MCP method: {request.get('method')}",
+        },
+    }
+
+
+def cancelled(id: RequestId) -> JsonObject:
+    return {"jsonrpc": "2.0", "method": "notifications/cancelled", "params": {"requestId": id}}
+
+
+def header_value(value: str) -> str:
+    """``value`` as a header: as is when plain visible ASCII, else Base64
+    between ``=?base64?`` and ``?=``."""
+    plain = (
+        _VISIBLE_ASCII.match(value) is not None
+        and value.strip() == value
+        and not (value.startswith(BASE64_PREFIX) and value.endswith(BASE64_SUFFIX))
+    )
+    if plain:
+        return value
+    return f"{BASE64_PREFIX}{base64.b64encode(text_encode(value)).decode('ascii')}{BASE64_SUFFIX}"
+
+
+@dataclass(frozen=True, slots=True)
+class HeaderParameter:
+    path: tuple[str, ...]
+    header: str
+    type: str
+
+
+def header_parameters(tool: Tool) -> list[HeaderParameter] | None:
+    """The ``x-mcp-header`` annotations along chains of ``properties``, or
+    ``None`` when one is invalid or found anywhere else."""
+    parameters: list[HeaderParameter] = []
+    names: set[str] = set()
+
+    def visit(schema: object, path: tuple[str, ...] | None) -> bool:
+        if not isinstance(schema, dict):
+            return True
+        node = cast("dict[str, object]", schema)
+        name = node.get("x-mcp-header")
+        if name is not None:
+            kind = node.get("type")
+            if (
+                not path
+                or not isinstance(name, str)
+                or _HEADER_TOKEN.match(name) is None
+                or name.lower() in names
+                or kind not in ("string", "integer", "boolean")
+            ):
+                return False
+            names.add(name.lower())
+            parameters.append(HeaderParameter(path, f"mcp-param-{name.lower()}", cast("str", kind)))
+        for keyword, value in node.items():
+            if keyword in _SCHEMA_MAP_KEYWORDS and isinstance(value, dict):
+                children = cast("dict[str, object]", value)
+                for key, child in children.items():
+                    child_path = (
+                        (*path, key) if keyword == "properties" and path is not None else None
+                    )
+                    if not visit(child, child_path):
+                        return False
+            elif isinstance(value, list):
+                if keyword in _SCHEMA_ARRAY_KEYWORDS and not all(
+                    visit(child, None) for child in cast("list[object]", value)
+                ):
+                    return False
+            elif keyword in _SCHEMA_KEYWORDS and not visit(value, None):
+                return False
+        return True
+
+    return parameters if visit(tool["inputSchema"], ()) else None
+
+
+def routing_headers(
+    message: Mapping[str, Any], tool: Tool | None
+) -> Effect[dict[str, str], McpClientError]:
+    """The 2026-07-28 HTTP routing headers of a request."""
+    method = message.get("method")
+    if not isinstance(method, str):
+        return succeed({})
+    headers = {"mcp-method": method}
+    params = cast("Mapping[str, Any]", message.get("params") or {})
+    name = params.get("uri") if method == "resources/read" else params.get("name")
+    if isinstance(name, str) and method in ("tools/call", "prompts/get", "resources/read"):
+        headers["mcp-name"] = header_value(name)
+    if method != "tools/call":
+        return succeed(headers)
+    parameters = None if tool is None else header_parameters(tool)
+    if parameters is None:
+        return fail(failure(UnsupportedError("Tool has invalid x-mcp-header annotations")))
+    for parameter in parameters:
+        value: object = params.get("arguments")
+        for key in parameter.path:
+            value = cast("dict[str, object]", value).get(key) if isinstance(value, dict) else None
+        if value is None:
+            continue
+        valid = (
+            isinstance(value, int) and not isinstance(value, bool)
+            if parameter.type == "integer"
+            else isinstance(value, bool)
+            if parameter.type == "boolean"
+            else isinstance(value, str)
+        )
+        if not valid:
+            return fail(
+                failure(
+                    ValidationError(f"Invalid value for MCP header parameter {parameter.header}")
+                )
+            )
+        text = ("true" if value else "false") if isinstance(value, bool) else str(value)
+        headers[parameter.header] = header_value(text)
+    return succeed(headers)
+
+
+def to_text(result: CallToolResult) -> Effect[str, McpClientError]:
+    """What a model sees of a tool result: its text, resource links and
+    text resources, or the JSON of ``structuredContent`` when it has none."""
+
+    def unsupported(content: str) -> Effect[str, McpClientError]:
+        return fail(
+            failure(
+                UnsupportedError(f"MCP {content} requires an application text converter", result)
+            )
+        )
+
+    parts: list[str] = []
+    for block in result["content"]:
+        if block["type"] == "text":
+            parts.append(block["text"])
+        elif block["type"] == "resource_link":
+            label = block.get("title") or block["name"]
+            description = block.get("description")
+            parts.append(
+                f"{label}: {block['uri']}" + ("" if description is None else f"\n{description}")
+            )
+        elif block["type"] == "resource":
+            resource = block["resource"]
+            if "text" not in resource:
+                return unsupported("binary resources")
+            parts.append(cast("Any", resource)["text"])
+        else:
+            return unsupported(f"{block['type']} content")
+    if not parts and "structuredContent" in result:
+        return succeed(_json_text.stringify(result["structuredContent"]))
+    return succeed("\n".join(parts))
+
+
+def requires_tasks(tool: object) -> bool:
+    if not isinstance(tool, dict):
+        return False
+    execution = cast("dict[str, object]", tool).get("execution")
+    return (
+        isinstance(execution, dict)
+        and cast("dict[str, object]", execution).get("taskSupport") == "required"
+    )
+
+
+def media_type(headers: Mapping[str, str]) -> str | None:
+    content_type = headers.get("content-type")
+    return None if content_type is None else content_type.split(";", 1)[0].strip().lower()
+
+
+__all__: Sequence[str] = ()