quick-agent 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

tests/test_orchestrator.py

@@ -1,7 +1,7 @@
 import sys
 import types
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, Literal, cast
 
 import pytest
 from pydantic import BaseModel
@@ -11,6 +11,7 @@ from pydantic_ai.toolsets import FunctionToolset
 
 from quick_agent import quick_agent as qa_module
 from quick_agent import agent_tools as tools_module
+from quick_agent import input_adaptors as input_adaptors_module
 from quick_agent.agent_call_tool import AgentCallTool
 from quick_agent.agent_registry import AgentRegistry
 from quick_agent.agent_tools import AgentTools
@@ -26,6 +27,7 @@ from quick_agent.orchestrator import Orchestrator
 from quick_agent.quick_agent import QuickAgent
 from quick_agent.quick_agent import build_model
 from quick_agent.quick_agent import resolve_schema
+from quick_agent.prompting import make_user_prompt
 
 
 class DummyProvider:
@@ -76,7 +78,8 @@ class FakeAgent:
     def __init__(
         self,
         model: Any,
-        instructions: str,
+        instructions: str | None,
+        system_prompt: str | list[str],
         toolsets: list[Any],
         output_type: Any,
         model_settings: Any | None = None,
@@ -84,6 +87,7 @@ class FakeAgent:
         FakeAgent.last_init = {
             "model": model,
             "instructions": instructions,
+            "system_prompt": system_prompt,
             "toolsets": toolsets,
             "output_type": output_type,
             "model_settings": model_settings,
@@ -157,10 +161,10 @@ class RecordingQuickAgent(QuickAgent):
 
 class HandoffQuickAgent(QuickAgent):
     def __init__(self) -> None:
-        self.calls: list[tuple[str, Path]] = []
+        self.calls: list[tuple[str, input_adaptors_module.InputAdaptor | Path]] = []
 
-    async def _run_nested_agent(self, agent_id: str, input_path: Path) -> str:
-        self.calls.append((agent_id, input_path))
+    async def _run_nested_agent(self, agent_id: str, input_data: input_adaptors_module.InputAdaptor | Path) -> str:
+        self.calls.append((agent_id, input_data))
         return "ok"
 
 
@@ -187,7 +191,12 @@ def _make_loaded_with_chain(
         output=output or OutputSpec(file="out/result.json"),
         handoff=handoff or HandoffSpec(),
     )
-    return LoadedAgentFile(spec=spec, body="system", step_prompts={"step:one": "do thing"})
+    return LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="system",
+        system_prompt="",
+        step_prompts={"step:one": "do thing"},
+    )
 
 
 def _permissions(tmp_path: Path | None = None) -> DirectoryPermissions:
@@ -236,7 +245,7 @@ def test_resolve_schema_valid_missing_and_invalid() -> None:
         chain=[ChainStepSpec(id="s1", kind="text", prompt_section="step:one")],
         schemas={"Good": "schemas.orch:GoodSchema", "Bad": "schemas.orch:NotSchema"},
     )
-    loaded = LoadedAgentFile(spec=spec, body="", step_prompts={})
+    loaded = LoadedAgentFile.from_parts(spec=spec, instructions="", system_prompt="", step_prompts={})
 
     try:
         assert resolve_schema(loaded, "Good") is GoodSchema
@@ -306,12 +315,41 @@ def test_maybe_inject_agent_call_tool_skips_when_missing() -> None:
     assert toolset.add_calls == []
 
 
+@pytest.mark.anyio
+async def test_agent_call_tool_accepts_input_text() -> None:
+    recorder = AsyncCallRecorder(return_value="ok")
+    tool = AgentCallTool(recorder, "run/input.json")
+
+    result = await tool(agent="child", input_text="hello")
+
+    assert result == {"text": "ok"}
+    assert len(recorder.calls) == 1
+    args = recorder.calls[0]["args"]
+    assert args[0] == "child"
+    assert isinstance(args[1], input_adaptors_module.TextInput)
+    run_input = args[1].load()
+    assert run_input.kind == "text"
+    assert run_input.text == "hello"
+
+
+@pytest.mark.anyio
+async def test_agent_call_tool_rejects_missing_or_duplicate_input() -> None:
+    recorder = AsyncCallRecorder(return_value="ok")
+    tool = AgentCallTool(recorder, "run/input.json")
+
+    with pytest.raises(ValueError):
+        await tool(agent="child")
+    with pytest.raises(ValueError):
+        await tool(agent="child", input_file="a.txt", input_text="hi")
+
+
 def test_init_state_contains_agent_id_and_steps() -> None:
     qa = object.__new__(QuickAgent)
 
