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

tests/test_orchestrator.py

@@ -27,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:
@@ -77,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,
@@ -85,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,
@@ -188,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:
@@ -237,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
@@ -408,21 +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)
-    qa.loaded = loaded
-    qa.run_input = run_input
-    qa.state = {"agent_id": "agent-1", "steps": {}, "final_output": None}
-    with pytest.raises(KeyError):
-        qa._build_user_prompt(
-            step=step,
-        )
-
-
 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])
@@ -434,19 +427,40 @@ def test_build_user_prompt_uses_prompting(monkeypatch: pytest.MonkeyPatch) -> No
     qa.loaded = loaded
     qa.run_input = run_input
     qa.state = {"agent_id": "agent-1", "steps": {}, "final_output": None}
-    result = qa._build_user_prompt(
-        step=step,
-    )
+    result = qa._build_user_prompt()
 
     assert result == "prompt"
     assert recorder.calls == [
         (
-            (loaded.step_prompts["step:one"], run_input, {"agent_id": "agent-1", "steps": {}, "final_output": None}),
+            (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
 async def test_run_step_text_returns_output(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(qa_module, "Agent", FakeAgent)
@@ -461,6 +475,7 @@ async def test_run_step_text_returns_output(monkeypatch: pytest.MonkeyPatch) ->
     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(
@@ -470,10 +485,37 @@ async def test_run_step_text_returns_output(monkeypatch: pytest.MonkeyPatch) ->
     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)
@@ -490,7 +532,12 @@ 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:
@@ -499,6 +546,7 @@ async def test_run_step_structured_parses_json_with_fallback(monkeypatch: pytest
         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(
@@ -510,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
@@ -544,6 +594,7 @@ async def test_run_text_step_uses_build_user_prompt(monkeypatch: pytest.MonkeyPa
     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"))
 
@@ -556,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)
@@ -590,7 +764,12 @@ 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:
@@ -599,6 +778,7 @@ async def test_run_structured_step_parses_json(monkeypatch: pytest.MonkeyPatch)
         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(
@@ -627,7 +807,12 @@ 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:
@@ -636,6 +821,7 @@ async def test_run_structured_step_adds_json_schema_for_openai(monkeypatch: pyte
         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(
@@ -675,6 +861,80 @@ async def test_run_chain_updates_state_and_returns_last() -> None:
     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"
@@ -768,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()
@@ -819,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 == {}
@@ -829,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] == [
@@ -851,6 +1117,65 @@ async def test_run_agent_wires_dependencies(monkeypatch: pytest.MonkeyPatch, tmp
     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"),