test(cost): resolve OpenRouter handler via LiteLLM provider pipeline

docs/advanced/configuration.mdx

@@ -19,14 +19,6 @@ Configure Strix using environment variables or a config file.
   Custom API base URL. Also accepts `OPENAI_API_BASE`, `LITELLM_BASE_URL`, or `OLLAMA_API_BASE`.
 </ParamField>
 
-<ParamField path="LLM_EXTRA_HEADERS" type="string">
-  Extra HTTP headers sent on every LLM request, as a JSON object (e.g.
-  `{"X-Feature-Key":"value","X-Tenant":"acme"}`). Useful for OpenAI-compatible
-  gateways that require attribution or routing headers in addition to the bearer
-  token. The bearer token itself still comes from `LLM_API_KEY`. Applies to both
-  the LiteLLM and native OpenAI routing paths.
-</ParamField>
-
 <ParamField path="LLM_TIMEOUT" default="300" type="integer">
   Request timeout in seconds for LLM calls.
 </ParamField>
@@ -36,7 +28,7 @@ Configure Strix using environment variables or a config file.
 </ParamField>
 
 <ParamField path="STRIX_REASONING_EFFORT" default="high" type="string">
-  Control thinking effort for reasoning models. Valid values: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Defaults to `medium` for quick scan mode.
+  Control thinking effort for reasoning models. Valid values: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`. Defaults to `medium` for quick scan mode.
 </ParamField>
 
 <ParamField path="STRIX_MEMORY_COMPRESSOR_TIMEOUT" default="30" type="integer">
@@ -63,12 +55,6 @@ affecting the agents that do the actual testing.
   model runs on a different endpoint than the main model.
 </ParamField>
 
-<ParamField path="DEDUPE_LLM_EXTRA_HEADERS" type="string">
-  Optional JSON object of extra HTTP headers sent on every deduplication-model
-  request, e.g. `{"X-Feature-Key":"value"}`. A dedicated dedupe model never
-  inherits `LLM_EXTRA_HEADERS`; set this when its endpoint needs custom headers.
-</ParamField>
-
 <ParamField path="STRIX_DEDUPE_REASONING_EFFORT" type="string">
   Reasoning effort for the deduplication model. Defaults to the model's own
   baseline when unset.

docs/llm-providers/local.mdx

@@ -54,55 +54,3 @@ If you use LM Studio, vLLM, or other runners:
 export STRIX_LLM="openai/local-model"
 export LLM_API_BASE="http://localhost:1234/v1"  # Adjust port as needed
 ```
-
-### Gateways that require custom headers
-
-Some OpenAI-compatible gateways require extra HTTP headers (for attribution or
-tenant routing) alongside the bearer token. Set them with `LLM_EXTRA_HEADERS` as
-a JSON object — they are sent on every request:
-
-```bash
-export STRIX_LLM="openai/your-model"
-export LLM_API_BASE="https://your-gateway.example/v1"
-export LLM_API_KEY="your-bearer-token"          # sent as Authorization: Bearer ...
-export LLM_EXTRA_HEADERS='{"X-Feature-Key":"value","X-Tenant":"acme"}'
-```
-
-For endpoints behind a private CA, point Strix at your certificate bundle with
-the standard `SSL_CERT_FILE=/path/to/ca-bundle.pem` — never disable TLS
-verification against a real endpoint.
-
-## Tool calling must return structured `tool_calls`
-
-Strix is entirely tool-driven: every working turn must be a **native** function/tool call. If your inference server returns the tool call as plain assistant text instead of a structured `tool_calls` field, Strix never sees a call it can execute, so the agent makes no real progress — it re-prompts the model for a tool call and gives up once its recovery attempts are exhausted.
-
-This is almost always an **inference-server configuration** problem, not a model or Strix problem. Common symptoms are the model printing a call as text such as:
-
-```text
-<tool_call>{"name": "exec_command", "arguments": {"cmd": "nmap ..."}}</tool_call>
-exec_command(cmd="nmap ...", timeout=180)
-{"action": "exec_command", "params": {"cmd": "nmap ..."}}
-```
-
-The fix belongs on the inference server: it must be configured to parse the model's tool tokens into structured `tool_calls`. A correctly configured endpoint either returns a structured call or rejects the request outright — it never leaks the call as text.
-
-### Fixes by server
-
-**llama.cpp (`llama-server`)**
-- Run with `--jinja` and a correct tool-use chat template (`--chat-template` / `--chat-template-file` matching the model). Recent builds enable `--jinja` by default — **upgrade** if yours doesn't.
-- For thinking models, align or disable reasoning (`--reasoning-format`, `-rea off`) so it doesn't break tool-call parsing.
-- A low temperature (e.g. `--temp 0.2`) improves tool-call reliability.
-
-**Ollama**
-- Use a recent Ollama and a model whose template wires tools. Modern Ollama refuses tools (`tools param requires --jinja flag`) if the template lacks tool support.
-- For reasoning models (e.g. qwen3), disable the model's **thinking** mode — thinking left on frequently pushes the tool call into the text `content` instead of the structured `tool_calls` field. Turn it off on the Ollama side (a non-thinking model variant, or `think: false` in the model's parameters / `Modelfile`).
-- Raise **`num_ctx`** to at least 16k–32k. Strix sends a large system prompt plus many tool schemas; at Ollama's small default context the tool definitions are truncated out of the prompt and the model stops emitting valid calls. A short test prompt can look fine while a real scan fails, so set this explicitly rather than inferring it from a quick check.
-
-**vLLM**
-- Start with `--enable-auto-tool-choice`, a matching `--tool-call-parser` (`hermes`, `qwen3_xml`, or `llama3_json`), and a matching `--reasoning-parser` for reasoning models.
-
-A low sampling temperature (roughly 0.2–0.6, depending on the family) also measurably reduces malformed tool calls on open-weight models. Set it on the server or in your model's parameters.
-
-<Warning>
-Even correctly configured, small models (< ~30B) emit malformed or text-form tool calls far more often than frontier models. Prefer a capable model for reliable agentic behavior.
-</Warning>

pyproject.toml

