steerable-agent-runtime 0.6.52__tar.gz → 0.6.53__tar.gz

{steerable_agent_runtime-0.6.52 → steerable_agent_runtime-0.6.53}/PKG-INFO

@@ -1,10 +1,12 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.52
+Version: 0.6.53
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 License: Apache-2.0
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Requires-Dist: httpx[socks]>=0.27
+Requires-Dist: mcp<2.0.0,>=1.13.0
 Requires-Dist: pydantic>=2.10.0
 Requires-Dist: steerable-agent-protocol<1.0.0,>=0.1.0
 Requires-Dist: steerable-agent-harness<1.0.0,>=0.1.0
@@ -15,14 +17,12 @@ Provides-Extra: fastapi
 Requires-Dist: fastapi>=0.110; extra == "fastapi"
 Requires-Dist: starlette>=0.37; extra == "fastapi"
 Provides-Extra: openai
-Requires-Dist: httpx[socks]>=0.27; extra == "openai"
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.40; extra == "anthropic"
 Provides-Extra: all
 Requires-Dist: sqlalchemy>=2.0; extra == "all"
 Requires-Dist: fastapi>=0.110; extra == "all"
 Requires-Dist: starlette>=0.37; extra == "all"
-Requires-Dist: httpx[socks]>=0.27; extra == "all"
 Requires-Dist: anthropic>=0.40; extra == "all"
 
 # steerable-agent-runtime

{steerable_agent_runtime-0.6.52 → steerable_agent_runtime-0.6.53}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.52"
+version = "0.6.53"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 license = { text = "Apache-2.0" }
 readme = "README.md"
