quick-agent 0.1.1__py3-none-any.whl

tests/test_agent.py

@@ -0,0 +1,196 @@
+import json
+import sys
+import types
+from pathlib import Path
+
+import pytest
+
+from pydantic import BaseModel
+
+from quick_agent import agent_registry
+from quick_agent import io_utils
+from quick_agent import prompting
+from quick_agent import tools_loader
+from quick_agent.directory_permissions import DirectoryPermissions
+from quick_agent.models import AgentSpec
+from quick_agent.models import ChainStepSpec
+from quick_agent.models import LoadedAgentFile
+from quick_agent.models import ModelSpec
+from quick_agent.models.run_input import RunInput
+from quick_agent.quick_agent import resolve_schema
+
+
+def test_import_symbol_valid_and_invalid() -> None:
+    tmp_module = types.ModuleType("tmpmod")
+    tmp_module.__dict__["Value"] = 123
+    sys.modules["tmpmod"] = tmp_module
+    try:
+        assert tools_loader.import_symbol("tmpmod:Value") == 123
+        with pytest.raises(ValueError):
+            tools_loader.import_symbol("tmpmod.Value")
+    finally:
+        sys.modules.pop("tmpmod", None)
+
+
+def test_split_step_sections_extracts_content() -> None:
+    body = """
+# Title
+
+## step:one
+
+Hello one.
+
+## step:two
+
+Hello two.
+"""
+    sections = agent_registry.split_step_sections(body)
+    assert sections["step:one"] == "Hello one."
+    assert sections["step:two"] == "Hello two."
+
+
+def test_load_input_json_and_text(tmp_path: Path) -> None:
+    safe_root = tmp_path / "safe"
+    safe_root.mkdir(parents=True, exist_ok=True)
+    permissions = DirectoryPermissions(safe_root)
+    json_path = safe_root / "in.json"
+    json_path.write_text(json.dumps({"a": 1}), encoding="utf-8")
+    run_input = io_utils.load_input(json_path, permissions)
+    assert run_input.kind == "json"
+    assert run_input.data == {"a": 1}
+    assert "\n" in run_input.text
+
+    txt_path = safe_root / "in.txt"
+    txt_path.write_text("hello", encoding="utf-8")
+    run_input = io_utils.load_input(txt_path, permissions)
+    assert run_input.kind == "text"
+    assert run_input.text == "hello"
+    assert run_input.data is None
+
+
+def test_write_output_creates_parent(tmp_path: Path) -> None:
+    safe_root = tmp_path / "safe"
+    safe_root.mkdir(parents=True, exist_ok=True)
+    permissions = DirectoryPermissions(safe_root)
+    out_path = safe_root / "nested" / "out.txt"
+    io_utils.write_output(out_path, "data", permissions)
+    assert out_path.read_text(encoding="utf-8") == "data"
+
+
+def test_make_user_prompt_contains_sections() -> None:
+    run_input = RunInput(source_path="file.txt", kind="text", text="hi", data=None)
+    prompt = prompting.make_user_prompt("do thing", run_input, {"x": 1})
+
+    assert "# Task Input" in prompt
+    assert "source_path: file.txt" in prompt
+    assert "## Input Content" in prompt
+    assert "hi" in prompt
+    assert "## Chain State (JSON)" in prompt
+    assert '"x": 1' in prompt
+    assert "## Step Instructions" in prompt
+    assert "do thing" in prompt
+
+
+def test_resolve_schema_valid_missing_and_invalid() -> None:
+    schema_module = types.ModuleType("schemas.tmp")
+
+    class GoodSchema(BaseModel):
+        x: int
+
+    class NotSchema:
+        pass
+
+    schema_module.__dict__["GoodSchema"] = GoodSchema
+    schema_module.__dict__["NotSchema"] = NotSchema
+    sys.modules["schemas.tmp"] = schema_module
+
+    spec = AgentSpec(
+        name="test",
+        model=ModelSpec(base_url="http://x", model_name="y"),
+        chain=[ChainStepSpec(id="s1", kind="text", prompt_section="step:one")],
+        schemas={"Good": "schemas.tmp:GoodSchema", "Bad": "schemas.tmp:NotSchema"},
+    )
+    loaded = LoadedAgentFile(spec=spec, body="", step_prompts={})
+
+    try:
+        assert resolve_schema(loaded, "Good") is GoodSchema
+
+        with pytest.raises(KeyError):
+            resolve_schema(loaded, "Missing")
+
+        with pytest.raises(TypeError):
+            resolve_schema(loaded, "Bad")
+    finally:
+        sys.modules.pop("schemas.tmp", None)
+
+
+def test_load_agent_file_parses_frontmatter_and_steps(tmp_path: Path) -> None:
+    md = """---
+name: Test
+description: Hello
+model:
+  base_url: http://localhost
+  model_name: test
+chain:
+  - id: one
+    kind: text
+    prompt_section: step:one
+---
+
+## step:one
+
+body.
+"""
+    md_path = tmp_path / "agent.md"
+    md_path.write_text(md, encoding="utf-8")
+
+    loaded = agent_registry.load_agent_file(md_path)
+    assert loaded.spec.name == "Test"
+    assert loaded.step_prompts["step:one"] == "body."
+
+
+def test_load_agent_file_model_defaults_when_missing(tmp_path: Path) -> None:
+    md = """---
+name: Defaults
+model: {}
+chain:
+  - id: one
+    kind: text
+    prompt_section: step:one
+---
+
+## step:one
+
+body.
+"""
+    md_path = tmp_path / "agent.md"
+    md_path.write_text(md, encoding="utf-8")
+
+    loaded = agent_registry.load_agent_file(md_path)
+    assert loaded.spec.model.base_url == "https://api.openai.com/v1"
+    assert loaded.spec.model.api_key_env == "OPENAI_API_KEY"
+    assert loaded.spec.model.model_name == "gpt-5.2"
+    assert loaded.spec.model.provider == "openai-compatible"
+
+
+def test_load_agent_file_allows_missing_model_block(tmp_path: Path) -> None:
+    md = """---
+name: Defaults
+chain:
+  - id: one
+    kind: text
+    prompt_section: step:one
+---
+
+## step:one
+
+body.
+"""
+    md_path = tmp_path / "agent.md"
+    md_path.write_text(md, encoding="utf-8")
+
+    loaded = agent_registry.load_agent_file(md_path)
+    assert loaded.spec.model.base_url == "https://api.openai.com/v1"
+    assert loaded.spec.model.api_key_env == "OPENAI_API_KEY"
+    assert loaded.spec.model.model_name == "gpt-5.2"
+    assert loaded.spec.model.provider == "openai-compatible"

