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

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

@@ -1,10 +1,12 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.51
+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.51 → steerable_agent_runtime-0.6.53}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.51"
+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.51 → 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.51 → steerable_agent_runtime-0.6.53}/src/steerable_agent_runtime/approval.py

@@ -53,6 +53,7 @@ __all__ = [
     "ApprovalStore",
     "Approver",
     "AutoApprover",
+    "WorkspaceAutoApprover",
     "InMemoryApprovalStore",
     "JsonApprovalStore",
     "SessionApprovalCache",
@@ -130,6 +131,91 @@ class Approver(Protocol):
     async def approve(self, request: ApprovalRequest) -> ApprovalDecision: ...
 
 
+_PATH_ARG_TOOLS = {
+    "local_read_file": "path",
+    "local_write_file": "path",
+    "local_edit_file": "path",
+    "view_image": "path",
+}
+
+
+def declared_target_paths(request: ApprovalRequest) -> list[str] | None:
+    """Filesystem targets of a path-scoped tool, or None when the call is not one.
+
+    ``None`` means the approver cannot prove the call stays inside the
+    project, so the interactive prompt still runs. Shell commands stay in
+    that bucket: the command text can name paths the cwd does not.
+    """
+    if request.tool_name == "present_files":
+        files = request.arguments.get("files")
+        if not isinstance(files, list) or not files:
+            return None
+        paths: list[str] = []
+        for item in files:
+            if not isinstance(item, dict):
+                return None
+            raw = item.get("path")
+            if not isinstance(raw, str) or not raw.strip():
+                return None
+            paths.append(raw.strip())
+        return paths
+    key = _PATH_ARG_TOOLS.get(request.tool_name)
+    if key is None:
+        return None
+    raw = request.arguments.get(key)
+    if not isinstance(raw, str) or not raw.strip():
+        return None
+    return [raw.strip()]
+
+
+def path_inside_writable_roots(raw: str, roots: list[str]) -> bool:
+    """True when ``raw`` is the configured directory or one of its subdirectories.
+
+    Relative paths are project-relative. A ``..`` segment can leave the
+    project, so those still go to the prompt. Absolute paths must sit under
+    one of ``roots``.
+    """
+    expanded = os.path.expanduser(raw.strip())
+    if not os.path.isabs(expanded):
+        normalized = os.path.normpath(expanded)
+        return normalized != ".." and not normalized.startswith(".." + os.sep)
+    target = os.path.abspath(expanded)
+    for root in roots:
+        if not isinstance(root, str) or not root.strip():
+            continue
+        root_abs = os.path.abspath(os.path.expanduser(root.strip()))
+        try:
+            if os.path.commonpath([target, root_abs]) == root_abs:
+                return True
+        except ValueError:
+            continue
+    return False
+
+
+class WorkspaceAutoApprover:
+    """Skip the host prompt when every declared path is already inside a writable root.
+
+    The allow is request-scoped. The next call is judged again, so an
+    in-project ``present_files`` does not grant the same tool outside the
+    project. Calls with no path we can check, or any path outside the roots,
+    fall through to the inner approver.
+    """
+
+    def __init__(self, inner: Approver, writable_roots: list[str]) -> None:
+        self._inner = inner
+        self._roots = [root for root in writable_roots if isinstance(root, str) and root.strip()]
+
+    async def approve(self, request: ApprovalRequest) -> ApprovalDecision:
+        paths = declared_target_paths(request)
+        if (
+            self._roots
+            and paths is not None
+            and all(path_inside_writable_roots(path, self._roots) for path in paths)
+        ):
+            return ApprovalDecision("allow_once", "path is inside a writable project root")
+        return await self._inner.approve(request)
+
+
 class AutoApprover:
     """Headless approver: never blocks, decides by tool mode.
 

{steerable_agent_runtime-0.6.51 → steerable_agent_runtime-0.6.53}/src/steerable_agent_runtime/default.harness.json

@@ -23,8 +23,6 @@
   "memory": "stateless",
   "orchestration": "single",
   "loop": {
-    "max_rounds": 80,
-    "max_tool_errors": 16,
     "tool_dedup": false
   }
 }

{steerable_agent_runtime-0.6.51 → steerable_agent_runtime-0.6.53}/src/steerable_agent_runtime/default.harness.yaml

@@ -22,7 +22,9 @@ memory: stateless
 orchestration: single
 # Loop limits the harness pins (W3.4.2.4): entrypoints read these instead of
 # hardcoding knobs. Absent fields fall back to the entrypoint's baseline.
+# max_rounds and max_tool_errors are absent on purpose — a cap here ends a
+# long task at budget_exhausted / consecutive tool errors. The baseline is
+# no cap. A caller that wants a wall passes maxRounds / maxToolErrors, and
+# Harbor passes --max-rounds 250.
 loop:
-  max_rounds: 80
-  max_tool_errors: 16
   tool_dedup: false

{steerable_agent_runtime-0.6.51 → 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.51 → steerable_agent_runtime-0.6.53}/src/steerable_agent_runtime/orchestration.py

@@ -38,6 +38,7 @@ from typing import Any
 
 from steerable_agent_protocol.generated import ToolCall, ToolResult
 
+from .hooks import ChainHooks, CompletionAction, CompletionDraft, NoopHooks
 from .llm import LLMProvider
 from .loop import CoreLoop, LoopConfig, LoopContext, LoopHooks, ToolExecutor
 from .pool import (
@@ -51,12 +52,61 @@ from .subagent import FilteredToolsExecutor, _schema_name
 __all__ = [
     "AgentPool",
     "ChildOutcome",
+    "ChildBudgetWrapUp",
     "OrchestrationBudgetExceeded",
     "OrchestrationConfig",
     "OrchestrationExecutor",
     "orchestration_tool_descriptors",
 ]
 
+#: Terminal status of a run stopped by ``max_rounds`` or the token budget.
+_BUDGET_WALL_STATUS = "budget_exhausted"
+
+_BUDGET_WRAP_UP_REQUEST = (
+    "[system notice] This run has used its round budget and tools are now "
+    "withheld. Answer the original task now from what you have already "
+    "gathered: give your concrete findings first, then list what you could "
+    "not finish or verify. Do not describe the steps you took."
+)
+
+_RESUME_HINT = (
+    "The child stopped at its round budget; `answer` is its interim report. "
+    "To continue, agent_send this childId a message naming what is still "
+    "missing — it resumes with its prior context and a fresh budget. Do not "
+    "spawn a new child for the same task."
+)
+
+
+class ChildBudgetWrapUp(NoopHooks):
+    """``before_completion``: one no-tools answer round at a child's budget wall.
+
+    Without it a child stopped by ``max_rounds`` or the token budget returns
+    whatever text its last working round produced — usually a progress note,
+    not an answer. The parent then gets ``budget_exhausted`` with nothing
+    usable. The ``narrate`` action runs one round without tools and keeps the
+    ``budget_exhausted`` status, so the parent can still tell the answer is
+    interim and resume the child with ``agent_send``.
+
+    One instance per child loop. A resumed child runs the same loop with a new
+    ``LoopContext``, so the one-round limit applies per run.
+    """
+
+    def __init__(self) -> None:
+        self._wrapped_run: LoopContext | None = None
+
+    async def before_completion(
+        self, draft: CompletionDraft, ctx: LoopContext
+    ) -> CompletionAction:
+        """Narrate once per run when the draft stops at the budget wall."""
+        if draft.status != _BUDGET_WALL_STATUS or self._wrapped_run is ctx:
+            return CompletionAction(kind="accept")
+        self._wrapped_run = ctx
+        return CompletionAction(
+            kind="narrate",
+            message=_BUDGET_WRAP_UP_REQUEST,
+            reason="child_budget_wrap_up",
+        )
+
 
 def orchestration_tool_descriptors(
     config: OrchestrationConfig | None = None,
@@ -119,7 +169,10 @@ def orchestration_tool_descriptors(
         fn(
             config.wait_tool,
             "Wait for a sub-agent to finish and return its outcome. A child "
-            "still running at the timeout returns status 'running'.",
+            "still running at the timeout returns status 'running'. A child "
+            "that hit its round budget returns status 'budget_exhausted' with "
+            "an interim answer and resumable: true — continue it with "
+            "agent_send instead of spawning a new child.",
             {
                 "childId": {"type": "string"},
                 "timeoutMs": {"type": "integer"},
@@ -228,11 +281,15 @@ class OrchestrationExecutor:
                 _lineage=child_id,
             )
             schemas = [*schemas, *orchestration_tool_descriptors(self._config)]
+        wrap_up = ChildBudgetWrapUp()
         loop = CoreLoop(
             self._provider,
             base,
-            LoopConfig(max_rounds=self._config.child_max_rounds),
-            hooks=self._hooks,
+            LoopConfig(
+                max_rounds=self._config.child_max_rounds,
+                max_tool_errors=self._config.child_max_tool_errors,
+            ),
+            hooks=wrap_up if self._hooks is None else ChainHooks(self._hooks, wrap_up),
         )
         return loop, schemas or None
 
@@ -343,15 +400,17 @@ class OrchestrationExecutor:
                 error=f"unknown_child: {child_id!r}",
                 needsFollowup=True,
             )
+        payload: dict[str, Any] = {
+            "childId": outcome.child_id,
+            "status": outcome.status,
+            "answer": outcome.answer,
+        }
+        if self._pool.resumable(outcome.child_id):
+            payload["resumable"] = True
+            payload["hint"] = _RESUME_HINT
         return ToolResult(
             success=True,
-            message=json.dumps(
-                {
-                    "childId": outcome.child_id,
-                    "status": outcome.status,
-                    "answer": outcome.answer,
-                }
-            ),
+            message=json.dumps(payload),
             data={"childId": outcome.child_id, "status": outcome.status},
         )