steerable-agent-runtime 0.6.41__tar.gz → 0.6.43__tar.gz

{steerable_agent_runtime-0.6.41 → steerable_agent_runtime-0.6.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.41
+Version: 0.6.43
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 License: Apache-2.0
 Requires-Python: >=3.10
@@ -8,7 +8,7 @@ Description-Content-Type: text/markdown
 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
-Requires-Dist: steerable-agent-runtime-native==0.6.39
+Requires-Dist: steerable-agent-runtime-native==0.6.40
 Provides-Extra: sqlalchemy
 Requires-Dist: sqlalchemy>=2.0; extra == "sqlalchemy"
 Provides-Extra: fastapi

{steerable_agent_runtime-0.6.41 → steerable_agent_runtime-0.6.43}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.41"
+version = "0.6.43"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 license = { text = "Apache-2.0" }
 readme = "README.md"
@@ -16,7 +16,7 @@ dependencies = [
   "pydantic>=2.10.0",
   "steerable-agent-protocol>=0.1.0,<1.0.0",
   "steerable-agent-harness>=0.1.0,<1.0.0",
-  "steerable-agent-runtime-native==0.6.39",
+  "steerable-agent-runtime-native==0.6.40",
 ]
 
 [project.optional-dependencies]

{steerable_agent_runtime-0.6.41 → steerable_agent_runtime-0.6.43}/src/steerable_agent_runtime/approval.py

@@ -24,6 +24,7 @@ invoker — instead of being baked into one registry.
 from __future__ import annotations
 
 import asyncio
+import contextvars
 import json
 import logging
 import os
@@ -249,6 +250,41 @@ def _default_resolver(call: ToolCall, ctx: LoopContext) -> ApprovalRequest:
     )
 
 
