steerable-agent-runtime 0.6.34__tar.gz → 0.6.35__tar.gz

{steerable_agent_runtime-0.6.34 → steerable_agent_runtime-0.6.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.34
+Version: 0.6.35
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{steerable_agent_runtime-0.6.34 → steerable_agent_runtime-0.6.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.34"
+version = "0.6.35"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 readme = "README.md"
 requires-python = ">=3.10"

{steerable_agent_runtime-0.6.34 → steerable_agent_runtime-0.6.35}/src/steerable_agent_runtime/__init__.py

@@ -250,9 +250,11 @@ from .spill import FilesystemSpillStore, InMemorySpillStore, SpillHooks, SpillSt
 from .storage import StorageAdapter
 from .subagent import (
     FilteredToolsExecutor,
+    PARENT_INPUT_TOOL_NAME,
     SubagentConfig,
     SubagentExecutor,
     SubagentRegistry,
+    parent_input_tool_descriptor,
     subagent_tool_descriptor,
 )
 from .tokens import (
@@ -285,6 +287,7 @@ __all__ = [
     "MODEL_INFOS",
     "MODEL_PRICES",
     "MODEL_TOKEN_FACTORS",
+    "PARENT_INPUT_TOOL_NAME",
     "REASONING_EFFORT_ORDER",
     "RECORD_FORMAT_VERSION",
     "ReasoningEffortUnsupported",
@@ -465,6 +468,7 @@ __all__ = [
     "load_transcript",
     "make_ask_user_tool",
     "make_todo_write_tool",
+    "parent_input_tool_descriptor",
     "matches_conditions",
     "mcp_invoker",
     "merge_patch",

{steerable_agent_runtime-0.6.34 → steerable_agent_runtime-0.6.35}/src/steerable_agent_runtime/ask_user.py

@@ -125,7 +125,9 @@ def _derive_header(text: str) -> str:
     return truncated
 
 
-def _normalize_questions(questions: list[dict[str, Any]]) -> list[dict[str, Any]]:
+def normalize_ask_user_questions(
+    questions: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
     """Map known alias keys onto the canonical payload fields, enforce the
     Claude Code ``AskUserQuestion`` bounds (1-4 questions, 2-4 options per
     select, ``header`` <=12 chars, ``multiSelect`` explicit), and require the
@@ -238,7 +240,7 @@ 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
     ) -> dict[str, Any]:
-        normalized = _normalize_questions(questions)
+        normalized = normalize_ask_user_questions(questions)
         answers = await handler(intro, normalized)
         return {
             "intro": intro,

{steerable_agent_runtime-0.6.34 → steerable_agent_runtime-0.6.35}/src/steerable_agent_runtime/pool.py

@@ -22,6 +22,9 @@ Design:
 - **Children stay out of the parent record.** A child's transcript is its
   own loop's; hosts that want child traces subscribe via ``event_sink``
   (lifecycle events with lineage) or wrap children in their own hooks.
+- **Session state is isolated.** A child runs with its durable record id as
+  ``chat_id`` when available, otherwise a pool-local id, so session-scoped
+  tools such as ``todo_write`` cannot overwrite a sibling or parent list.
 """
 
 from __future__ import annotations
@@ -30,6 +33,7 @@ import asyncio
 import logging
 from collections.abc import Callable
 from dataclasses import dataclass
+from itertools import count
 from typing import Any
 
 from .llm import LLMMessage
@@ -40,6 +44,7 @@ logger = logging.getLogger(__name__)
 #: Grace between a cooperative close (``loop.cancel()``) and the hard-cancel
 #: backstop for a child that fails to wind down.
 _CLOSE_GRACE_S = 2.0
+_POOL_CONTEXT_SEQUENCE = count(1)
 
 
 class OrchestrationBudgetExceeded(Exception):
@@ -144,6 +149,7 @@ class AgentPool:
         self._config = config
         self._depth = depth
         self._lineage = lineage
+        self._context_namespace = next(_POOL_CONTEXT_SEQUENCE)
         self._loop_factory = loop_factory
         self._event_sink = event_sink
         self._children: dict[str, _ChildHandle] = {}
@@ -241,7 +247,14 @@ class AgentPool:
         answer_parts: list[str] = []
         status = "completed"
         try:
-            async for event in handle.loop.run(seed, tools=handle.schemas):
+            async for event in handle.loop.run(
+                seed,
+                tools=handle.schemas,
+                chat_id=(
+                    handle.loop.record_id
+                    or f"subagent:{self._context_namespace}:{handle.child_id}"
+                ),
+            ):
                 if event.kind == "content_delta":
                     answer_parts.append(str(event.data.get("delta") or ""))
                 elif event.kind == "completion":

{steerable_agent_runtime-0.6.34 → steerable_agent_runtime-0.6.35}/src/steerable_agent_runtime/subagent.py

@@ -27,6 +27,10 @@ Design:
   ``recordId``), which is how a host renders the delegation's process
   afterwards. Without them the child runs storage-free, as before.
 - The child's answer is its accumulated assistant text at completion.
+- User interaction stays with the parent. Every child receives the
+  ``request_parent_input`` coordination tool instead of ``ask_user``; a
+  request ends the child run and returns structured ``needs_input`` data so
+  the parent can ask and re-delegate with the answers.
 - Opt-out: hosts advertise ``subagent_tool_descriptor`` in the tools list
   and wrap their executor; the sidecar does both by default and
   ``params.subagent: false`` turns delegation off.
@@ -47,21 +51,54 @@ Design:
 
 from __future__ import annotations
 
+import json
 from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any
 
 from steerable_agent_protocol.generated import ToolCall, ToolResult
 
+from .ask_user import (
+    ASK_USER_SCHEMA,
+    ASK_USER_TOOL_NAME,
+    normalize_ask_user_questions,
+)
+from .errors import ToolDispatchError
 from .llm import LLMProvider
 from .loop import CoreLoop, LoopConfig, LoopContext, LoopHooks, ToolExecutor
-from .pool import AgentPool, LoopFactory, OrchestrationBudgetExceeded, OrchestrationConfig
+from .pool import (
+    AgentPool,
+    LoopFactory,
+    OrchestrationBudgetExceeded,
+    OrchestrationConfig,
+)
 
 #: ``profile`` label on lifecycle events for a delegation that named no
 #: ``subagent_type`` — mirrors the tool schema's "default general-purpose
 #: profile" wording.
 DEFAULT_PROFILE_LABEL = "general-purpose"
 
+#: Child-only coordination tool. A child reports missing user-owned input to
+#: its parent instead of opening an interactive question card itself.
+PARENT_INPUT_TOOL_NAME = "request_parent_input"
+
+
+def parent_input_tool_descriptor() -> dict[str, Any]:
+    """OpenAI schema for a child to return structured questions to its parent."""
+    return {
+        "type": "function",
+        "function": {
+            "name": PARENT_INPUT_TOOL_NAME,
+            "description": (
+                "Report information that only the user can provide to the "
+                "parent agent. Do not call ask_user from a sub-agent. After "
+                "calling this tool, stop and let the parent ask the user, then "
+                "re-delegate a self-contained task with the answers."
+            ),
+            "parameters": ASK_USER_SCHEMA,
+        },
+    }
+
 
 @dataclass(frozen=True, slots=True)
 class SubagentConfig:
@@ -106,7 +143,9 @@ class SubagentConfig:
     description: str = (
         "Delegate a self-contained subtask to a sub-agent with its own "
         "reasoning loop. Good for parallelizable or context-heavy subtasks; "
-        "the sub-agent returns only its final answer."
+        "the sub-agent returns only its final answer. If it returns status "
+        "needs_input, ask the user the returned questions and then delegate "
+        "again with the answers included in the task."
     )
 
 
@@ -174,9 +213,7 @@ def subagent_tool_descriptor(
             f"- {name}: {(registry.get(name) or config).description}"
             for name in registry.names()
         )
-        description = (
-            f"{description}\n\nAvailable subagent_type profiles:\n{roster}"
-        )
+        description = f"{description}\n\nAvailable subagent_type profiles:\n{roster}"
     return {
         "type": "function",
         "function": {
@@ -234,6 +271,72 @@ class FilteredToolsExecutor:
         return bool(inner_safe and inner_safe(call))
 
 
+class _ParentInputExecutor:
+    """Keep user interaction at the parent while recording child questions."""
+
+    def __init__(
+        self,
+        inner: ToolExecutor,
+        on_request: Callable[[dict[str, Any]], None],
+    ) -> None:
+        self._inner = inner
+        self._on_request = on_request
+
+    async def execute(self, call: ToolCall, ctx: LoopContext) -> ToolResult:
+        if call.name == ASK_USER_TOOL_NAME:
+            return ToolResult(
+                success=False,
+                error=(
+                    "sub-agents cannot call ask_user directly; call "
+                    f"{PARENT_INPUT_TOOL_NAME} so the parent agent can ask"
+                ),
+                needsFollowup=True,
+            )
+        if call.name != PARENT_INPUT_TOOL_NAME:
+            return await self._inner.execute(call, ctx)
+        intro = str(call.arguments.get("intro") or "").strip()
+        if not intro:
+            return ToolResult(
+                success=False,
+                error=f"{PARENT_INPUT_TOOL_NAME}: intro must be non-empty",
+                needsFollowup=True,
+            )
+        try:
+            questions = normalize_ask_user_questions(call.arguments.get("questions"))
+        except ToolDispatchError as exc:
+            return ToolResult(
+                success=False,
+                error=str(exc),
+                needsFollowup=True,
+            )
+        payload = {
+            "status": "needs_input",
+            "intro": intro,
+            "questions": questions,
+            **(
+                {"outro": str(call.arguments["outro"])}
+                if call.arguments.get("outro") is not None
+                else {}
+            ),
+        }
+        self._on_request(payload)
+        return ToolResult(
+            success=True,
+            terminal=True,
+            message=(
+                "The parent-input request was recorded. Stop this subtask "
+                "and return control to the parent agent."
+            ),
+            data={**payload, "terminal_status": "completed"},
+        )
+
+    def concurrency_safe(self, call: ToolCall) -> bool:
+        if call.name in {ASK_USER_TOOL_NAME, PARENT_INPUT_TOOL_NAME}:
+            return False
+        inner_safe = getattr(self._inner, "concurrency_safe", None)
+        return bool(inner_safe and inner_safe(call))
+
+
 def _schema_name(schema: dict[str, Any]) -> str:
     function = schema.get("function")
     if isinstance(function, dict) and function.get("name"):
@@ -288,6 +391,7 @@ class SubagentExecutor:
         self._parent_tools = list(tools or [])
         self._history_store = history_store
         self._record_id_prefix = record_id_prefix
+        self._parent_input_requests: dict[str, dict[str, Any]] = {}
         self._pool = pool or AgentPool(
             config=OrchestrationConfig(max_parallel=self._config.max_parallel),
             depth=0,
@@ -353,6 +457,18 @@ class SubagentExecutor:
                 error=f"orchestration_budget_exceeded: {exc}",
                 needsFollowup=True,
             )
+        parent_input = self._parent_input_requests.pop(outcome.child_id, None)
+        if parent_input is not None:
+            return ToolResult(
+                success=True,
+                message=json.dumps(parent_input, ensure_ascii=False),
+                data=parent_input,
+                needsFollowup=True,
+                nextAction=(
+                    "Parent agent: call ask_user with these questions, then "
+                    "delegate again with the answers in the task."
+                ),
+            )
         if outcome.status != "completed":
             return ToolResult(
                 success=False,
@@ -377,14 +493,17 @@ class SubagentExecutor:
                 # execute() fails closed before the spawn when a
                 # model-bearing profile has no provider factory.
                 provider = self._provider_factory(config.model)
-            schemas: list[dict[str, Any]] | None = None
+            schemas: list[dict[str, Any]] = []
             if config.allow_tools:
                 schemas = [
                     schema
                     for schema in self._parent_tools
                     if _schema_name(schema) != self._config.tool_name
+                    and _schema_name(schema) != ASK_USER_TOOL_NAME
+                    and _schema_name(schema) != PARENT_INPUT_TOOL_NAME
                     and (tool_filter is None or _schema_name(schema) in tool_filter)
-                ] or None
+                ]
+            schemas.append(parent_input_tool_descriptor())
             # A child writes its own durable record when the host gave us a
             # store and a prefix, so the delegation's process can be read
             # back afterwards (`<parent record>:child:<lineage id>`). The
@@ -398,7 +517,12 @@ class SubagentExecutor:
             return (
                 CoreLoop(
                     provider,
-                    self._child_executor(config),
+                    _ParentInputExecutor(
+                        self._child_executor(config),
+                        lambda payload: self._parent_input_requests.__setitem__(
+                            child_id, payload
+                        ),
+                    ),
                     LoopConfig(
                         max_rounds=config.max_rounds,
                         max_tool_errors=config.max_tool_errors,
@@ -424,6 +548,7 @@ class SubagentExecutor:
         hosts call this on stream teardown (a no-op twice, so a shared
         pool may also be shut down via the orchestration executor)."""
         await self._pool.shutdown()
+        self._parent_input_requests.clear()
 
     def concurrency_safe(self, call: ToolCall) -> bool:
         # Delegation spawns a full child loop — batched with siblings only

{steerable_agent_runtime-0.6.34 → steerable_agent_runtime-0.6.35}/src/steerable_agent_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.34
+Version: 0.6.35
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{steerable_agent_runtime-0.6.34 → steerable_agent_runtime-0.6.35}/tests/test_subagent.py

@@ -6,6 +6,7 @@ import asyncio
 
 import pytest
 from steerable_agent_runtime import (
+    PARENT_INPUT_TOOL_NAME,
     CoreLoop,
     LoopConfig,
     RouterToolExecutor,
@@ -13,15 +14,17 @@ from steerable_agent_runtime import (
     SubagentExecutor,
     SubagentRegistry,
     ToolRouter,
+    parent_input_tool_descriptor,
     subagent_tool_descriptor,
 )
 from steerable_agent_runtime.llm import LLMMessage, LLMStreamChunk
-
 from test_loop import collect
 from test_trace_recorder import make_provider, tc
 
 
-async def _run_parent(script, router: ToolRouter, *, config: SubagentConfig | None = None):
+async def _run_parent(
+    script, router: ToolRouter, *, config: SubagentConfig | None = None
+):
     provider = make_provider(script)
     executor = SubagentExecutor(RouterToolExecutor(router), provider, config)
     loop = CoreLoop(provider, executor, LoopConfig())
@@ -80,6 +83,100 @@ async def test_child_writes_its_own_durable_record_and_publishes_the_id() -> Non
     assert "chat-1" not in history.records
 
 
+@pytest.mark.asyncio
+async def test_children_use_their_record_ids_as_isolated_chat_contexts() -> None:
+    """Session-scoped child tools such as todo_write must not share the empty
+    chat id or overwrite the parent's state."""
+    contexts: list[str] = []
+    router = ToolRouter()
+
+    async def capture_context(
+        label: str, context: dict | None = None
+    ) -> dict[str, str]:
+        chat_id = str((context or {}).get("chat_id") or "")
+        contexts.append(chat_id)
+        return {"label": label, "chatId": chat_id}
+
+    router.register(capture_context)
+    provider = make_provider(
+        [
+            {"tool_calls": [tc("delegate_subagent", {"task": "first"})]},
+            {"tool_calls": [tc("capture_context", {"label": "first"})]},
+            {"content": "first done"},
+            {"tool_calls": [tc("delegate_subagent", {"task": "second"})]},
+            {"tool_calls": [tc("capture_context", {"label": "second"})]},
+            {"content": "second done"},
+            {"content": "parent done"},
+        ]
+    )
+    history = _MemoryHistory()
+    capture_schema = {
+        "type": "function",
+        "function": {
+            "name": "capture_context",
+            "parameters": {
+                "type": "object",
+                "properties": {"label": {"type": "string"}},
+                "required": ["label"],
+            },
+        },
+    }
+    executor = SubagentExecutor(
+        RouterToolExecutor(router),
+        provider,
+        tools=[capture_schema],
+        history_store=history,
+        record_id_prefix="chat-1",
+    )
+    loop = CoreLoop(provider, executor, LoopConfig())
+    [e async for e in loop.run([LLMMessage.text_of("user", "go")])]
+    await executor.shutdown()
+
+    assert contexts == ["chat-1:child:0.1", "chat-1:child:0.2"]
+
+
+@pytest.mark.asyncio
+async def test_children_without_records_use_distinct_pool_local_chat_contexts() -> None:
+    contexts: list[str] = []
+    router = ToolRouter()
+
+    async def capture_context(context: dict | None = None) -> str:
+        chat_id = str((context or {}).get("chat_id") or "")
+        contexts.append(chat_id)
+        return chat_id
+
+    router.register(capture_context)
+    capture_schema = {
+        "type": "function",
+        "function": {"name": "capture_context", "parameters": {"type": "object"}},
+    }
+
+    async def run_one() -> None:
+        provider = make_provider(
+            [
+                {"tool_calls": [tc("delegate_subagent", {"task": "capture"})]},
+                {"tool_calls": [tc("capture_context")]},
+                {"content": "child done"},
+                {"content": "parent done"},
+            ]
+        )
+        executor = SubagentExecutor(
+            RouterToolExecutor(router),
+            provider,
+            tools=[capture_schema],
+        )
+        loop = CoreLoop(provider, executor, LoopConfig())
+        [e async for e in loop.run([LLMMessage.text_of("user", "go")])]
+        await executor.shutdown()
+
+    await run_one()
+    await run_one()
+
+    assert len(contexts) == 2
+    assert contexts[0] != contexts[1]
+    assert all(context.startswith("subagent:") for context in contexts)
+
+
 @pytest.mark.asyncio
 async def test_child_stays_storage_free_without_a_prefix() -> None:
     provider = make_provider(
@@ -313,7 +410,9 @@ def test_descriptor_is_openai_tool_schema() -> None:
 
 def test_descriptor_with_registry_advertises_subagent_type_enum() -> None:
     registry = SubagentRegistry()
-    registry.register("researcher", SubagentConfig(tool_filter=frozenset({"read_file"})))
+    registry.register(
+        "researcher", SubagentConfig(tool_filter=frozenset({"read_file"}))
+    )
     registry.register("writer", SubagentConfig())
     d = subagent_tool_descriptor(registry=registry)
     prop = d["function"]["parameters"]["properties"]["subagent_type"]
@@ -351,9 +450,7 @@ async def test_registered_profile_governs_the_child() -> None:
             {"content": "parent done"},
         ]
     )
-    executor = SubagentExecutor(
-        RouterToolExecutor(router), provider, registry=registry
-    )
+    executor = SubagentExecutor(RouterToolExecutor(router), provider, registry=registry)
     loop = CoreLoop(provider, executor, LoopConfig())
     events = [e async for e in loop.run([LLMMessage.text_of("user", "go")])]
 
@@ -720,9 +817,7 @@ async def test_attach_pool_shares_the_orchestration_pool() -> None:
         ]
     )
     subagent = SubagentExecutor(RouterToolExecutor(ToolRouter()), provider)
-    orchestration = OrchestrationExecutor(
-        subagent, provider, OrchestrationConfig()
-    )
+    orchestration = OrchestrationExecutor(subagent, provider, OrchestrationConfig())
     subagent.attach_pool(orchestration.pool)
     loop = CoreLoop(provider, orchestration, LoopConfig())
     events = [
@@ -745,9 +840,8 @@ async def test_attach_pool_shares_the_orchestration_pool() -> None:
 
 @pytest.mark.asyncio
 async def test_child_advertises_the_delegated_tool_surface() -> None:
-    """Children see the parent's advertised schemas minus the delegation
-    tool itself, intersected with the profile's tool filter — a child
-    never re-delegates (depth-1 by construction, advertised honestly)."""
+    """Children see the filtered parent tools plus parent-input coordination,
+    but never delegation itself (depth-1 by construction)."""
     seen_tools: list[list[str] | None] = []
     script = iter(
         [
@@ -765,9 +859,7 @@ async def test_child_advertises_the_delegated_tool_surface() -> None:
             raise NotImplementedError
 
         def stream(self, messages, *, tools=None, **kw):
-            seen_tools.append(
-                [t["function"]["name"] for t in tools] if tools else None
-            )
+            seen_tools.append([t["function"]["name"] for t in tools] if tools else None)
             entry = next(script)
 
             async def _gen():
@@ -800,7 +892,131 @@ async def test_child_advertises_the_delegated_tool_surface() -> None:
     # Round 1 is the parent's request (full surface); round 2 is the
     # child's — filtered to the delegated domain.
     assert seen_tools[0] == ["read_file", "write_file", "delegate_subagent"]
-    assert seen_tools[1] == ["read_file"]
+    assert seen_tools[1] == ["read_file", PARENT_INPUT_TOOL_NAME]
+
+
+@pytest.mark.asyncio
+async def test_child_uses_parent_input_protocol_instead_of_ask_user() -> None:
+    """A child never receives the interactive ``ask_user`` tool. It always
+    receives the child-only parent-input tool, even when the profile narrows
+    the delegated host-tool domain."""
+    seen_tools: list[list[str] | None] = []
+    script = iter(
+        [
+            {"tool_calls": [tc("delegate_subagent", {"task": "prepare"})]},
+            {"content": "child done"},
+            {"content": "parent done"},
+        ]
+    )
+
+    class _CapturingProvider:
+        name = "fake"
+        model = "fake-model"
+
+        async def complete(self, messages, *, tools=None, **kw):
+            raise NotImplementedError
+
+        def stream(self, messages, *, tools=None, **kw):
+            seen_tools.append([t["function"]["name"] for t in tools] if tools else None)
+            entry = next(script)
+
+            async def _gen():
+                if entry.get("content"):
+                    yield LLMStreamChunk(content_delta=entry["content"])
+                for call in entry.get("tool_calls", []):
+                    yield LLMStreamChunk(tool_call_delta=call)
+                yield LLMStreamChunk(
+                    finish_reason="tool_calls" if entry.get("tool_calls") else "stop"
+                )
+
+            return _gen()
+
+    parent_tools = [
+        {"type": "function", "function": {"name": "read_file", "parameters": {}}},
+        {"type": "function", "function": {"name": "ask_user", "parameters": {}}},
+        subagent_tool_descriptor(),
+    ]
+    provider = _CapturingProvider()
+    executor = SubagentExecutor(
+        RouterToolExecutor(ToolRouter()),
+        provider,
+        SubagentConfig(allow_tools=False),
+        tools=parent_tools,
+    )
+    loop = CoreLoop(provider, executor, LoopConfig())
+    [e async for e in loop.run([LLMMessage.text_of("user", "go")], tools=parent_tools)]
+    await executor.shutdown()
+
+    assert seen_tools[0] == ["read_file", "ask_user", "delegate_subagent"]
+    assert seen_tools[1] == [PARENT_INPUT_TOOL_NAME]
+
+
+@pytest.mark.asyncio
+async def test_parent_input_request_becomes_structured_delegation_result() -> None:
+    direct_ask_calls = 0
+
+    async def ask_user(**kwargs) -> dict:
+        nonlocal direct_ask_calls
+        direct_ask_calls += 1
+        return kwargs
+
+    router = ToolRouter()
+    router.register(ask_user)
+    questions = [
+        {
+            "id": "template",
+            "text": "选择哪种模板？",
+            "header": "模板",
+            "type": "select",
+            "options": ["标准", "精简"],
+            "multiSelect": False,
+        }
+    ]
+    provider = make_provider(
+        [
+            {"tool_calls": [tc("delegate_subagent", {"task": "prepare"})]},
+            {
+                "tool_calls": [
+                    tc(
+                        "ask_user",
+                        {"intro": "wrong path", "questions": questions},
+                    )
+                ]
+            },
+            {
+                "tool_calls": [
+                    tc(
+                        PARENT_INPUT_TOOL_NAME,
+                        {"intro": "missing questions"},
+                    )
+                ]
+            },
+            {
+                "tool_calls": [
+                    tc(
+                        PARENT_INPUT_TOOL_NAME,
+                        {"intro": "需要补充信息", "questions": questions},
+                    )
+                ]
+            },
+            {"content": "parent will ask"},
+        ]
+    )
+    executor = SubagentExecutor(
+        RouterToolExecutor(router),
+        provider,
+        tools=[parent_input_tool_descriptor()],
+    )
+    loop = CoreLoop(provider, executor, LoopConfig())
+    events = [e async for e in loop.run([LLMMessage.text_of("user", "go")])]
+    await executor.shutdown()
+
+    result = _tool_results(events)[0]
+    assert result["success"] is True
+    assert '"status": "needs_input"' in result["resultPreview"]
+    assert "选择哪种模板？" in result["resultPreview"]
+    assert provider._idx == 5
+    assert direct_ask_calls == 0
 
 
 @pytest.mark.asyncio