@@ -220,7 +220,6 @@ ignore = [
 # Stdlib HTTP handler overrides (do_GET/do_POST).
 "strix/interface/auth_cli.py" = ["N802"]
 "tests/test_codex_streaming.py" = ["N802"]
-"tests/test_disable_streaming.py" = ["N802"]
 "tests/test_report_pdf.py" = ["S105", "S106"]
 # Stdlib HTTP handler overrides (do_GET/do_POST) and lazy imports that avoid a
 # circular dependency with strix.telemetry / strix.interface.viewer.report_pdf.

strix/agents/factory.py

@@ -23,7 +23,7 @@ from strix.tools.agents_graph.tools import (
     send_message_to_agent,
     stop_agent,
     view_agent_graph,
-    wait_for_agents,
+    wait_for_message,
 )
 from strix.tools.finish.tool import finish_scan
 from strix.tools.load_skill.tool import load_skill
@@ -49,7 +49,6 @@ from strix.tools.reporting.tool import (
     get_report,
     list_reports,
 )
-from strix.tools.respond.tool import respond_to_user
 from strix.tools.thinking.tool import think
 from strix.tools.todo.tools import (
     create_todo,
@@ -143,83 +142,6 @@ def _with_bounded_result(tool: FunctionTool) -> FunctionTool:
     return tool
 
 
-def _schema_types(spec: dict[str, Any]) -> set[str]:
-    types: set[str] = set()
-    raw = spec.get("type")
-    if isinstance(raw, str):
-        types.add(raw)
-    elif isinstance(raw, list):
-        types.update(t for t in raw if isinstance(t, str))
-    for variant in spec.get("anyOf") or ():
-        if isinstance(variant, dict):
-            types |= _schema_types(variant)
-    types.discard("null")
-    return types
-
-
-def _decode_structured(value: str, types: set[str]) -> Any:
-    stripped = value.strip()
-    if not stripped:
-        return value
-    try:
-        decoded = json.loads(stripped)
-    except json.JSONDecodeError:
-        return value
-    wanted = list if "array" in types else dict
-    return decoded if isinstance(decoded, wanted) else value
-
-
-def _coerce_argument(value: Any, spec: dict[str, Any]) -> Any:
-    types = _schema_types(spec)
-    if not types or value is None:
-        return value
-    if isinstance(value, list | dict) and "string" in types and not types & {"array", "object"}:
-        return json.dumps(value, ensure_ascii=False)
-    if isinstance(value, str) and types & {"array", "object"} and "string" not in types:
-        return _decode_structured(value, types)
-    return value
-
-
-def _coerce_arguments(raw_input: str, schema: dict[str, Any]) -> str:
-    properties = schema.get("properties")
-    if not isinstance(properties, dict) or not properties:
-        return raw_input
-    try:
-        payload = json.loads(raw_input) if raw_input else None
-    except json.JSONDecodeError:
-        return raw_input
-    if not isinstance(payload, dict):
-        return raw_input
-
-    changed = False
-    for key, value in payload.items():
-        spec = properties.get(key)
-        if not isinstance(spec, dict):
-            continue
-        coerced = _coerce_argument(value, spec)
-        if coerced is not value:
-            payload[key] = coerced
-            changed = True
-
-    if not changed:
-        return raw_input
-    return json.dumps(payload, ensure_ascii=False)
-
-
-def _with_coerced_arguments(tool: FunctionTool) -> FunctionTool:
-    if getattr(tool, "_strix_coerced", False):
-        return tool
-    invoke_tool = tool.on_invoke_tool
-    schema = tool.params_json_schema
-
-    async def invoke(ctx: Any, raw_input: str) -> Any:
-        return await invoke_tool(ctx, _coerce_arguments(raw_input, schema))
-
-    tool.on_invoke_tool = invoke
-    tool._strix_coerced = True  # type: ignore[attr-defined]
-    return tool
-
-
 def _function_tool_with_error_result(tool: FunctionTool) -> FunctionTool:
     invoke_tool = tool.on_invoke_tool
 
@@ -289,13 +211,11 @@ def _configure_filesystem_tools(toolset: Any, *, chat_completions: bool) -> None
             if isinstance(tool, CustomTool):
                 setattr(toolset, name, _custom_tool_as_function_tool(tool))
             elif isinstance(tool, FunctionTool):
-                setattr(
-                    toolset, name, _function_tool_with_error_result(_with_coerced_arguments(tool))
-                )
+                setattr(toolset, name, _function_tool_with_error_result(tool))
         elif isinstance(tool, CustomTool):
             setattr(toolset, name, _bound_custom_tool(tool))
         elif isinstance(tool, FunctionTool):
-            setattr(toolset, name, _with_bounded_result(_with_coerced_arguments(tool)))
+            setattr(toolset, name, _with_bounded_result(tool))
 
 
 def _make_filesystem_configurator(*, chat_completions: bool) -> Any:
@@ -408,7 +328,7 @@ def _configure_shell_tools(toolset: Any, *, chat_completions: bool) -> None:
     for name, tool in vars(toolset).items():
         if not isinstance(tool, FunctionTool):
             continue
-        wrapped = _with_coerced_arguments(tool)
+        wrapped = tool
         if tool.name == "exec_command":
             wrapped = _wrap_exec_command(wrapped)
         elif tool.name == "write_stdin":
@@ -425,10 +345,6 @@ def _make_shell_configurator(*, chat_completions: bool) -> Any:
     return configure
 
 
-# Tools that hand control away by parking the agent rather than ending the scan.
-_PARKING_TOOLS: frozenset[str] = frozenset({"respond_to_user", "wait_for_agents"})
-
-
 def _lifecycle_tool_completed(tool_name: str, output: Any) -> bool:
     if tool_name == "agent_finish":
         completion_key = "agent_completed"
@@ -447,7 +363,7 @@ def _lifecycle_tool_completed(tool_name: str, output: Any) -> bool:
 
 
 def _wait_tool_parked(tool_name: str, output: Any) -> bool:
-    if tool_name not in _PARKING_TOOLS or not isinstance(output, str):
+    if tool_name != "wait_for_message" or not isinstance(output, str):
         return False
     try:
         parsed = json.loads(output)
@@ -509,7 +425,7 @@ _BASE_TOOLS: tuple[Tool, ...] = (
     scope_rules,
     view_agent_graph,
     send_message_to_agent,
-    wait_for_agents,
+    wait_for_message,
     create_agent,
     stop_agent,
 )
@@ -593,19 +509,13 @@ def build_strix_agent(
         )
 
     agent_tools = [*_EXTRA_TOOLS, *(extra_tools or [])]
-    if interactive:
-        # Yielding to the user is only meaningful when one is attached.
-        agent_tools.append(respond_to_user)
     if is_root:
         tools: list[Tool] = [*_BASE_TOOLS, *agent_tools, finish_scan]
     else:
         tools = [*_BASE_TOOLS, *agent_tools, agent_finish]
     _ensure_unique_tool_names(tools)
     tools = [
-        _with_bounded_result(_with_coerced_arguments(tool))
-        if isinstance(tool, FunctionTool)
-        else tool
-        for tool in tools
+        _with_bounded_result(tool) if isinstance(tool, FunctionTool) else tool for tool in tools
     ]
 
     logger.info(

strix/agents/prompts/system_prompt.jinja

@@ -31,26 +31,28 @@ INTER-AGENT MESSAGES:
 
 {% if interactive %}
 INTERACTIVE BEHAVIOR:
-- You are in an interactive conversation with a user.
-- HOW EXECUTION ENDS: your turn ends ONLY when you make an explicit lifecycle tool call. Plain text NEVER ends your turn and NEVER hands control to the user — text is shown to the user, and then execution continues.
-  - To answer the user and hand control back, call respond_to_user. It delivers your message AND parks you for their reply in one call, so there is no way to answer and then forget to stop. This is the ONLY way to yield to the user.
-  - To wait on another AGENT (a child's report, a peer's reply), call wait_for_agents. That is not a way to reach the user.
-  - To end the whole engagement, call the lifecycle tool: finish_scan (root) or agent_finish (subagent).
-  - A turn that ends with plain text and no tool call does NOT stop you: the system nudges you to continue and will re-run you. Do not rely on going silent to pause — it will not pause you.
-- Answering a user question: put the answer in respond_to_user's message. Do not write the answer as plain text and then fall silent — that does not reach a stopping point, it just triggers a continuation nudge.
-- You may include brief explanatory text before a tool call, and you can narrate while you work — plain text is shown to the user as you go. Narrating is free; respond_to_user is specifically the act of WAITING for the user, so do not call it just to give a status update.
-- Respond naturally when the user asks questions or gives instructions.
-- While actively working on a task, every turn should carry exactly one tool call — use think to plan, the appropriate tool to act, and respond_to_user only when you genuinely need the user.
-- Never loop through think or other tools just to prepare, polish, confirm, or announce an answer. Once you know the answer, send it with respond_to_user.
+- You are in an interactive conversation with a user
+- CRITICAL: A message WITHOUT a tool call IMMEDIATELY STOPS your entire execution and waits for user input. This is a HARD SYSTEM CONSTRAINT, not a suggestion.
+  - Statements like "Planning the assessment..." or "I'll now scan..." or "Starting with..." WITHOUT a tool call will HALT YOUR WORK COMPLETELY. The system interprets no-tool-call as "I'm done, waiting for the user."
+  - If you want to plan, call the think tool. If you want to act, call the appropriate tool. There is NO valid reason to output text without a tool call while working on a task.
+  - The ONLY time you may send a message without a tool call is when you are genuinely DONE and presenting final results, or when you NEED the user to answer a question before continuing.
+- EVERY message while working MUST contain exactly one tool call — this is what keeps execution moving. No tool call = execution stops.
+- You may include brief explanatory text BEFORE the tool call
+- Respond naturally when the user asks questions or gives instructions
+- For simple conversation, acknowledgements, or direct questions that you can answer from current context, reply in plain text and stop. Do NOT call think just to prepare wording.
+- If you use a tool to answer a user question (for example list_todos, view_agent_graph, or a file read), then after the tool result arrives, provide the answer in plain text and stop unless the user explicitly asked you to continue working.
+- Never loop through think or other tools just to prepare, polish, confirm, or announce a final answer. Once you know the answer, say it.
+- NEVER send empty messages — if you have nothing to do or say, call the wait_for_message tool
+- If you catch yourself about to describe multiple steps without a tool call, STOP and call the think tool instead
 {% else %}
 AUTONOMOUS BEHAVIOR:
 - Work autonomously by default
 - You should NOT ask for user input or confirmation - you should always proceed with your task autonomously.
 - Minimize user messaging: avoid redundancy and repetition; consolidate updates into a single concise message
-- NEVER send an empty or blank message. If you have no content to output or need to wait for subagent results, you MUST call the wait_for_agents tool (or another appropriate tool) instead of emitting an empty response.
-- There is no user attached to this run, so there is nobody to ask and nothing to yield to. If there is nothing left to execute: do NOT send filler/repetitive text — either call wait_for_agents (only if you are genuinely expecting another agent to message you) or finish your work (subagents: agent_finish; root: finish_scan)
-- While the agent loop is running, almost every output MUST be a tool call. Do NOT send plain text messages; act via tools. If waiting on another agent, use wait_for_agents; when done, use agent_finish (subagents) or finish_scan (root)
-- A text-only turn does nothing: it neither ends the run nor yields — it just wastes a turn and forces a retry. The lifecycle tools (``finish_scan`` for root, ``agent_finish`` for subagents) are the ONLY way to terminate, and the report flows through them. If you find yourself wanting to say "Done!" or "Scan complete" without a tool call, call the lifecycle tool instead.
+- NEVER send an empty or blank message. If you have no content to output or need to wait (for user input, subagent results, or any other reason), you MUST call the wait_for_message tool (or another appropriate tool) instead of emitting an empty response.
+- If there is nothing to execute and no user query to answer any more: do NOT send filler/repetitive text — either call wait_for_message or finish your work (subagents: agent_finish; root: finish_scan)
+- While the agent loop is running, almost every output MUST be a tool call. Do NOT send plain text messages; act via tools. If idle, use wait_for_message; when done, use agent_finish (subagents) or finish_scan (root)
+- A text-only turn — even one — IMMEDIATELY ends the scan/run with no report written. The lifecycle tools (``finish_scan`` for root, ``agent_finish`` for subagents) are the ONLY valid way to terminate. If you find yourself wanting to say "Done!" or "Scan complete" without a tool call, call the lifecycle tool instead — the report and termination signal both flow through it.
 {% endif %}
 </communication_rules>
 
@@ -444,19 +446,8 @@ PROXY & INTERCEPTION:
 - Caido CLI - Modern web proxy (already running). Use the proxy tools
   directly, or import `caido_api` from sandbox Python scripts.
 - HTTPQL filters (for `list_requests`): quote string values, leave integers unquoted (`resp.code.eq:200`, not `"200"`); combine terms with `AND`/`OR` (there is no `NOT` — use the negated operator `ne`/`ncont`/`nregex`). Numeric fields (`resp.code`, `req.port`) use `eq`/`ne`/`gt`/`gte`/`lt`/`lte`; text fields (`req.host`, `req.path`, `req.method`, `req.raw`) use `cont`/`ncont`/`eq`/`regex`. Example: `resp.code.gte:200 AND resp.code.lt:300 AND req.host.cont:"api"`.
-
-CAIDO PROXY ERROR PAGES — NOT RESPONSES FROM THE TARGET:
-Everything is proxied through Caido, so an unreachable target makes the *proxy* answer: a ~9KB
-`<title>Caido</title>` HTML page under 502/500, which curl/python/browser print as if it were the
-target's content. The request never reached a server. It also appears in `list_requests` with no
-response at all (`resp` null), unlike a real 502.
-- Don't dump it; extract the cause with `curl -s ... | grep -A8 'c-title"'`.
-- The `c-details` cause says what to fix: "Failed to query DNS" — host doesn't resolve, check
-  `dig +short <host>`, then correct or drop it; "Connection refused" — nothing on that port, check
-  `nc -z -v <host> <port>`; "TLS handshake"/"wrong version number" — scheme/port mismatch, flip
-  http/https; timeout — filtered or unreachable from the sandbox.
-- NEVER treat these as target behavior: not a finding, not evidence, not a WAF, not a server
-  error. Fix the url/host/port/scheme and retry, or move on — do not keep re-requesting a dead host.
+- NOTE: If you are seeing proxy errors when sending requests, it usually means you are not sending requests to a correct url/host/port.
+- Ignore Caido proxy-generated 50x HTML error pages; these are proxy issues (might happen when requesting a wrong host or SSL/TLS issues, etc).
 
 PROGRAMMING:
 - Python 3, uv, Node.js/npm

strix/config/models.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import contextlib
 import inspect
 import os
-import time
 from typing import TYPE_CHECKING, Any
 
 from agents import (
@@ -14,8 +13,6 @@ from agents import (
     set_tracing_disabled,
 )
 from agents.model_settings import ModelSettings
-from agents.models.fake_id import FAKE_RESPONSES_ID
-from agents.models.interface import Model
 from agents.models.multi_provider import MultiProvider
 from agents.models.openai_responses import OpenAIResponsesModel
 from agents.retry import (
@@ -24,8 +21,6 @@ from agents.retry import (
     RetryPolicyContext,
     retry_policies,
 )
-from openai.types.responses import Response, ResponseCompletedEvent
-from openai.types.responses.response_usage import ResponseUsage
 from openai.types.shared import Reasoning
 
 from strix.config import codex
@@ -35,17 +30,10 @@ from strix.config.loader import load_settings
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator
 
-    from agents.agent_output import AgentOutputSchemaBase
-    from agents.handoffs import Handoff
-    from agents.items import ModelResponse, TResponseInputItem, TResponseStreamEvent
-    from agents.models.interface import ModelProvider, ModelTracing
-    from agents.retry import ModelRetryAdvice, ModelRetryAdviceRequest
-    from agents.tool import Tool
-    from agents.usage import Usage
+    from agents.models.interface import Model, ModelProvider
     from openai import AsyncOpenAI
-    from openai.types.responses.response_prompt_param import ResponsePromptParam
 
-    from strix.config.settings import LlmSettings, ReasoningEffort, Settings
+    from strix.config.settings import ReasoningEffort, Settings
 
 
 def request_timeout_extra_args(timeout_s: float | None) -> dict[str, float] | None:
@@ -83,13 +71,10 @@ class _CodexResponsesModel(OpenAIResponsesModel):
         effort = self._reasoning_effort
         if effort and effort != "none":
             # Clamp to efforts the backend accepts.
-            match effort:
-                case "minimal":
-                    effort = "low"
-                case "xhigh" | "max":
-                    effort = "high"
-                case _:
-                    pass
+            if effort == "minimal":
+                effort = "low"
+            elif effort == "xhigh":
+                effort = "high"
             overrides = overrides.resolve(ModelSettings(reasoning=Reasoning(effort=effort)))
         return model_settings.resolve(overrides)
 
@@ -150,124 +135,6 @@ class _CodexResponsesModel(OpenAIResponsesModel):
                     await result
 
 
-class _NonStreamingModel(Model):
-    """Serve the SDK's streamed run loop from a single non-streaming request.
-
-    Some OpenAI-compatible gateways do not support Server-Sent Events, or
-    deliver them unreliably (dropping structured tool-call deltas, or stalling
-    mid-stream so the whole turn waits out the read timeout). The SDK run loop
-    Strix uses only issues streamed requests, so such a gateway fails every
-    turn. Opt in with ``LLM_DISABLE_STREAMING=true`` to wrap the resolved model
-    so each turn makes one non-streaming ``get_response`` (``stream:false`` on
-    the wire) and the completed result is replayed as a single terminal stream
-    event. The run loop then executes tools and emits run items from that final
-    response exactly as it would for a real stream, so nothing else changes.
-    """
-
-    def __init__(self, inner: Model) -> None:
-        self._inner = inner
-
-    async def close(self) -> None:
-        await self._inner.close()
-
-    def get_retry_advice(self, request: ModelRetryAdviceRequest) -> ModelRetryAdvice | None:
-        return self._inner.get_retry_advice(request)
-
-    async def get_response(
-        self,
-        system_instructions: str | None,
-        input: str | list[TResponseInputItem],  # noqa: A002
-        model_settings: ModelSettings,
-        tools: list[Tool],
-        output_schema: AgentOutputSchemaBase | None,
-        handoffs: list[Handoff],
-        tracing: ModelTracing,
-        *,
-        previous_response_id: str | None,
-        conversation_id: str | None,
-        prompt: ResponsePromptParam | None,
-    ) -> ModelResponse:
-        return await self._inner.get_response(
-            system_instructions,
-            input,
-            model_settings,
-            tools,
-            output_schema,
-            handoffs,
-            tracing,
-            previous_response_id=previous_response_id,
-            conversation_id=conversation_id,
-            prompt=prompt,
-        )
-
-    async def stream_response(
-        self,
-        system_instructions: str | None,
-        input: str | list[TResponseInputItem],  # noqa: A002
-        model_settings: ModelSettings,
-        tools: list[Tool],
-        output_schema: AgentOutputSchemaBase | None,
-        handoffs: list[Handoff],
-        tracing: ModelTracing,
-        *,
-        previous_response_id: str | None,
-        conversation_id: str | None,
-        prompt: ResponsePromptParam | None,
-    ) -> AsyncIterator[TResponseStreamEvent]:
-        response = await self._inner.get_response(
-            system_instructions,
-            input,
-            model_settings,
-            tools,
-            output_schema,
-            handoffs,
-            tracing,
-            previous_response_id=previous_response_id,
-            conversation_id=conversation_id,
-            prompt=prompt,
-        )
-        yield _completed_stream_event(response, getattr(self._inner, "model", None))
-
-
-def _completed_stream_event(
-    model_response: ModelResponse, model_name: object | None
-) -> TResponseStreamEvent:
-    """Wrap a non-streamed ``ModelResponse`` as the terminal event of a stream.
-
-    The run loop builds its authoritative per-turn response solely from the
-    ``response.completed`` event, so a single event carrying the full output
-    and usage is all it needs.
-    """
-    response = Response(
-        id=model_response.response_id or FAKE_RESPONSES_ID,
-        created_at=time.time(),
-        model=str(model_name) if model_name else "",
-        object="response",
-        output=list(model_response.output),
-        tool_choice="auto",
-        tools=[],
-        parallel_tool_calls=False,
-        usage=_response_usage(model_response.usage),
-    )
-    return ResponseCompletedEvent(
-        response=response,
-        sequence_number=0,
-        type="response.completed",
-    )
-
-
-def _response_usage(usage: Usage | None) -> ResponseUsage | None:
-    if usage is None:
-        return None
-    return ResponseUsage(
-        input_tokens=usage.input_tokens,
-        output_tokens=usage.output_tokens,
-        total_tokens=usage.total_tokens,
-        input_tokens_details=usage.input_tokens_details,
-        output_tokens_details=usage.output_tokens_details,
-    )
-
-
 class StrixProvider(MultiProvider):
     """Route any non-OpenAI prefix through LiteLLM with the prefix preserved,
     so users type ``deepseek/deepseek-chat`` rather than
@@ -292,21 +159,14 @@ class StrixProvider(MultiProvider):
         return self._get_fallback_provider("litellm"), original_model_name
 
     def get_model(self, model_name: str | None) -> Model:
-        llm = load_settings().llm
         slug = codex.subscription_model(model_name)
         if slug:
-            # The ChatGPT subscription backend is always streamed; it has no
-            # non-streaming mode to fall back to, so LLM_DISABLE_STREAMING
-            # does not apply here.
             return _CodexResponsesModel(
                 slug,
                 codex.get_subscription_client(),
-                reasoning_effort=llm.reasoning_effort,
+                reasoning_effort=load_settings().llm.reasoning_effort,
             )
-        model = super().get_model(model_name)
-        if llm.disable_streaming:
-            return _NonStreamingModel(model)
-        return model
+        return super().get_model(model_name)
 
 
 DEFAULT_MODEL_RETRY = ModelRetrySettings(
@@ -383,7 +243,6 @@ def configure_sdk_model_defaults(settings: Settings) -> None:
         set_default_openai_api("chat_completions")
     else:
         set_default_openai_api("responses")
-    _configure_extra_headers(llm)
 
 
 def _mirror_api_key_to_provider_env(model_name: str | None, api_key: str) -> None:
@@ -488,43 +347,6 @@ def _configure_openrouter_attribution(model_name: str | None) -> None:
     litellm.headers = {**existing, **_OPENROUTER_ATTRIBUTION_HEADERS}  # type: ignore[assignment]
 
 
-def _configure_extra_headers(llm: LlmSettings) -> None:
-    """Send user-provided default headers on every LLM request.
-
-    Some OpenAI-compatible endpoints require extra HTTP headers (e.g. request
-    attribution or tenant routing) alongside the bearer token. Users supply
-    them via ``LLM_EXTRA_HEADERS``; they are applied to both routing paths:
-    the LiteLLM route (``litellm.headers``) and the SDK-native OpenAI route
-    (a default client carrying ``default_headers``), so they take effect
-    regardless of the ``STRIX_LLM`` prefix.
-    """
-    headers = llm.extra_headers
-    if not headers:
-        return
-    _merge_litellm_headers(headers)
-    _register_openai_client_with_headers(llm, headers)
-
-
-def _merge_litellm_headers(headers: dict[str, str]) -> None:
-    import litellm
-
-    current: object = litellm.headers
-    existing: dict[str, str] = current if isinstance(current, dict) else {}
-    litellm.headers = {**existing, **headers}  # type: ignore[assignment]
-
-
-def _register_openai_client_with_headers(llm: LlmSettings, headers: dict[str, str]) -> None:
-    from agents import set_default_openai_client
-    from openai import AsyncOpenAI
-
-    client = AsyncOpenAI(
-        api_key=llm.api_key or "not-needed",
-        base_url=llm.api_base,
-        default_headers=dict(headers),
-    )
-    set_default_openai_client(client, use_for_tracing=False)
-
-
 def _register_litellm_cost_callback() -> None:
     import litellm
 

strix/config/settings.py

@@ -8,9 +8,7 @@ from pydantic import AliasChoices, Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
-ReasoningEffort = Literal["none", "minimal", "low", "medium", "high", "xhigh", "max"]
-
-DEFAULT_MAX_TURNS = 500
+ReasoningEffort = Literal["none", "minimal", "low", "medium", "high", "xhigh"]
 
 _BASE_CONFIG = SettingsConfigDict(
     case_sensitive=False,
@@ -37,10 +35,6 @@ class LlmSettings(BaseSettings):
             "OLLAMA_API_BASE",
         ),
     )
-    extra_headers: dict[str, str] | None = Field(
-        default=None,
-        alias="LLM_EXTRA_HEADERS",
-    )
     reasoning_effort: ReasoningEffort = Field(default="high", alias="STRIX_REASONING_EFFORT")
     force_required_tool_choice: bool = Field(
         default=False,
@@ -50,10 +44,6 @@ class LlmSettings(BaseSettings):
         default=True,
         alias="STRIX_PROMPT_CACHE",
     )
-    disable_streaming: bool = Field(
-        default=False,
-        alias="LLM_DISABLE_STREAMING",
-    )
     timeout: int = Field(default=300, alias="LLM_TIMEOUT")
 
 
@@ -67,10 +57,6 @@ class DedupeSettings(BaseSettings):
     )
     api_key: str | None = Field(default=None, alias="DEDUPE_LLM_API_KEY")
     api_base: str | None = Field(default=None, alias="DEDUPE_LLM_API_BASE")
-    extra_headers: dict[str, str] | None = Field(
-        default=None,
-        alias="DEDUPE_LLM_EXTRA_HEADERS",
-    )
 
 
 class ContextSettings(BaseSettings):

strix/core/agents.py

@@ -24,11 +24,6 @@ logger = logging.getLogger(__name__)
 
 Status = Literal["running", "waiting", "completed", "stopped", "crashed", "failed", "budget_paused"]
 
-# Why an agent parked. The user can message any agent, so this - not the agent's
-# position in the tree - decides whether waiting is bounded: only an agent waiting
-# on other agents is re-checked on a timer.
-WaitKind = Literal["user", "agents", "stalled"]
-
 
 @dataclass(slots=True)
 class AgentRuntime:
@@ -37,8 +32,6 @@ class AgentRuntime:
     stream: Any | None = None
     interrupt_on_message: bool = False
     wake: asyncio.Event = field(default_factory=asyncio.Event)
-    mailbox: list[dict[str, Any]] = field(default_factory=list)
-    user_wake_required: bool = False
 
 
 class AgentCoordinator:
@@ -51,11 +44,7 @@ class AgentCoordinator:
         self.metadata: dict[str, dict[str, Any]] = {}
         self.pending_counts: dict[str, int] = {}
         self.errors: dict[str, str] = {}
-        self.recovery_counts: dict[str, int] = {}
-        self.idle_resume_counts: dict[str, int] = {}
-        self.wait_kinds: dict[str, WaitKind] = {}
         self.runtimes: dict[str, AgentRuntime] = {}
-        self._parent_notified: set[str] = set()
         self._lock = asyncio.Lock()
         self._snapshot_path: Path | None = None
         self.is_shutting_down = False
@@ -190,59 +179,11 @@ class AgentCoordinator:
             if agent_id in self.statuses:
                 self.statuses[agent_id] = "running"
                 self.errors.pop(agent_id, None)
-                self.wait_kinds.pop(agent_id, None)
-                self.runtimes.setdefault(agent_id, AgentRuntime()).user_wake_required = False
-                self._parent_notified.discard(agent_id)
         await self._maybe_snapshot()
 
-    async def park_waiting(self, agent_id: str, *, wait_kind: WaitKind) -> None:
-        """Park an agent, recording what it is waiting on so the driver can time it."""
-        async with self._lock:
-            if agent_id in self.statuses:
-                self.wait_kinds[agent_id] = wait_kind
+    async def park_waiting(self, agent_id: str) -> None:
         await self.set_status(agent_id, "waiting")
 
-    async def wait_kind_of(self, agent_id: str) -> WaitKind | None:
-        async with self._lock:
-            return self.wait_kinds.get(agent_id)
-
-    async def record_recovery(self, agent_id: str) -> int:
-        """Count a turn that ended without a lifecycle tool call; return the new total.
-
-        Persisted so a resumed agent cannot earn a fresh nudge budget on every
-        auto-resume and loop forever.
-        """
-        async with self._lock:
-            count = self.recovery_counts.get(agent_id, 0) + 1
-            self.recovery_counts[agent_id] = count
-        await self._maybe_snapshot()
-        return count
-
-    async def reset_recovery(self, agent_id: str) -> None:
-        """Clear the nudge budget after real progress (new message or a lifecycle tool)."""
-        async with self._lock:
-            if self.recovery_counts.pop(agent_id, None) is None:
-                return
-        await self._maybe_snapshot()
-
-    async def record_idle_resume(self, agent_id: str) -> int:
-        """Count an auto-resume that no message triggered; return the new total.
-
-        An agent that parks again after every auto-resume would otherwise burn a
-        model turn per timeout for the rest of the scan.
-        """
-        async with self._lock:
-            count = self.idle_resume_counts.get(agent_id, 0) + 1
-            self.idle_resume_counts[agent_id] = count
-        await self._maybe_snapshot()
-        return count
-
-    async def reset_idle_resumes(self, agent_id: str) -> None:
-        async with self._lock:
-            if self.idle_resume_counts.pop(agent_id, None) is None:
-                return
-        await self._maybe_snapshot()
-
     async def set_status(
         self, agent_id: str, status: Status | str, *, error: str | None = None
     ) -> None:
@@ -254,71 +195,57 @@ class AgentCoordinator:
                 self.errors[agent_id] = error
             elif status == "running":
                 self.errors.pop(agent_id, None)
-            if status == "running":
-                # Running again means a fresh stint that owes its parent its own notice.
-                self._parent_notified.discard(agent_id)
             runtime = self.runtimes.setdefault(agent_id, AgentRuntime())
-            runtime.user_wake_required = status in {"failed", "crashed"}
             runtime.wake.set()
         logger.info("agent.status %s=%s", agent_id, status)
         await self._maybe_snapshot()
 
-    async def claim_parent_notice(self, agent_id: str) -> bool:
-        """Reserve the one notice a child owes its parent when it stops running.
-
-        A completion report and a terminal notice carry the same information, so
-        whichever comes first claims the slot and the other is skipped.
-        """
-        async with self._lock:
-            if agent_id in self._parent_notified:
-                return False
-            self._parent_notified.add(agent_id)
-            return True
-
     async def send(
         self, target_agent_id: str, message: dict[str, Any], *, interrupt: bool = True
     ) -> bool:
-        """Queue a user/peer message in the target's mailbox and wake it."""
-        from_user = message.get("from") == "user"
-        if from_user and self._budget_paused:
+        """Deliver a user/peer message by appending it to the target SDK session."""
+        if message.get("from") == "user" and self._budget_paused:
             await self.resume_from_budget_pause(exclude=target_agent_id)
         async with self._lock:
             if target_agent_id not in self.statuses:
                 logger.debug("agent.send dropped unknown target=%s", target_agent_id)
                 return False
             runtime = self.runtimes.setdefault(target_agent_id, AgentRuntime())
-            runtime.mailbox.append(dict(message))
-            self.pending_counts[target_agent_id] = self.pending_counts.get(target_agent_id, 0) + 1
-            if from_user:
-                runtime.user_wake_required = False
-            runtime.wake.set()
+            session = runtime.session
             stream = runtime.stream
             interrupt_on_message = runtime.interrupt_on_message
+        if session is None:
+            logger.warning(
+                "agent.send dropped target=%s because its SDK session is not attached",
+                target_agent_id,
+            )
+            return False
+        try:
+            async with session_write_lock(session):
+                await session.add_items([self._message_to_session_item(message)])
+        except Exception:
+            logger.exception(
+                "agent.send failed to append to SDK session target=%s",
+                target_agent_id,
+            )
+            return False
+        async with self._lock:
+            self.pending_counts[target_agent_id] = self.pending_counts.get(target_agent_id, 0) + 1
+            self.runtimes.setdefault(target_agent_id, AgentRuntime()).wake.set()
         if stream is not None and interrupt and interrupt_on_message:
             stream.cancel(mode="immediate")
         await self._maybe_snapshot()
         return True
 
-    async def wait_for_message(self, agent_id: str, *, timeout: float | None = None) -> bool:
-        """Wait until a message is ready for ``agent_id``; False on ``timeout``."""
+    async def wait_for_message(self, agent_id: str) -> None:
         while True:
             async with self._lock:
-                runtime = self.runtimes.setdefault(agent_id, AgentRuntime())
                 reserve_exit = self._reserve_stopped and self.parent_of.get(agent_id) is not None
-                pending_ready = (
-                    self.pending_counts.get(agent_id, 0) > 0 and not runtime.user_wake_required
-                )
-                if self._budget_stopped or reserve_exit or pending_ready:
-                    return True
-                wake = runtime.wake
+                if self._budget_stopped or reserve_exit or self.pending_counts.get(agent_id, 0) > 0:
+                    return
+                wake = self.runtimes.setdefault(agent_id, AgentRuntime()).wake
                 wake.clear()
-            if timeout is None:
-                await wake.wait()
-            else:
-                try:
-                    await asyncio.wait_for(wake.wait(), timeout)
-                except TimeoutError:
-                    return False
+            await wake.wait()
 
     async def consume_pending(
         self,
@@ -326,38 +253,17 @@ class AgentCoordinator:
         *,
         include_items: bool = False,
     ) -> tuple[int, list[Any]]:
-        """Drain the agent's mailbox into its own SDK session."""
         async with self._lock:
-            runtime = self.runtimes.setdefault(agent_id, AgentRuntime())
-            queued = list(runtime.mailbox)
-            runtime.mailbox.clear()
-            count = max(self.pending_counts.get(agent_id, 0), len(queued))
+            count = self.pending_counts.get(agent_id, 0)
             self.pending_counts[agent_id] = 0
-            session = runtime.session
+            session = self.runtimes.get(agent_id, AgentRuntime()).session
         if count <= 0:
             return 0, []
-        items = [self._message_to_session_item(m) for m in queued]
-        if items:
-            if session is None:
-                logger.warning(
-                    "agent %s has no SDK session attached; %d queued messages were not persisted",
-                    agent_id,
-                    len(items),
-                )
-            else:
-                try:
-                    async with session_write_lock(session):
-                        await session.add_items(items)
-                except Exception:
-                    logger.exception(
-                        "failed to append %d queued messages to the session of %s",
-                        len(items),
-                        agent_id,
-                    )
         await self._maybe_snapshot()
-        if not include_items:
+        if not include_items or session is None:
             return count, []
-        return count, items
+        items = await session.get_items()
+        return count, list(items[-count:])
 
     async def request_stop(self, agent_id: str) -> None:
         async with self._lock:
@@ -383,15 +289,12 @@ class AgentCoordinator:
         if tasks:
             await asyncio.gather(*tasks, return_exceptions=True)
 
-    async def cancel_descendants_graceful(self, agent_id: str) -> list[str]:
-        """Stop a subtree leaves-first and report which agents were stopped."""
+    async def cancel_descendants_graceful(self, agent_id: str) -> None:
         async with self._lock:
             order = self._subtree_order_locked(agent_id)
-        stopped = list(reversed(order))
-        for aid in stopped:
+        for aid in reversed(order):
             await self.request_stop(aid)
         await self._maybe_snapshot()
-        return stopped
 
     async def attach_stream(
         self,
@@ -471,14 +374,6 @@ class AgentCoordinator:
                 "names": dict(self.names),
                 "metadata": {aid: dict(md) for aid, md in self.metadata.items()},
                 "pending_counts": dict(self.pending_counts),
-                "recovery_counts": dict(self.recovery_counts),
-                "idle_resume_counts": dict(self.idle_resume_counts),
-                "wait_kinds": dict(self.wait_kinds),
-                "mailboxes": {
-                    aid: [dict(m) for m in runtime.mailbox]
-                    for aid, runtime in self.runtimes.items()
-                    if runtime.mailbox
-                },
                 "errors": dict(self.errors),
                 "budget_stopped": self._budget_stopped,
                 "reserve_stopped": self._reserve_stopped,
@@ -493,15 +388,6 @@ class AgentCoordinator:
             self.metadata = {aid: dict(md) for aid, md in snap.get("metadata", {}).items()}
             self.pending_counts = dict(snap.get("pending_counts", {}))
             self.errors = dict(snap.get("errors", {}))
-            self.recovery_counts = dict(snap.get("recovery_counts", {}))
-            self.idle_resume_counts = dict(snap.get("idle_resume_counts", {}))
-            self.wait_kinds = dict(snap.get("wait_kinds", {}))
-            mailboxes = snap.get("mailboxes", {})
-            if isinstance(mailboxes, dict):
-                for aid, msgs in mailboxes.items():
-                    if isinstance(msgs, list):
-                        runtime = self.runtimes.setdefault(aid, AgentRuntime())
-                        runtime.mailbox = [dict(m) for m in msgs if isinstance(m, dict)]
             self._budget_stopped = bool(snap.get("budget_stopped", False))
             self._reserve_stopped = bool(snap.get("reserve_stopped", False))
             self._budget_paused = bool(snap.get("budget_paused", False))

strix/core/execution.py

@@ -9,7 +9,6 @@ import uuid
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, cast
 
-import litellm
 from agents import RunConfig, Runner
 from agents.exceptions import AgentsException, MaxTurnsExceeded, UserError
 from agents.sandbox.errors import ExecTransportError
@@ -17,7 +16,9 @@ from docker import errors as docker_errors  # type: ignore[import-untyped, unuse
 from openai import (
     APIConnectionError,
     APIError,
+    APIStatusError,
     APITimeoutError,
+    RateLimitError,
 )
 
 from strix.config import codex
@@ -30,8 +31,6 @@ from strix.core.inputs import child_initial_input
 from strix.core.sessions import (
     enforce_image_budget,
     open_agent_session,
-    replace_session_items,
-    seed_initial_input,
     strip_all_images_from_session,
 )
 from strix.llm.compaction import is_context_overflow, maybe_compact
@@ -56,23 +55,6 @@ _INPUT_REJECTION_CODES = frozenset({400, 404, 422})
 _MAX_COMPACTIONS_PER_CYCLE = 2
 
 
-class ProviderRefusalError(AgentsException):
-    """Raised when a provider returns a structured refusal instead of an exception."""
-
-
-def _structured_provider_refusal(result: Any) -> str | None:
-    for item in getattr(result, "new_items", ()) or ():
-        raw_item = getattr(item, "raw_item", None)
-        for content in getattr(raw_item, "content", ()) or ():
-            if getattr(content, "type", None) != "refusal":
-                continue
-            refusal = getattr(content, "refusal", None)
-            if isinstance(refusal, str) and refusal.strip():
-                return refusal.strip()
-            return "The model provider refused this request."
-    return None
-
-
 def _run_config_model(run_config: RunConfig) -> str | None:
     return run_config.model if isinstance(run_config.model, str) else None
 
@@ -107,9 +89,15 @@ async def _compact_session(
     )
 
 
-_MAX_TRANSIENT_MODEL_RETRIES = 5
+_GUARDRAIL_PARK_ERROR = (
+    "Blocked by the model's content guardrail (flagged as a possible cybersecurity risk). "
+    "Set STRIX_LLM to a model that isn't blocked and resume the scan to continue."
+)
+
+_TRANSIENT_MODEL_STATUS_CODES = frozenset({408, 500, 502, 503, 504})
+_MAX_TRANSIENT_MODEL_RETRIES = 4
 _TRANSIENT_MODEL_RETRY_BASE_DELAY_S = 2.0
-_TRANSIENT_MODEL_RETRY_MAX_DELAY_S = 90.0
+_TRANSIENT_MODEL_RETRY_MAX_DELAY_S = 30.0
 
 
 def _model_error_status_code(exc: BaseException) -> int | None:
@@ -118,16 +106,15 @@ def _model_error_status_code(exc: BaseException) -> int | None:
 
 
 def _is_transient_model_error(exc: BaseException) -> bool:
-    if codex.is_content_guardrail_error(exc):
+    if isinstance(exc, RateLimitError):
         return False
-    if isinstance(
-        exc, APITimeoutError | APIConnectionError | TimeoutError | ConnectionError | OSError
-    ):
+    if isinstance(exc, APITimeoutError | APIConnectionError):
         return True
-    code = _model_error_status_code(exc)
-    if code is not None:
-        return bool(litellm._should_retry(code))
-    return isinstance(exc, APIError)
+    if isinstance(exc, APIStatusError):
+        return exc.status_code in _TRANSIENT_MODEL_STATUS_CODES
+    if isinstance(exc, APIError):
+        return _model_error_status_code(exc) is None
+    return False
 
 
 def _transient_model_retry_delay(attempt: int) -> float:
@@ -135,40 +122,6 @@ def _transient_model_retry_delay(attempt: int) -> float:
     return min(delay, _TRANSIENT_MODEL_RETRY_MAX_DELAY_S)
 
 
-async def _salvage_stream_to_session(
-    session: Session,
-    pre_run_items: list[Any],
-    stream: Any,
-    agent_id: str,
-) -> None:
-    """Persist a crashed run's full history so a revived agent loses no context."""
-    if stream is None:
-        return
-    try:
-        replay = list(stream.to_input_list())
-    except Exception:
-        logger.exception("could not build salvage history for %s", agent_id)
-        return
-    desired = list(pre_run_items) + replay
-    if len(desired) <= len(pre_run_items):
-        return
-    try:
-        await replace_session_items(session, desired)
-    except Exception:
-        logger.exception("salvaging crashed run history failed for %s", agent_id)
-
-
-async def _seed_and_prepare_first_input(
-    session: Session | None, initial_input: Any, *, start_parked: bool
-) -> Any:
-    """Persist the opening input up front so it survives a first-turn crash."""
-    if initial_input and session is not None and not start_parked:
-        with contextlib.suppress(Exception):
-            if await seed_initial_input(session, initial_input):
-                return []
-    return initial_input
-
-
 async def run_agent_loop(
     *,
     agent: Any,
@@ -191,10 +144,6 @@ async def run_agent_loop(
     )
     result: RunResultBase | None = None
 
-    first_cycle_input = await _seed_and_prepare_first_input(
-        session, initial_input, start_parked=start_parked
-    )
-
     budget_stopped = coordinator.budget_stopped
     reserve_stopped = coordinator.reserve_stopped
     if budget_stopped:
@@ -208,17 +157,31 @@ async def run_agent_loop(
         await coordinator.send(agent_id, _reserve_notice())
 
     if not (start_parked and interactive):
-        with contextlib.suppress(BudgetPausedError):
-            result = await _run_until_lifecycle(
+        if interactive:
+            with contextlib.suppress(BudgetPausedError):
+                result = await _run_cycle(
+                    agent,
+                    coordinator,
+                    agent_id,
+                    input_data=initial_input,
+                    run_config=run_config,
+                    context=context,
+                    max_turns=max_turns,
+                    session=session,
+                    interactive=interactive,
+                    event_sink=event_sink,
+                    hooks=hooks,
+                )
+        else:
+            result = await _run_noninteractive_until_lifecycle(
                 agent,
                 coordinator,
                 agent_id,
-                initial_input=first_cycle_input,
+                initial_input=initial_input,
                 run_config=run_config,
                 context=context,
                 max_turns=max_turns,
                 session=session,
-                interactive=interactive,
                 event_sink=event_sink,
                 hooks=hooks,
             )
@@ -227,9 +190,8 @@ async def run_agent_loop(
         return result
 
     while True:
-        timeout = await _plain_waiting_timeout(coordinator, agent_id)
         try:
-            woke = await coordinator.wait_for_message(agent_id, timeout=timeout)
+            await coordinator.wait_for_message(agent_id)
         except asyncio.CancelledError:
             return result
 
@@ -241,46 +203,18 @@ async def run_agent_loop(
             await coordinator.set_status(agent_id, "stopped")
             raise SubagentBudgetReservedError("scan reached the sub-agent budget reserve")
 
-        if woke:
-            # Real input is real progress, so the nudge budget starts over. A bare
-            # auto-resume is not: it must not hand a wedged agent a fresh budget.
-            await coordinator.reset_recovery(agent_id)
-            await coordinator.reset_idle_resumes(agent_id)
-        else:
-            idle_resumes = await coordinator.record_idle_resume(agent_id)
-            if idle_resumes >= _MAX_IDLE_AUTO_RESUMES:
-                logger.warning(
-                    "agent %s auto-resumed %d times without hearing from anyone; "
-                    "leaving it parked until a real message arrives",
-                    agent_id,
-                    idle_resumes,
-                )
-                await coordinator.park_waiting(agent_id, wait_kind="stalled")
-                await _notify_parent_on_stall(coordinator, agent_id)
-                continue
-            logger.info("agent %s reached its waiting timeout; auto-resuming", agent_id)
-            await coordinator.send(
-                agent_id,
-                {
-                    "from": "system",
-                    "type": "auto_resume",
-                    "content": "Waiting timeout reached. Resuming execution.",
-                },
-                interrupt=False,
-            )
-
         await coordinator.consume_pending(agent_id)
         with contextlib.suppress(BudgetPausedError):
-            result = await _run_until_lifecycle(
+            result = await _run_cycle(
                 agent,
                 coordinator,
                 agent_id,
-                initial_input=[],
+                input_data=[],
                 run_config=run_config,
                 context=context,
                 max_turns=max_turns,
                 session=session,
-                interactive=True,
+                interactive=interactive,
                 event_sink=event_sink,
                 hooks=hooks,
             )
@@ -376,6 +310,7 @@ async def respawn_subagents(
             if coordinator.parent_of.get(aid) is None or aid == root_id:
                 continue
             md["_restored_status"] = status
+            md["_restored_error"] = coordinator.errors.get(aid)
             candidates.append(
                 (
                     aid,
@@ -388,7 +323,8 @@ async def respawn_subagents(
     for child_id, name, parent_id, md in candidates:
         try:
             restored_status = str(md.get("_restored_status") or "running")
-            start_parked = interactive and restored_status != "running"
+            recoverable_park = restored_status == "waiting" and bool(md.get("_restored_error"))
+            start_parked = interactive and restored_status != "running" and not recoverable_park
 
             if start_parked:
                 logger.warning(
@@ -431,10 +367,7 @@ async def respawn_subagents(
                 await coordinator.set_status(child_id, "crashed")
 
 
-_INTERACTIVE_TOOL_RECOVERY_LIMIT = 3
-
-
-async def _run_until_lifecycle(
+async def _run_noninteractive_until_lifecycle(
     agent: Any,
     coordinator: AgentCoordinator,
     agent_id: str,
@@ -444,20 +377,14 @@ async def _run_until_lifecycle(
     context: dict[str, Any],
     max_turns: int,
     session: Session | None,
-    interactive: bool,
     event_sink: StreamEventSink | None,
     hooks: RunHooks[dict[str, Any]] | None,
 ) -> RunResultBase | None:
-    """Drive an agent until an explicit lifecycle tool settles its status.
-
-    A turn that ends without ``finish_scan``, ``agent_finish``,
-    ``respond_to_user``, or ``wait_for_agents`` leaves the agent ``running``:
-    plain text never terminates a run and never yields to the user. Such a turn
-    is nudged back into a tool call, bounded by a recovery limit.
-    """
+    """Non-chat mode keeps running until finish_scan / agent_finish settles status."""
     result: RunResultBase | None = None
     input_data: Any = initial_input
-    recovery_limit = _INTERACTIVE_TOOL_RECOVERY_LIMIT if interactive else max(1, max_turns)
+    invalid_final_outputs = 0
+    invalid_final_output_limit = max(1, max_turns)
 
     while True:
         if coordinator.budget_stopped:
@@ -468,143 +395,7 @@ async def _run_until_lifecycle(
             await coordinator.set_status(agent_id, "stopped")
             raise SubagentBudgetReservedError("scan reached the sub-agent budget reserve")
 
-        if interactive:
-            result = await _run_cycle_parked(
-                agent,
-                coordinator,
-                agent_id,
-                input_data=input_data,
-                run_config=run_config,
-                context=context,
-                max_turns=max_turns,
-                session=session,
-                event_sink=event_sink,
-                hooks=hooks,
-            )
-        else:
-            result = await _run_cycle(
-                agent,
-                coordinator,
-                agent_id,
-                input_data=input_data,
-                run_config=run_config,
-                context=context,
-                max_turns=max_turns,
-                session=session,
-                interactive=False,
-                event_sink=event_sink,
-                hooks=hooks,
-            )
-
-        status = await _agent_status(coordinator, agent_id)
-        if status != "running":
-            await coordinator.reset_recovery(agent_id)
-            return result
-
-        recoveries = await coordinator.record_recovery(agent_id)
-        logger.warning(
-            "agent %s ended a turn without a lifecycle tool call (interactive=%s); "
-            "forcing tool continuation (%d/%d): %s",
-            agent_id,
-            interactive,
-            recoveries,
-            recovery_limit,
-            _final_output_preview(result),
-        )
-
-        if recoveries >= recovery_limit:
-            return await _exhausted_recovery(coordinator, agent_id, result, interactive=interactive)
-
-        input_data = await _append_tool_required_message(
-            session=session,
-            context=context,
-            attempt=recoveries,
-            limit=recovery_limit,
-            interactive=interactive,
-        )
-
-
-async def _exhausted_recovery(
-    coordinator: AgentCoordinator,
-    agent_id: str,
-    result: RunResultBase | None,
-    *,
-    interactive: bool,
-) -> RunResultBase | None:
-    """Settle an agent that never recovered into a tool call.
-
-    Interactive runs park instead of dying: a human is attached and can message
-    any agent, so the scan stays resumable. Autonomous runs have nobody to
-    resume them, so they fail loudly.
-    """
-    if not interactive:
-        await coordinator.set_status(agent_id, "crashed")
-        await notify_parent_on_terminal(coordinator, agent_id, "crashed")
-        raise MaxTurnsExceeded(
-            "Agent exhausted recovery attempts without calling finish_scan or agent_finish."
-        )
-
-    logger.warning(
-        "agent %s exhausted tool-call recovery attempts; parking until a message arrives",
-        agent_id,
-    )
-    await coordinator.park_waiting(agent_id, wait_kind="stalled")
-    # A parked child owes its parent a completion report it can no longer send. The
-    # parent is an agent, not a watching human, so nothing else tells it to stop
-    # waiting and it burns its full timeout on a message that is never coming.
-    await _notify_parent_on_stall(coordinator, agent_id)
-    return result
-
-
-_WAITING_AUTO_RESUME_TIMEOUT_S = 300.0
-
-# An agent that parks again after every auto-resume makes no progress, so stop
-# spending a model turn per timeout and leave it parked for a real message.
-_MAX_IDLE_AUTO_RESUMES = 3
-
-
-async def _plain_waiting_timeout(
-    coordinator: AgentCoordinator,
-    agent_id: str,
-) -> float | None:
-    """Auto-resume timeout for a parked agent; None waits until a message arrives.
-
-    Driven by what the agent is waiting on, not by where it sits in the graph:
-    the user can message any agent, so an agent awaiting a human parks
-    indefinitely whether or not it is the root. Only an agent awaiting other
-    agents is re-checked on a timer, and only until it has spent its idle
-    budget re-parking without hearing anything.
-    """
-    async with coordinator._lock:
-        status = coordinator.statuses.get(agent_id)
-        has_error = agent_id in coordinator.errors
-        runtime = coordinator.runtimes.get(agent_id)
-        gated = runtime.user_wake_required if runtime is not None else False
-        wait_kind = coordinator.wait_kinds.get(agent_id)
-        idle_resumes = coordinator.idle_resume_counts.get(agent_id, 0)
-    if status != "waiting" or has_error or gated:
-        return None
-    if wait_kind != "agents" or idle_resumes >= _MAX_IDLE_AUTO_RESUMES:
-        return None
-    return _WAITING_AUTO_RESUME_TIMEOUT_S
-
-
-async def _run_cycle_parked(
-    agent: Any,
-    coordinator: AgentCoordinator,
-    agent_id: str,
-    *,
-    input_data: Any,
-    run_config: RunConfig,
-    context: dict[str, Any],
-    max_turns: int,
-    session: Session | None,
-    event_sink: StreamEventSink | None,
-    hooks: RunHooks[dict[str, Any]] | None,
-) -> RunResultBase | None:
-    """Interactive run cycle that parks on any error instead of killing the runner."""
-    try:
-        return await _run_cycle(
+        result = await _run_cycle(
             agent,
             coordinator,
             agent_id,
@@ -613,17 +404,39 @@ async def _run_cycle_parked(
             context=context,
             max_turns=max_turns,
             session=session,
-            interactive=True,
+            interactive=False,
             event_sink=event_sink,
             hooks=hooks,
         )
-    except (BudgetExceededError, BudgetPausedError, SubagentBudgetReservedError):
-        raise
-    except Exception as exc:
-        logger.exception("error escaped the run cycle for %s; parking as failed", agent_id)
-        await coordinator.set_status(agent_id, "failed", error=str(exc) or type(exc).__name__)
-        await notify_parent_on_terminal(coordinator, agent_id, "failed")
-        return None
+
+        status = await _agent_status(coordinator, agent_id)
+        if status != "running":
+            return result
+
+        invalid_final_outputs += 1
+        logger.warning(
+            "agent %s produced non-lifecycle final output in non-interactive mode; "
+            "forcing tool continuation (%d/%d): %s",
+            agent_id,
+            invalid_final_outputs,
+            invalid_final_output_limit,
+            _final_output_preview(result),
+        )
+
+        if invalid_final_outputs >= invalid_final_output_limit:
+            await coordinator.set_status(agent_id, "crashed")
+            await _notify_parent_on_terminal(coordinator, agent_id, "crashed")
+            raise MaxTurnsExceeded(
+                "Agent exhausted non-interactive recovery attempts without calling "
+                "finish_scan or agent_finish."
+            )
+
+        input_data = await _append_noninteractive_tool_required_message(
+            session=session,
+            context=context,
+            attempt=invalid_final_outputs,
+            limit=invalid_final_output_limit,
+        )
 
 
 async def _run_cycle(  # noqa: PLR0912, PLR0915
@@ -644,8 +457,6 @@ async def _run_cycle(  # noqa: PLR0912, PLR0915
     compactions = 0
     model_retries = 0
     while True:
-        stream: Any = None
-        pre_run_items: list[Any] = []
         try:
             await coordinator.mark_running(agent_id)
             if session is not None:
@@ -659,8 +470,6 @@ async def _run_cycle(  # noqa: PLR0912, PLR0915
                     await _compact_session(agent, session, run_config, force=False)
                 except Exception:
                     logger.exception("proactive compaction failed for %s", agent_id)
-                with contextlib.suppress(Exception):
-                    pre_run_items = list(await session.get_items())
             stream = Runner.run_streamed(
                 agent,
                 input=input_data,
@@ -681,8 +490,6 @@ async def _run_cycle(  # noqa: PLR0912, PLR0915
                                 logger.exception("stream event sink failed for %s", agent_id)
                     if stream.run_loop_exception is not None:
                         raise stream.run_loop_exception
-                    if refusal := _structured_provider_refusal(stream):
-                        raise ProviderRefusalError(refusal)
                 except (BudgetExceededError, BudgetPausedError, SubagentBudgetReservedError):
                     raise
                 except RuntimeError as stream_exc:
@@ -773,13 +580,10 @@ async def _run_cycle(  # noqa: PLR0912, PLR0915
                 if session is not None:
                     input_data = []
                 continue
-            if session is not None:
-                await _salvage_stream_to_session(session, pre_run_items, stream, agent_id)
-            if isinstance(exc, ProviderRefusalError):
-                logger.warning("agent %s refused by the model provider: %s", agent_id, exc)
-                await coordinator.set_status(agent_id, "failed", error=str(exc))
-                await notify_parent_on_terminal(coordinator, agent_id, "failed")
-                return None
+            if codex.is_content_guardrail_error(exc):
+                return await _handle_content_guardrail(
+                    coordinator, agent_id, exc, interactive=interactive
+                )
             if not interactive:
                 raise
             if isinstance(exc, MaxTurnsExceeded):
@@ -790,10 +594,44 @@ async def _run_cycle(  # noqa: PLR0912, PLR0915
                 status = "crashed"
             logger.exception("agent run failed for %s; parking as %s", agent_id, status)
             await coordinator.set_status(agent_id, status, error=str(exc) or type(exc).__name__)
-            await notify_parent_on_terminal(coordinator, agent_id, status)
+            await _notify_parent_on_terminal(coordinator, agent_id, status)
             return None
         else:
-            return cast("RunResultBase | None", stream)
+            await _settle_run_result(coordinator, agent_id, interactive)
+            return stream
+
+
+async def _handle_content_guardrail(
+    coordinator: AgentCoordinator,
+    agent_id: str,
+    exc: BaseException,
+    *,
+    interactive: bool,
+) -> RunResultBase | None:
+    logger.warning("agent %s blocked by the model's content guardrail: %s", agent_id, exc)
+    if interactive:
+        await coordinator.set_status(agent_id, "waiting", error=_GUARDRAIL_PARK_ERROR)
+        return None
+    await coordinator.set_status(agent_id, "failed", error=_GUARDRAIL_PARK_ERROR)
+    await _notify_parent_on_terminal(coordinator, agent_id, "failed")
+    return None
+
+
+async def _settle_run_result(
+    coordinator: AgentCoordinator,
+    agent_id: str,
+    interactive: bool,
+) -> None:
+    async with coordinator._lock:
+        current_status = coordinator.statuses.get(agent_id)
+
+    if current_status != "running":
+        return
+
+    if not interactive:
+        return
+
+    await coordinator.set_status(agent_id, "waiting")
 
 
 async def _agent_status(coordinator: AgentCoordinator, agent_id: str) -> Status | None:
@@ -811,37 +649,23 @@ def _final_output_preview(result: RunResultBase | None) -> str:
     return text[:300]
 
 
-async def _append_tool_required_message(
+async def _append_noninteractive_tool_required_message(
     *,
     session: Session | None,
     context: dict[str, Any],
     attempt: int,
     limit: int,
-    interactive: bool,
 ) -> list[dict[str, str]]:
     finish_tool = "finish_scan" if context.get("parent_id") is None else "agent_finish"
-    if interactive:
-        message = (
-            "Your previous message ended a turn without a tool call. Plain text never ends "
-            "execution and never hands control to the user: it is shown to the user, and the "
-            "run continues. Continue immediately and call exactly one tool. "
-            "If you have something to tell the user and nothing to do until they reply, "
-            "call respond_to_user. "
-            "If you are blocked waiting for another agent, call wait_for_agents. "
-            f"If the whole engagement is complete, call {finish_tool}. "
-            "Otherwise use the appropriate execution or planning tool. "
-            f"This is recovery attempt {attempt}/{limit}."
-        )
-    else:
-        message = (
-            "Your previous response ended the autonomous Strix run without a lifecycle tool "
-            "call. That is invalid in non-interactive mode; plain text final answers are "
-            "ignored. Continue immediately and call exactly one tool. "
-            f"If your work is complete, call {finish_tool}. "
-            "If you are blocked waiting for another agent, call wait_for_agents. "
-            "Otherwise use the appropriate execution or planning tool. "
-            f"This is recovery attempt {attempt}/{limit}."
-        )
+    message = (
+        "Your previous response ended the autonomous Strix run without a lifecycle tool call. "
+        "That is invalid in non-interactive mode; plain text final answers are ignored. "
+        "Continue immediately and call exactly one tool. "
+        f"If your work is complete, call {finish_tool}. "
+        "If you are blocked waiting for another agent, call wait_for_message. "
+        "Otherwise use the appropriate execution or planning tool. "
+        f"This is recovery attempt {attempt}/{limit}."
+    )
     item = {"role": "user", "content": message}
     if session is None:
         return [item]
@@ -851,11 +675,6 @@ async def _append_tool_required_message(
 
 
 _TERMINAL_NOTICE = {
-    "completed": (
-        "[Agent completed] {name} ({agent_id}) finished and is no longer running, but it "
-        "sent no completion report. Stop waiting on this child; ask it directly if you "
-        "need its results."
-    ),
     "crashed": (
         "[Agent crash] {name} ({agent_id}) terminated unexpectedly. "
         "Stop waiting on this child unless you want to message it again."
@@ -866,44 +685,14 @@ _TERMINAL_NOTICE = {
         "message it again."
     ),
     "stopped": (
-        "[Agent stopped] {name} ({agent_id}) was stopped before finishing (turn limit "
-        "or an explicit stop). It will not send a completion report, so stop waiting "
-        "on this child; account for its unfinished subtask and continue."
+        "[Agent capped] {name} ({agent_id}) hit its turn limit and was stopped "
+        "before finishing. It will not send a completion report, so stop waiting "
+        "on this child; account for its capped subtask and continue."
     ),
 }
 
 
-_STALL_NOTICE = (
-    "[Agent stalled] {name} ({agent_id}) kept ending turns without a tool call and is "
-    "parked until it receives a message. It will not send a completion report on its "
-    "own: either message it with a concrete next step to unblock it, or stop waiting on "
-    "it and account for its unfinished subtask."
-)
-
-
-async def _notify_parent_on_stall(
-    coordinator: AgentCoordinator,
-    agent_id: str,
-) -> None:
-    """Tell the parent that a child parked mid-task, so it stops waiting blindly."""
-    async with coordinator._lock:
-        parent = coordinator.parent_of.get(agent_id)
-        name = coordinator.names.get(agent_id, agent_id)
-    if parent is None:
-        return
-    await coordinator.send(
-        parent,
-        {
-            "from": agent_id,
-            "type": "stalled",
-            "priority": "high",
-            "content": _STALL_NOTICE.format(name=name, agent_id=agent_id),
-        },
-        interrupt=False,
-    )
-
-
-async def notify_parent_on_terminal(
+async def _notify_parent_on_terminal(
     coordinator: AgentCoordinator,
     agent_id: str,
     status: str,
@@ -916,8 +705,6 @@ async def notify_parent_on_terminal(
         name = coordinator.names.get(agent_id, agent_id)
     if parent is None:
         return
-    if not await coordinator.claim_parent_notice(agent_id):
-        return
     await coordinator.send(
         parent,
         {
@@ -952,21 +739,6 @@ async def _notify_root_on_budget_reserve(coordinator: AgentCoordinator) -> None:
     await coordinator.send(root, _reserve_notice())
 
 
-async def _notify_parent_on_exit(
-    coordinator: AgentCoordinator,
-    agent_id: str,
-) -> None:
-    """Backstop for a child whose loop ended without telling its parent.
-
-    Every terminal state counts, including ``completed``: a child that skips its
-    completion report leaves the parent waiting on a message nobody will send.
-    """
-    status = await _agent_status(coordinator, agent_id)
-    if status is None:
-        return
-    await notify_parent_on_terminal(coordinator, agent_id, status)
-
-
 async def _start_child_runner(
     *,
     parent_ctx: dict[str, Any],
@@ -1020,9 +792,6 @@ async def _start_child_runner(
             logger.info("child %s stopped after reaching the scan budget limit", child_id)
         except SubagentBudgetReservedError:
             logger.info("child %s stopped at the sub-agent budget reserve", child_id)
-        finally:
-            if not coordinator.is_shutting_down:
-                await _notify_parent_on_exit(coordinator, child_id)
 
     task_handle = asyncio.create_task(_child_loop(), name=f"agent-{name}-{child_id}")
     await coordinator.attach_runtime(child_id, task=task_handle)

strix/core/inputs.py

@@ -24,6 +24,9 @@ if TYPE_CHECKING:
     from strix.config.settings import ReasoningEffort
 
 
+DEFAULT_MAX_TURNS = 500
+
+
 def _accepts_required_tool_choice(model_name: str | None) -> bool:
     name = (model_name or "").strip().lower()
     for prefix in ("litellm/", "any-llm/"):
@@ -129,14 +132,12 @@ def make_model_settings(
     force_required_tool_choice: bool = False,
     request_timeout: float | None = None,
     prompt_cache: bool = True,
-    extra_headers: dict[str, str] | None = None,
 ) -> ModelSettings:
     model_settings = ModelSettings(
         parallel_tool_calls=False,
         retry=DEFAULT_MODEL_RETRY,
         include_usage=True,
         extra_args=request_timeout_extra_args(request_timeout),
-        extra_headers=dict(extra_headers) if extra_headers else None,
     )
     if (
         reasoning_effort is not None
@@ -144,7 +145,7 @@ def make_model_settings(
         and model_supports_reasoning(model_name)
     ):
         model_settings = model_settings.resolve(
-            _reasoning_settings(reasoning_effort, model_settings.extra_args),
+            ModelSettings(reasoning=Reasoning(effort=reasoning_effort)),
         )
     if force_required_tool_choice and _accepts_required_tool_choice(model_name):
         model_settings = model_settings.resolve(ModelSettings(tool_choice="required"))
@@ -159,22 +160,6 @@ def make_model_settings(
     return model_settings
 
 
-def _reasoning_settings(
-    effort: ReasoningEffort,
-    extra_args: dict[str, Any] | None,
-) -> ModelSettings:
-    """``max`` is not in the OpenAI SDK's ``Reasoning.effort`` enum, so send it as
-    a raw body field instead — also keeping it clear of LiteLLM's DeepSeek mapping,
-    which collapses every ``reasoning_effort`` level to plain thinking-enabled.
-    Providers that don't support ``max`` reject the request.
-    """
-    if effort != "max":
-        return ModelSettings(reasoning=Reasoning(effort=effort))
-    return ModelSettings(
-        extra_args={**(extra_args or {}), "extra_body": {"reasoning_effort": "max"}},
-    )
-
-
 def _prompt_cache_extra_args(model_name: str) -> dict[str, Any] | None:
     """LiteLLM ``cache_control_injection_points`` for Claude prompt caching.
 

strix/core/runner.py

@@ -23,7 +23,6 @@ from strix.config.models import (
     configure_sdk_model_defaults,
     uses_chat_completions_tool_schema,
 )
-from strix.config.settings import DEFAULT_MAX_TURNS
 from strix.core.agents import AgentCoordinator
 from strix.core.execution import (
     respawn_subagents,
@@ -34,6 +33,7 @@ from strix.core.execution import (
 )
 from strix.core.hooks import BudgetExceededError, ReportUsageHooks, recomputed_budget_flags
 from strix.core.inputs import (
+    DEFAULT_MAX_TURNS,
     build_root_task,
     build_scope_context,
     make_model_settings,
@@ -250,7 +250,6 @@ async def run_strix_scan(
             force_required_tool_choice=settings.llm.force_required_tool_choice,
             request_timeout=settings.llm.timeout,
             prompt_cache=settings.llm.prompt_cache,
-            extra_headers=settings.llm.extra_headers,
         )
         run_config = RunConfig(
             model=resolved_model,
@@ -377,6 +376,12 @@ async def run_strix_scan(
 
         async with coordinator._lock:
             root_status = coordinator.statuses.get(root_id)
+            root_error = coordinator.errors.get(root_id)
+
+        root_recoverable_park = root_status == "waiting" and bool(root_error)
+        root_start_parked = bool(
+            interactive and is_resume and root_status != "running" and not root_recoverable_park
+        )
 
         result = await run_agent_loop(
             agent=root_agent,
@@ -388,7 +393,7 @@ async def run_strix_scan(
             agent_id=root_id,
             interactive=interactive,
             session=root_session,
-            start_parked=bool(interactive and is_resume and root_status != "running"),
+            start_parked=root_start_parked,
             event_sink=event_sink,
             hooks=hooks,
         )

strix/core/sessions.py

@@ -7,7 +7,6 @@ import logging
 from typing import TYPE_CHECKING, Any, cast
 from weakref import WeakKeyDictionary
 
-from agents.items import ItemHelpers
 from agents.memory import SQLiteSession
 
 
@@ -27,18 +26,6 @@ def open_agent_session(agent_id: str, path: Path) -> SQLiteSession:
     return SQLiteSession(session_id=agent_id, db_path=path)
 
 
-async def seed_initial_input(session: Session, initial_input: Any) -> bool:
-    """Commit an agent's opening identity/task input before its first run cycle."""
-    items = ItemHelpers.input_to_new_input_list(initial_input)
-    if not items:
-        return False
-    async with session_write_lock(session):
-        if await session.get_items():
-            return False
-        await session.add_items(items)
-    return True
-
-
 _IMAGE_REJECTED_TEXT = "[image rejected by the model]"
 _IMAGE_ELIDED_TEXT = "[older screenshot elided to bound context memory]"
 _INHERITED_IMAGE_TEXT = "[screenshot omitted from inherited context]"

strix/interface/cli.py

@@ -13,7 +13,7 @@ from rich.panel import Panel
 from rich.text import Text
 
 from strix.config import load_settings
-from strix.config.settings import DEFAULT_MAX_TURNS
+from strix.core.inputs import DEFAULT_MAX_TURNS
 from strix.core.runner import run_strix_scan
 from strix.report.state import ReportState, set_global_report_state
 from strix.runtime import session_manager

strix/interface/main.py

@@ -11,6 +11,9 @@ import sys
 from datetime import UTC, datetime
 from pathlib import Path
 
+from agents.model_settings import ModelSettings
+from agents.models.interface import ModelTracing
+from docker.errors import DockerException
 from rich.console import Console
 from rich.panel import Panel
 from rich.text import Text
@@ -21,8 +24,17 @@ from strix.config import (
     load_settings,
     persist_current,
 )
-from strix.config.settings import DEFAULT_MAX_TURNS
+from strix.config.models import (
+    RECOMMENDED_MODEL_NAMES,
+    StrixProvider,
+    configure_sdk_model_defaults,
+    is_known_openai_bare_model,
+    is_recommended_or_frontier_model,
+)
+from strix.core.inputs import DEFAULT_MAX_TURNS
 from strix.core.paths import run_dir_for, runtime_state_dir
+from strix.interface.cli import run_cli
+from strix.interface.tui import run_tui
 from strix.interface.update_check import (
     is_binary_install,
     notify_update,
@@ -49,6 +61,8 @@ from strix.interface.utils import (
     rewrite_localhost_targets,
     validate_config_file,
 )
+from strix.report.state import get_global_report_state
+from strix.report.writer import read_run_record, write_run_record
 from strix.telemetry import posthog, scarf
 from strix.telemetry.logging import configure_dependency_logging
 
@@ -157,8 +171,8 @@ def validate_environment() -> None:
                     error_text.append("• ", style="white")
                     error_text.append("STRIX_REASONING_EFFORT", style="bold cyan")
                     error_text.append(
-                        " - Reasoning effort level: none, minimal, low, medium, high, xhigh, "
-                        "max (default: high)\n",
+                        " - Reasoning effort level: none, minimal, low, medium, high, xhigh "
+                        "(default: high)\n",
                         style="white",
                     )
 
@@ -296,18 +310,6 @@ def _subscription_error_hint(exc: BaseException) -> str | None:
 
 
 async def warm_up_llm(show_model_warning: bool = True) -> None:
-    from agents.model_settings import ModelSettings
-    from agents.models.interface import ModelTracing
-
-    from strix.config.models import (
-        RECOMMENDED_MODEL_NAMES,
-        StrixProvider,
-        configure_sdk_model_defaults,
-        is_known_openai_bare_model,
-        is_recommended_or_frontier_model,
-    )
-    from strix.core.inputs import make_model_settings
-
     console = Console()
     logger.info("Warming up LLM connection")
 
@@ -380,13 +382,7 @@ async def warm_up_llm(show_model_warning: bool = True) -> None:
             model.get_response(
                 system_instructions="You are a helpful assistant.",
                 input="Reply with just 'OK'.",
-                model_settings=make_model_settings(
-                    None,
-                    model_name=raw_model,
-                    request_timeout=llm.timeout,
-                    prompt_cache=False,
-                    extra_headers=llm.extra_headers,
-                ),
+                model_settings=ModelSettings(),
                 tools=[],
                 output_schema=None,
                 handoffs=[],
@@ -408,19 +404,7 @@ async def warm_up_llm(show_model_warning: bool = True) -> None:
             # Match the runtime path: send the dedupe key/endpoint per call so a
             # separate-provider dedupe model authenticates during warm-up too.
             deduper_extra = _dedupe_extra_args(settings.dedupe)
-            # A dedicated dedupe model may route to another provider, which must
-            # never receive the main endpoint's headers; it has its own
-            # DEDUPE_LLM_EXTRA_HEADERS.
-            deduper_settings = make_model_settings(
-                None,
-                model_name=dedupe_model,
-                request_timeout=llm.timeout,
-                prompt_cache=False,
-                extra_headers=settings.dedupe.extra_headers,
-            )
-            if deduper_extra:
-                merged = {**(deduper_settings.extra_args or {}), **deduper_extra}
-                deduper_settings = deduper_settings.resolve(ModelSettings(extra_args=merged))
+            deduper_settings = ModelSettings(extra_args=deduper_extra or None)
             await asyncio.wait_for(
                 deduper.get_response(
                     system_instructions="You are a helpful assistant.",
@@ -792,8 +776,6 @@ Examples:
 
 
 def _persist_run_record(args: argparse.Namespace) -> None:
-    from strix.report.writer import write_run_record
-
     run_dir = run_dir_for(args.run_name)
     run_dir.mkdir(parents=True, exist_ok=True)
     run_record = {
@@ -817,8 +799,6 @@ def _persist_run_record(args: argparse.Namespace) -> None:
 
 def _load_resume_state(args: argparse.Namespace, parser: argparse.ArgumentParser) -> None:
     """Populate ``args.targets_info`` and friends from a prior run's run.json."""
-    from strix.report.writer import read_run_record
-
     run_dir = run_dir_for(args.resume)
     state_path = run_dir / "run.json"
     if not state_path.exists():
@@ -863,8 +843,6 @@ def _load_resume_state(args: argparse.Namespace, parser: argparse.ArgumentParser
 
 
 def display_completion_message(args: argparse.Namespace, results_path: Path) -> None:
-    from strix.report.state import get_global_report_state
-
     console = Console()
     report_state = get_global_report_state()
 
@@ -944,8 +922,6 @@ def display_completion_message(args: argparse.Namespace, results_path: Path) ->
 
 
 def pull_docker_image() -> None:
-    from docker.errors import DockerException
-
     console = Console()
     client = check_docker_connection()
 
@@ -1092,17 +1068,11 @@ def main() -> None:
     posthog.start(**_telemetry_start_kwargs)
     scarf.start(**_telemetry_start_kwargs)
 
-    from strix.report.state import get_global_report_state
-
     exit_reason = "user_exit"
     try:
         if args.non_interactive:
-            from strix.interface.cli import run_cli
-
             asyncio.run(run_cli(args))
         else:
-            from strix.interface.tui import run_tui
-
             asyncio.run(run_tui(args))
     except KeyboardInterrupt:
         exit_reason = "interrupted"

strix/interface/tui/app.py

@@ -15,7 +15,6 @@ from typing import TYPE_CHECKING, Any, ClassVar
 
 
 if TYPE_CHECKING:
-    from pygments.token import _TokenType
     from textual.timer import Timer
 
 from rich.align import Align
@@ -34,8 +33,8 @@ from textual.widgets.tree import TreeNode
 
 from strix.config import load_settings
 from strix.config.models import is_recommended_or_frontier_model
-from strix.config.settings import DEFAULT_MAX_TURNS
 from strix.core.hooks import BudgetExceededError
+from strix.core.inputs import DEFAULT_MAX_TURNS
 from strix.core.runner import run_strix_scan
 from strix.interface.tui.live_view import TuiLiveView
 from strix.interface.tui.messages import send_user_message_to_agent
@@ -353,7 +352,7 @@ class VulnerabilityDetailScreen(ModalScreen):  # type: ignore[misc]
                 if not token_value:
                     continue
                 color = None
-                tt: _TokenType | None = token_type
+                tt = token_type
                 while tt:
                     if tt in colors:
                         color = colors[tt]
@@ -1041,9 +1040,9 @@ class StrixTUIApp(App):  # type: ignore[misc]
                             name=names.get(agent_id, agent_id),
                             parent_id=parent_of.get(agent_id),
                             status=status,
-                            error_message=error or "",
+                            error_message=error,
                         )
-                        if error:
+                        if status in {"failed", "crashed"} and error:
                             if agent_id not in self._error_noted_agents:
                                 self._error_noted_agents.add(agent_id)
                                 self.live_view.record_agent_error(agent_id, error)
@@ -1293,10 +1292,6 @@ class StrixTUIApp(App):  # type: ignore[misc]
                 text.append("Send a message to continue", style="dim")
                 keymap = keymap_styled([("ctrl-q", "quit")])
             else:
-                error_msg = agent_data.get("error_message") or ""
-                if error_msg:
-                    text.append(error_msg, style="red")
-                    text.append(" \u00b7 ", style="dim")
                 text.append("Send message to resume", style="dim")
             return (text, keymap, False)
 

strix/interface/tui/live_view.py

@@ -82,7 +82,7 @@ class TuiLiveView:
             current["parent_id"] = parent_id
         if status is not None:
             current["status"] = status
-        if error_message is not None:
+        if error_message:
             current["error_message"] = error_message
         current["updated_at"] = now
 

strix/interface/tui/renderers/__init__.py

@@ -6,7 +6,6 @@ from . import (
     notes_renderer,
     proxy_renderer,
     reporting_renderer,
-    respond_renderer,
     shell_renderer,
     thinking_renderer,
     todo_renderer,
@@ -24,7 +23,6 @@ __all__ = [
     "proxy_renderer",
     "render_tool_widget",
     "reporting_renderer",
-    "respond_renderer",
     "shell_renderer",
     "thinking_renderer",
     "todo_renderer",

strix/interface/tui/renderers/agents_graph_renderer.py

@@ -117,8 +117,8 @@ class AgentFinishRenderer(BaseToolRenderer):
 
 
 @register_tool_renderer
-class WaitForAgentsRenderer(BaseToolRenderer):
-    tool_name: ClassVar[str] = "wait_for_agents"
+class WaitForMessageRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "wait_for_message"
     css_classes: ClassVar[list[str]] = ["tool-call", "agents-graph-tool"]
 
     @classmethod

strix/interface/tui/renderers/respond_renderer.py

@@ -1,35 +0,0 @@
-from typing import Any, ClassVar
-
-from rich.text import Text
-from textual.widgets import Static
-
-from .agent_message_renderer import AgentMessageRenderer
-from .base_renderer import BaseToolRenderer
-from .registry import register_tool_renderer
-
-
-@register_tool_renderer
-class RespondToUserRenderer(BaseToolRenderer):
-    """Render a reply as the agent's own prose, not as a tool call.
-
-    ``respond_to_user`` carries the message the user is meant to read, so it
-    gets the same markdown treatment as a plain assistant turn.
-    """
-
-    tool_name: ClassVar[str] = "respond_to_user"
-    css_classes: ClassVar[list[str]] = ["tool-call", "respond-tool"]
-
-    @classmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:
-        args = tool_data.get("args", {})
-        message = args.get("message", "")
-
-        text = Text()
-        if message:
-            text.append_text(AgentMessageRenderer.render_simple(message))
-            text.append("\n\n")
-        text.append("○ ", style="#6b7280")
-        text.append("waiting for your reply", style="dim")
-
-        css_classes = cls.get_css_classes(tool_data.get("status", "unknown"))
-        return Static(text, classes=css_classes)

strix/interface/viewer/frontend/src/components/live/tool-renderers/AgentCommsRenderer.tsx

@@ -54,7 +54,7 @@ export default function AgentCommsRenderer({ toolName, args }: ToolRendererProps
     );
   }
 
-  if (toolName === "wait_for_agents") {
+  if (toolName === "wait_for_message") {
     const reason = (args.reason as string) ?? "";
     return (
       <div className="flex items-center gap-2">

strix/interface/viewer/frontend/src/components/live/tool-renderers/RespondRenderer.tsx

@@ -1,20 +0,0 @@
-"use client";
-
-import type { ToolRendererProps } from "@/types/events";
-import Markdown from "./Markdown";
-
-/**
- * `respond_to_user` carries the message the user is meant to read, so it renders
- * as the agent's own prose rather than as a tool call.
- */
-export default function RespondRenderer({ args }: ToolRendererProps) {
-  const message = (args.message as string) ?? "";
-  if (!message) return null;
-
-  return (
-    <div>
-      <Markdown text={message} />
-      <div className="mt-1.5 text-[#888] text-[13px]">waiting for your reply</div>
-    </div>
-  );
-}

strix/interface/viewer/frontend/src/components/live/tool-renderers/index.ts

@@ -24,7 +24,6 @@ import NotesRenderer from "./NotesRenderer";
 import TodoRenderer from "./TodoRenderer";
 import FallbackRenderer from "./FallbackRenderer";
 import LoadSkillRenderer from "./LoadSkillRenderer";
-import RespondRenderer from "./RespondRenderer";
 
 /**
  * Tool-renderer mapping — data-driven, keyed by the engine's tool *family*.
@@ -105,10 +104,10 @@ const CATEGORY_TOOLS: Record<ToolCategory, readonly string[]> = {
   proxy: ["list_requests", "view_request", "repeat_request", "list_sitemap", "view_sitemap_entry", "scope_rules", "send_request"],
   reporting: ["create_vulnerability_report", "list_reports", "get_report"],
   thinking: ["think"],
-  agents: ["create_agent", "agent_finish", "send_message_to_agent", "wait_for_agents", "view_agent_graph", "stop_agent"],
+  agents: ["create_agent", "agent_finish", "send_message_to_agent", "wait_for_message", "view_agent_graph", "stop_agent"],
   search: ["web_search"],
   // scan_start_info / subagent_start_info are strix-app synthetic events; finish_scan is the engine's
-  lifecycle: ["scan_start_info", "subagent_start_info", "finish_scan", "respond_to_user"],
+  lifecycle: ["scan_start_info", "subagent_start_info", "finish_scan"],
   notes: ["create_note", "delete_note", "update_note", "list_notes", "get_note"],
   skills: ["load_skill"],
   todos: ["create_todo", "list_todos", "update_todo", "mark_todo_done", "mark_todo_pending", "delete_todo"],
@@ -128,7 +127,6 @@ const TOOL_CATEGORY: Record<string, ToolCategory> = Object.fromEntries(
  */
 const RENDERER_OVERRIDES: Partial<Record<string, ComponentType<ToolRendererProps>>> = {
   finish_scan: FinishRenderer,
-  respond_to_user: RespondRenderer,
   apply_patch: ApplyPatchRenderer,
   view_image: ViewImageRenderer,
   list_reports: ReportListRenderer,
@@ -142,8 +140,7 @@ const RENDERER_OVERRIDES: Partial<Record<string, ComponentType<ToolRendererProps
 const ICON_OVERRIDES: Partial<Record<string, ToolIconMeta>> = {
   agent_finish: { icon: Flag, color: "text-cyan-400" },
   send_message_to_agent: { icon: MessageCircle, color: "text-cyan-400" },
-  wait_for_agents: { icon: MessageCircle, color: "text-cyan-400" },
-  respond_to_user: { icon: MessageCircle, color: "text-emerald-400" },
+  wait_for_message: { icon: MessageCircle, color: "text-cyan-400" },
   view_agent_graph: { icon: Eye, color: "text-cyan-400" },
   stop_agent: { icon: Ban, color: "text-red-400" },
   scan_start_info: { icon: Crosshair, color: "text-emerald-400" },

strix/interface/viewer/static/index.html

@@ -6,7 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="color-scheme" content="dark" />
     <title>Strix Results</title>
-    <script type="module" crossorigin src="./assets/index-CGvQq6oe.js"></script>
+    <script type="module" crossorigin src="./assets/index-DzvI_0HX.js"></script>
     <link rel="stylesheet" crossorigin href="./assets/index-C3kQ5kk8.css">
   </head>
   <body>

strix/llm/compaction.py

@@ -12,20 +12,15 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any
 
-from agents.model_settings import ModelSettings
-from agents.models.interface import ModelTracing
+import litellm
 from litellm.exceptions import BadRequestError, ContextWindowExceededError
-from openai.types.responses import ResponseOutputMessage, ResponseOutputText
 
 from strix.config import load_settings
-from strix.config.models import StrixProvider
-from strix.core.inputs import make_model_settings
 from strix.core.sessions import replace_session_items, session_write_lock
 from strix.llm.context_budget import context_window, count_tokens, output_limit
 
 
 if TYPE_CHECKING:
-    from agents.items import ModelResponse
     from agents.memory import Session
 
 
@@ -273,53 +268,26 @@ def _checkpoint_item(summary: str) -> dict[str, Any]:
     }
 
 
-def _extract_text(response: ModelResponse) -> str:
-    parts: list[str] = []
-    for item in response.output:
-        if not isinstance(item, ResponseOutputMessage):
-            continue
-        parts.extend(
-            chunk.text
-            for chunk in item.content
-            if isinstance(chunk, ResponseOutputText) and chunk.text
-        )
-    return "".join(parts)
-
-
 async def _summarize(model: str, prompt: str, max_tokens: int) -> str | None:
     llm = load_settings().llm
-    model_settings = make_model_settings(
-        None,
-        model_name=model,
-        request_timeout=llm.timeout,
-        prompt_cache=False,
-        extra_headers=llm.extra_headers,
-    ).resolve(ModelSettings(max_tokens=max_tokens))
     try:
-        response = (
-            await StrixProvider()
-            .get_model(model)
-            .get_response(
-                system_instructions=None,
-                input=prompt,
-                model_settings=model_settings,
-                tools=[],
-                output_schema=None,
-                handoffs=[],
-                tracing=ModelTracing.DISABLED,
-                previous_response_id=None,
-                conversation_id=None,
-                prompt=None,
-            )
+        response = await litellm.acompletion(
+            model=model,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=max_tokens,
+            api_key=llm.api_key,
+            api_base=llm.api_base,
+            timeout=llm.timeout,
         )
     except Exception:
         logger.exception("compaction summary call failed for model %s", model)
         return None
-    content = _extract_text(response).strip()
-    if not content:
+    try:
+        content = response.choices[0].message.content
+    except (AttributeError, IndexError, KeyError):
         logger.warning("compaction summary returned no content")
         return None
-    return content
+    return content.strip() if isinstance(content, str) and content.strip() else None
 
 
 async def maybe_compact(

strix/llm/context_budget.py

@@ -17,14 +17,7 @@ logger = logging.getLogger(__name__)
 
 # LiteLLM keys models without the routing prefix users type (``openai/``,
 # ``litellm/``, ``ollama/`` ...). Strip a leading provider segment on lookup.
-_STRIPPABLE_PREFIXES = (
-    "openai/",
-    "chatgpt/",
-    "litellm/",
-    "any-llm/",
-    "ollama/",
-    "ollama_chat/",
-)
+_STRIPPABLE_PREFIXES = ("openai/", "litellm/", "any-llm/", "ollama/", "ollama_chat/")
 
 _DEFAULT_OUTPUT_TOKENS = 8_192
 
@@ -45,11 +38,7 @@ def _safe_get_model_info(model: str) -> dict[str, Any] | None:
 
 @lru_cache(maxsize=128)
 def _model_info(model: str) -> dict[str, int]:
-    lookup_key = _lookup_key(model)
-    # Provider-qualified ChatGPT lookups may start a synchronous device-login
-    # poll. LiteLLM keys the metadata by the underlying model slug.
-    candidates = (lookup_key,) if model.startswith("chatgpt/") else (model, lookup_key)
-    for candidate in candidates:
+    for candidate in (model, _lookup_key(model)):
         info = _safe_get_model_info(candidate)
         if info is not None:
             return {

strix/report/dedupe.py

@@ -51,24 +51,17 @@ def _dedupe_extra_args(dedupe: DedupeSettings) -> dict[str, str]:
 def _dedupe_model_settings(
     dedupe: DedupeSettings, model_name: str, request_timeout: float | None
 ) -> ModelSettings:
-    llm = load_settings().llm
     settings = make_model_settings(
         dedupe.reasoning_effort,
         model_name=model_name,
         force_required_tool_choice=False,
         request_timeout=request_timeout,
-        # The main model's headers apply only when dedupe falls back to the main
-        # model; a dedicated dedupe model may route to another provider, which
-        # must never receive the main endpoint's credentials. A dedicated model
-        # gets its own DEDUPE_LLM_EXTRA_HEADERS instead.
-        extra_headers=dedupe.extra_headers if dedupe.model else llm.extra_headers,
     )
     extra = _dedupe_extra_args(dedupe)
     if extra:
         settings = settings.resolve(ModelSettings(extra_args=extra))
     return settings
 
-
 DEDUPE_SYSTEM_PROMPT = """You are an expert vulnerability report deduplication judge.
 Your task is to determine if a candidate vulnerability report describes the SAME vulnerability
 as any existing report.
@@ -354,7 +347,9 @@ async def check_duplicate(
         response = await model.get_response(
             system_instructions=DEDUPE_SYSTEM_PROMPT,
             input=user_msg,
-            model_settings=_dedupe_model_settings(dedupe, resolved_model, settings.llm.timeout),
+            model_settings=_dedupe_model_settings(
+                dedupe, resolved_model, settings.llm.timeout
+            ),
             tools=[],
             output_schema=None,
             handoffs=[],

strix/runtime/docker_client.py

@@ -110,19 +110,6 @@ def _apply_log_limits(create_kwargs: dict[str, Any]) -> None:
     )
 
 
-def _apply_run_labels(create_kwargs: dict[str, Any]) -> None:
-    run_id = os.getenv("STRIX_RUN_ID")
-    if not run_id:
-        return
-    labels = create_kwargs.setdefault("labels", {})
-    if not isinstance(labels, dict):
-        return
-    labels["strix-run-id"] = run_id
-    run_type = os.getenv("STRIX_RUN_TYPE")
-    if run_type:
-        labels["strix-run-type"] = run_type
-
-
 class StrixDockerSandboxSession(DockerSandboxSession):
     sandbox_network: str = ""
 
@@ -235,7 +222,6 @@ class StrixDockerSandboxClient(DockerSandboxClient):
         _apply_sandbox_network(create_kwargs)
         _apply_resource_limits(create_kwargs)
         _apply_log_limits(create_kwargs)
-        _apply_run_labels(create_kwargs)
 
         # Strix injection: host bind mounts (e.g. large repos passed via --mount)
         # that bypass the SDK's file-by-file LocalDir copy.

strix/telemetry/logging.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import contextlib
 import logging
 import os
-import sys
 import warnings
 from contextvars import ContextVar
 from pathlib import Path  # noqa: TC003  used at runtime by ``setup_scan_logging``
@@ -79,10 +78,11 @@ class _StdoutQuietFilter(logging.Filter):
 
 def configure_dependency_logging() -> None:
     """Quiet dependency logging/warnings that obscure Strix scan logs."""
-    litellm = sys.modules.get("litellm")
-    if litellm is not None:
-        with contextlib.suppress(Exception):
-            litellm._logging._disable_debugging()
+    with contextlib.suppress(Exception):
+        import litellm
+
+        litellm_logging = litellm._logging
+        litellm_logging._disable_debugging()  # type: ignore[no-untyped-call]
 
     logging.getLogger("asyncio").setLevel(logging.CRITICAL)
     logging.getLogger("asyncio").propagate = False

strix/tools/agents_graph/tools.py

@@ -13,7 +13,6 @@ from typing import Any, Literal, get_args
 from agents import RunContextWrapper, function_tool
 
 from strix.core.agents import Status, coordinator_from_context
-from strix.core.execution import notify_parent_on_terminal
 from strix.skills import validate_requested_skills
 
 
@@ -219,43 +218,25 @@ def _session_items_payload(items: list[Any]) -> list[dict[str, Any]]:
     return payload
 
 
-_WAIT_DEFAULT_TIMEOUT_S = 300
-# Enforced by the SDK around the whole tool call, so it caps an oversized
-# ``timeout_seconds`` the model asks for. One second of headroom lets the
-# tool's own timeout fire first and return a clean result.
-_WAIT_HARD_CEILING_S = _WAIT_DEFAULT_TIMEOUT_S + 1
-
-
-@function_tool(timeout=_WAIT_HARD_CEILING_S)
-async def wait_for_agents(  # noqa: PLR0911
+@function_tool(timeout=601)
+async def wait_for_message(  # noqa: PLR0911
     ctx: RunContextWrapper,
     reason: str = "Waiting for messages from other agents",
-    timeout_seconds: int = _WAIT_DEFAULT_TIMEOUT_S,
+    timeout_seconds: int = 600,
 ) -> str:
-    """Pause until another AGENT messages you (or the timeout elapses).
+    """Pause this agent until a message lands in its inbox (or timeout).
 
-    Use when you have nothing useful to do until a child or peer
-    responds — typically after spawning subagents and you want their
-    completion reports. You resume the instant any message arrives, so
-    size ``timeout_seconds`` to the work you're awaiting.
-
-    **This tool is only for waiting on other agents.** Two things it is
-    NOT for:
-
-    - **Talking to the user.** Use ``respond_to_user``, which delivers
-      your message and hands control back in one call.
-    - **Waiting for a long-running command.** This tool does not watch
-      processes at all — it sleeps until a *message* arrives, so it
-      burns the full timeout even if your command finished a second
-      later. Poll the process instead: ``exec_command`` returns a
-      session/process id, and ``write_stdin`` with ``chars=""`` returns
-      as soon as there is new output or the process exits.
+    Use when you have nothing useful to do until a child/peer responds
+    — typically after spawning subagents and you want to wait for
+    their completion reports. The agent automatically resumes when any
+    message arrives, so pick a ``timeout_seconds`` proportional to the
+    work you're awaiting.
 
     **Critical caveats:**
 
-    - **Never** call this if you have no agents left to hear from —
-      that just strands you until the timeout. Call ``finish_scan``
-      (root) or ``agent_finish`` (subagent) instead.
+    - **Never** call this if you finished your own task and have **no**
+      child agents running — that's a permanent stall. Call
+      ``finish_scan`` (root) or ``agent_finish`` (subagent) instead.
     - If you're waiting on an agent that **isn't your child**, message
       it first asking it to ping you when done — otherwise it has no
       reason to send to your inbox and you'll wait the full timeout.
@@ -266,8 +247,7 @@ async def wait_for_agents(  # noqa: PLR0911
         reason: One-line note shown in graph snapshots while you're
             waiting (helps a human or sibling agent debug who's stuck
             on what).
-        timeout_seconds: Max seconds to wait (default 300, and values above
-            that are cut short by a hard ceiling). This is only
+        timeout_seconds: Max seconds to wait (default 600). This is only
             a cap — the tool returns the INSTANT a message arrives, so a
             larger value never makes you wait longer when the reply does
             come. Right-size it to what you're waiting on: a short wait
@@ -277,7 +257,9 @@ async def wait_for_agents(  # noqa: PLR0911
             bites when the expected message never arrives — so an oversized
             timeout on a trivial wait just strands you idle until it
             elapses. On timeout the tool returns and you decide whether to
-            keep working or wait again.
+            keep working or wait again. (Applies to autonomous multi-agent
+            runs; in interactive/chat sessions the agent instead parks until
+            a message arrives and this cap is not enforced.)
     """
     inner = _ctx(ctx)
     coordinator = coordinator_from_context(inner)
@@ -320,7 +302,7 @@ async def wait_for_agents(  # noqa: PLR0911
         )
 
     if interactive:
-        await coordinator.park_waiting(me, wait_kind="agents")
+        await coordinator.park_waiting(me)
         return json.dumps(
             {
                 "success": True,
@@ -332,7 +314,7 @@ async def wait_for_agents(  # noqa: PLR0911
             default=str,
         )
 
-    await coordinator.park_waiting(me, wait_kind="agents")
+    await coordinator.park_waiting(me)
     try:
         await asyncio.wait_for(coordinator.wait_for_message(me), timeout_seconds)
     except TimeoutError:
@@ -391,7 +373,7 @@ async def create_agent(
 
     Decompose complex pentests by handing focused subtasks to dedicated
     children. The child runs asynchronously — the parent continues
-    immediately and can ``wait_for_agents`` later (or just keep
+    immediately and can ``wait_for_message`` later (or just keep
     working in parallel). When the child calls ``agent_finish``, its
     completion report lands in the parent's inbox.
 
@@ -559,7 +541,7 @@ async def agent_finish(
         )
 
     parent_notified = False
-    if report_to_parent and await coordinator.claim_parent_notice(me):
+    if report_to_parent:
         async with coordinator._lock:
             agent_name = coordinator.names.get(me, me)
         report = _render_completion_report(
@@ -583,11 +565,6 @@ async def agent_finish(
         )
         parent_notified = True
 
-    await coordinator.set_status(me, "completed")
-    if not parent_notified:
-        # Silence here would leave a parent waiting on a report that is never coming.
-        await notify_parent_on_terminal(coordinator, me, "completed")
-
     logger.info(
         "agent_finish: %s success=%s findings=%d parent_notified=%s",
         me,
@@ -595,6 +572,7 @@ async def agent_finish(
         len(findings or []),
         parent_notified,
     )
+    await coordinator.set_status(me, "completed")
 
     return json.dumps(
         {
@@ -685,16 +663,9 @@ async def stop_agent(
         )
 
     if cascade:
-        stopped = await coordinator.cancel_descendants_graceful(target_agent_id)
+        await coordinator.cancel_descendants_graceful(target_agent_id)
     else:
         await coordinator.request_stop(target_agent_id)
-        stopped = [target_agent_id]
-
-    # The stopper knows what it just did; anyone else waiting on those agents does not.
-    async with coordinator._lock:
-        orphaned = [aid for aid in stopped if coordinator.parent_of.get(aid) not in (None, me)]
-    for aid in orphaned:
-        await notify_parent_on_terminal(coordinator, aid, "stopped")
 
     logger.info(
         "stop_agent: target=%s cascade=%s reason=%r",

strix/tools/finish/tool.py

@@ -101,7 +101,7 @@ async def finish_scan(
     execution stops. There is no draft mode and no second chance: never
     submit placeholder, provisional, or "checking if done" text in any
     field, and never call ``finish_scan`` to poll whether subagents are
-    done (use ``view_agent_graph`` / ``wait_for_agents`` for that).
+    done (use ``view_agent_graph`` / ``wait_for_message`` for that).
     Call it exactly ONCE, only when every field holds genuine, finished
     assessment prose.
 
@@ -111,7 +111,7 @@ async def finish_scan(
        summary. If ANY agent is in ``running`` / ``waiting`` state,
        you MUST NOT call ``finish_scan`` yet —
        wrap them up first via ``send_message_to_agent`` (ask them to
-       finish), ``wait_for_agents`` (block until their report
+       finish), ``wait_for_message`` (block until their report
        arrives), or ``stop_agent`` (graceful cancel). Only ``completed``
        / ``crashed`` / ``stopped`` agents are safe to leave behind.
        Calling ``finish_scan`` while children are alive orphans their

strix/tools/respond/__init__.py

@@ -1,6 +0,0 @@
-"""User-facing reply tool for interactive sessions."""
-
-from strix.tools.respond.tool import respond_to_user
-
-
-__all__ = ["respond_to_user"]

strix/tools/respond/tool.py

@@ -1,110 +0,0 @@
-"""``respond_to_user`` — deliver a reply and hand control back to the user."""
-
-from __future__ import annotations
-
-import json
-from typing import Any
-
-from agents import RunContextWrapper, function_tool
-
-from strix.core.agents import coordinator_from_context
-
-
-def _ctx(ctx: RunContextWrapper) -> dict[str, Any]:
-    return ctx.context if isinstance(ctx.context, dict) else {}
-
-
-@function_tool
-async def respond_to_user(ctx: RunContextWrapper, message: str) -> str:
-    """Answer the user and hand control back to them.
-
-    This is the ONLY way to yield to the user. Delivering the message and
-    yielding are the same call on purpose: there is no way to answer and
-    then forget to stop, and no way to stop without having answered.
-
-    Call it when you have something for the user and nothing to do until
-    they reply — you answered their question, you need a decision or a
-    credential only they can give, or you finished a chunk of work and
-    want direction. You resume exactly where you left off when they
-    reply, with everything you have done so far intact.
-
-    Do NOT call it to narrate progress or to think out loud. Plain text
-    is still shown to the user as you work, so say whatever you like
-    mid-task without stopping; ``respond_to_user`` is specifically the
-    act of *waiting* for them. Every call costs the user their attention.
-
-    Not for these:
-
-    - **Waiting on another agent** (a child's report, a peer's reply) —
-      use ``wait_for_agents``.
-    - **Ending the engagement** — use ``finish_scan`` (root) or
-      ``agent_finish`` (subagent). Those are terminal; this is a pause.
-
-    Args:
-        message: What to say to the user. Self-contained: they may not
-            have followed the tool calls that led here. Lead with the
-            answer or the decision you need, and if you are blocked, say
-            exactly what you need from them.
-    """
-    inner = _ctx(ctx)
-    coordinator = coordinator_from_context(inner)
-    me = inner.get("agent_id")
-    interactive = bool(inner.get("interactive", False))
-
-    if coordinator is None or me is None:
-        return json.dumps(
-            {"success": False, "error": "Agent coordinator or agent_id missing in context"},
-            ensure_ascii=False,
-            default=str,
-        )
-
-    if not interactive:
-        return json.dumps(
-            {
-                "success": False,
-                "error": (
-                    "No user is attached to an autonomous run. Keep working, and call "
-                    "finish_scan (root) or agent_finish (subagent) when the task is done."
-                ),
-            },
-            ensure_ascii=False,
-            default=str,
-        )
-
-    async with coordinator._lock:
-        stopped = coordinator.statuses.get(me) == "stopped"
-    if stopped:
-        return json.dumps(
-            {"success": True, "wait_outcome": "stopped", "message": message},
-            ensure_ascii=False,
-            default=str,
-        )
-
-    # A message that arrived while this turn was running is the user already
-    # talking: take it now instead of parking for one they have sent.
-    pending, _ = await coordinator.consume_pending(me)
-    if pending > 0:
-        await coordinator.mark_running(me)
-        return json.dumps(
-            {
-                "success": True,
-                "wait_outcome": "message_arrived",
-                "pending_messages": pending,
-                "message": message,
-                "note": "Your reply was delivered; the user had already sent a new message.",
-            },
-            ensure_ascii=False,
-            default=str,
-        )
-
-    await coordinator.park_waiting(me, wait_kind="user")
-    return json.dumps(
-        {
-            "success": True,
-            "wait_outcome": "waiting",
-            "message": message,
-            "note": "Reply delivered; parked until the user responds.",
-        },
-        ensure_ascii=False,
-        default=str,
-    )

tests/test_agent_factory_tool_arguments.py

@@ -1,124 +0,0 @@
-"""Tests for tool-argument shape coercion in the agent factory."""
-
-from __future__ import annotations
-
-import json
-from typing import Any, cast
-
-import pytest
-from agents.tool import FunctionTool
-
-from strix.agents import factory
-
-
-def _capturing_tool(captured: dict[str, str], schema: dict[str, Any]) -> FunctionTool:
-    async def invoke(_ctx: Any, raw_input: str) -> str:
-        captured["raw_input"] = raw_input
-        return "ok"
-
-    return FunctionTool(
-        name="probe",
-        description="test tool",
-        params_json_schema={"type": "object", "properties": schema},
-        on_invoke_tool=invoke,
-    )
-
-
-async def _roundtrip(schema: dict[str, Any], payload: dict[str, Any]) -> dict[str, Any]:
-    captured: dict[str, str] = {}
-    wrapped = factory._with_coerced_arguments(_capturing_tool(captured, schema))
-    assert await wrapped.on_invoke_tool(cast("Any", None), json.dumps(payload)) == "ok"
-    return cast("dict[str, Any]", json.loads(captured["raw_input"]))
-
-
-_STRING = {"todos": {"type": "string"}}
-_ARRAY = {"tags": {"type": "array", "items": {"type": "string"}}}
-_NULLABLE_ARRAY = {
-    "tags": {"anyOf": [{"type": "array", "items": {"type": "string"}}, {"type": "null"}]}
-}
-_OBJECT = {"modifications": {"type": "object"}}
-
-
-@pytest.mark.asyncio
-async def test_structured_value_is_encoded_for_a_string_parameter() -> None:
-    parsed = await _roundtrip(_STRING, {"todos": [{"title": "Phase 1: recon"}]})
-
-    assert parsed["todos"] == '[{"title": "Phase 1: recon"}]'
-
-
-@pytest.mark.asyncio
-async def test_string_parameter_keeps_an_already_encoded_value() -> None:
-    parsed = await _roundtrip(_STRING, {"todos": '[{"title": "a"}]'})
-
-    assert parsed["todos"] == '[{"title": "a"}]'
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("schema", [_ARRAY, _NULLABLE_ARRAY])
-async def test_encoded_list_is_decoded_for_an_array_parameter(schema: dict[str, Any]) -> None:
-    parsed = await _roundtrip(schema, {"tags": '["auth", "idor"]'})
-
-    assert parsed["tags"] == ["auth", "idor"]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "value",
-    [
-        "auth, idor",
-        "auth\nidor",
-        "auth",
-        "Endpoint /admin leaks user data, and session tokens never expire",
-        '"auth"',
-        "",
-    ],
-)
-async def test_free_form_strings_are_never_split_into_an_array(value: str) -> None:
-    parsed = await _roundtrip(_ARRAY, {"tags": value})
-
-    assert parsed["tags"] == value
-
-
-@pytest.mark.asyncio
-async def test_encoded_mapping_is_decoded_for_an_object_parameter() -> None:
-    parsed = await _roundtrip(_OBJECT, {"modifications": '{"method": "POST"}'})
-
-    assert parsed["modifications"] == {"method": "POST"}
-
-
-@pytest.mark.asyncio
-async def test_a_decoded_container_of_the_wrong_kind_is_not_substituted() -> None:
-    parsed = await _roundtrip(_OBJECT, {"modifications": '["POST"]'})
-
-    assert parsed["modifications"] == '["POST"]'
-
-
-@pytest.mark.asyncio
-async def test_values_matching_the_schema_are_left_alone() -> None:
-    parsed = await _roundtrip({**_ARRAY, **_OBJECT}, {"tags": ["auth"], "modifications": {"a": 1}})
-
-    assert parsed == {"tags": ["auth"], "modifications": {"a": 1}}
-
-
-@pytest.mark.asyncio
-async def test_unknown_and_null_arguments_are_untouched() -> None:
-    parsed = await _roundtrip(_NULLABLE_ARRAY, {"tags": None, "other": ["x"]})
-
-    assert parsed == {"tags": None, "other": ["x"]}
-
-
-@pytest.mark.asyncio
-async def test_non_object_payloads_pass_through_unchanged() -> None:
-    captured: dict[str, str] = {}
-    wrapped = factory._with_coerced_arguments(_capturing_tool(captured, _ARRAY))
-
-    assert await wrapped.on_invoke_tool(cast("Any", None), "not json") == "ok"
-    assert captured["raw_input"] == "not json"
-
-
-@pytest.mark.asyncio
-async def test_coercion_is_applied_once_per_tool() -> None:
-    captured: dict[str, str] = {}
-    tool = factory._with_coerced_arguments(_capturing_tool(captured, _ARRAY))
-
-    assert factory._with_coerced_arguments(tool) is tool

tests/test_agent_tool_registration.py

@@ -2,29 +2,18 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
-
 import pytest
 from agents.tool import FunctionTool
 
 from strix.agents import factory
 
 
-if TYPE_CHECKING:
-    from agents.tool_context import ToolContext
-
-
 def _tool(name: str) -> FunctionTool:
-    # A per-tool closure keeps two same-named tools unequal, which is what the
-    # duplicate-name tests exercise.
-    async def invoke(_ctx: ToolContext[Any], _input: str) -> str:
-        return "ok"
-
     return FunctionTool(
         name=name,
         description="test tool",
         params_json_schema={"type": "object", "properties": {}, "additionalProperties": False},
-        on_invoke_tool=invoke,
+        on_invoke_tool=lambda _ctx, _inp: "ok",
     )
 
 
@@ -97,18 +86,3 @@ def test_no_override_renders_builtin_prompt() -> None:
 
     assert isinstance(agent.instructions, str)
     assert agent.instructions != ""
-
-
-def test_respond_to_user_is_interactive_only() -> None:
-    """Yielding to the user is meaningless when no user is attached."""
-    interactive = factory.build_strix_agent(is_root=True, interactive=True)
-    autonomous = factory.build_strix_agent(is_root=True, interactive=False)
-
-    assert "respond_to_user" in [t.name for t in interactive.tools]
-    assert "respond_to_user" not in [t.name for t in autonomous.tools]
-
-
-def test_wait_for_agents_is_available_in_both_modes() -> None:
-    for interactive in (True, False):
-        agent = factory.build_strix_agent(is_root=True, interactive=interactive)
-        assert "wait_for_agents" in [t.name for t in agent.tools]

tests/test_compaction.py

@@ -7,7 +7,6 @@ from typing import TYPE_CHECKING, Any
 
 import pytest
 from litellm.exceptions import BadRequestError, ContextWindowExceededError, RateLimitError
-from openai.types.responses import ResponseOutputMessage, ResponseOutputText
 
 from strix.config import ContextSettings
 from strix.llm import compaction
@@ -147,35 +146,17 @@ def _patch_budget(monkeypatch: pytest.MonkeyPatch, *, keep_tokens: int, window:
     context.auto_compact = True
     settings = SimpleNamespace(
         context=context,
-        llm=SimpleNamespace(api_key=None, api_base=None, timeout=1, extra_headers=None),
+        llm=SimpleNamespace(api_key=None, api_base=None, timeout=1),
     )
     monkeypatch.setattr(compaction, "load_settings", lambda: settings)
 
 
-def _model_response(text: str) -> Any:
-    chunk = ResponseOutputText(annotations=[], text=text, type="output_text")
-    message = ResponseOutputMessage(
-        id="msg", content=[chunk], role="assistant", status="completed", type="message"
-    )
-    return SimpleNamespace(output=[message])
+def _patch_summary(monkeypatch: pytest.MonkeyPatch, text: str) -> None:
+    async def fake_acompletion(**_kwargs: Any) -> Any:
+        message = SimpleNamespace(content=text)
+        return SimpleNamespace(choices=[SimpleNamespace(message=message)])
 
-
-def _patch_summary(
-    monkeypatch: pytest.MonkeyPatch, text: str, captured: dict[str, Any] | None = None
-) -> None:
-    class FakeModel:
-        async def get_response(self, **kwargs: Any) -> Any:
-            if captured is not None:
-                captured.update(kwargs)
-            return _model_response(text)
-
-    class FakeProvider:
-        def get_model(self, model_name: str | None) -> Any:
-            if captured is not None:
-                captured["model"] = model_name
-            return FakeModel()
-
-    monkeypatch.setattr(compaction, "StrixProvider", FakeProvider)
+    monkeypatch.setattr("strix.llm.compaction.litellm.acompletion", fake_acompletion)
 
 
 @pytest.mark.asyncio
@@ -208,38 +189,19 @@ async def test_maybe_compact_rewrites_and_keeps_pairs(monkeypatch: pytest.Monkey
 async def test_maybe_compact_updates_previous_summary(monkeypatch: pytest.MonkeyPatch) -> None:
     # Window large enough to leave real room for the summary instructions.
     _patch_budget(monkeypatch, keep_tokens=30, window=4_000)
-    captured: dict[str, Any] = {}
-    _patch_summary(monkeypatch, "NEW", captured)
+    captured: dict[str, str] = {}
+
+    async def fake_acompletion(**kwargs: Any) -> Any:
+        captured["prompt"] = kwargs["messages"][0]["content"]
+        return SimpleNamespace(choices=[SimpleNamespace(message=SimpleNamespace(content="NEW"))])
+
+    monkeypatch.setattr("strix.llm.compaction.litellm.acompletion", fake_acompletion)
 
     prior = compaction._checkpoint_item("OLD SUMMARY TEXT")
     session = FakeSession([prior, *_turns(12)])
 
     assert await compaction.maybe_compact(session, model="m", force=True) is True
-    assert "OLD SUMMARY TEXT" in captured["input"]
-
-
-@pytest.mark.asyncio
-async def test_summarize_routes_through_provider_with_settings(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    _patch_budget(monkeypatch, keep_tokens=30, window=4_000)
-    monkeypatch.setattr(
-        compaction,
-        "load_settings",
-        lambda: SimpleNamespace(
-            llm=SimpleNamespace(
-                api_key=None, api_base=None, timeout=1, extra_headers={"X-Feature-Key": "svc"}
-            )
-        ),
-    )
-    captured: dict[str, Any] = {}
-    _patch_summary(monkeypatch, "S", captured)
-
-    assert await compaction._summarize("litellm/openai/some-model", "p", 64) == "S"
-    assert captured["model"] == "litellm/openai/some-model"
-    settings = captured["model_settings"]
-    assert settings.extra_headers == {"X-Feature-Key": "svc"}
-    assert settings.max_tokens == 64
+    assert "OLD SUMMARY TEXT" in captured["prompt"]
 
 
 def test_fit_to_tokens_truncates_oversized_text(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -271,14 +233,19 @@ def test_summary_output_tokens_capped_at_model_limit(monkeypatch: pytest.MonkeyP
 async def test_maybe_compact_bounds_summary_prompt(monkeypatch: pytest.MonkeyPatch) -> None:
     # A tiny window with a huge head must not send an oversized summary request.
     _patch_budget(monkeypatch, keep_tokens=30, window=4_000)
-    captured: dict[str, Any] = {}
-    _patch_summary(monkeypatch, "S", captured)
+    captured: dict[str, str] = {}
+
+    async def fake_acompletion(**kwargs: Any) -> Any:
+        captured["prompt"] = kwargs["messages"][0]["content"]
+        return SimpleNamespace(choices=[SimpleNamespace(message=SimpleNamespace(content="S"))])
+
+    monkeypatch.setattr("strix.llm.compaction.litellm.acompletion", fake_acompletion)
     big_turns = [{"role": "user", "content": "y" * 2_000} for _ in range(50)]
     session = FakeSession(big_turns)
 
     assert await compaction.maybe_compact(session, model="m") is True
     # count_tokens==len(chars); prompt must fit the model window.
-    assert len(captured["input"]) <= 4_000
+    assert len(captured["prompt"]) <= 4_000
 
 
 @pytest.mark.asyncio
@@ -289,27 +256,27 @@ async def test_summary_request_fits_when_room_is_below_old_floor(
     instructions = len(compaction._SUMMARY_INSTRUCTIONS)
     window = instructions + 64 + 256 + 300  # summary_max(64)+slack(256)+room(300)
     _patch_budget(monkeypatch, keep_tokens=30, window=window)
-    captured: dict[str, Any] = {}
-    _patch_summary(monkeypatch, "S", captured)
+    captured: dict[str, str] = {}
+
+    async def fake_acompletion(**kwargs: Any) -> Any:
+        captured["prompt"] = kwargs["messages"][0]["content"]
+        return SimpleNamespace(choices=[SimpleNamespace(message=SimpleNamespace(content="S"))])
+
+    monkeypatch.setattr("strix.llm.compaction.litellm.acompletion", fake_acompletion)
     session = FakeSession([{"role": "user", "content": "y" * 5_000} for _ in range(20)])
 
     assert await compaction.maybe_compact(session, model="m") is True
-    assert len(captured["input"]) <= window
+    assert len(captured["prompt"]) <= window
 
 
 @pytest.mark.asyncio
 async def test_maybe_compact_skips_when_summary_fails(monkeypatch: pytest.MonkeyPatch) -> None:
     _patch_budget(monkeypatch, keep_tokens=30, window=4_000)
 
-    class BoomModel:
-        async def get_response(self, **_kwargs: Any) -> Any:
-            raise RuntimeError("boom")
+    async def fake_acompletion(**_kwargs: Any) -> Any:
+        raise RuntimeError("boom")
 
-    class BoomProvider:
-        def get_model(self, _model_name: str | None) -> Any:
-            return BoomModel()
-
-    monkeypatch.setattr(compaction, "StrixProvider", BoomProvider)
+    monkeypatch.setattr("strix.llm.compaction.litellm.acompletion", fake_acompletion)
     session = FakeSession(_turns(12))
     before = await session.get_items()
 
@@ -323,11 +290,17 @@ async def test_maybe_compact_skips_when_no_room_to_summarise(
 ) -> None:
     # No room for any head -> no (doomed) summary is attempted.
     _patch_budget(monkeypatch, keep_tokens=30, window=200)
-    captured: dict[str, Any] = {}
-    _patch_summary(monkeypatch, "S", captured)
+    called = False
+
+    async def fake_acompletion(**_kwargs: Any) -> Any:
+        nonlocal called
+        called = True
+        return SimpleNamespace(choices=[SimpleNamespace(message=SimpleNamespace(content="S"))])
+
+    monkeypatch.setattr("strix.llm.compaction.litellm.acompletion", fake_acompletion)
     session = FakeSession(_turns(12))
     before = await session.get_items()
 
     assert await compaction.maybe_compact(session, model="m", force=True) is False
-    assert not captured
+    assert called is False
     assert await session.get_items() == before

tests/test_context_budget.py

@@ -21,24 +21,6 @@ def test_context_window_strips_provider_prefix() -> None:
     assert context_budget.context_window("openai/gpt-4o") == 128_000
 
 
-def test_context_window_chatgpt_prefix_skips_provider_auth(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    context_budget._model_info.cache_clear()
-    calls: list[str] = []
-
-    def _model_info(model: str) -> dict[str, int]:
-        calls.append(model)
-        return {"max_input_tokens": 1_050_000, "max_output_tokens": 128_000}
-
-    monkeypatch.setattr("strix.llm.context_budget.litellm.get_model_info", _model_info)
-    try:
-        assert context_budget.context_window("chatgpt/gpt-5.6-luna") == 1_050_000
-        assert calls == ["gpt-5.6-luna"]
-    finally:
-        context_budget._model_info.cache_clear()
-
-
 def test_context_window_unmapped_uses_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
     context_budget._model_info.cache_clear()
 

tests/test_dedupe_model.py

@@ -44,38 +44,6 @@ def test_dedupe_endpoint_sent_per_call() -> None:
     assert (settings.extra_args or {})["api_key"] == "dedupe-key"
 
 
-def test_dedicated_dedupe_model_uses_own_headers_not_main() -> None:
-    dedupe = DedupeSettings(
-        STRIX_DEDUPE_MODEL="deepseek/cheap",
-        DEDUPE_LLM_EXTRA_HEADERS={"X-Dedupe": "yes"},
-    )
-    settings = _dedupe_model_settings(dedupe, "deepseek/cheap", 300)
-    assert settings.extra_headers == {"X-Dedupe": "yes"}
-
-
-def test_dedicated_dedupe_model_gets_no_main_headers_by_default(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setenv("LLM_EXTRA_HEADERS", json.dumps({"X-Main": "secret"}))
-    loader._cached = None
-    try:
-        dedupe = DedupeSettings(STRIX_DEDUPE_MODEL="deepseek/cheap")
-        settings = _dedupe_model_settings(dedupe, "deepseek/cheap", 300)
-        assert settings.extra_headers is None
-    finally:
-        loader._cached = None
-
-
-def test_fallback_dedupe_inherits_main_headers(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setenv("LLM_EXTRA_HEADERS", json.dumps({"X-Main": "svc"}))
-    loader._cached = None
-    try:
-        settings = _dedupe_model_settings(DedupeSettings(), "openai/main-model", 300)
-        assert settings.extra_headers == {"X-Main": "svc"}
-    finally:
-        loader._cached = None
-
-
 def test_dedupe_defaults_are_empty() -> None:
     settings = DedupeSettings()
     assert settings.model is None

tests/test_disable_streaming.py

@@ -1,326 +0,0 @@
-"""Tests for LLM_DISABLE_STREAMING: serve the streamed run loop without SSE.
-
-A gateway that rejects ``stream:true`` (or delivers SSE unreliably) breaks the
-SDK run loop, which only issues streamed requests. ``_NonStreamingModel`` wraps
-the resolved model so each turn makes one non-streaming ``get_response`` and
-replays the completed result as a single terminal stream event. A local server
-that rejects streamed requests but answers non-streamed ones — including a
-structured tool call — proves the wrapper works where the stock model fails.
-"""
-
-from __future__ import annotations
-
-import json
-import threading
-from http.server import BaseHTTPRequestHandler, HTTPServer
-from typing import TYPE_CHECKING, Any
-
-import pytest
-from agents import Agent, Runner, function_tool
-from agents.model_settings import ModelSettings
-from agents.models.interface import Model, ModelProvider, ModelTracing
-from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
-from agents.run import RunConfig
-from openai import AsyncOpenAI, BadRequestError
-from openai.types.responses import (
-    ResponseCompletedEvent,
-    ResponseFunctionToolCall,
-    ResponseOutputMessage,
-    ResponseOutputText,
-)
-
-from strix.config import codex, loader
-from strix.config.loader import load_settings
-from strix.config.models import StrixProvider, _NonStreamingModel
-
-
-if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Iterator
-
-
-def _tool_call_completion() -> dict[str, Any]:
-    return {
-        "id": "chatcmpl-1",
-        "object": "chat.completion",
-        "created": 0,
-        "model": "gw-model",
-        "choices": [
-            {
-                "index": 0,
-                "finish_reason": "tool_calls",
-                "message": {
-                    "role": "assistant",
-                    "content": None,
-                    "tool_calls": [
-                        {
-                            "id": "call_1",
-                            "type": "function",
-                            "function": {"name": "do_thing", "arguments": '{"n": 1}'},
-                        }
-                    ],
-                },
-            }
-        ],
-        "usage": {"prompt_tokens": 5, "completion_tokens": 2, "total_tokens": 7},
-    }
-
-
-def _text_completion() -> dict[str, Any]:
-    return {
-        "id": "chatcmpl-2",
-        "object": "chat.completion",
-        "created": 0,
-        "model": "gw-model",
-        "choices": [
-            {
-                "index": 0,
-                "finish_reason": "stop",
-                "message": {"role": "assistant", "content": "hello from gateway"},
-            }
-        ],
-        "usage": {"prompt_tokens": 5, "completion_tokens": 3, "total_tokens": 8},
-    }
-
-
-_CAPTURED: dict[str, Any] = {}
-_PAYLOAD: dict[str, dict[str, Any]] = {"value": _tool_call_completion()}
-
-
-class _Handler(BaseHTTPRequestHandler):
-    """A gateway that only speaks non-streaming Chat Completions."""
-
-    def log_message(self, *args: Any) -> None:
-        pass
-
-    def do_POST(self) -> None:
-        length = int(self.headers.get("Content-Length", 0))
-        body = json.loads(self.rfile.read(length) or b"{}")
-        _CAPTURED.clear()
-        _CAPTURED.update(body)
-        if body.get("stream"):
-            payload = json.dumps(
-                {"error": {"message": "streaming is not supported by this endpoint"}}
-            ).encode()
-            self.send_response(400)
-            self.send_header("Content-Type", "application/json")
-            self.send_header("Content-Length", str(len(payload)))
-            self.end_headers()
-            self.wfile.write(payload)
-            return
-        payload = json.dumps(_PAYLOAD["value"]).encode()
-        self.send_response(200)
-        self.send_header("Content-Type", "application/json")
-        self.send_header("Content-Length", str(len(payload)))
-        self.end_headers()
-        self.wfile.write(payload)
-
-
-@pytest.fixture
-def gateway_url() -> Iterator[str]:
-    _PAYLOAD["value"] = _tool_call_completion()
-    server = HTTPServer(("127.0.0.1", 0), _Handler)
-    thread = threading.Thread(target=server.serve_forever, daemon=True)
-    thread.start()
-    try:
-        yield f"http://127.0.0.1:{server.server_address[1]}/v1"
-    finally:
-        server.shutdown()
-        server.server_close()
-
-
-def _model(base_url: str) -> OpenAIChatCompletionsModel:
-    client = AsyncOpenAI(api_key="tok", base_url=base_url)
-    return OpenAIChatCompletionsModel(model="gw-model", openai_client=client)
-
-
-def _call_kwargs() -> dict[str, Any]:
-    return {
-        "system_instructions": "s",
-        "input": "hi",
-        "model_settings": ModelSettings(),
-        "tools": [],
-        "output_schema": None,
-        "handoffs": [],
-        "tracing": ModelTracing.DISABLED,
-        "previous_response_id": None,
-        "conversation_id": None,
-        "prompt": None,
-    }
-
-
-async def _drain(gen: AsyncIterator[Any]) -> list[Any]:
-    return [event async for event in gen]
-
-
-@pytest.mark.asyncio
-async def test_stock_model_streaming_fails_on_non_streaming_gateway(gateway_url: str) -> None:
-    # The stock model issues stream:true and the gateway rejects it.
-    model = _model(gateway_url)
-    with pytest.raises(BadRequestError, match="streaming is not supported"):
-        await _drain(model.stream_response(**_call_kwargs()))
-    assert _CAPTURED["stream"] is True
-
-
-@pytest.mark.asyncio
-async def test_wrapper_streams_tool_call_without_streaming_request(gateway_url: str) -> None:
-    # The wrapper turns the streamed run-loop call into one non-streaming
-    # request and replays the completed result as a terminal stream event.
-    model = _NonStreamingModel(_model(gateway_url))
-    events = await _drain(model.stream_response(**_call_kwargs()))
-
-    assert _CAPTURED.get("stream") is not True
-    assert len(events) == 1
-    completed = events[0]
-    assert isinstance(completed, ResponseCompletedEvent)
-
-    tool_call = completed.response.output[0]
-    assert isinstance(tool_call, ResponseFunctionToolCall)
-    assert tool_call.name == "do_thing"
-    assert json.loads(tool_call.arguments) == {"n": 1}
-
-    assert completed.response.usage is not None
-    assert completed.response.usage.total_tokens == 7
-
-
-@pytest.mark.asyncio
-async def test_wrapper_streams_plain_text(gateway_url: str) -> None:
-    _PAYLOAD["value"] = _text_completion()
-    model = _NonStreamingModel(_model(gateway_url))
-    events = await _drain(model.stream_response(**_call_kwargs()))
-
-    assert _CAPTURED.get("stream") is not True
-    message = events[0].response.output[0]
-    assert isinstance(message, ResponseOutputMessage)
-    text = message.content[0]
-    assert isinstance(text, ResponseOutputText)
-    assert text.text == "hello from gateway"
-
-
-@pytest.mark.asyncio
-async def test_wrapper_get_response_stays_non_streaming(gateway_url: str) -> None:
-    # The non-streaming path is a plain pass-through to the inner model.
-    model = _NonStreamingModel(_model(gateway_url))
-    response = await model.get_response(**_call_kwargs())
-    assert _CAPTURED.get("stream") is not True
-    tool_call = response.output[0]
-    assert isinstance(tool_call, ResponseFunctionToolCall)
-    assert tool_call.name == "do_thing"
-
-
-_TURN_STREAM_FLAGS: list[bool] = []
-
-
-class _MultiTurnHandler(BaseHTTPRequestHandler):
-    """Non-streaming gateway: a tool call on turn 1, a final answer on turn 2."""
-
-    def log_message(self, *args: Any) -> None:
-        pass
-
-    def do_POST(self) -> None:
-        length = int(self.headers.get("Content-Length", 0))
-        body = json.loads(self.rfile.read(length) or b"{}")
-        _TURN_STREAM_FLAGS.append(bool(body.get("stream")))
-        completion = _tool_call_completion() if len(_TURN_STREAM_FLAGS) == 1 else _text_completion()
-        if len(_TURN_STREAM_FLAGS) > 1:
-            completion["choices"][0]["message"]["content"] = "all done"
-        payload = json.dumps(completion).encode()
-        self.send_response(200)
-        self.send_header("Content-Type", "application/json")
-        self.send_header("Content-Length", str(len(payload)))
-        self.end_headers()
-        self.wfile.write(payload)
-
-
-@pytest.fixture
-def multiturn_url() -> Iterator[str]:
-    _TURN_STREAM_FLAGS.clear()
-    server = HTTPServer(("127.0.0.1", 0), _MultiTurnHandler)
-    thread = threading.Thread(target=server.serve_forever, daemon=True)
-    thread.start()
-    try:
-        yield f"http://127.0.0.1:{server.server_address[1]}/v1"
-    finally:
-        server.shutdown()
-        server.server_close()
-
-
-@pytest.mark.asyncio
-async def test_run_loop_executes_tool_and_completes_without_streaming(multiturn_url: str) -> None:
-    # The whole streamed agent loop runs against a non-streaming gateway: the
-    # synthetic terminal event feeds the runner, which executes the tool and
-    # continues the turn until a final answer.
-    calls: list[int] = []
-
-    @function_tool
-    def do_thing(n: int) -> str:
-        calls.append(n)
-        return f"did {n}"
-
-    class _Provider(ModelProvider):
-        def get_model(self, model_name: str | None) -> Model:  # noqa: ARG002
-            return _NonStreamingModel(_model(multiturn_url))
-
-    agent = Agent(name="t", instructions="use the tool", tools=[do_thing], model="gw-model")
-    result = Runner.run_streamed(
-        agent, input="please", run_config=RunConfig(model_provider=_Provider())
-    )
-    async for _ in result.stream_events():
-        pass
-
-    assert calls == [1]  # tool executed with the streamed tool-call args
-    assert result.final_output == "all done"
-    assert len(_TURN_STREAM_FLAGS) == 2  # two turns, both...
-    assert not any(_TURN_STREAM_FLAGS)  # ...issued as non-streaming requests
-
-
-class _DummyModel(Model):
-    async def get_response(self, *args: Any, **kwargs: Any) -> Any:
-        raise NotImplementedError
-
-    def stream_response(self, *args: Any, **kwargs: Any) -> Any:
-        raise NotImplementedError
-
-
-@pytest.fixture
-def _reset_settings(monkeypatch: pytest.MonkeyPatch) -> Iterator[None]:
-    for key in ("STRIX_LLM", "LLM_DISABLE_STREAMING"):
-        monkeypatch.delenv(key, raising=False)
-    monkeypatch.setattr(loader, "_cached", None)
-    monkeypatch.setattr(loader, "_override", None)
-    yield
-
-
-def test_get_model_wraps_when_disabled(
-    monkeypatch: pytest.MonkeyPatch, _reset_settings: None
-) -> None:
-    inner = _DummyModel()
-    monkeypatch.setattr("strix.config.models.MultiProvider.get_model", lambda *_: inner)
-    monkeypatch.setenv("LLM_DISABLE_STREAMING", "true")
-    load_settings()
-
-    model = StrixProvider().get_model("openai/gpt-4o-mini")
-    assert isinstance(model, _NonStreamingModel)
-
-
-def test_get_model_unwrapped_by_default(
-    monkeypatch: pytest.MonkeyPatch, _reset_settings: None
-) -> None:
-    inner = _DummyModel()
-    monkeypatch.setattr("strix.config.models.MultiProvider.get_model", lambda *_: inner)
-    load_settings()
-
-    model = StrixProvider().get_model("openai/gpt-4o-mini")
-    assert model is inner
-
-
-def test_get_model_does_not_wrap_subscription_model(
-    monkeypatch: pytest.MonkeyPatch, _reset_settings: None
-) -> None:
-    # Subscription (ChatGPT) models are always streamed and must not be wrapped.
-    monkeypatch.setattr(codex, "subscription_model", lambda *_: "gpt-5.5")
-    monkeypatch.setattr(codex, "get_subscription_client", lambda: AsyncOpenAI(api_key="x"))
-    monkeypatch.setenv("LLM_DISABLE_STREAMING", "true")
-    load_settings()
-
-    model = StrixProvider().get_model("gpt-5.5")
-    assert not isinstance(model, _NonStreamingModel)

tests/test_e2e_budget_lifecycle.py

@@ -7,7 +7,7 @@ from unittest.mock import MagicMock, patch
 import pytest
 
 from strix.core import execution
-from strix.core.agents import AgentCoordinator, WaitKind
+from strix.core.agents import AgentCoordinator
 from strix.core.execution import _start_child_runner, run_agent_loop
 from strix.core.hooks import BudgetExceededError, ReportUsageHooks
 from strix.core.sessions import open_agent_session
@@ -42,32 +42,23 @@ class _FakeStream:
         hooks: ReportUsageHooks,
         context: dict[str, Any],
         agent: Any,
-        coordinator: AgentCoordinator,
     ) -> None:
         self._ledger = ledger
         self._hooks = hooks
         self._context = context
         self._agent = agent
-        self._coordinator = coordinator
         self.run_loop_exception: BaseException | None = None
         self.final_output = None
 
     async def stream_events(self) -> AsyncIterator[Any]:
-        agent_id = str(self._context.get("agent_id"))
         self._ledger.cost += COST_PER_CALL
-        self._ledger.calls.append(agent_id)
+        self._ledger.calls.append(str(self._context.get("agent_id")))
         ctx_wrapper = MagicMock()
         ctx_wrapper.context = self._context
         try:
             await self._hooks.on_llm_end(ctx_wrapper, self._agent, MagicMock())
         except Exception as exc:  # noqa: BLE001
             self.run_loop_exception = exc
-        # Stand in for the explicit yield tool a real turn ends with. Without it
-        # every turn looks like a forgotten tool call and burns the recovery
-        # budget, which is a different scenario from the one under test here.
-        if self._coordinator.statuses.get(agent_id) == "running":
-            wait_kind: WaitKind = "user" if self._context.get("parent_id") is None else "agents"
-            await self._coordinator.park_waiting(agent_id, wait_kind=wait_kind)
         items: tuple[Any, ...] = ()
         for item in items:
             yield item
@@ -76,7 +67,7 @@ class _FakeStream:
         return
 
 
-def _fake_runner(ledger: _FakeLedger, coordinator: AgentCoordinator) -> Any:
+def _fake_runner(ledger: _FakeLedger) -> Any:
     class _FakeRunner:
         @staticmethod
         def run_streamed(
@@ -89,13 +80,7 @@ def _fake_runner(ledger: _FakeLedger, coordinator: AgentCoordinator) -> Any:
             session: Any,  # noqa: ARG004
             hooks: ReportUsageHooks,
         ) -> _FakeStream:
-            return _FakeStream(
-                ledger=ledger,
-                hooks=hooks,
-                context=context,
-                agent=agent,
-                coordinator=coordinator,
-            )
+            return _FakeStream(ledger=ledger, hooks=hooks, context=context, agent=agent)
 
     return _FakeRunner
 
@@ -118,10 +103,10 @@ async def test_full_budget_lifecycle_reserve_then_cap(  # noqa: PLR0915
 ) -> None:
     ledger = _FakeLedger()
     hooks = ReportUsageHooks(model="test-model", max_budget_usd=MAX_BUDGET)
-    coordinator = AgentCoordinator()
-    monkeypatch.setattr(execution, "Runner", _fake_runner(ledger, coordinator))
+    monkeypatch.setattr(execution, "Runner", _fake_runner(ledger))
     monkeypatch.setattr(execution, "_compact_session", _noop_compact)
 
+    coordinator = AgentCoordinator()
     db_path = tmp_path / "agents.sqlite"
     sessions: list[Any] = []
     run_config = MagicMock()
@@ -233,6 +218,7 @@ async def test_respawned_children_after_reserve_never_spend(
     ledger = _FakeLedger()
     ledger.cost = 9.5
     hooks = ReportUsageHooks(model="test-model", max_budget_usd=MAX_BUDGET)
+    monkeypatch.setattr(execution, "Runner", _fake_runner(ledger))
     monkeypatch.setattr(execution, "_compact_session", _noop_compact)
 
     coordinator = AgentCoordinator()
@@ -244,7 +230,6 @@ async def test_respawned_children_after_reserve_never_spend(
     restored = AgentCoordinator()
     await restored.restore(snap)
     assert restored.reserve_stopped is True
-    monkeypatch.setattr(execution, "Runner", _fake_runner(ledger, restored))
 
     sessions: list[Any] = []
     with patch("strix.core.hooks.get_global_report_state", return_value=ledger):
@@ -279,6 +264,7 @@ async def test_resumed_parked_root_after_reserve_is_renotified_and_finalizes(
     ledger = _FakeLedger()
     ledger.cost = 9.0
     hooks = ReportUsageHooks(model="test-model", max_budget_usd=MAX_BUDGET)
+    monkeypatch.setattr(execution, "Runner", _fake_runner(ledger))
     monkeypatch.setattr(execution, "_compact_session", _noop_compact)
 
     coordinator = AgentCoordinator()
@@ -290,7 +276,6 @@ async def test_resumed_parked_root_after_reserve_is_renotified_and_finalizes(
     restored = AgentCoordinator()
     await restored.restore(snap)
     assert restored.reserve_stopped is True
-    monkeypatch.setattr(execution, "Runner", _fake_runner(ledger, restored))
 
     root_session = open_agent_session("root", tmp_path / "agents.sqlite")
     with patch("strix.core.hooks.get_global_report_state", return_value=ledger):
@@ -327,10 +312,10 @@ async def test_interactive_budget_pause_then_user_message_extends_and_resumes(
     ledger = _FakeLedger()
     ledger.cost = 9.0
     hooks = ReportUsageHooks(model="test-model", max_budget_usd=MAX_BUDGET, interactive=True)
-    coordinator = AgentCoordinator()
-    monkeypatch.setattr(execution, "Runner", _fake_runner(ledger, coordinator))
+    monkeypatch.setattr(execution, "Runner", _fake_runner(ledger))
     monkeypatch.setattr(execution, "_compact_session", _noop_compact)
 
+    coordinator = AgentCoordinator()
     coordinator.set_budget_extender(hooks.extend_budget)
     await coordinator.register("root", "strix", parent_id=None)
     root_session = open_agent_session("root", tmp_path / "agents.sqlite")

tests/test_execution.py

@@ -5,54 +5,25 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import json
-from typing import Any, cast
+from typing import Any
 from unittest.mock import MagicMock
 
 import pytest
-from agents.exceptions import MaxTurnsExceeded
-from agents.items import MessageOutputItem
 from agents.memory import SQLiteSession
 from agents.tool_context import ToolContext
-from openai.types.responses import ResponseOutputMessage, ResponseOutputRefusal
 
+from strix.config import codex
 from strix.core import execution
 from strix.core.agents import AgentCoordinator
 from strix.core.execution import (
+    _handle_content_guardrail,
+    _notify_parent_on_terminal,
     _notify_root_on_budget_reserve,
-    notify_parent_on_terminal,
+    respawn_subagents,
 )
-from strix.core.sessions import seed_initial_input
-from strix.tools.agents_graph.tools import agent_finish, stop_agent
 from strix.tools.finish.tool import finish_scan
 
 
-_NO_STREAM_EVENTS: list[Any] = []
-
-
-class _StructuredRefusalStream:
-    def __init__(self, refusal: str) -> None:
-        self.run_loop_exception: BaseException | None = None
-        self.new_items = [
-            MessageOutputItem(
-                agent=MagicMock(),
-                raw_item=ResponseOutputMessage(
-                    id="msg-refusal",
-                    content=[ResponseOutputRefusal(type="refusal", refusal=refusal)],
-                    role="assistant",
-                    status="completed",
-                    type="message",
-                ),
-            )
-        ]
-
-    async def stream_events(self) -> Any:
-        for event in _NO_STREAM_EVENTS:
-            yield event
-
-    def cancel(self, mode: str = "immediate") -> None:  # noqa: ARG002
-        return
-
-
 async def _call_finish_scan(
     coordinator: AgentCoordinator, agent_id: str, parent_id: str | None
 ) -> dict[str, Any]:
@@ -68,43 +39,6 @@ async def _call_finish_scan(
     return parsed
 
 
-async def _call_agent_finish(
-    coordinator: AgentCoordinator,
-    agent_id: str,
-    parent_id: str | None,
-    *,
-    report_to_parent: bool,
-) -> dict[str, Any]:
-    ctx = ToolContext(
-        context={"coordinator": coordinator, "agent_id": agent_id, "parent_id": parent_id},
-        tool_name="agent_finish",
-        tool_call_id="call-1",
-        tool_arguments="{}",
-    )
-    result: str = await agent_finish.on_invoke_tool(
-        ctx,
-        json.dumps({"result_summary": "done", "report_to_parent": report_to_parent}),
-    )
-    parsed: dict[str, Any] = json.loads(result)
-    return parsed
-
-
-async def _call_stop_agent(
-    coordinator: AgentCoordinator, agent_id: str, target_agent_id: str
-) -> dict[str, Any]:
-    ctx = ToolContext(
-        context={"coordinator": coordinator, "agent_id": agent_id},
-        tool_name="stop_agent",
-        tool_call_id="call-1",
-        tool_arguments="{}",
-    )
-    result: str = await stop_agent.on_invoke_tool(
-        ctx, json.dumps({"target_agent_id": target_agent_id})
-    )
-    parsed: dict[str, Any] = json.loads(result)
-    return parsed
-
-
 @pytest.mark.asyncio
 async def test_reserve_stop_notifies_root_once(monkeypatch: pytest.MonkeyPatch) -> None:
     coordinator = AgentCoordinator()
@@ -504,11 +438,11 @@ async def test_snapshot_round_trip_preserves_budget_pause() -> None:
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("status", ["completed", "stopped", "failed", "crashed"])
+@pytest.mark.parametrize("status", ["stopped", "failed", "crashed"])
 async def test_terminal_child_wakes_parked_parent(tmp_path: Any, status: str) -> None:
-    # Regression for #870 and #947: a child reaching any terminal state - including a
-    # plain "completed" - must wake the parent parked in wait_for_agents, so the root
-    # can finalize the scan instead of hanging for a report that never arrives.
+    # Regression for #870: a child reaching a terminal state (e.g. MaxTurnsExceeded
+    # -> "stopped") must wake the parent parked in wait_for_message, so the root can
+    # finalize the scan instead of hanging for a completion report that never arrives.
     coordinator = AgentCoordinator()
     await coordinator.register("root", "strix", parent_id=None)
     await coordinator.register("child", "SQL Injection", parent_id="root")
@@ -520,82 +454,13 @@ async def test_terminal_child_wakes_parked_parent(tmp_path: Any, status: str) ->
     assert not root_waiter.done()
 
     await coordinator.set_status("child", status, error="Max turns (500) exceeded")
-    await notify_parent_on_terminal(coordinator, "child", status)
+    await _notify_parent_on_terminal(coordinator, "child", status)
 
     await asyncio.wait_for(root_waiter, timeout=1.0)
     assert coordinator.pending_counts.get("root", 0) > 0
     session.close()
 
 
-@pytest.mark.asyncio
-async def test_agent_finish_without_report_still_wakes_parent(tmp_path: Any) -> None:
-    # Regression for #947: a child that completes with report_to_parent=False owes its
-    # parent a terminal notice, otherwise the parent waits out its full timeout.
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    await coordinator.register("child", "recon", parent_id="root")
-    session = SQLiteSession("root", tmp_path / "agents.db")
-    await coordinator.attach_runtime("root", session=session)
-
-    root_waiter = asyncio.create_task(coordinator.wait_for_message("root"))
-    await asyncio.sleep(0)
-
-    await _call_agent_finish(coordinator, "child", "root", report_to_parent=False)
-
-    await asyncio.wait_for(root_waiter, timeout=1.0)
-    assert coordinator.statuses["child"] == "completed"
-    assert coordinator.pending_counts.get("root", 0) == 1
-    session.close()
-
-
-@pytest.mark.asyncio
-async def test_agent_finish_report_suppresses_the_terminal_notice(tmp_path: Any) -> None:
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    await coordinator.register("child", "recon", parent_id="root")
-    session = SQLiteSession("root", tmp_path / "agents.db")
-    await coordinator.attach_runtime("root", session=session)
-
-    await _call_agent_finish(coordinator, "child", "root", report_to_parent=True)
-    # The exit backstop must not duplicate the report the child already delivered.
-    await execution._notify_parent_on_exit(coordinator, "child")
-
-    assert coordinator.pending_counts.get("root", 0) == 1
-    session.close()
-
-
-@pytest.mark.asyncio
-async def test_stop_agent_notifies_a_parent_that_is_not_the_stopper(tmp_path: Any) -> None:
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    await coordinator.register("child", "recon", parent_id="root")
-    await coordinator.register("grandchild", "sqli", parent_id="child")
-    session = SQLiteSession("child", tmp_path / "agents.db")
-    await coordinator.attach_runtime("child", session=session)
-
-    await _call_stop_agent(coordinator, "root", "grandchild")
-
-    assert coordinator.statuses["grandchild"] == "stopped"
-    assert coordinator.pending_counts.get("child", 0) == 1
-    # The stopper already knows; only the waiting parent needs telling.
-    assert coordinator.pending_counts.get("root", 0) == 0
-    session.close()
-
-
-@pytest.mark.asyncio
-async def test_stop_agent_does_not_notify_the_stopping_parent(tmp_path: Any) -> None:
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    await coordinator.register("child", "recon", parent_id="root")
-    session = SQLiteSession("root", tmp_path / "agents.db")
-    await coordinator.attach_runtime("root", session=session)
-
-    await _call_stop_agent(coordinator, "root", "child")
-
-    assert coordinator.pending_counts.get("root", 0) == 0
-    session.close()
-
-
 @pytest.mark.asyncio
 async def test_notify_parent_on_terminal_ignores_non_terminal_status(tmp_path: Any) -> None:
     coordinator = AgentCoordinator()
@@ -604,7 +469,7 @@ async def test_notify_parent_on_terminal_ignores_non_terminal_status(tmp_path: A
     session = SQLiteSession("root", tmp_path / "agents.db")
     await coordinator.attach_runtime("root", session=session)
 
-    await notify_parent_on_terminal(coordinator, "child", "waiting")
+    await _notify_parent_on_terminal(coordinator, "child", "waiting")
 
     assert coordinator.pending_counts.get("root", 0) == 0
     session.close()
@@ -630,7 +495,7 @@ async def test_terminal_notice_does_not_cancel_parent_stream(tmp_path: Any) -> N
     await coordinator.attach_runtime("root", session=session, interrupt_on_message=True)
     await coordinator.attach_stream("root", stream)
 
-    await notify_parent_on_terminal(coordinator, "child", "crashed")
+    await _notify_parent_on_terminal(coordinator, "child", "crashed")
 
     assert stream.cancelled is False
     assert coordinator.pending_counts.get("root", 0) > 0
@@ -638,560 +503,76 @@ async def test_terminal_notice_does_not_cancel_parent_stream(tmp_path: Any) -> N
 
 
 @pytest.mark.asyncio
-async def test_send_queues_without_session_and_drains_on_consume(tmp_path: Any) -> None:
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-
-    assert await coordinator.send("root", {"from": "user", "content": "hello"}) is True
-    assert coordinator.pending_counts["root"] == 1
-
-    session = SQLiteSession("root", tmp_path / "agents.db")
-    await coordinator.attach_runtime("root", session=session)
-
-    count, items = await coordinator.consume_pending("root", include_items=True)
-    assert count == 1
-    assert items[0]["content"] == "hello"
-    stored = await session.get_items()
-    last = cast("dict[str, Any]", stored[-1])
-    assert last["content"] == "hello"
-    session.close()
-
-
-@pytest.mark.asyncio
-async def test_error_parked_agent_only_released_by_user_message(tmp_path: Any) -> None:
+async def test_guardrail_interactive_parks_agent_wakeable(tmp_path: Any) -> None:
     coordinator = AgentCoordinator()
     await coordinator.register("root", "strix", parent_id=None)
     await coordinator.register("child", "recon", parent_id="root")
+    exc = codex.CodexContentGuardrailError("chatgpt/gpt-5.6-sol")
+
+    result = await _handle_content_guardrail(coordinator, "child", exc, interactive=True)
+
+    assert result is None
+    assert coordinator.statuses["child"] == "waiting"
+    assert "STRIX_LLM" in coordinator.errors["child"]
+
+    waiter = asyncio.create_task(coordinator.wait_for_message("child"))
+    await asyncio.sleep(0)
+    assert not waiter.done()
     session = SQLiteSession("child", tmp_path / "agents.db")
     await coordinator.attach_runtime("child", session=session)
-    await coordinator.set_status("child", "crashed", error="boom")
-
-    await coordinator.send("child", {"from": "root", "content": "peer nudge"})
-    waiter = asyncio.create_task(coordinator.wait_for_message("child"))
-    await asyncio.sleep(0.05)
-    assert not waiter.done()
-
-    await coordinator.send("child", {"from": "user", "content": "wake up"})
-    assert await asyncio.wait_for(waiter, timeout=1.0) is True
-
-    count, items = await coordinator.consume_pending("child", include_items=True)
-    assert count == 2
-    assert items[0]["content"].endswith("peer nudge")
-    assert items[1]["content"] == "wake up"
+    await coordinator.send("child", {"from": "user", "content": "switched model, resume"})
+    await asyncio.wait_for(waiter, timeout=1.0)
     session.close()
 
 
 @pytest.mark.asyncio
-async def test_wait_for_message_timeout_returns_false() -> None:
-    coordinator = AgentCoordinator()
-    await coordinator.register("child", "recon", parent_id="root")
-
-    assert await coordinator.wait_for_message("child", timeout=0.05) is False
-
-
-@pytest.mark.asyncio
-async def test_snapshot_round_trip_preserves_mailboxes() -> None:
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    await coordinator.send("root", {"from": "user", "content": "queued"})
-
-    snap = await coordinator.snapshot()
-    restored = AgentCoordinator()
-    await restored.restore(snap)
-
-    assert restored.pending_counts["root"] == 1
-    assert restored.runtimes["root"].mailbox == [{"from": "user", "content": "queued"}]
-
-
-@pytest.mark.asyncio
-async def test_run_cycle_parked_parks_instead_of_raising(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    async def _boom(*_args: Any, **_kwargs: Any) -> Any:
-        raise RuntimeError("unexpected explosion")
-
-    monkeypatch.setattr(execution, "_run_cycle", _boom)
-
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-
-    result = await execution._run_cycle_parked(
-        object(),
-        coordinator,
-        "root",
-        input_data=[],
-        run_config=None,  # type: ignore[arg-type]
-        context={},
-        max_turns=5,
-        session=None,
-        event_sink=None,
-        hooks=None,
-    )
-
-    assert result is None
-    assert coordinator.statuses["root"] == "failed"
-    assert coordinator.errors["root"] == "unexpected explosion"
-
-
-class _SalvageStream:
-    def __init__(self, replay: list[dict[str, Any]]) -> None:
-        self._replay = replay
-
-    def to_input_list(self) -> list[dict[str, Any]]:
-        return self._replay
-
-
-@pytest.mark.asyncio
-async def test_salvage_stream_to_session_preserves_full_history(tmp_path: Any) -> None:
-    session = SQLiteSession("child", tmp_path / "agents.db")
-    await session.add_items([{"role": "user", "content": "identity + task"}])
-    pre_run = list(await session.get_items())
-
-    # A crash mid-run: the stream produced two turns the SDK never committed.
-    stream = _SalvageStream(
-        [
-            {"role": "assistant", "content": "recon turn 1"},
-            {"role": "assistant", "content": "recon turn 2"},
-        ]
-    )
-    await execution._salvage_stream_to_session(session, pre_run, stream, "child")
-
-    stored = [cast("dict[str, Any]", i) for i in await session.get_items()]
-    assert [i["content"] for i in stored] == [
-        "identity + task",
-        "recon turn 1",
-        "recon turn 2",
-    ]
-
-    # A crash with nothing new to salvage leaves the session untouched.
-    await execution._salvage_stream_to_session(
-        session, list(await session.get_items()), _SalvageStream([]), "child"
-    )
-    assert len(await session.get_items()) == 3
-    session.close()
-
-
-@pytest.mark.asyncio
-async def test_seed_initial_input_persists_and_is_idempotent(tmp_path: Any) -> None:
-    session = SQLiteSession("child", tmp_path / "agents.db")
-    identity = [{"role": "user", "content": "You are agent recon (abc); do X."}]
-
-    assert await seed_initial_input(session, identity) is True
-    assert len(await session.get_items()) == 1
-
-    # A populated session is left untouched (no duplicate identity message).
-    assert await seed_initial_input(session, identity) is False
-    assert len(await session.get_items()) == 1
-
-    assert await seed_initial_input(session, []) is False
-    session.close()
-
-
-@pytest.mark.asyncio
-async def test_structured_provider_refusal_fails_interactive_agent(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    refusal = "This request was blocked under the provider's usage policy."
-    stream = _StructuredRefusalStream(refusal)
-    monkeypatch.setattr(
-        "strix.core.execution.Runner.run_streamed", lambda *_args, **_kwargs: stream
-    )
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-
-    result = await execution._run_cycle(
-        MagicMock(),
-        coordinator,
-        "root",
-        input_data="task",
-        run_config=MagicMock(),
-        context={},
-        max_turns=5,
-        session=None,
-        interactive=True,
-        event_sink=None,
-        hooks=None,
-    )
-
-    assert result is None
-    assert coordinator.statuses["root"] == "failed"
-    assert coordinator.errors["root"] == refusal
-
-
-@pytest.mark.asyncio
-async def test_structured_provider_refusal_fails_noninteractive_child(
-    tmp_path: Any,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    refusal = "This request was blocked under the provider's usage policy."
-    stream = _StructuredRefusalStream(refusal)
-    monkeypatch.setattr(
-        "strix.core.execution.Runner.run_streamed", lambda *_args, **_kwargs: stream
-    )
+async def test_guardrail_noninteractive_fails_only_blocked_agent(tmp_path: Any) -> None:
     coordinator = AgentCoordinator()
     await coordinator.register("root", "strix", parent_id=None)
     await coordinator.register("child", "recon", parent_id="root")
     session = SQLiteSession("root", tmp_path / "agents.db")
     await coordinator.attach_runtime("root", session=session)
+    exc = codex.CodexContentGuardrailError("chatgpt/gpt-5.6-sol")
 
-    result = await execution._run_cycle(
-        MagicMock(),
-        coordinator,
-        "child",
-        input_data="task",
-        run_config=MagicMock(),
-        context={"parent_id": "root"},
-        max_turns=5,
-        session=None,
-        interactive=False,
-        event_sink=None,
-        hooks=None,
-    )
+    result = await _handle_content_guardrail(coordinator, "child", exc, interactive=False)
 
     assert result is None
     assert coordinator.statuses["child"] == "failed"
-    assert coordinator.errors["child"] == refusal
+    assert "STRIX_LLM" in coordinator.errors["child"]
+    assert coordinator.statuses["root"] == "running"
     assert coordinator.pending_counts.get("root", 0) > 0
     session.close()
 
 
 @pytest.mark.asyncio
-async def test_run_agent_loop_seeds_identity_before_first_cycle(
+async def test_resume_revives_guardrail_parked_child_but_not_plain_waiting(
     tmp_path: Any, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     coordinator = AgentCoordinator()
-    await coordinator.register("child", "recon", parent_id="root")
-    session = SQLiteSession("child", tmp_path / "agents.db")
+    await coordinator.register("root", "strix", parent_id=None)
+    await coordinator.register("blocked", "recon", parent_id="root")
+    await coordinator.register("peer_waiter", "recon", parent_id="root")
+    await coordinator.set_status("blocked", "waiting", error="STRIX_LLM guardrail")
+    await coordinator.set_status("peer_waiter", "waiting")
 
-    captured: dict[str, Any] = {}
+    parked: dict[str, bool] = {}
 
-    async def _crash_first_turn(*_args: Any, **kwargs: Any) -> Any:
-        captured["input_data"] = kwargs.get("input_data")
-        captured["items_at_start"] = await session.get_items()
-        raise RuntimeError("first-turn crash")
+    async def _fake_start_child_runner(**kwargs: Any) -> None:
+        parked[kwargs["child_id"]] = bool(kwargs["start_parked"])
 
-    monkeypatch.setattr(execution, "_run_cycle", _crash_first_turn)
+    monkeypatch.setattr(execution, "_start_child_runner", _fake_start_child_runner)
 
-    identity = [{"role": "user", "content": "You are agent recon (abc); maintain your identity."}]
-    with pytest.raises(RuntimeError, match="first-turn crash"):
-        await execution.run_agent_loop(
-            agent=object(),
-            initial_input=identity,
-            run_config=None,  # type: ignore[arg-type]
-            context={"agent_id": "child", "parent_id": "root"},
-            max_turns=5,
-            coordinator=coordinator,
-            agent_id="child",
-            interactive=False,
-            session=session,
-        )
-
-    # The first cycle ran with an empty input against the pre-seeded session.
-    assert captured["input_data"] == []
-    assert captured["items_at_start"]
-    # The identity/task survives the first-turn crash, so a revival can resume it.
-    stored = await session.get_items()
-    assert any("recon" in str(cast("dict[str, Any]", i).get("content", "")) for i in stored)
-    session.close()
-
-
-def _scripted_cycle(
-    coordinator: AgentCoordinator,
-    agent_id: str,
-    statuses: list[str],
-    calls: list[Any],
-) -> Any:
-    """Fake run cycle that leaves ``agent_id`` in a scripted status per call."""
-
-    async def _cycle(*_args: Any, **kwargs: Any) -> Any:
-        calls.append(kwargs.get("input_data"))
-        status = statuses[min(len(calls) - 1, len(statuses) - 1)]
-        await coordinator.set_status(agent_id, status)
-        return MagicMock(final_output="plain text, no tool call")
-
-    return _cycle
-
-
-async def _drive(
-    coordinator: AgentCoordinator,
-    agent_id: str,
-    *,
-    interactive: bool,
-    max_turns: int = 5,
-) -> Any:
-    return await execution._run_until_lifecycle(
-        MagicMock(),
-        coordinator,
-        agent_id,
-        initial_input=[],
+    await respawn_subagents(
+        coordinator=coordinator,
+        factory=lambda **_kwargs: object(),
+        agents_db_path=tmp_path / "agents.db",
+        sessions_to_close=[],
         run_config=MagicMock(),
-        context={"agent_id": agent_id, "parent_id": None},
-        max_turns=max_turns,
-        session=None,
-        interactive=interactive,
-        event_sink=None,
-        hooks=None,
+        max_turns=10,
+        interactive=True,
+        parent_ctx={"agent_id": "root", "parent_id": None},
+        root_id="root",
     )
 
-
-@pytest.mark.asyncio
-async def test_interactive_text_only_turn_is_nudged_instead_of_parking(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """A no-tool-call turn must not silently hand control back to the user."""
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    calls: list[Any] = []
-    monkeypatch.setattr(
-        execution,
-        "_run_cycle_parked",
-        _scripted_cycle(coordinator, "root", ["running", "completed"], calls),
-    )
-
-    await _drive(coordinator, "root", interactive=True)
-
-    assert len(calls) == 2
-    # The retry carries an explicit "call a tool" nudge rather than empty input.
-    nudge = calls[1][0]["content"]
-    assert "without a tool call" in nudge
-    assert "respond_to_user" in nudge
-    assert coordinator.statuses["root"] == "completed"
-
-
-@pytest.mark.asyncio
-async def test_interactive_explicit_park_gets_no_nudge(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """``waiting`` is only reachable via respond_to_user / wait_for_agents."""
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    calls: list[Any] = []
-    monkeypatch.setattr(
-        execution,
-        "_run_cycle_parked",
-        _scripted_cycle(coordinator, "root", ["waiting"], calls),
-    )
-
-    await _drive(coordinator, "root", interactive=True)
-
-    assert len(calls) == 1
-    assert coordinator.statuses["root"] == "waiting"
-
-
-@pytest.mark.asyncio
-async def test_interactive_recovery_exhaustion_parks_instead_of_crashing(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """A human can resume an interactive scan, so exhaustion parks rather than dies."""
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    calls: list[Any] = []
-    monkeypatch.setattr(
-        execution,
-        "_run_cycle_parked",
-        _scripted_cycle(coordinator, "root", ["running"], calls),
-    )
-
-    await _drive(coordinator, "root", interactive=True)
-
-    assert len(calls) == execution._INTERACTIVE_TOOL_RECOVERY_LIMIT
-    assert coordinator.statuses["root"] == "waiting"
-
-
-@pytest.mark.asyncio
-async def test_interactive_subagent_exhaustion_tells_its_parent(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """A parked child must report up so its parent stops waiting on it.
-
-    The parent is an agent, not a watching human, so a parent blocked in
-    wait_for_agents otherwise burns its whole timeout on a completion
-    report the child can no longer send.
-    """
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    await coordinator.register("child", "recon", parent_id="root")
-    calls: list[Any] = []
-    monkeypatch.setattr(
-        execution,
-        "_run_cycle_parked",
-        _scripted_cycle(coordinator, "child", ["running"], calls),
-    )
-
-    await _drive(coordinator, "child", interactive=True)
-
-    assert coordinator.statuses["child"] == "waiting"
-    pending, items = await coordinator.consume_pending("root", include_items=True)
-    assert pending == 1
-    notice = str(items[0])
-    assert "child" in notice
-    assert "parked" in notice
-
-
-@pytest.mark.asyncio
-async def test_interactive_root_exhaustion_notifies_nobody(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """The root has no parent to report to, so parking stays silent."""
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    monkeypatch.setattr(
-        execution,
-        "_run_cycle_parked",
-        _scripted_cycle(coordinator, "root", ["running"], []),
-    )
-
-    await _drive(coordinator, "root", interactive=True)
-
-    pending, _ = await coordinator.consume_pending("root")
-    assert pending == 0
-
-
-@pytest.mark.asyncio
-async def test_noninteractive_recovery_exhaustion_crashes(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """No user is present to resume an autonomous run, so it still fails loudly."""
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    calls: list[Any] = []
-    monkeypatch.setattr(
-        execution,
-        "_run_cycle",
-        _scripted_cycle(coordinator, "root", ["running"], calls),
-    )
-
-    with pytest.raises(MaxTurnsExceeded):
-        await _drive(coordinator, "root", interactive=False, max_turns=2)
-
-    assert len(calls) == 2
-    assert coordinator.statuses["root"] == "crashed"
-
-
-@pytest.mark.asyncio
-async def test_tool_required_message_is_persisted_to_the_session(tmp_path: Any) -> None:
-    session = SQLiteSession("root", tmp_path / "agents.db")
-
-    assert (
-        await execution._append_tool_required_message(
-            session=session,
-            context={"parent_id": None},
-            attempt=1,
-            limit=3,
-            interactive=True,
-        )
-        == []
-    )
-
-    stored = [cast("dict[str, Any]", i) for i in await session.get_items()]
-    assert "finish_scan" in stored[0]["content"]
-    assert "respond_to_user" in stored[0]["content"]
-    session.close()
-
-
-@pytest.mark.asyncio
-async def test_recovery_count_survives_a_snapshot_round_trip(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """A resumed agent must not earn a fresh nudge budget and loop forever."""
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    calls: list[Any] = []
-    monkeypatch.setattr(
-        execution,
-        "_run_cycle_parked",
-        _scripted_cycle(coordinator, "root", ["running"], calls),
-    )
-
-    await _drive(coordinator, "root", interactive=True)
-    assert coordinator.recovery_counts["root"] == execution._INTERACTIVE_TOOL_RECOVERY_LIMIT
-
-    restored = AgentCoordinator()
-    await restored.restore(await coordinator.snapshot())
-    assert restored.recovery_counts["root"] == execution._INTERACTIVE_TOOL_RECOVERY_LIMIT
-
-    # The restored agent is already at its cap, so it parks after a single
-    # further text-only cycle instead of starting the whole budget over.
-    resumed_calls: list[Any] = []
-    monkeypatch.setattr(
-        execution,
-        "_run_cycle_parked",
-        _scripted_cycle(restored, "root", ["running"], resumed_calls),
-    )
-    await _drive(restored, "root", interactive=True)
-
-    assert len(resumed_calls) == 1
-    assert restored.statuses["root"] == "waiting"
-
-
-@pytest.mark.asyncio
-async def test_recovery_count_is_cleared_by_a_lifecycle_tool(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    calls: list[Any] = []
-    monkeypatch.setattr(
-        execution,
-        "_run_cycle_parked",
-        _scripted_cycle(coordinator, "root", ["running", "completed"], calls),
-    )
-
-    await _drive(coordinator, "root", interactive=True)
-
-    assert "root" not in coordinator.recovery_counts
-
-
-@pytest.mark.asyncio
-async def test_agent_awaiting_a_human_is_never_auto_resumed() -> None:
-    """The user can message any agent, so parking for one is not root-only."""
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    await coordinator.register("child", "recon", parent_id="root")
-
-    for agent_id in ("root", "child"):
-        await coordinator.park_waiting(agent_id, wait_kind="user")
-        assert await execution._plain_waiting_timeout(coordinator, agent_id) is None
-
-
-@pytest.mark.asyncio
-async def test_agent_awaiting_other_agents_is_re_checked_on_a_timer() -> None:
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    await coordinator.park_waiting("root", wait_kind="agents")
-
-    timeout = await execution._plain_waiting_timeout(coordinator, "root")
-    assert timeout == execution._WAITING_AUTO_RESUME_TIMEOUT_S
-
-
-@pytest.mark.asyncio
-async def test_idle_auto_resumes_stop_after_their_budget() -> None:
-    """A wedged agent must not burn a model turn per timeout for the whole scan."""
-    coordinator = AgentCoordinator()
-    await coordinator.register("child", "recon", parent_id="root")
-    await coordinator.park_waiting("child", wait_kind="agents")
-
-    for _ in range(execution._MAX_IDLE_AUTO_RESUMES):
-        assert await execution._plain_waiting_timeout(coordinator, "child") is not None
-        await coordinator.record_idle_resume("child")
-
-    assert await execution._plain_waiting_timeout(coordinator, "child") is None
-
-    # A real message is real progress, so the budget starts over.
-    await coordinator.reset_idle_resumes("child")
-    assert await execution._plain_waiting_timeout(coordinator, "child") is not None
-
-
-@pytest.mark.asyncio
-async def test_wait_kind_survives_a_snapshot_round_trip() -> None:
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    await coordinator.park_waiting("root", wait_kind="user")
-    await coordinator.record_idle_resume("root")
-
-    restored = AgentCoordinator()
-    await restored.restore(await coordinator.snapshot())
-
-    assert restored.wait_kinds["root"] == "user"
-    assert restored.idle_resume_counts["root"] == 1
-    assert await execution._plain_waiting_timeout(restored, "root") is None
+    assert parked["blocked"] is False
+    assert parked["peer_waiter"] is True

tests/test_execution_transient_retry.py

@@ -15,7 +15,6 @@ from openai import (
     RateLimitError,
 )
 
-from strix.config import codex
 from strix.core import execution
 from strix.core.agents import AgentCoordinator
 
@@ -56,27 +55,11 @@ def test_server_errors_are_transient() -> None:
         assert execution._is_transient_model_error(_status_error(status)) is True
 
 
-def test_rate_limit_is_retried() -> None:
+def test_rate_limit_is_not_retried_here() -> None:
     rate_limited = RateLimitError(
         "slow down", response=httpx.Response(429, request=_request()), body=None
     )
-    assert execution._is_transient_model_error(rate_limited) is True
-
-
-def test_dns_and_connection_errors_are_transient() -> None:
-    assert execution._is_transient_model_error(OSError("nodename nor servname provided")) is True
-    assert execution._is_transient_model_error(ConnectionError("reset")) is True
-    assert execution._is_transient_model_error(TimeoutError("timed out")) is True
-
-
-def test_content_guardrail_is_not_retried() -> None:
-    guardrail = APIError(
-        "This content was flagged for possible cybersecurity risk",
-        _request(),
-        body=None,
-    )
-    assert codex.is_content_guardrail_error(guardrail) is True
-    assert execution._is_transient_model_error(guardrail) is False
+    assert execution._is_transient_model_error(rate_limited) is False
 
 
 def test_client_errors_are_not_transient() -> None:

tests/test_inputs.py

@@ -129,17 +129,6 @@ def test_prompt_cache_kept_for_non_bedrock_claude_even_if_unmapped(monkeypatch:
         ]
 
 
-def test_max_reasoning_effort_sent_as_raw_body_field() -> None:
-    # "max" is absent from the OpenAI SDK's Reasoning enum, and LiteLLM's DeepSeek
-    # mapping collapses every effort to thinking-enabled, so it has to ride along
-    # as a raw body field to reach the provider.
-    settings = make_model_settings(
-        "max", model_name="deepseek/deepseek-v4-flash", request_timeout=30
-    )
-    assert settings.reasoning is None
-    assert settings.extra_args == {"timeout": 30, "extra_body": {"reasoning_effort": "max"}}
-
-
 def test_conversation_tail_breakpoint_moves_with_appended_transcript() -> None:
     # LiteLLM must place the index=-1 cache_control on the last message however
     # long the transcript grows.
@@ -283,30 +272,6 @@ def test_make_model_settings_omits_timeout_when_unset() -> None:
     assert settings.extra_args is None
 
 
-def test_make_model_settings_sets_extra_headers() -> None:
-    settings = make_model_settings(
-        "none",
-        model_name="openai/some-model",
-        extra_headers={"X-Feature-Key": "svc", "X-Tenant": "acme"},
-    )
-
-    assert settings.extra_headers == {"X-Feature-Key": "svc", "X-Tenant": "acme"}
-
-
-def test_make_model_settings_omits_extra_headers_when_unset() -> None:
-    assert make_model_settings("none", model_name="gpt-4o").extra_headers is None
-
-
-def test_make_model_settings_extra_headers_survive_reasoning_resolve() -> None:
-    settings = make_model_settings(
-        "high",
-        model_name="openai/o3",
-        extra_headers={"X-Feature-Key": "svc"},
-    )
-
-    assert settings.extra_headers == {"X-Feature-Key": "svc"}
-
-
 def test_make_model_settings_timeout_survives_reasoning_resolve() -> None:
     # Reasoning is resolved via ModelSettings.resolve(); the timeout in extra_args
     # must not be dropped when a reasoning override is merged in.

tests/test_llm_extra_headers.py

@@ -1,97 +0,0 @@
-"""Tests for LLM_EXTRA_HEADERS: custom default headers on OpenAI-compatible endpoints."""
-
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING
-
-import litellm
-import pytest
-from agents.models import _openai_shared
-
-from strix.config import loader
-from strix.config.loader import load_settings
-from strix.config.models import configure_sdk_model_defaults
-
-
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-
-
-_ENV_KEYS = ["STRIX_LLM", "LLM_API_KEY", "LLM_API_BASE", "LLM_EXTRA_HEADERS"]
-
-
-@pytest.fixture(autouse=True)
-def _reset(monkeypatch: pytest.MonkeyPatch) -> Iterator[None]:
-    for key in _ENV_KEYS:
-        monkeypatch.delenv(key, raising=False)
-    monkeypatch.setattr(loader, "_cached", None)
-    monkeypatch.setattr(loader, "_override", None)
-
-    saved_headers = litellm.headers
-    saved_client = _openai_shared.get_default_openai_client()
-    litellm.headers = None
-    try:
-        yield
-    finally:
-        litellm.headers = saved_headers
-        _openai_shared.set_default_openai_client(saved_client)  # type: ignore[arg-type]
-
-
-def test_extra_headers_parsed_from_json_env(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setenv("LLM_EXTRA_HEADERS", json.dumps({"X-A": "1", "X-B": "2"}))
-    settings = load_settings()
-    assert settings.llm.extra_headers == {"X-A": "1", "X-B": "2"}
-
-
-def test_extra_headers_merged_into_litellm_headers(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setenv("STRIX_LLM", "litellm/openai/some-model")
-    monkeypatch.setenv("LLM_API_BASE", "https://gateway.example/v1")
-    monkeypatch.setenv("LLM_API_KEY", "token")
-    headers = {"X-Feature-Key": "svc", "X-Tenant": "acme"}
-    monkeypatch.setenv("LLM_EXTRA_HEADERS", json.dumps(headers))
-
-    configure_sdk_model_defaults(load_settings())
-
-    current: object = litellm.headers
-    assert isinstance(current, dict)
-    assert current["X-Feature-Key"] == "svc"
-    assert current["X-Tenant"] == "acme"
-
-
-def test_extra_headers_applied_to_native_openai_client(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setenv("STRIX_LLM", "openai/some-model")
-    monkeypatch.setenv("LLM_API_BASE", "https://gateway.example/v1")
-    monkeypatch.setenv("LLM_API_KEY", "token")
-    monkeypatch.setenv("LLM_EXTRA_HEADERS", json.dumps({"X-Feature-Key": "svc"}))
-
-    configure_sdk_model_defaults(load_settings())
-
-    client = _openai_shared.get_default_openai_client()
-    assert client is not None
-    assert client.default_headers.get("X-Feature-Key") == "svc"
-    assert str(client.base_url).rstrip("/") == "https://gateway.example/v1"
-
-
-def test_extra_headers_applied_to_native_openai_without_custom_base(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setenv("STRIX_LLM", "openai/gpt-5")
-    monkeypatch.setenv("LLM_API_KEY", "token")
-    monkeypatch.setenv("LLM_EXTRA_HEADERS", json.dumps({"X-Feature-Key": "svc"}))
-
-    configure_sdk_model_defaults(load_settings())
-
-    client = _openai_shared.get_default_openai_client()
-    assert client is not None
-    assert client.default_headers.get("X-Feature-Key") == "svc"
-
-
-def test_no_extra_headers_leaves_litellm_headers_untouched(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setenv("STRIX_LLM", "openai/some-model")
-    monkeypatch.setenv("LLM_API_BASE", "https://gateway.example/v1")
-    monkeypatch.setenv("LLM_API_KEY", "token")
-
-    configure_sdk_model_defaults(load_settings())
-
-    assert litellm.headers is None

tests/test_respond_to_user.py

@@ -1,66 +0,0 @@
-"""Tests for the ``respond_to_user`` yield tool."""
-
-from __future__ import annotations
-
-import json
-from typing import Any
-
-import pytest
-from agents.tool_context import ToolContext
-
-from strix.core.agents import AgentCoordinator
-from strix.tools.respond.tool import respond_to_user
-
-
-async def _call(context: dict[str, Any], message: str = "here is what I found") -> dict[str, Any]:
-    ctx = ToolContext(
-        context=context,
-        tool_name="respond_to_user",
-        tool_call_id="call-1",
-        tool_arguments="{}",
-    )
-    raw = await respond_to_user.on_invoke_tool(ctx, json.dumps({"message": message}))
-    return json.loads(raw)  # type: ignore[no-any-return]
-
-
-async def _context(*, interactive: bool, agent_id: str = "root") -> dict[str, Any]:
-    coordinator = AgentCoordinator()
-    await coordinator.register("root", "strix", parent_id=None)
-    return {"coordinator": coordinator, "agent_id": agent_id, "interactive": interactive}
-
-
-@pytest.mark.asyncio
-async def test_parks_the_agent_and_carries_the_message() -> None:
-    context = await _context(interactive=True)
-    result = await _call(context)
-
-    coordinator = context["coordinator"]
-    assert result["success"] is True
-    assert result["wait_outcome"] == "waiting"
-    assert result["message"] == "here is what I found"
-    assert coordinator.statuses["root"] == "waiting"
-    # Recorded as a human wait, so the driver never auto-resumes it.
-    assert coordinator.wait_kinds["root"] == "user"
-
-
-@pytest.mark.asyncio
-async def test_rejected_in_an_autonomous_run() -> None:
-    context = await _context(interactive=False)
-    result = await _call(context)
-
-    assert result["success"] is False
-    assert "finish_scan" in result["error"]
-    assert context["coordinator"].statuses["root"] == "running"
-
-
-@pytest.mark.asyncio
-async def test_a_message_that_already_arrived_is_taken_instead_of_parking() -> None:
-    context = await _context(interactive=True)
-    coordinator = context["coordinator"]
-    await coordinator.send("root", {"from": "user", "content": "wait, one more thing"})
-
-    result = await _call(context)
-
-    assert result["wait_outcome"] == "message_arrived"
-    assert result["pending_messages"] == 1
-    assert coordinator.statuses["root"] == "running"

tests/test_runner_rate_limit.py

@@ -40,7 +40,6 @@ async def test_persistent_rate_limit_stops_gracefully(
             force_required_tool_choice=False,
             timeout=300,
             prompt_cache=True,
-            extra_headers=None,
         ),
         runtime=types.SimpleNamespace(max_context_images=3),
     )

tests/test_runner_root_prompt.py

@@ -48,7 +48,6 @@ def _patch_engine_scaffold(
             force_required_tool_choice=False,
             timeout=300,
             prompt_cache=True,
-            extra_headers=None,
         ),
         runtime=types.SimpleNamespace(max_context_images=3),
     )