+class ToolTimeoutClock:
+    """Pauses the loop's tool cap while an approval prompt is unanswered.
+
+    The cap still covers the command after the user decides. The object is
+    shared through a contextvar so the waiting tool and ``ApprovalExecutor``
+    see the same clock.
+    """
+
+    def __init__(self) -> None:
+        self._depth = 0
+        self.resumed = asyncio.Event()
+        self.resumed.set()
+        self.paused = asyncio.Event()
+
+    def suspend(self) -> None:
+        self._depth += 1
+        self.resumed.clear()
+        self.paused.set()
+
+    def resume(self) -> None:
+        self._depth = max(0, self._depth - 1)
+        if self._depth == 0:
+            self.paused.clear()
+            self.resumed.set()
+
+    @property
+    def suspended(self) -> bool:
+        return self._depth > 0
+
+
+tool_timeout_clock: contextvars.ContextVar[ToolTimeoutClock | None] = contextvars.ContextVar(
+    "tool_timeout_clock", default=None
+)
+
+
 class ApprovalExecutor:
     """``ToolExecutor`` decorator enforcing the approval algebra.
 
@@ -365,18 +401,27 @@ class ApprovalExecutor:
         return self._durable
 
     async def _ask(self, request: ApprovalRequest) -> ApprovalDecision:
-        if self._timeout_s is None:
-            return await self._approver.approve(request)
+        # No timeout means wait until the user decides. That wait is not
+        # part of the tool cap; the command after the decision still is.
+        clock = tool_timeout_clock.get() if self._timeout_s is None else None
+        if clock is not None:
+            clock.suspend()
         try:
-            return await asyncio.wait_for(
-                self._approver.approve(request), timeout=self._timeout_s
-            )
-        except (TimeoutError, asyncio.TimeoutError):
-            # Fail closed, keeping the variant for observability (codex's
-            # TimedOut semantics: no decision arrived, do not execute).
-            return ApprovalDecision(
-                "timed_out", f"approval request timed out after {self._timeout_s}s"
-            )
+            if self._timeout_s is None:
+                return await self._approver.approve(request)
+            try:
+                return await asyncio.wait_for(
+                    self._approver.approve(request), timeout=self._timeout_s
+                )
+            except (TimeoutError, asyncio.TimeoutError):
+                # Fail closed, keeping the variant for observability (codex's
+                # TimedOut semantics: no decision arrived, do not execute).
+                return ApprovalDecision(
+                    "timed_out", f"approval request timed out after {self._timeout_s}s"
+                )
+        finally:
+            if clock is not None:
+                clock.resume()
 
     def _persist(self, request: ApprovalRequest, decision: ApprovalDecision) -> None:
         if decision.kind in _SESSION_KINDS and self._session is not None:

{steerable_agent_runtime-0.6.41 → steerable_agent_runtime-0.6.43}/src/steerable_agent_runtime/ask_user.py

@@ -15,8 +15,9 @@ record and the model's next context. This mirrors dsh's ``ask_user_question``
 
 from __future__ import annotations
 
+import inspect
 from collections.abc import Awaitable, Callable
-from typing import Any, Protocol
+from typing import Any, Protocol, cast
 
 from .errors import ToolDispatchError
 
@@ -220,6 +221,11 @@ class AskUserHandler(Protocol):
     mapping of question id → answer (a string, or a list of strings for a
     multi-select). Implementations must not raise on a user cancel — return
     an empty mapping so the loop records "no answer" and moves on.
+
+    A handler that declares ``context`` also receives the loop dispatch
+    context (``chat_id``, ``round``) so the product can scope the prompt to
+    the chat that asked. Handlers that omit the parameter are called without
+    it.
     """
 
     def __call__(
@@ -238,10 +244,13 @@ def make_ask_user_tool(handler: AskUserHandler) -> Callable[..., Awaitable[dict[
     """
 
     async def ask_user(
-        intro: str, questions: list[dict[str, Any]], outro: str | None = None
+        intro: str,
+        questions: list[dict[str, Any]],
+        outro: str | None = None,
+        context: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         normalized = normalize_ask_user_questions(questions)
-        answers = await handler(intro, normalized)
+        answers = await _call_handler(handler, intro, normalized, context)
         return {
             "intro": intro,
             "outro": outro,
@@ -263,3 +272,32 @@ def make_ask_user_tool(handler: AskUserHandler) -> Callable[..., Awaitable[dict[
         "exposure": "direct",
     }
     return ask_user
+
+
+def _call_handler(
+    handler: AskUserHandler,
+    intro: str,
+    questions: list[dict[str, Any]],
+    context: dict[str, Any] | None,
+) -> Awaitable[dict[str, Any]]:
+    """Pass ``context`` only when the handler declares it.
+
+    Existing handlers take ``(intro, questions)``. The desktop host handler
+    also takes ``context`` so the question card can be scoped to ``chat_id``.
+    """
+    try:
+        signature = inspect.signature(handler)
+    except (TypeError, ValueError):
+        return handler(intro, questions)
+    accepts_context = any(
+        parameter.name == "context"
+        or parameter.kind is inspect.Parameter.VAR_KEYWORD
+        for parameter in signature.parameters.values()
+    )
+    if accepts_context:
+        contextual = cast(
+            Callable[..., Awaitable[dict[str, Any]]],
+            handler,
+        )
+        return contextual(intro, questions, context=context)
+    return handler(intro, questions)

{steerable_agent_runtime-0.6.41 → steerable_agent_runtime-0.6.43}/src/steerable_agent_runtime/loop.py

@@ -61,6 +61,7 @@ from typing import Any, Literal, Protocol, runtime_checkable
 from steerable_agent_harness import BudgetLimit
 from steerable_agent_protocol.generated import ToolCall, ToolResult
 
+from .approval import ToolTimeoutClock, tool_timeout_clock
 from .history import (
     KIND_ASSISTANT,
     KIND_SYSTEM,
@@ -673,14 +674,25 @@ class CoreLoop:
         blocked by a hung peer again.
         """
 
+        # ask_user blocks until the user answers. The generic tool cap would
+        # cancel that wait (default 5 minutes) and continue without an answer.
+        if call.name == "ask_user":
+            return await self._executor.execute(call, ctx)
         timeout_ms = self._effective_tool_timeout_ms()
         if timeout_ms is None:
             return await self._executor.execute(call, ctx)
+        clock = ToolTimeoutClock()
+        token = tool_timeout_clock.set(clock)
+        task = asyncio.create_task(self._executor.execute(call, ctx))
         try:
-            return await asyncio.wait_for(
-                self._executor.execute(call, ctx), timeout=timeout_ms / 1000
-            )
-        except asyncio.TimeoutError:
+            return await _await_tool_deadline(task, clock, timeout_ms / 1000)
+        except asyncio.CancelledError:
+            task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+            raise
+        except TimeoutError:
+            task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
             return ToolResult(
                 success=False,
                 error="tool_timeout",
@@ -693,6 +705,8 @@ class CoreLoop:
                     ),
                 },
             )
+        finally:
+            tool_timeout_clock.reset(token)
 
     def _effective_tool_timeout_ms(self) -> int | None:
         """Resolve the wall-clock cap for the tool about to run.
@@ -848,6 +862,34 @@ _TOOL_TIMEOUT_MESSAGE = (
 )
 
 
+async def _await_tool_deadline(
+    task: asyncio.Task[ToolResult], clock: ToolTimeoutClock, timeout_s: float
+) -> ToolResult:
+    """Wait for a tool, freezing the deadline while approval is unanswered."""
+    loop = asyncio.get_running_loop()
+    deadline = loop.time() + timeout_s
+    while True:
+        if clock.suspended:
+            resume = asyncio.create_task(clock.resumed.wait())
+            done, _pending = await asyncio.wait(
+                {task, resume}, return_when=asyncio.FIRST_COMPLETED
+            )
+            resume.cancel()
+            if task in done:
+                return task.result()
+            continue
+        remaining = deadline - loop.time()
+        if remaining <= 0:
+            raise TimeoutError
+        pause = asyncio.create_task(clock.paused.wait())
+        done, _pending = await asyncio.wait(
+            {task, pause}, timeout=remaining, return_when=asyncio.FIRST_COMPLETED
+        )
+        pause.cancel()
+        if task in done:
+            return task.result()
+
+
 def _honors_forced_tool_choice(provider: LLMProvider, tool_choice: str) -> bool:
     """Whether ``tool_choice`` survives to the wire on this provider.
 

{steerable_agent_runtime-0.6.41 → steerable_agent_runtime-0.6.43}/src/steerable_agent_runtime/native_bridge.py

@@ -82,7 +82,10 @@ def _config_json(loop: CoreLoop) -> str:
         "persist_tool_results": config.persist_tool_results,
         "parallel_tools": config.parallel_tools,
         "tool_dedup": config.tool_dedup,
-        "tool_timeout_ms": config.tool_timeout_ms,
+        # Python `_execute_tool` owns this cap and exempts `ask_user` (it
+        # blocks until the user answers). The native loop would apply the
+        # same number to every call, including that wait.
+        "tool_timeout_ms": None,
         "soft_timeout_ms": config.soft_timeout_ms,
         "wrap_up_keeps_tools": config.wrap_up_keeps_tools,
         "wrap_up_max_tool_rounds": config.wrap_up_max_tool_rounds,
@@ -685,7 +688,14 @@ async def run_native(
             for task in tuple(active_stream_tasks):
                 task.cancel()
 
-        aio_loop.call_soon_threadsafe(cancel_now)
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+        if current_loop is aio_loop:
+            cancel_now()
+        else:
+            aio_loop.call_soon_threadsafe(cancel_now)
 
     def cancel() -> None:
         cancel_flag.set()
@@ -1006,6 +1016,11 @@ async def run_native(
             yield event
         finally:
             consumed.set()
+    remaining_tasks = tuple(active_tool_tasks | active_stream_tasks)
+    for task in remaining_tasks:
+        task.cancel()
+    if remaining_tasks:
+        await asyncio.gather(*remaining_tasks, return_exceptions=True)
     if worker_error:
         raise worker_error[0]
     raw_history = worker_result[0].get("history", []) if worker_result else []

{steerable_agent_runtime-0.6.41 → steerable_agent_runtime-0.6.43}/src/steerable_agent_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.41
+Version: 0.6.43
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 License: Apache-2.0
 Requires-Python: >=3.10
@@ -8,7 +8,7 @@ Description-Content-Type: text/markdown
 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
-Requires-Dist: steerable-agent-runtime-native==0.6.39
+Requires-Dist: steerable-agent-runtime-native==0.6.40
 Provides-Extra: sqlalchemy
 Requires-Dist: sqlalchemy>=2.0; extra == "sqlalchemy"
 Provides-Extra: fastapi

{steerable_agent_runtime-0.6.41 → steerable_agent_runtime-0.6.43}/src/steerable_agent_runtime.egg-info/requires.txt

@@ -1,7 +1,7 @@
 pydantic>=2.10.0
 steerable-agent-protocol<1.0.0,>=0.1.0
 steerable-agent-harness<1.0.0,>=0.1.0
-steerable-agent-runtime-native==0.6.39
+steerable-agent-runtime-native==0.6.40
 
 [all]
 sqlalchemy>=2.0

{steerable_agent_runtime-0.6.41 → steerable_agent_runtime-0.6.43}/tests/test_tool_timeout.py

@@ -21,7 +21,9 @@ from steerable_agent_runtime import (
     LoopEvent,
     RouterToolExecutor,
     ToolRouter,
+    make_ask_user_tool,
 )
+from steerable_agent_runtime.approval import ApprovalDecision, ApprovalExecutor
 from steerable_agent_runtime.llm import LLMMessage, LLMStreamChunk
 
 
@@ -227,6 +229,93 @@ async def test_slow_tool_under_the_limit_is_untouched() -> None:
     assert results_of(events)[0].data["success"] is True
 
 
+@pytest.mark.asyncio
+async def test_ask_user_waits_for_the_answer_past_the_tool_timeout() -> None:
+    provider = make_provider(
+        [
+            {
+                "content": "",
+                "tool_calls": [
+                    tc(
+                        "ask_user",
+                        {
+                            "intro": "Pick one",
+                            "questions": [
+                                {
+                                    "id": "color",
+                                    "text": "Which color?",
+                                    "type": "select",
+                                    "options": ["red", "blue"],
+                                    "multiSelect": False,
+                                }
+                            ],
+                        },
+                    )
+                ],
+            },
+            {"content": "done"},
+        ]
+    )
+    router = ToolRouter()
+
+    async def handler(intro: str, questions: list[dict[str, Any]]) -> dict[str, str]:
+        await asyncio.sleep(0.05)
+        return {"color": "blue"}
+
+    fn = make_ask_user_tool(handler)
+    meta = fn.__steerable_tool_meta__
+    router.register(
+        fn,
+        name=meta["name"],
+        mode=meta["mode"],
+        description=meta["description"],
+        schema=meta["schema"],
+        require_consent=meta["require_consent"],
+        concurrency_safe=meta["concurrency_safe"],
+        exposure=meta["exposure"],
+    )
+    loop = CoreLoop(
+        provider,
+        RouterToolExecutor(router),
+        LoopConfig(tool_timeout_ms=20),
+    )
+    events = await collect(loop.run([LLMMessage.text_of("user", "go")]))
+    result = results_of(events)[0].data
+    assert result["success"] is True, result
+    assert "blue" in str(result)
+
+
+@pytest.mark.asyncio
+async def test_approval_wait_is_not_part_of_the_tool_timeout() -> None:
+    provider = make_provider(
+        [
+            {"content": "", "tool_calls": [tc("shell", {"cmd": "ls"})]},
+            {"content": "done"},
+        ]
+    )
+    router = ToolRouter()
+
+    async def shell(cmd: str) -> str:
+        return f"ran {cmd}"
+
+    router.register(shell)
+
+    class _SlowApprover:
+        async def approve(self, request: Any) -> ApprovalDecision:
+            await asyncio.sleep(0.05)
+            return ApprovalDecision("allow_once")
+
+    loop = CoreLoop(
+        provider,
+        ApprovalExecutor(RouterToolExecutor(router), _SlowApprover()),
+        LoopConfig(tool_timeout_ms=20),
+    )
+    events = await collect(loop.run([LLMMessage.text_of("user", "go")]))
+    result = results_of(events)[0].data
+    assert result["success"] is True, result
+    assert "ran ls" in str(result)
+
+
 def test_default_is_a_generous_backstop() -> None:
     assert LoopConfig().tool_timeout_ms == 300_000