-    state = qa._init_state("agent-1")
+    qa._agent_id = "agent-1"
+    state = qa._init_state()
 
-    assert state == {"agent_id": "agent-1", "steps": {}}
+    assert state == {"agent_id": "agent-1", "steps": {}, "final_output": None}
 
 
 def test_build_model_settings_openai_compatible() -> None:
@@ -348,14 +386,11 @@ def test_build_model_settings_other_provider() -> None:
 def test_build_structured_model_settings_non_openai_passthrough() -> None:
     qa = object.__new__(QuickAgent)
     schema = ExampleSchema
-    model = cast(OpenAIChatModel, DummyOpenAIModel("http://localhost"))
     settings: ModelSettings = {"extra_body": {"format": "json"}}
+    qa.model = cast(OpenAIChatModel, DummyOpenAIModel("http://localhost"))
+    qa.model_settings_json = settings
 
-    result = qa._build_structured_model_settings(
-        model=model,
-        model_settings_json=settings,
-        schema_cls=schema,
-    )
+    result = qa._build_structured_model_settings(schema_cls=schema)
 
     assert result == settings
 
@@ -363,13 +398,10 @@ def test_build_structured_model_settings_non_openai_passthrough() -> None:
 def test_build_structured_model_settings_openai_injects_schema() -> None:
     qa = object.__new__(QuickAgent)
     schema = ExampleSchema
-    model = cast(OpenAIChatModel, DummyOpenAIModel("https://api.openai.com/v1"))
+    qa.model = cast(OpenAIChatModel, DummyOpenAIModel("https://api.openai.com/v1"))
+    qa.model_settings_json = None
 
-    result = qa._build_structured_model_settings(
-        model=model,
-        model_settings_json=None,
-        schema_cls=schema,
-    )
+    result = qa._build_structured_model_settings(schema_cls=schema)
 
     assert result is not None
     extra_body_obj = result.get("extra_body")
@@ -384,16 +416,6 @@ def test_build_structured_model_settings_openai_injects_schema() -> None:
     assert json_schema_obj["strict"] is True
 
 
-def test_build_user_prompt_raises_for_missing_section() -> None:
-    step = ChainStepSpec(id="s1", kind="text", prompt_section="step:missing")
-    loaded = LoadedAgentFile(spec=_make_loaded_with_chain([step]).spec, body="body", step_prompts={})
-    run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
-
-    qa = object.__new__(QuickAgent)
-    with pytest.raises(KeyError):
-        qa._build_user_prompt(step=step, loaded=loaded, run_input=run_input, state={"steps": {}})
-
-
 def test_build_user_prompt_uses_prompting(monkeypatch: pytest.MonkeyPatch) -> None:
     step = ChainStepSpec(id="s1", kind="text", prompt_section="step:one")
     loaded = _make_loaded_with_chain([step])
@@ -402,10 +424,41 @@ def test_build_user_prompt_uses_prompting(monkeypatch: pytest.MonkeyPatch) -> No
     monkeypatch.setattr(qa_module, "make_user_prompt", recorder)
 
     qa = object.__new__(QuickAgent)
-    result = qa._build_user_prompt(step=step, loaded=loaded, run_input=run_input, state={"steps": {}})
+    qa.loaded = loaded
+    qa.run_input = run_input
+    qa.state = {"agent_id": "agent-1", "steps": {}, "final_output": None}
+    result = qa._build_user_prompt()
 
     assert result == "prompt"