tests/test_directory_permissions.py

@@ -0,0 +1,89 @@
+from pathlib import Path
+
+import pytest
+
+from quick_agent.directory_permissions import DirectoryPermissions
+from quick_agent.orchestrator import Orchestrator
+from quick_agent.quick_agent import QuickAgent
+
+
+class AsyncReturner:
+    def __init__(self, value: object) -> None:
+        self.value = value
+
+    async def __call__(self, *args: object, **kwargs: object) -> object:
+        return self.value
+
+
+def test_directory_permissions_resolve_allows_within_root(tmp_path: Path) -> None:
+    safe_root = tmp_path / "safe"
+    safe_root.mkdir(parents=True, exist_ok=True)
+    perms = DirectoryPermissions(safe_root)
+
+    resolved = perms.resolve(Path("nested/file.txt"), for_write=False)
+
+    assert resolved == safe_root / "nested" / "file.txt"
+
+
+def test_directory_permissions_resolve_blocks_escape(tmp_path: Path) -> None:
+    safe_root = tmp_path / "safe"
+    safe_root.mkdir(parents=True, exist_ok=True)
+    perms = DirectoryPermissions(safe_root)
+
+    with pytest.raises(PermissionError):
+        perms.resolve(Path("../outside.txt"), for_write=False)
+
+
+def test_directory_permissions_can_read_write(tmp_path: Path) -> None:
+    safe_root = tmp_path / "safe"
+    safe_root.mkdir(parents=True, exist_ok=True)
+    perms = DirectoryPermissions(safe_root)
+
+    assert perms.can_read(Path("ok.txt")) is True
+    assert perms.can_write(Path("ok.txt")) is True
+    assert perms.can_read(Path("../nope.txt")) is False
+    assert perms.can_write(Path("../nope.txt")) is False
+
+
+def test_agent_cannot_write_outside_scoped_directory(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    safe_root = tmp_path / "safe"
+    safe_root.mkdir(parents=True, exist_ok=True)
+    agents_dir = tmp_path / "agents"
+    agents_dir.mkdir(parents=True, exist_ok=True)
+
+    agent_md = """---
+name: "Scoped Agent"
+safe_dir: "agent"
+chain:
+  - id: one
+    kind: text
+    prompt_section: step:one
+output:
+  format: json
+  file: ../out.json
+---
+
+## step:one
+
+Say ok.
+"""
+    (agents_dir / "scoped.md").write_text(agent_md, encoding="utf-8")
+
+    input_path = safe_root / "agent" / "input.txt"
+    input_path.parent.mkdir(parents=True, exist_ok=True)
+    input_path.write_text("hi", encoding="utf-8")
+
+    orch = Orchestrator(
+        [agents_dir],
+        [tmp_path / "tools"],
+        safe_dir=safe_root,
+    )
+    monkeypatch.setattr(QuickAgent, "_run_chain", AsyncReturner("ok"))
+
+    with pytest.raises(PermissionError):
+        import anyio
+
+        anyio.run(orch.run, "scoped", input_path)

tests/test_integration.py

@@ -0,0 +1,221 @@
+from pathlib import Path
+import os
+
+import pytest
+from quick_agent.orchestrator import Orchestrator
+from pydantic import BaseModel
+
+
+async def _run_agent(orchestrator: Orchestrator, agent_id: str, input_path: Path) -> str:
+    result = await orchestrator.run(agent_id, input_path)
+    assert isinstance(result, str)
+    return result
+
+
+async def _run_agent_any(orchestrator: Orchestrator, agent_id: str, input_path: Path) -> BaseModel | str:
+    return await orchestrator.run(agent_id, input_path)
+
+
+def _require_env(name: str) -> str:
+    value = os.environ.get(name)
+    if not value:
+        pytest.skip(f"Missing required env var: {name}")
+        raise RuntimeError(f"Missing required env var: {name}")
+    return value
+
+
+class ContactInfo(BaseModel):
+    name: str
+    company: str
+    email: str
+    phone: str
+    role: str | None = None
+
+
+class ContactSummary(BaseModel):
+    contact: ContactInfo
+    summary: str
+
+
+def test_orchestrator_runs_agent_end_to_end(tmp_path: Path) -> None:
+    _require_env("OPENAI_API_KEY")
+    safe_root = tmp_path / "safe"
+    safe_root.mkdir(parents=True, exist_ok=True)
+
+    from quick_agent.orchestrator import Orchestrator
+
+    agents_dir = tmp_path / "agents"
+    agents_dir.mkdir(parents=True)
+
+    base_url = os.environ.get("OPENAI_BASE_URL") or "https://api.openai.com/v1"
+    model_name = os.environ.get("OPENAI_MODEL") or "gpt-5.2"
+
+    output_path = safe_root / "out" / "result.json"
+    agent_md = f"""---
+name: Test Agent
+model:
+  provider: openai-compatible
+  base_url: {base_url}
+  api_key_env: OPENAI_API_KEY
+  model_name: {model_name}
+chain:
+  - id: one
+    kind: text
+    prompt_section: step:one
+output:
+  format: json
+  file: {output_path}
+---
+
+## step:one
+
+Say ok.
+"""
+    (agents_dir / "example.md").write_text(agent_md, encoding="utf-8")
+
+    input_path = safe_root / "input.txt"
+    input_path.write_text("hello", encoding="utf-8")
+
+    orchestrator = Orchestrator(
+        [agents_dir],
+        [tmp_path / "tools"],
+        safe_dir=safe_root,
+    )
+
+    import anyio
+
+    output = anyio.run(_run_agent, orchestrator, "example", input_path)
+    assert output == "ok"
+
+
+def test_orchestrator_runs_multi_step_contact_extraction(tmp_path: Path) -> None:
+    _require_env("OPENAI_API_KEY")
+    safe_root = tmp_path / "safe"
+    safe_root.mkdir(parents=True, exist_ok=True)
+
+    agents_dir = tmp_path / "agents"
+    agents_dir.mkdir(parents=True)
+
+    output_path = safe_root / "out" / "result.json"
+    agent_md = f"""---
+name: Contact Extractor
+schemas:
+  ContactInfo: test_integration:ContactInfo
+  ContactSummary: test_integration:ContactSummary
+chain:
+  - id: extract
+    kind: structured
+    prompt_section: step:extract
+    output_schema: ContactInfo
+  - id: summary
+    kind: structured
+    prompt_section: step:summary
+    output_schema: ContactSummary
+output:
+  format: json
+  file: {output_path}
+---
+
+## step:extract
+
+Extract the primary business contact from the conversation as JSON that matches the ContactInfo schema.
+The \"name\" field should include the person's full name.
+If the role is not explicitly stated, set \"role\" to null.
+
+## step:summary
+
+Produce JSON matching ContactSummary. The summary must be a single sentence and include the contact name and company.
+Use the extracted JSON from the chain state as the ContactInfo object.
+"""
+    (agents_dir / "contact.md").write_text(agent_md, encoding="utf-8")
+
+    conversation = (
+        "Alex: Thanks for chatting today. The right point of contact is Avery Chen, our "
+        "Head of Partnerships at Acme Robotics. You can reach Avery at avery.chen@acmerobotics.com "
+        "or call +1-415-555-0199. Let's follow up next week."
+    )
+    input_path = safe_root / "input.txt"
+    input_path.write_text(conversation, encoding="utf-8")
+
+    orchestrator = Orchestrator(
+        [agents_dir],
+        [tmp_path / "tools"],
+        safe_dir=safe_root,
+    )
+
+    import anyio
+
+    output = anyio.run(_run_agent_any, orchestrator, "contact", input_path)
+    assert isinstance(output, ContactSummary)
+    assert output.contact.name == "Avery Chen"
+    assert output.contact.company == "Acme Robotics"
+    assert output.contact.email == "avery.chen@acmerobotics.com"
+    assert output.contact.phone == "+1-415-555-0199"
+    assert output.summary
+    assert "Avery" in output.summary
+    assert "Acme" in output.summary
+
+
+def test_orchestrator_allows_agent_call_tool(tmp_path: Path) -> None:
+    _require_env("OPENAI_API_KEY")
+    safe_root = tmp_path / "safe"
+    safe_root.mkdir(parents=True, exist_ok=True)
+
+    agents_dir = tmp_path / "agents"
+    agents_dir.mkdir(parents=True)
+
+    child_output = safe_root / "out" / "child.json"
+    child_md = f"""---
+name: Child Agent
+chain:
+  - id: respond
+    kind: text
+    prompt_section: step:respond
+output:
+  format: json
+  file: {child_output}
+---
+
+## step:respond
+
+Reply with exactly: pong
+"""
+    (agents_dir / "child.md").write_text(child_md, encoding="utf-8")
+
+    parent_output = safe_root / "out" / "parent.json"
+    parent_md = f"""---
+name: Parent Agent
+tools:
+  - "agent.call"
+chain:
+  - id: invoke
+    kind: text
+    prompt_section: step:invoke
+output:
+  format: json
+  file: {parent_output}
+---
+
+## step:invoke
+
+Call agent_call with agent "child" and input_file "{{base_directory}}/child_input.txt".
+Then respond with only the returned text value.
+"""
+    (agents_dir / "parent.md").write_text(parent_md, encoding="utf-8")
+
+    child_input = safe_root / "child_input.txt"
+    child_input.write_text("ignored", encoding="utf-8")
+
+    parent_input = safe_root / "parent_input.txt"
+    parent_input.write_text("call child", encoding="utf-8")
+
+    orchestrator = Orchestrator(
+        [agents_dir],
+        [tmp_path / "tools"],
+        safe_dir=safe_root,
+    )
+
+    import anyio
+
+    output = anyio.run(_run_agent, orchestrator, "parent", parent_input)
+    assert output == "pong"