@@ -13,6 +13,11 @@ requires-python = ">=3.10"
 # CoreLoop execution is the Rust engine. The matching native wheel
 # is a hard dependency: install or startup fails if it is missing.
 dependencies = [
+  # MCP Streamable HTTP and OpenAI-compatible providers both construct httpx
+  # clients. Keep SOCKS support in the base install because exported proxy
+  # variables are evaluated during client construction.
+  "httpx[socks]>=0.27",
+  "mcp>=1.13.0,<2.0.0",
   "pydantic>=2.10.0",
   "steerable-agent-protocol>=0.1.0,<1.0.0",
   "steerable-agent-harness>=0.1.0,<1.0.0",
@@ -22,17 +27,12 @@ dependencies = [
 [project.optional-dependencies]
 sqlalchemy = ["sqlalchemy>=2.0"]
 fastapi = ["fastapi>=0.110", "starlette>=0.37"]
-# The `socks` extra is not optional in practice: httpx builds a transport for
-# every proxy the environment declares while the client is constructed, so a
-# host exporting `all_proxy=socks5://…` — the common shell proxy snippet — makes
-# construction raise without it, failing provider calls that never reach a URL.
-openai = ["httpx[socks]>=0.27"]
+openai = []
 anthropic = ["anthropic>=0.40"]
 all = [
   "sqlalchemy>=2.0",
   "fastapi>=0.110",
   "starlette>=0.37",
-  "httpx[socks]>=0.27",
   "anthropic>=0.40",
 ]
 

{steerable_agent_runtime-0.6.52 → steerable_agent_runtime-0.6.53}/src/steerable_agent_runtime/__init__.py

@@ -163,9 +163,12 @@ from .mcp import (
     DEFAULT_MAX_SERVER_TOOLS,
     McpCallResult,
     McpCatalogError,
+    McpClient,
     McpError,
+    McpStreamableHttpClient,
     McpStdioClient,
     McpToolInfo,
+    create_mcp_client,
     mcp_invoker,
     parse_mcp_name,
     qualify_mcp_name,
@@ -374,7 +377,9 @@ __all__ = [
     "LoopHooks",
     "McpCallResult",
     "McpCatalogError",
+    "McpClient",
     "McpError",
+    "McpStreamableHttpClient",
     "McpStdioClient",
     "McpToolInfo",
     "ModelCalibration",
@@ -472,6 +477,7 @@ __all__ = [
     "make_todo_write_tool",
     "parent_input_tool_descriptor",
     "matches_conditions",
+    "create_mcp_client",
     "mcp_invoker",
     "merge_patch",
     "message_from_dict",

{steerable_agent_runtime-0.6.52 → steerable_agent_runtime-0.6.53}/src/steerable_agent_runtime/mcp.py

@@ -1,4 +1,4 @@
-"""MCP client seam: qualified names, capped catalogs, minimal stdio client.
+"""MCP client seam: qualified names, capped catalogs, transport clients.
 
 MCP is the largest unbounded, third-party, mutable source of model-visible
 context an agent system can add, so it lands on the Wave 2 foundation:
@@ -22,9 +22,9 @@ caps.
 Architecture (recorded in docs/roadmap.md): in the desktop product, MCP
 servers are launched host-side (Electron main) and reached through
 `ToolRouter.register_remote` — a Seatbelt-confined sidecar never spawns
-them. `McpStdioClient` exists for hosts that embed the runtime directly
-(CLI agents, tests, non-Electron hosts); it is transport-only and holds no
-loop state.
+them. `McpStdioClient` and `McpStreamableHttpClient` exist for hosts that
+embed the runtime directly (CLI agents, tests, non-Electron hosts); both
+are transport-only and hold no loop state.
 """
 
 from __future__ import annotations
@@ -34,8 +34,15 @@ import json
 import logging
 import os
 from collections.abc import Awaitable, Callable, Mapping, Sequence
+from contextlib import AsyncExitStack
 from dataclasses import dataclass, field
-from typing import Any
+from datetime import timedelta
+from typing import Any, Protocol
+from urllib.parse import urlparse
+
+import httpx
+from mcp import ClientSession
+from mcp.client.streamable_http import streamable_http_client
 
 from .errors import RuntimeError as SteerableRuntimeError
 from .tools import RegisteredTool, ToolExposure, ToolRouter
@@ -126,6 +133,26 @@ class McpCallResult:
     structured: Any = None
 
 
+class McpClient(Protocol):
+    """Transport-independent client operations consumed by MCP mounting paths."""
+
+    server_info: dict[str, Any]
+
+    async def __aenter__(self) -> McpClient: ...
+
+    async def __aexit__(self, *exc: Any) -> None: ...
+
+    async def start(self) -> None: ...
+
+    async def aclose(self) -> None: ...
+
+    async def list_tools(self) -> list[McpToolInfo]: ...
+
+    async def call_tool(
+        self, name: str, arguments: dict[str, Any]
+    ) -> McpCallResult: ...
+
+
 def register_mcp_catalog(
     router: ToolRouter,
     *,
@@ -178,9 +205,9 @@ def register_mcp_catalog(
 
 
 def mcp_invoker(
-    client: "McpStdioClient",
+    client: McpClient,
 ) -> Callable[[str, dict[str, Any]], Awaitable[Any]]:
-    """Adapt `McpStdioClient.call_tool` to the catalog invoker contract.
+    """Adapt an MCP client's `call_tool` to the catalog invoker contract.
 
     Maps ``isError`` results to failed `ToolResult`s (follow-up allowed —
     the model sees the server's error text and can correct its arguments)
@@ -199,6 +226,214 @@ def mcp_invoker(
     return _invoke
 
 
+def create_mcp_client(
+    config: Mapping[str, Any],
+    *,
+    environ: Mapping[str, str] | None = None,
+    request_timeout: float = 30.0,
+) -> McpClient:
+    """Build a client from an explicit or legacy-discriminated config entry.
+
+    ``transport`` accepts ``stdio`` and ``streamable-http``. For existing
+    callers, an omitted discriminator is inferred from exactly one of
+    ``command`` or ``url``. Environment-sourced header values are resolved
+    only into the client and are redacted from transport failures.
+    """
+    command = config.get("command")
+    url = config.get("url")
+    if command and url:
+        raise McpError("MCP config cannot contain both 'command' and 'url'")
+
+    transport = config.get("transport")
+    if transport is None:
+        if command:
+            transport = "stdio"
+        elif url:
+            transport = "streamable-http"
+        else:
+            raise McpError("MCP config requires a non-empty 'command' or 'url'")
+
+    if transport == "stdio":
+        if not command:
+            raise McpError("stdio MCP config requires a non-empty 'command'")
+        if url:
+            raise McpError("stdio MCP config cannot contain 'url'")
+        raw_env = config.get("env") or {}
+        if not isinstance(raw_env, Mapping):
+            raise McpError("stdio MCP config 'env' must be an object")
+        return McpStdioClient(
+            str(command),
+            [str(arg) for arg in config.get("args") or []],
+            env={str(key): str(value) for key, value in raw_env.items()} or None,
+            request_timeout=request_timeout,
+        )
+
+    if transport != "streamable-http":
+        raise McpError(f"unsupported MCP transport: {transport!r}")
+    if not url:
+        raise McpError("streamable-http MCP config requires a non-empty 'url'")
+    if command:
+        raise McpError("streamable-http MCP config cannot contain 'command'")
+    parsed = urlparse(str(url))
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise McpError("streamable-http MCP config 'url' must be an HTTP(S) URL")
+    if parsed.username or parsed.password:
+        raise McpError("streamable-http MCP config 'url' cannot contain credentials")
+
+    raw_headers = config.get("headers") or {}
+    raw_headers_from_env = config.get("headersFromEnv") or {}
+    if not isinstance(raw_headers, Mapping):
+        raise McpError("streamable-http MCP config 'headers' must be an object")
+    if not isinstance(raw_headers_from_env, Mapping):
+        raise McpError(
+            "streamable-http MCP config 'headersFromEnv' must be an object"
+        )
+    source = os.environ if environ is None else environ
+    headers = {str(name): str(value) for name, value in raw_headers.items()}
+    secret_values = [value for value in headers.values() if value]
+    for raw_name, raw_env_name in raw_headers_from_env.items():
+        env_name = str(raw_env_name)
+        value = source.get(env_name)
+        if not value:
+            raise McpError(
+                f"streamable-http MCP header environment variable "
+                f"{env_name!r} is not set"
+            )
+        headers[str(raw_name)] = value
+        secret_values.append(value)
+    bearer_env = config.get("bearerTokenEnvVar")
+    if bearer_env is not None:
+        env_name = str(bearer_env)
+        value = source.get(env_name)
+        if not value:
+            raise McpError(
+                f"streamable-http MCP bearer environment variable "
+                f"{env_name!r} is not set"
+            )
+        headers["Authorization"] = f"Bearer {value}"
+        secret_values.append(value)
+
+    return McpStreamableHttpClient(
+        str(url),
+        headers=headers,
+        secret_values=secret_values,
+        request_timeout=request_timeout,
+    )
+
+
+class McpStreamableHttpClient:
+    """MCP Streamable HTTP client backed by the official Python MCP SDK."""
+
+    def __init__(
+        self,
+        url: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        secret_values: Sequence[str] = (),
+        request_timeout: float = 30.0,
+    ) -> None:
+        self._url = url
+        self._headers = dict(headers or {})
+        self._secret_values = tuple(value for value in secret_values if value)
+        self._request_timeout = request_timeout
+        self._stack: AsyncExitStack | None = None
+        self._session: ClientSession | None = None
+        self.server_info: dict[str, Any] = {}
+
+    async def __aenter__(self) -> McpStreamableHttpClient:
+        await self.start()
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.aclose()
+
+    async def start(self) -> None:
+        if self._stack is not None:
+            raise McpError("McpStreamableHttpClient already started")
+        stack = AsyncExitStack()
+        self._stack = stack
+        try:
+            http_client = await stack.enter_async_context(
+                httpx.AsyncClient(headers=self._headers)
+            )
+            read_stream, write_stream, _session_id = await stack.enter_async_context(
+                streamable_http_client(self._url, http_client=http_client)
+            )
+            session = await stack.enter_async_context(
+                ClientSession(
+                    read_stream,
+                    write_stream,
+                    read_timeout_seconds=timedelta(seconds=self._request_timeout),
+                )
+            )
+            initialized = await session.initialize()
+            self._session = session
+            self.server_info = initialized.serverInfo.model_dump(
+                by_alias=True, exclude_none=True
+            )
+        except Exception as exc:
+            await self.aclose()
+            raise self._error("initialize", exc) from exc
+
+    async def aclose(self) -> None:
+        stack, self._stack = self._stack, None
+        self._session = None
+        if stack is not None:
+            await stack.aclose()
+
+    async def list_tools(self) -> list[McpToolInfo]:
+        session = self._require_session()
+        tools: list[McpToolInfo] = []
+        cursor: str | None = None
+        try:
+            while True:
+                result = await session.list_tools(cursor=cursor)
+                tools.extend(
+                    McpToolInfo(
+                        name=tool.name,
+                        description=tool.description or "",
+                        schema=dict(tool.inputSchema),
+                    )
+                    for tool in result.tools
+                )
+                cursor = result.nextCursor
+                if cursor is None:
+                    return tools
+        except Exception as exc:
+            raise self._error("tools/list", exc) from exc
+
+    async def call_tool(
+        self, name: str, arguments: dict[str, Any]
+    ) -> McpCallResult:
+        session = self._require_session()
+        try:
+            result = await session.call_tool(name, arguments)
+        except Exception as exc:
+            raise self._error("tools/call", exc) from exc
+        parts: list[str] = []
+        for content in result.content:
+            if content.type == "text":
+                parts.append(content.text)
+            else:
+                parts.append(f"[mcp {content.type} content]")
+        return McpCallResult(
+            text="\n".join(parts),
+            is_error=result.isError,
+            structured=result.structuredContent,
+        )
+
+    def _require_session(self) -> ClientSession:
+        if self._session is None:
+            raise McpError("MCP Streamable HTTP client is not running")
+        return self._session
+
+    def _error(self, operation: str, exc: Exception) -> McpError:
+        message = str(exc)
+        for secret in self._secret_values:
+            message = message.replace(secret, "[redacted]")
+        return McpError(f"MCP Streamable HTTP {operation} failed: {message}")
+
+
 # ---------------------------------------------------------------------------
 # Minimal stdio client (NDJSON JSON-RPC 2.0)
 # ---------------------------------------------------------------------------

{steerable_agent_runtime-0.6.52 → steerable_agent_runtime-0.6.53}/src/steerable_agent_runtime.egg-info/PKG-INFO

@@ -1,10 +1,12 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.52
+Version: 0.6.53
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 License: Apache-2.0
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Requires-Dist: httpx[socks]>=0.27
+Requires-Dist: mcp<2.0.0,>=1.13.0
 Requires-Dist: pydantic>=2.10.0
 Requires-Dist: steerable-agent-protocol<1.0.0,>=0.1.0
 Requires-Dist: steerable-agent-harness<1.0.0,>=0.1.0
@@ -15,14 +17,12 @@ Provides-Extra: fastapi
 Requires-Dist: fastapi>=0.110; extra == "fastapi"
 Requires-Dist: starlette>=0.37; extra == "fastapi"
 Provides-Extra: openai
-Requires-Dist: httpx[socks]>=0.27; extra == "openai"
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.40; extra == "anthropic"
 Provides-Extra: all
 Requires-Dist: sqlalchemy>=2.0; extra == "all"
 Requires-Dist: fastapi>=0.110; extra == "all"
 Requires-Dist: starlette>=0.37; extra == "all"
-Requires-Dist: httpx[socks]>=0.27; extra == "all"
 Requires-Dist: anthropic>=0.40; extra == "all"
 
 # steerable-agent-runtime

{steerable_agent_runtime-0.6.52 → steerable_agent_runtime-0.6.53}/src/steerable_agent_runtime.egg-info/requires.txt

@@ -1,3 +1,5 @@
+httpx[socks]>=0.27
+mcp<2.0.0,>=1.13.0
 pydantic>=2.10.0
 steerable-agent-protocol<1.0.0,>=0.1.0
 steerable-agent-harness<1.0.0,>=0.1.0
@@ -7,7 +9,6 @@ steerable-agent-runtime-native==1.0.3
 sqlalchemy>=2.0
 fastapi>=0.110
 starlette>=0.37
-httpx[socks]>=0.27
 anthropic>=0.40
 
 [anthropic]
@@ -18,7 +19,6 @@ fastapi>=0.110
 starlette>=0.37
 
 [openai]
-httpx[socks]>=0.27
 
 [sqlalchemy]
 sqlalchemy>=2.0

{steerable_agent_runtime-0.6.52 → steerable_agent_runtime-0.6.53}/tests/test_mcp.py

@@ -10,8 +10,11 @@ The end-to-end test runs the full chain: server → catalog → deferred tier
 
 from __future__ import annotations
 
+import socket
+import subprocess
 import sys
 import textwrap
+import time
 from collections.abc import AsyncIterator
 from pathlib import Path
 from typing import Any
@@ -24,10 +27,12 @@ from steerable_agent_runtime import (
     LLMMessage,
     McpCatalogError,
     McpError,
+    McpStreamableHttpClient,
     McpStdioClient,
     McpToolInfo,
     RouterToolExecutor,
     ToolRouter,
+    create_mcp_client,
     mcp_invoker,
     parse_mcp_name,
     qualify_mcp_name,
@@ -319,6 +324,69 @@ def fake_server(tmp_path: Path) -> Path:
     return script
 
 
+_FAKE_HTTP_SERVER = textwrap.dedent(
+    """
+    import sys
+
+    from mcp.server.fastmcp import Context, FastMCP
+
+    server = FastMCP(
+        "fake-http-mcp",
+        host="127.0.0.1",
+        port=int(sys.argv[1]),
+        stateless_http=True,
+    )
+
+    @server.tool()
+    def echo_headers(text: str, ctx: Context) -> str:
+        headers = ctx.request_context.request.headers
+        return "|".join(
+            (
+                "echo:" + text,
+                "tenant:" + str(headers.get("x-tenant") == "acme"),
+                "api:" + str(headers.get("x-api-key") == "api-secret"),
+                "auth:" + str(
+                    headers.get("authorization") == "Bearer bearer-secret"
+                ),
+            )
+        )
+
+    server.run(transport="streamable-http")
+    """
+)
+
+
+@pytest.fixture()
+def fake_http_server(tmp_path: Path) -> str:
+    script = tmp_path / "fake_http_mcp_server.py"
+    script.write_text(_FAKE_HTTP_SERVER)
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        port = sock.getsockname()[1]
+    process = subprocess.Popen(
+        [sys.executable, str(script), str(port)],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    deadline = time.monotonic() + 10
+    while time.monotonic() < deadline:
+        if process.poll() is not None:
+            raise RuntimeError("fake Streamable HTTP MCP server exited during startup")
+        try:
+            with socket.create_connection(("127.0.0.1", port), timeout=0.1):
+                break
+        except OSError:
+            time.sleep(0.05)
+    else:
+        process.terminate()
+        raise RuntimeError("fake Streamable HTTP MCP server did not start")
+    try:
+        yield f"http://127.0.0.1:{port}/mcp"
+    finally:
+        process.terminate()
+        process.wait(timeout=5)
+
+
 @pytest.mark.asyncio
 async def test_stdio_client_handshake_list_and_call(fake_server: Path) -> None:
     async with McpStdioClient(sys.executable, [str(fake_server)]) as client:
@@ -376,6 +444,93 @@ async def test_stdio_client_use_before_start_fails(fake_server: Path) -> None:
         await client.call_tool("echo", {})
 
 
+def test_create_mcp_client_supports_explicit_and_legacy_transports() -> None:
+    assert isinstance(
+        create_mcp_client({"transport": "stdio", "command": "server"}),
+        McpStdioClient,
+    )
+    assert isinstance(create_mcp_client({"command": "server"}), McpStdioClient)
+    assert isinstance(
+        create_mcp_client(
+            {"transport": "streamable-http", "url": "https://example.test/mcp"}
+        ),
+        McpStreamableHttpClient,
+    )
+    assert isinstance(
+        create_mcp_client({"url": "https://example.test/mcp"}),
+        McpStreamableHttpClient,
+    )
+
+
+def test_create_mcp_client_rejects_mixed_transport_config() -> None:
+    with pytest.raises(McpError, match="both 'command' and 'url'"):
+        create_mcp_client(
+            {"command": "server", "url": "https://example.test/mcp"}
+        )
+
+
+@pytest.mark.asyncio
+async def test_streamable_http_client_uses_sdk_and_env_headers(
+    fake_http_server: str,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("MCP_API_KEY", "api-secret")
+    monkeypatch.setenv("MCP_BEARER", "bearer-secret")
+    config = {
+        "transport": "streamable-http",
+        "url": fake_http_server,
+        "headers": {"X-Tenant": "acme"},
+        "headersFromEnv": {"X-Api-Key": "MCP_API_KEY"},
+        "bearerTokenEnvVar": "MCP_BEARER",
+    }
+    async with create_mcp_client(config) as client:
+        tools = await client.list_tools()
+        assert [tool.name for tool in tools] == ["echo_headers"]
+        result = await client.call_tool("echo_headers", {"text": "hello"})
+    assert result.text == "echo:hello|tenant:True|api:True|auth:True"
+    assert "api-secret" not in result.text
+    assert "bearer-secret" not in result.text
+    assert "api-secret" not in repr(config)
+    assert "bearer-secret" not in repr(config)
+
+
+def test_streamable_http_client_requires_env_header_values(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("MISSING_MCP_TOKEN", raising=False)
+    with pytest.raises(McpError, match="MISSING_MCP_TOKEN"):
+        create_mcp_client(
+            {
+                "url": "https://example.test/mcp",
+                "headersFromEnv": {"X-Api-Key": "MISSING_MCP_TOKEN"},
+            }
+        )
+
+
+def test_streamable_http_client_rejects_url_credentials() -> None:
+    with pytest.raises(McpError, match="credentials"):
+        create_mcp_client({"url": "https://user:secret@example.test/mcp"})
+
+
+def test_streamable_http_client_redacts_header_values_from_errors() -> None:
+    client = create_mcp_client(
+        {
+            "url": "https://example.test/mcp",
+            "headers": {"X-Api-Key": "direct-secret"},
+            "headersFromEnv": {"X-Other-Key": "OTHER_KEY"},
+            "bearerTokenEnvVar": "BEARER_KEY",
+        },
+        environ={"OTHER_KEY": "env-secret", "BEARER_KEY": "bearer-secret"},
+    )
+    assert isinstance(client, McpStreamableHttpClient)
+    error = client._error(
+        "test", RuntimeError("direct-secret env-secret bearer-secret")
+    )
+    assert str(error) == (
+        "MCP Streamable HTTP test failed: [redacted] [redacted] [redacted]"
+    )
+
+
 # ---------------------------------------------------------------------------
 # End to end: server → catalog → deferred tier → tool_search → loop
 # ---------------------------------------------------------------------------