-    assert recorder.calls == [((loaded.step_prompts["step:one"], run_input, {"steps": {}}), {})]
+    assert recorder.calls == [
+        (
+            (run_input, {"agent_id": "agent-1", "steps": {}, "final_output": None}),
+            {},
+        )
+    ]
+
+
+@pytest.mark.anyio
+async def test_run_text_step_raises_for_missing_section(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(qa_module, "Agent", FakeAgent)
+
+    step = ChainStepSpec(id="s1", kind="text", prompt_section="step:missing")
+    loaded = _make_loaded_with_chain([step])
+    run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
+
+    qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.tool_ids = []
+    qa.run_input = run_input
+    qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
+
+    with pytest.raises(KeyError):
+        await qa._run_text_step(
+            step=step,
+        )
 
 
 @pytest.mark.anyio
@@ -418,23 +471,51 @@ async def test_run_step_text_returns_output(monkeypatch: pytest.MonkeyPatch) ->
     run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
 
     qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.tool_ids = []
+    qa.run_input = run_input
+    qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
     output, final = await qa._run_step(
         step=step,
-        loaded=loaded,
-        model=cast(OpenAIChatModel, object()),
-        model_settings_json=None,
-        toolset=RecordingToolset(),
-        run_input=run_input,
-        state={"agent_id": "a", "steps": {}},
     )
 
     assert output == "hello"
     assert final == "hello"
     assert FakeAgent.last_init is not None
-    assert FakeAgent.last_init["instructions"] == "system"
+    assert FakeAgent.last_init["instructions"] == "systemdo thing"
+    assert FakeAgent.last_init["system_prompt"] == []
     assert FakeAgent.last_init["output_type"] is str
 
 
+@pytest.mark.anyio
+async def test_run_text_step_omits_tools_when_disabled(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(qa_module, "Agent", FakeAgent)
+    FakeAgent.next_output = "hello"
+
+    step = ChainStepSpec(id="s1", kind="text", prompt_section="step:one")
+    loaded = _make_loaded_with_chain([step])
+    run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
+
+    qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.run_input = run_input
+    qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
+    qa.tool_ids = []
+
+    await qa._run_text_step(
+        step=step,
+    )
+
+    assert FakeAgent.last_init is not None
+    assert FakeAgent.last_init["toolsets"] == []
+
+
 @pytest.mark.anyio
 async def test_run_step_structured_parses_json_with_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(qa_module, "Agent", FakeAgent)
@@ -451,19 +532,25 @@ async def test_run_step_structured_parses_json_with_fallback(monkeypatch: pytest
         chain=[step],
         schemas={"Example": "schemas.struct:ExampleSchema"},
     )
-    loaded = LoadedAgentFile(spec=spec, body="system", step_prompts={"step:one": "do thing"})
+    loaded = LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="system",
+        system_prompt="",
+        step_prompts={"step:one": "do thing"},
+    )
     run_input = RunInput(source_path="in.json", kind="json", text="{}", data={})
 
     try:
         qa = object.__new__(QuickAgent)
+        qa.loaded = loaded
+        qa.model = cast(OpenAIChatModel, object())
+        qa.model_settings_json = {"extra_body": {"format": "json"}}
+        qa.toolset = RecordingToolset()
+        qa.tool_ids = []
+        qa.run_input = run_input
+        qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
         output, final = await qa._run_step(
             step=step,
-            loaded=loaded,
-            model=cast(OpenAIChatModel, object()),
-            model_settings_json={"extra_body": {"format": "json"}},
-            toolset=RecordingToolset(),
-            run_input=run_input,
-            state={"agent_id": "a", "steps": {}},
         )
     finally:
         sys.modules.pop("schemas.struct", None)
@@ -471,6 +558,8 @@ async def test_run_step_structured_parses_json_with_fallback(monkeypatch: pytest
     assert output == {"x": 7}
     assert isinstance(final, ExampleSchema)
     assert final.x == 7
+    assert FakeAgent.last_init is not None
+    assert FakeAgent.last_init["output_type"] is ExampleSchema
 
 
 @pytest.mark.anyio
@@ -481,15 +570,15 @@ async def test_run_step_unknown_kind_raises(monkeypatch: pytest.MonkeyPatch) ->
     run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
 
     qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.run_input = run_input
+    qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
     with pytest.raises(NotImplementedError):
         await qa._run_step(
             step=step,
-            loaded=loaded,
-            model=cast(OpenAIChatModel, object()),
-            model_settings_json=None,
-            toolset=RecordingToolset(),
-            run_input=run_input,
-            state={"agent_id": "a", "steps": {}},
         )
 
 
@@ -502,15 +591,15 @@ async def test_run_text_step_uses_build_user_prompt(monkeypatch: pytest.MonkeyPa
     run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
 
     qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.toolset = RecordingToolset()
+    qa.tool_ids = []
+    qa.run_input = run_input
     monkeypatch.setattr(qa, "_build_user_prompt", SyncCallRecorder(return_value="prompt"))
 
     output, final = await qa._run_text_step(
         step=step,
-        loaded=loaded,
-        model=cast(OpenAIChatModel, object()),
-        toolset=RecordingToolset(),
-        run_input=run_input,
-        state={"agent_id": "a", "steps": {}},
     )
 
     assert output == "ok"
@@ -518,6 +607,129 @@ async def test_run_text_step_uses_build_user_prompt(monkeypatch: pytest.MonkeyPa
     assert FakeAgent.last_prompt == "prompt"
 
 
+@pytest.mark.anyio
+async def test_run_text_step_no_instructions_or_system_prompt(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(qa_module, "Agent", FakeAgent)
+    FakeAgent.next_output = "ok"
+
+    step = ChainStepSpec(id="s1", kind="text", prompt_section="step:one")
+    spec = AgentSpec(
+        name="test",
+        model=ModelSpec(base_url="http://x", model_name="m"),
+        chain=[step],
+        output=OutputSpec(file=None),
+    )
+    loaded = LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="",
+        system_prompt="",
+        step_prompts={"step:one": "do thing"},
+    )
+    run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
+
+    qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.tool_ids = []
+    qa.run_input = run_input
+    qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
+
+    output, final = await qa._run_text_step(
+        step=step,
+    )
+
+    assert output == "ok"
+    assert final == "ok"
+    assert FakeAgent.last_init is not None
+    assert FakeAgent.last_init["instructions"] == "do thing"
+    assert FakeAgent.last_init["system_prompt"] == []
+    assert FakeAgent.last_prompt == make_user_prompt(run_input, qa.state)
+
+
+@pytest.mark.anyio
+async def test_run_text_step_system_prompt_only(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(qa_module, "Agent", FakeAgent)
+    FakeAgent.next_output = "ok"
+
+    step = ChainStepSpec(id="s1", kind="text", prompt_section="step:one")
+    spec = AgentSpec(
+        name="test",
+        model=ModelSpec(base_url="http://x", model_name="m"),
+        chain=[step],
+        output=OutputSpec(file=None),
+    )
+    loaded = LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="",
+        system_prompt="You are concise.",
+        step_prompts={"step:one": "do thing"},
+    )
+    run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
+
+    qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.tool_ids = []
+    qa.run_input = run_input
+    qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
+
+    output, final = await qa._run_text_step(
+        step=step,
+    )
+
+    assert output == "ok"
+    assert final == "ok"
+    assert FakeAgent.last_init is not None
+    assert FakeAgent.last_init["instructions"] == "do thing"
+    assert FakeAgent.last_init["system_prompt"] == "You are concise."
+    assert FakeAgent.last_prompt == make_user_prompt(run_input, qa.state)
+
+
+@pytest.mark.anyio
+async def test_run_text_step_instructions_only(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(qa_module, "Agent", FakeAgent)
+    FakeAgent.next_output = "ok"
+
+    step = ChainStepSpec(id="s1", kind="text", prompt_section="step:one")
+    spec = AgentSpec(
+        name="test",
+        model=ModelSpec(base_url="http://x", model_name="m"),
+        chain=[step],
+        output=OutputSpec(file=None),
+    )
+    loaded = LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="Use the tool.",
+        system_prompt="",
+        step_prompts={"step:one": "do thing"},
+    )
+    run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
+
+    qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.tool_ids = []
+    qa.run_input = run_input
+    qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
+
+    output, final = await qa._run_text_step(
+        step=step,
+    )
+
+    assert output == "ok"
+    assert final == "ok"
+    assert FakeAgent.last_init is not None
+    assert FakeAgent.last_init["instructions"] == "Use the tool.do thing"
+    assert FakeAgent.last_init["system_prompt"] == []
+    assert FakeAgent.last_prompt == make_user_prompt(run_input, qa.state)
+
+
 @pytest.mark.anyio
 async def test_run_structured_step_missing_schema_raises() -> None:
     step = ChainStepSpec(id="s1", kind="structured", prompt_section="step:one", output_schema=None)
@@ -525,15 +737,14 @@ async def test_run_structured_step_missing_schema_raises() -> None:
     run_input = RunInput(source_path="in.json", kind="json", text="{}", data={})
 
     qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.run_input = run_input
     with pytest.raises(ValueError):
         await qa._run_structured_step(
             step=step,
-            loaded=loaded,
-            model=cast(OpenAIChatModel, object()),
-            model_settings_json=None,
-            toolset=RecordingToolset(),
-            run_input=run_input,
-            state={"agent_id": "a", "steps": {}},
         )
 
 
@@ -553,19 +764,25 @@ async def test_run_structured_step_parses_json(monkeypatch: pytest.MonkeyPatch)
         chain=[step],
         schemas={"Example": "schemas.struct2:ExampleSchema"},
     )
-    loaded = LoadedAgentFile(spec=spec, body="system", step_prompts={"step:one": "do thing"})
+    loaded = LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="system",
+        system_prompt="",
+        step_prompts={"step:one": "do thing"},
+    )
     run_input = RunInput(source_path="in.json", kind="json", text="{}", data={})
 
     try:
         qa = object.__new__(QuickAgent)
+        qa.loaded = loaded
+        qa.model = cast(OpenAIChatModel, object())
+        qa.model_settings_json = None
+        qa.toolset = RecordingToolset()
+        qa.tool_ids = []
+        qa.run_input = run_input
+        qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
         output, final = await qa._run_structured_step(
             step=step,
-            loaded=loaded,
-            model=cast(OpenAIChatModel, object()),
-            model_settings_json=None,
-            toolset=RecordingToolset(),
-            run_input=run_input,
-            state={"agent_id": "a", "steps": {}},
         )
     finally:
         sys.modules.pop("schemas.struct2", None)
@@ -590,19 +807,25 @@ async def test_run_structured_step_adds_json_schema_for_openai(monkeypatch: pyte
         chain=[step],
         schemas={"Example": "schemas.struct3:ExampleSchema"},
     )
-    loaded = LoadedAgentFile(spec=spec, body="system", step_prompts={"step:one": "do thing"})
+    loaded = LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="system",
+        system_prompt="",
+        step_prompts={"step:one": "do thing"},
+    )
     run_input = RunInput(source_path="in.json", kind="json", text="{}", data={})
 
     try:
         qa = object.__new__(QuickAgent)
+        qa.loaded = loaded
+        qa.model = cast(OpenAIChatModel, DummyOpenAIModel("https://api.openai.com/v1"))
+        qa.model_settings_json = None
+        qa.toolset = RecordingToolset()
+        qa.tool_ids = []
+        qa.run_input = run_input
+        qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
         await qa._run_structured_step(
             step=step,
-            loaded=loaded,
-            model=cast(OpenAIChatModel, DummyOpenAIModel("https://api.openai.com/v1")),
-            model_settings_json=None,
-            toolset=RecordingToolset(),
-            run_input=run_input,
-            state={"agent_id": "a", "steps": {}},
         )
     finally:
         sys.modules.pop("schemas.struct3", None)
@@ -623,22 +846,95 @@ async def test_run_chain_updates_state_and_returns_last() -> None:
     loaded = _make_loaded_with_chain([step1, step2])
 
     qa = RecordingQuickAgent(outputs=[({"a": 1}, "first"), ("b", "second")])
-    state = {"agent_id": "a", "steps": {}}
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
+    qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
 
-    final = await qa._run_chain(
-        loaded=loaded,
-        model=cast(OpenAIChatModel, object()),
-        model_settings_json=None,
-        toolset=RecordingToolset(),
-        run_input=RunInput(source_path="in.txt", kind="text", text="hi", data=None),
-        state=state,
-    )
+    final = await qa._run_chain()
 
     assert final == "second"
-    assert state["steps"] == {"s1": {"a": 1}, "s2": "b"}
+    assert qa.state["steps"] == {"s1": {"a": 1}, "s2": "b"}
+    assert qa.state["final_output"] == "b"
     assert qa.calls == ["s1", "s2"]
 
 
+@pytest.mark.anyio
+async def test_run_chain_single_shot_system_prompt_only(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(qa_module, "Agent", FakeAgent)
+    FakeAgent.next_output = "hello"
+
+    spec = AgentSpec(
+        name="test",
+        model=ModelSpec(base_url="http://x", model_name="m"),
+        chain=[],
+        output=OutputSpec(file=None),
+    )
+    loaded = LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="",
+        system_prompt="You are concise.",
+        step_prompts={},
+    )
+    run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
+
+    qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.tool_ids = []
+    qa.run_input = run_input
+    qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
+
+    output = await qa._run_chain()
+
+    assert output == "hello"
+    assert FakeAgent.last_init is not None
+    assert FakeAgent.last_init["instructions"] is None
+    assert FakeAgent.last_init["system_prompt"] == "You are concise."
+    assert FakeAgent.last_prompt == make_user_prompt(run_input, qa.state)
+
+
+@pytest.mark.anyio
+async def test_run_chain_single_shot_instructions_only(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(qa_module, "Agent", FakeAgent)
+    FakeAgent.next_output = "hello"
+
+    spec = AgentSpec(
+        name="test",
+        model=ModelSpec(base_url="http://x", model_name="m"),
+        chain=[],
+        output=OutputSpec(file=None),
+    )
+    loaded = LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="Use the tool.",
+        system_prompt="",
+        step_prompts={},
+    )
+    run_input = RunInput(source_path="in.txt", kind="text", text="hi", data=None)
+
+    qa = object.__new__(QuickAgent)
+    qa.loaded = loaded
+    qa.model = cast(OpenAIChatModel, object())
+    qa.model_settings_json = None
+    qa.toolset = RecordingToolset()
+    qa.tool_ids = []
+    qa.run_input = run_input
+    qa.state = {"agent_id": "a", "steps": {}, "final_output": None}
+
+    output = await qa._run_chain()
+
+    assert output == "hello"
+    assert FakeAgent.last_init is not None
+    assert FakeAgent.last_init["instructions"] == "Use the tool."
+    assert FakeAgent.last_init["system_prompt"] == []
+    assert FakeAgent.last_prompt == make_user_prompt(run_input, qa.state)
+
+
 def test_write_final_output_serializes_model(tmp_path: Path) -> None:
     safe_root = tmp_path / "safe"
     out_path = safe_root / "out.json"
@@ -648,7 +944,9 @@ def test_write_final_output_serializes_model(tmp_path: Path) -> None:
 
     permissions = DirectoryPermissions(safe_root)
     qa = object.__new__(QuickAgent)
-    result_path = qa._write_final_output(loaded, OutputSchema(msg="hi"), permissions)
+    qa.loaded = loaded
+    qa.permissions = permissions
+    result_path = qa._write_final_output(OutputSchema(msg="hi"))
 
     assert result_path == out_path
     assert "\"msg\": \"hi\"" in out_path.read_text(encoding="utf-8")
@@ -663,7 +961,9 @@ def test_write_final_output_writes_text(tmp_path: Path) -> None:
 
     permissions = DirectoryPermissions(safe_root)
     qa = object.__new__(QuickAgent)
-    result_path = qa._write_final_output(loaded, "hello", permissions)
+    qa.loaded = loaded
+    qa.permissions = permissions
+    result_path = qa._write_final_output("hello")
 
     assert result_path == out_path
     assert out_path.read_text(encoding="utf-8") == "hello"
@@ -671,26 +971,49 @@ def test_write_final_output_writes_text(tmp_path: Path) -> None:
 
 @pytest.mark.anyio
 async def test_handle_handoff_runs_followup() -> None:
-    out_path = Path("/tmp/out.json")
     handoff = HandoffSpec(enabled=True, agent_id="next")
     step = ChainStepSpec(id="s1", kind="text", prompt_section="step:one")
     loaded = _make_loaded_with_chain([step], handoff=handoff)
 
     qa = HandoffQuickAgent()
-    await qa._handle_handoff(loaded, out_path)
+    qa.loaded = loaded
+    await qa._handle_handoff("hello")
+
+    assert len(qa.calls) == 1
+    agent_id, input_data = qa.calls[0]
+    assert agent_id == "next"
+    assert isinstance(input_data, input_adaptors_module.TextInput)
+    run_input = input_data.load()
+    assert run_input.kind == "text"
+    assert run_input.text == "hello"
+
+
+@pytest.mark.anyio
+async def test_handle_handoff_serializes_structured_output() -> None:
+    handoff = HandoffSpec(enabled=True, agent_id="next")
+    step = ChainStepSpec(id="s1", kind="text", prompt_section="step:one")
+    loaded = _make_loaded_with_chain([step], handoff=handoff)
+
+    qa = HandoffQuickAgent()
+    qa.loaded = loaded
+    await qa._handle_handoff(OutputSchema(msg="hi"))
 
-    assert qa.calls == [("next", out_path)]
+    assert len(qa.calls) == 1
+    _, input_data = qa.calls[0]
+    assert isinstance(input_data, input_adaptors_module.TextInput)
+    run_input = input_data.load()
+    assert "\"msg\": \"hi\"" in run_input.text
 
 
 @pytest.mark.anyio
 async def test_handle_handoff_skips_when_disabled() -> None:
-    out_path = Path("/tmp/out.json")
     handoff = HandoffSpec(enabled=False, agent_id="next")
     step = ChainStepSpec(id="s1", kind="text", prompt_section="step:one")
     loaded = _make_loaded_with_chain([step], handoff=handoff)
 
     qa = HandoffQuickAgent()
-    await qa._handle_handoff(loaded, out_path)
+    qa.loaded = loaded
+    await qa._handle_handoff("ignored")
 
     assert qa.calls == []
 
@@ -705,7 +1028,12 @@ async def test_run_agent_wires_dependencies(monkeypatch: pytest.MonkeyPatch, tmp
         tools=["tool.a", "agent.call", "tool.a"],
         output=OutputSpec(file=str(tmp_path / "out.json")),
     )
-    loaded = LoadedAgentFile(spec=spec, body="system", step_prompts={"step:one": "do thing"})
+    loaded = LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="system",
+        system_prompt="",
+        step_prompts={"step:one": "do thing"},
+    )
 
     run_input = RunInput(source_path=str(tmp_path / "input.json"), kind="json", text="{}", data={})
     toolset = RecordingToolset()
@@ -722,7 +1050,7 @@ async def test_run_agent_wires_dependencies(monkeypatch: pytest.MonkeyPatch, tmp
     write_output_recorder = SyncCallRecorder(return_value=out_path)
     handoff_recorder = AsyncCallRecorder(return_value=None)
 
-    monkeypatch.setattr(qa_module, "load_input", load_input_recorder)
+    monkeypatch.setattr(input_adaptors_module, "load_input", load_input_recorder)
     monkeypatch.setattr(qa_module, "build_model", build_model_recorder)
     monkeypatch.setattr(QuickAgent, "_build_model_settings", build_settings_recorder)
     monkeypatch.setattr(QuickAgent, "_run_chain", run_chain_recorder)
@@ -739,7 +1067,7 @@ async def test_run_agent_wires_dependencies(monkeypatch: pytest.MonkeyPatch, tmp
         tools=tools,
         directory_permissions=_permissions(tmp_path),
         agent_id="agent-1",
-        input_path=tmp_path / "input.json",
+        input_data=tmp_path / "input.json",
         extra_tools=["tool.b"],
     )
 
@@ -756,6 +1084,8 @@ async def test_run_agent_wires_dependencies(monkeypatch: pytest.MonkeyPatch, tmp
     assert load_args[1].root == _permissions(tmp_path).root
     assert build_model_recorder.calls == [((loaded.spec.model,), {})]
 
+    assert build_settings_recorder.calls == [((loaded.spec.model,), {})]
+
     assert build_toolset_recorder.calls
     args, kwargs = build_toolset_recorder.calls[0]
     assert kwargs == {}
@@ -766,7 +1096,6 @@ async def test_run_agent_wires_dependencies(monkeypatch: pytest.MonkeyPatch, tmp
     ]
     assert isinstance(args[1], DirectoryPermissions)
 
-    assert build_settings_recorder.calls == [((loaded.spec.model,), {})]
     maybe_args, maybe_kwargs = maybe_inject_recorder.calls[0]
     assert maybe_kwargs == {}
     assert maybe_args[0] == [
@@ -779,19 +1108,104 @@ async def test_run_agent_wires_dependencies(monkeypatch: pytest.MonkeyPatch, tmp
     assert callable(maybe_args[3])
 
     assert run_chain_recorder.calls
-    run_chain_kwargs = run_chain_recorder.calls[0]["kwargs"]
-    assert run_chain_kwargs["loaded"] is loaded
-    assert run_chain_kwargs["model"] is model
-    assert run_chain_kwargs["model_settings_json"] is settings
-    assert run_chain_kwargs["toolset"] is toolset
-    assert run_chain_kwargs["run_input"] is run_input
-    assert run_chain_kwargs["state"]["agent_id"] == "agent-1"
+    assert run_chain_recorder.calls[0]["kwargs"] == {}
 
     assert write_output_recorder.calls
     write_args, write_kwargs = write_output_recorder.calls[0]
     assert write_kwargs == {}
-    assert write_args[0] is loaded
-    assert write_args[1] == "final"
-    assert isinstance(write_args[2], DirectoryPermissions)
-    assert write_args[2].root == _permissions(tmp_path).root
-    assert handoff_recorder.calls == [{"args": (loaded, out_path), "kwargs": {}}]
+    assert write_args[0] == "final"
+    assert handoff_recorder.calls == [{"args": ("final",), "kwargs": {}}]
+
+
+@pytest.mark.anyio
+async def test_run_skips_write_when_output_file_missing(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    step = ChainStepSpec(id="s1", kind="text", prompt_section="step:one")
+    spec = AgentSpec(
+        name="test",
+        model=ModelSpec(base_url="http://x", model_name="m"),
+        chain=[step],
+        output=OutputSpec(file=None),
+    )
+    loaded = LoadedAgentFile.from_parts(
+        spec=spec,
+        instructions="system",
+        system_prompt="",
+        step_prompts={"step:one": "do thing"},
+    )
+
+    run_input = RunInput(source_path=str(tmp_path / "input.json"), kind="json", text="{}", data={})
+    toolset = RecordingToolset()
+    model = object()
+
+    load_input_recorder = SyncCallRecorder(return_value=run_input)
+    build_model_recorder = SyncCallRecorder(return_value=model)
+    build_toolset_recorder = SyncCallRecorder(return_value=toolset)
+    build_settings_recorder = SyncCallRecorder(return_value=None)
+    maybe_inject_recorder = SyncCallRecorder(return_value=None)
+    run_chain_recorder = AsyncCallRecorder(return_value="final")
+    write_output_recorder = SyncCallRecorder(return_value=tmp_path / "out.json")
+    handoff_recorder = AsyncCallRecorder(return_value=None)
+
+    monkeypatch.setattr(input_adaptors_module, "load_input", load_input_recorder)
+    monkeypatch.setattr(qa_module, "build_model", build_model_recorder)
+    monkeypatch.setattr(QuickAgent, "_build_model_settings", build_settings_recorder)
+    monkeypatch.setattr(QuickAgent, "_run_chain", run_chain_recorder)
+    monkeypatch.setattr(QuickAgent, "_write_final_output", write_output_recorder)
+    monkeypatch.setattr(QuickAgent, "_handle_handoff", handoff_recorder)
+
+    tools = AgentTools([tmp_path])
+    monkeypatch.setattr(tools, "build_toolset", build_toolset_recorder)
+    monkeypatch.setattr(tools, "maybe_inject_agent_call", maybe_inject_recorder)
+    fake_registry = FakeRegistry(loaded)
+
+    agent = QuickAgent(
+        registry=fake_registry,
+        tools=tools,
+        directory_permissions=_permissions(tmp_path),
+        agent_id="agent-1",
+        input_data=tmp_path / "input.json",
+        extra_tools=None,
+    )
+
+    result = await agent.run()
+
+    assert result == "final"
+    assert write_output_recorder.calls == []
+    assert handoff_recorder.calls == [{"args": ("final",), "kwargs": {}}]
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    ("nested_output", "expected_write_output"),
+    [
+        ("inline", False),
+        ("file", True),
+    ],
+)
+async def test_run_nested_agent_respects_nested_output(
+    monkeypatch: pytest.MonkeyPatch,
+    nested_output: Literal["inline", "file"],
+    expected_write_output: bool,
+) -> None:
+    qa = object.__new__(QuickAgent)
+    qa._registry = cast(AgentRegistry, object())
+    qa._tools = cast(AgentTools, object())
+    qa._directory_permissions = cast(DirectoryPermissions, object())
+
+    step = ChainStepSpec(id="s1", kind="text", prompt_section="step:one")
+    loaded = _make_loaded_with_chain([step])
+    loaded.spec.nested_output = nested_output
+    qa.loaded = loaded
+
+    init_recorder = SyncCallRecorder(return_value=None)
+    run_recorder = AsyncCallRecorder(return_value="ok")
+    monkeypatch.setattr(QuickAgent, "__init__", init_recorder)
+    monkeypatch.setattr(QuickAgent, "run", run_recorder)
+
+    await qa._run_nested_agent("child", Path("input.txt"))
+
+    assert len(init_recorder.calls) == 1
+    _, kwargs = init_recorder.calls[0]
+    assert kwargs["write_output"] is expected_write_output