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

quick_agent/quick_agent.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
-from typing import Any, Type
+from typing import Any, Type, TypeAlias, TypedDict
 
 from pydantic import BaseModel, ValidationError
 from pydantic_ai import Agent
@@ -16,13 +16,24 @@ from pydantic_ai.toolsets import FunctionToolset
 from quick_agent.agent_registry import AgentRegistry
 from quick_agent.agent_tools import AgentTools
 from quick_agent.directory_permissions import DirectoryPermissions
-from quick_agent.io_utils import load_input, write_output
+from quick_agent.input_adaptors import FileInput, InputAdaptor, TextInput
+from quick_agent.io_utils import write_output
 from quick_agent.json_utils import extract_first_json_object
 from quick_agent.models.loaded_agent_file import LoadedAgentFile
+from quick_agent.models.chain_step_spec import ChainStepSpec
 from quick_agent.models.model_spec import ModelSpec
+from quick_agent.models.run_input import RunInput
 from quick_agent.prompting import make_user_prompt
 from quick_agent.tools_loader import import_symbol
 
+StepOutput: TypeAlias = str | dict[str, Any]
+
+
+class ChainState(TypedDict):
+    agent_id: str
+    steps: dict[str, StepOutput]
+    final_output: StepOutput | None
+
 
 class QuickAgent:
     def __init__(
@@ -32,29 +43,37 @@ class QuickAgent:
         tools: AgentTools,
         directory_permissions: DirectoryPermissions,
         agent_id: str,
-        input_path: Path,
+        input_data: InputAdaptor | Path,
         extra_tools: list[str] | None,
+        write_output: bool = True,
     ) -> None:
-        self._registry = registry
-        self._tools = tools
-        self._directory_permissions = directory_permissions
-        self._agent_id = agent_id
-        self._input_path = input_path
-        self._extra_tools = extra_tools
-
-        self.loaded = self._registry.get(self._agent_id)
+        self._registry: AgentRegistry = registry
+        self._tools: AgentTools = tools
+        self._directory_permissions: DirectoryPermissions = directory_permissions
+        self._agent_id: str = agent_id
+        self._input_data: InputAdaptor | Path = input_data
+        self._extra_tools: list[str] | None = extra_tools
+        self._write_output_file: bool = write_output
+
+        self.loaded: LoadedAgentFile = self._registry.get(self._agent_id)
         safe_dir = self.loaded.spec.safe_dir
         if safe_dir is not None and Path(safe_dir).is_absolute():
             raise ValueError("safe_dir must be a relative path.")
-        self.permissions = self._directory_permissions.scoped(safe_dir)
-        self.run_input = load_input(self._input_path, self.permissions)
+        self.permissions: DirectoryPermissions = self._directory_permissions.scoped(safe_dir)
+        if isinstance(self._input_data, InputAdaptor):
+            input_adaptor = self._input_data
+        else:
+            input_adaptor = FileInput(self._input_data, self.permissions)
+        self.run_input: RunInput = input_adaptor.load()
 
-        self.tool_ids = list(dict.fromkeys((self.loaded.spec.tools or []) + (self._extra_tools or [])))
-        self.toolset = self._tools.build_toolset(self.tool_ids, self.permissions)
+        self.tool_ids: list[str] = list(
+            dict.fromkeys((self.loaded.spec.tools or []) + (self._extra_tools or []))
+        )
+        self.toolset: FunctionToolset[Any] = self._tools.build_toolset(self.tool_ids, self.permissions)
 
-        self.model = build_model(self.loaded.spec.model)
-        self.model_settings_json = self._build_model_settings(self.loaded.spec.model)
-        self.state = self._init_state(self._agent_id)
+        self.model: OpenAIChatModel = build_model(self.loaded.spec.model)
+        self.model_settings_json: ModelSettings | None = self._build_model_settings(self.loaded.spec.model)
+        self.state: ChainState = self._init_state()
 
     async def run(self) -> BaseModel | str:
         self._tools.maybe_inject_agent_call(
@@ -64,36 +83,33 @@ class QuickAgent:
             self._run_nested_agent,
         )
 
-        final_output = await self._run_chain(
-            loaded=self.loaded,
-            model=self.model,
-            model_settings_json=self.model_settings_json,
-            toolset=self.toolset,
-            run_input=self.run_input,
-            state=self.state,
-        )
+        final_output = await self._run_chain()
 
-        out_path = self._write_final_output(self.loaded, final_output, self.permissions)
+        if self._write_output_file:
+            self._write_final_output(final_output)
 
-        await self._handle_handoff(self.loaded, out_path)
+        await self._handle_handoff(final_output)
 
         return final_output
 
-    async def _run_nested_agent(self, agent_id: str, input_path: Path) -> BaseModel | str:
+    async def _run_nested_agent(self, agent_id: str, input_data: InputAdaptor | Path) -> BaseModel | str:
+        nested_write_output = self.loaded.spec.nested_output == "file"
         agent = QuickAgent(
             registry=self._registry,
             tools=self._tools,
             directory_permissions=self._directory_permissions,
             agent_id=agent_id,
-            input_path=input_path,
+            input_data=input_data,
             extra_tools=None,
+            write_output=nested_write_output,
         )
         return await agent.run()
 
-    def _init_state(self, agent_id: str) -> dict[str, Any]:
+    def _init_state(self) -> ChainState:
         return {
-            "agent_id": agent_id,
+            "agent_id": self._agent_id,
             "steps": {},
+            "final_output": None,
         }
 
     def _build_model_settings(self, model_spec: ModelSpec) -> ModelSettings | None:
@@ -103,21 +119,15 @@ class QuickAgent:
                 return {"extra_body": {"format": "json"}}
         return None
 
-    def _build_structured_model_settings(
-        self,
-        *,
-        model: OpenAIChatModel,
-        model_settings_json: ModelSettings | None,
-        schema_cls: Type[BaseModel],
-    ) -> ModelSettings | None:
-        model_settings: ModelSettings | None = model_settings_json
-        provider = getattr(model, "provider", None)
+    def _build_structured_model_settings(self, *, schema_cls: Type[BaseModel]) -> ModelSettings | None:
+        model_settings: ModelSettings | None = self.model_settings_json
+        provider = getattr(self.model, "provider", None)
         base_url = getattr(provider, "base_url", None)
         if base_url == "https://api.openai.com/v1":
-            if model_settings_json is None:
+            if self.model_settings_json is None:
                 model_settings_dict: ModelSettings = {}
             else:
-                model_settings_dict = model_settings_json
+                model_settings_dict = self.model_settings_json
             extra_body_obj = model_settings_dict.get("extra_body")
             extra_body: dict[str, Any] = {}
             if isinstance(extra_body_obj, dict):
@@ -138,33 +148,16 @@ class QuickAgent:
     async def _run_step(
         self,
         *,
-        step: Any,
-        loaded: LoadedAgentFile,
-        model: OpenAIChatModel,
-        model_settings_json: ModelSettings | None,
-        toolset: FunctionToolset[Any],
-        run_input: Any,
-        state: dict[str, Any],
-    ) -> tuple[Any, BaseModel | str]:
+        step: ChainStepSpec,
+    ) -> tuple[StepOutput, BaseModel | str]:
         if step.kind == "text":
             return await self._run_text_step(
                 step=step,
-                loaded=loaded,
-                model=model,
-                toolset=toolset,
-                run_input=run_input,
-                state=state,
             )
 
         if step.kind == "structured":
             return await self._run_structured_step(
                 step=step,
-                loaded=loaded,
-                model=model,
-                model_settings_json=model_settings_json,
-                toolset=toolset,
-                run_input=run_input,
-                state=state,
             )
 
         raise NotImplementedError(f"Unknown step kind: {step.kind}")
@@ -172,37 +165,26 @@ class QuickAgent:
     def _build_user_prompt(
         self,
         *,
-        step: Any,
-        loaded: LoadedAgentFile,
-        run_input: Any,
-        state: dict[str, Any],
+        step: ChainStepSpec,
     ) -> str:
-        if step.prompt_section not in loaded.step_prompts:
+        if step.prompt_section not in self.loaded.step_prompts:
             raise KeyError(f"Missing step section {step.prompt_section!r} in agent.md body.")
 
-        step_prompt = loaded.step_prompts[step.prompt_section]
-        return make_user_prompt(step_prompt, run_input, state)
+        step_prompt = self.loaded.step_prompts[step.prompt_section]
+        return make_user_prompt(step_prompt, self.run_input, self.state)
 
     async def _run_text_step(
         self,
         *,
-        step: Any,
-        loaded: LoadedAgentFile,
-        model: OpenAIChatModel,
-        toolset: FunctionToolset[Any],
-        run_input: Any,
-        state: dict[str, Any],
-    ) -> tuple[Any, BaseModel | str]:
+        step: ChainStepSpec,
+    ) -> tuple[StepOutput, BaseModel | str]:
         user_prompt = self._build_user_prompt(
             step=step,
-            loaded=loaded,
-            run_input=run_input,
-            state=state,
         )
         agent = Agent(
-            model,
-            instructions=loaded.body,
-            toolsets=[toolset],
+            self.model,
+            instructions=self.loaded.body,
+            toolsets=[self.toolset],
             output_type=str,
         )
         result = await agent.run(user_prompt)
@@ -211,34 +193,21 @@ class QuickAgent:
     async def _run_structured_step(
         self,
         *,
-        step: Any,
-        loaded: LoadedAgentFile,
-        model: OpenAIChatModel,
-        model_settings_json: ModelSettings | None,
-        toolset: FunctionToolset[Any],
-        run_input: Any,
-        state: dict[str, Any],
-    ) -> tuple[Any, BaseModel | str]:
+        step: ChainStepSpec,
+    ) -> tuple[StepOutput, BaseModel | str]:
         if not step.output_schema:
             raise ValueError(f"Step {step.id} is structured but missing output_schema.")
-        schema_cls = resolve_schema(loaded, step.output_schema)
+        schema_cls = resolve_schema(self.loaded, step.output_schema)
 
-        model_settings = self._build_structured_model_settings(
-            model=model,
-            model_settings_json=model_settings_json,
-            schema_cls=schema_cls,
-        )
+        model_settings = self._build_structured_model_settings(schema_cls=schema_cls)
 
         user_prompt = self._build_user_prompt(
             step=step,
-            loaded=loaded,
-            run_input=run_input,
-            state=state,
         )
         agent = Agent(
-            model,
-            instructions=loaded.body,
-            toolsets=[toolset],
+            self.model,
+            instructions=self.loaded.body,
+            toolsets=[self.toolset],
             output_type=str,
             model_settings=model_settings,
         )
@@ -253,49 +222,35 @@ class QuickAgent:
 
     async def _run_chain(
         self,
-        *,
-        loaded: LoadedAgentFile,
-        model: OpenAIChatModel,
-        model_settings_json: ModelSettings | None,
-        toolset: FunctionToolset[Any],
-        run_input: Any,
-        state: dict[str, Any],
     ) -> BaseModel | str:
         final_output: BaseModel | str = ""
-        for step in loaded.spec.chain:
+        for step in self.loaded.spec.chain:
             step_out, step_final = await self._run_step(
                 step=step,
-                loaded=loaded,
-                model=model,
-                model_settings_json=model_settings_json,
-                toolset=toolset,
-                run_input=run_input,
-                state=state,
             )
-            state["steps"][step.id] = step_out
+            self.state["steps"][step.id] = step_out
+            self.state["final_output"] = step_out
             final_output = step_final
         return final_output
 
-    def _write_final_output(
-        self,
-        loaded: LoadedAgentFile,
-        final_output: BaseModel | str,
-        permissions: DirectoryPermissions,
-    ) -> Path:
-        out_path = Path(loaded.spec.output.file)
+    def _write_final_output(self, final_output: BaseModel | str) -> Path:
+        out_path = Path(self.loaded.spec.output.file)
         if isinstance(final_output, BaseModel):
-            if loaded.spec.output.format == "json":
-                write_output(out_path, final_output.model_dump_json(indent=2), permissions)
+            if self.loaded.spec.output.format == "json":
+                write_output(out_path, final_output.model_dump_json(indent=2), self.permissions)
             else:
-                write_output(out_path, final_output.model_dump_json(indent=2), permissions)
+                write_output(out_path, final_output.model_dump_json(indent=2), self.permissions)
         else:
-            write_output(out_path, str(final_output), permissions)
+            write_output(out_path, str(final_output), self.permissions)
         return out_path
 
-    async def _handle_handoff(self, loaded: LoadedAgentFile, out_path: Path) -> None:
-        if loaded.spec.handoff.enabled and loaded.spec.handoff.agent_id:
-            # For a more robust version, generate an intermediate file for handoff input.
-            await self._run_nested_agent(loaded.spec.handoff.agent_id, out_path)
+    async def _handle_handoff(self, final_output: BaseModel | str) -> None:
+        if self.loaded.spec.handoff.enabled and self.loaded.spec.handoff.agent_id:
+            if isinstance(final_output, BaseModel):
+                payload = final_output.model_dump_json(indent=2)
+            else:
+                payload = str(final_output)
+            await self._run_nested_agent(self.loaded.spec.handoff.agent_id, TextInput(payload))
 
 
 def resolve_schema(loaded: LoadedAgentFile, schema_name: str) -> Type[BaseModel]:

quick_agent/schemas/outputs.py

@@ -26,6 +26,12 @@ class ValidationResult(BaseModel):
     summary: str | None = None
 
 
+class BusinessSummary(BaseModel):
+    company_name: str
+    location: str
+    summary: str
+
+
 class EvalRowResult(BaseModel):
     index: int = 0
     agent: str

quick_agent-0.1.2.data/data/quick_agent/agents/business-extract-structured.md

@@ -0,0 +1,49 @@
+---
+name: "Business Extract Structured"
+description: "Extract company name, location, and summary into structured JSON."
+model:
+  provider: "openai-compatible"
+  base_url: "http://localhost:11434/v1"
+  api_key_env: "OPENAI_API_KEY"
+  model_name: "llama3"
+schemas:
+  BusinessSummary: "quick_agent.schemas.outputs:BusinessSummary"
+chain:
+  - id: company_name
+    kind: text
+    prompt_section: step:company_name
+  - id: location
+    kind: text
+    prompt_section: step:location
+  - id: summary
+    kind: structured
+    prompt_section: step:summary
+    output_schema: BusinessSummary
+output:
+  format: "json"
+  file: "out/business_extract_structured.json"
+---
+
+# Business Extract Structured
+
+Extract structured details from the input description.
+
+## step:company_name
+
+Extract the company name from the input description.
+Return only the company name.
+
+## step:location
+
+Extract the location from the input description.
+If a city and region are present, include both.
+Return only the location.
+
+## step:summary
+
+Return a JSON object with:
+- `company_name`
+- `location`
+- `summary` (one sentence)
+
+Use `state.steps.company_name` and `state.steps.location` for the fields if available.

quick_agent-0.1.2.data/data/quick_agent/agents/business-extract.md

@@ -0,0 +1,42 @@
+---
+name: "Business Extract"
+description: "Extract company name, location, and a short summary from a business description."
+model:
+  provider: "openai-compatible"
+  base_url: "http://localhost:11434/v1"
+  api_key_env: "OPENAI_API_KEY"
+  model_name: "llama3"
+chain:
+  - id: company_name
+    kind: text
+    prompt_section: step:company_name
+  - id: location
+    kind: text
+    prompt_section: step:location
+  - id: summary
+    kind: text
+    prompt_section: step:summary
+output:
+  format: "markdown"
+  file: "out/business_extract.md"
+---
+
+# Business Extract
+
+Extract structured details from the input description.
+
+## step:company_name
+
+Extract the company name from the input description.
+Return only the company name.
+
+## step:location
+
+Extract the location from the input description.
+If a city and region are present, include both.
+Return only the location.
+
+## step:summary
+
+Write one sentence summarizing the business.
+Use `state.steps.company_name` and `state.steps.location` if available.

{quick_agent-0.1.1.dist-info → quick_agent-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quick-agent
-Version: 0.1.1
+Version: 0.1.2
 Summary: Minimal, local-first agent runner using Markdown front matter.
 Author-email: Charles Verge <1906614+charlesverge@users.noreply.github.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -707,13 +707,14 @@ Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Dynamic: license-file
 
-# Simple Agent
+# Quick Agent
 
-Simple Agent is a minimal, local-first agent runner that loads agent definitions from Markdown front matter and executes a small chain of steps with limited context handling. It is intentionally small and explicit: you define the model, tools, and steps in a single Markdown file, and the orchestrator runs those steps in order with a bounded prompt preamble.
+Quick Agent is a minimal, local-first agent runner that loads agent definitions from Markdown front matter and executes a small chain of steps with limited context handling. It is intentionally small and explicit: you define the model, tools, and steps in a single Markdown file, and the orchestrator runs those steps in order with a bounded prompt preamble.
 
 ## Project Goal
 
 Provide a simple, maintainable agent framework that:
+
 - Uses Markdown front matter for agent configuration.
 - Runs a deterministic chain of steps (text or structured output).
 - Keeps context handling deliberately limited and predictable.
@@ -887,7 +888,7 @@ def main() -> None:
         tools=tools,
         directory_permissions=permissions,
         agent_id="hello",
-        input_path=Path("safe/path/to/input.txt"),
+        input_data=Path("safe/path/to/input.txt"),
         extra_tools=None,
     )
 
@@ -908,6 +909,17 @@ Agents are stored as Markdown files with YAML front matter and step sections:
 
 The orchestrator loads the agent, builds the tools, and executes each step in order, writing the final output to disk.
 
+## Nested Output
+
+When an agent invokes another agent via `agent_call` or `handoff`, the nested agent can either write its
+own `output.file` or return output inline only. Configure this in the parent agent front matter:
+
+```yaml
+nested_output: inline  # default, no output file for nested calls
+```
+
+Use `nested_output: file` to allow nested agents to write their configured output files.
+
 ## Documentation
 
 See the docs in `docs/`:
@@ -916,3 +928,4 @@ See the docs in `docs/`:
 - [docs/templates.md](docs/templates.md): Agent template format and examples.
 - [docs/python.md](docs/python.md): Embedding the orchestrator in scripts.
 - [docs/python.md#inter-agent-calls](docs/python.md#inter-agent-calls): Example of one agent calling another.
+- [src/quick_agent/llms.txt](src/quick_agent/llms.txt): LLM-oriented project summary and examples.

quick_agent-0.1.2.dist-info/RECORD

@@ -0,0 +1,51 @@
+quick_agent/__init__.py,sha256=lgTMjPhbumIZ1Pna33khCaAs4DSjErnYoCkvK_YxBCc,362
+quick_agent/agent_call_tool.py,sha256=yyXpWWpQlhSV8qxkeA1tLdrfcHhYg2cmhf4sxx8FfvA,2195
+quick_agent/agent_registry.py,sha256=laHxiB3ko2oaQDhN7xG7u7Kc7WTy7j-rPqvfiWdpxEY,2473
+quick_agent/agent_tools.py,sha256=GwaPkoG_vy1f6hatvRQFoDj0IJ-6nIYV746qc8y-yMg,1475
+quick_agent/cli.py,sha256=nzVF4paXxugaPzmHTMwCBkbQkfkkv9hqGQH4Fh0jJ_U,1973
+quick_agent/directory_permissions.py,sha256=r6Lc56oIrGhVVUVrCoPInue_BCdGZsD5oDgoAHJWiyE,1955
+quick_agent/input_adaptors.py,sha256=ZaK0Mm27cGMGb5y6fsgV0gXRPMW2zmHn9l9dXKzOufA,865
+quick_agent/io_utils.py,sha256=BUmUoZepL4lSYe0JbKxLm4mFFQ6Zt6MZQzprzgoBweU,1200
+quick_agent/json_utils.py,sha256=G6uP9SrdEw5WtA9--dBqdJcTYD2JgdgotPJdleErB_c,1003
+quick_agent/llms.txt,sha256=SNxYm6oFbqvc4mzGsxSpWg1l0iwT-Be0saVw3rtoruQ,6459
+quick_agent/orchestrator.py,sha256=SGa5oeRgbjkKXdFL5kszZT-R6-jIgyOkHEMmjLrDWjc,1321
+quick_agent/prompting.py,sha256=XMlnRut3aU2FEabhXuvb4Z_DXKzi1psZfbbx4iDyg_4,645
+quick_agent/py.typed,sha256=3Q9vdii9v-_pbj9sglgDzJAIelvARaYaDJlB2u-NDqg,38
+quick_agent/quick_agent.py,sha256=3Cok1VPzYZo4Nityyprub2XaKVRBkaoeTm6fs67BRZw,10319
+quick_agent/tools_loader.py,sha256=oveR-EGAZo3Q7NPJ2aWKU3d8xd8kIpibOrjInpUZwQg,2642
+quick_agent/models/__init__.py,sha256=YseFAVWLarh0wZCVUL0fmkjVgA-FnYJLEiVinG1-6Tk,737
+quick_agent/models/agent_spec.py,sha256=YsCrs9DSKJJJBsqnMAxb_19zG6UuNHtXwiuTZjbFg5U,882
+quick_agent/models/chain_step_spec.py,sha256=NcdYFmgJhA5ODIwCTgTb2fmmJJesAZCVAIy3cGC5dhs,342
+quick_agent/models/handoff_spec.py,sha256=46Pt4JGU8-6f-cdbDR0oqWuJbg5ENJcXrFN1IK3chvs,280
+quick_agent/models/loaded_agent_file.py,sha256=rWRxrm0KjgmNIiYfooMM95eohMB1zCZC-eqrp1mf8w0,313
+quick_agent/models/model_spec.py,sha256=spnIZ8BNtXT5t8YRL1nh7cXrgWwNSptt_BMnAB8w1Lg,425
+quick_agent/models/output_spec.py,sha256=bvKFU1ONeza95qethNIiVgrsnT7l1TKMsdHjfXVVJnc,229
+quick_agent/models/run_input.py,sha256=WpV-QPlOPXMmZR6eIvP7vJOuCeBt3xWe4j4ngEbmSxg,282
+quick_agent/models/tool_impl_spec.py,sha256=7B161m8nFZCNjslb4VZdSi-mdAZM0jhp4kV4uaq8X1s,216
+quick_agent/models/tool_json.py,sha256=eYFBPCqxmRfyo7GYHBXCfog7kUzpjginfjt9grQy4ic,274
+quick_agent/schemas/outputs.py,sha256=8FTIczUV079imbygbFU3h9tyLWSH8aQZCPBTxM8QVtk,1527
+quick_agent/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quick_agent/tools/filesystem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quick_agent/tools/filesystem/adapter.py,sha256=aYcX1qjI9wRSANSNSB3KWbKi7uDIYo3EpJotpUxnQUM,1027
+quick_agent/tools/filesystem/read_text.py,sha256=owpZxwCFoYbljABhwpNKU4g7-8xDPJDu0kZYF7bPLfs,478
+quick_agent/tools/filesystem/write_text.py,sha256=lwsMCk_p8xurVxychM2UBieXDp0SgN3C6rufLBUzDxo,584
+quick_agent/tools/filesystem.read_text/tool.json,sha256=UtkOxcpi6qYd611tJx-zFXVUjOwx2ZbmxEWsF4cAVpo,246
+quick_agent/tools/filesystem.write_text/tool.json,sha256=EcGmB_M_KDTqOrnxk_NVhKRoW_KADFFksgJ7fmw472s,275
+quick_agent-0.1.2.data/data/quick_agent/agents/business-extract-structured.md,sha256=mhieyFbkJ23kjZPvpKguW4xorkTgzwAev1EZCUkcS44,1182
+quick_agent-0.1.2.data/data/quick_agent/agents/business-extract.md,sha256=2SQdD9a4Bg_PXqL5-D5-kJMzZOYAigi0N54XsnoeNCU,996
+quick_agent-0.1.2.data/data/quick_agent/agents/function-spec-validator.md,sha256=Dlc4j1vFpDHj7w2vcWrvC83EEg_sWwwt1GOaRgcsm6Y,3289
+quick_agent-0.1.2.data/data/quick_agent/agents/subagent-validate-eval-list.md,sha256=K83L9BKvGcttPRINwD6VSPopEHnB_aw4tpfSI6KM2u8,4119
+quick_agent-0.1.2.data/data/quick_agent/agents/subagent-validator-contains.md,sha256=3VxtKpyogwcJ4Er5tQFyYNe2nJBtANErb5D-_snBATw,3115
+quick_agent-0.1.2.data/data/quick_agent/agents/template.md,sha256=6IBuVZjK5OPIchI8ruvxao8CdLy0ZOi0meh6d1exI0E,2458
+quick_agent-0.1.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+tests/test_agent.py,sha256=tcPpH9WmGPQjMo_jkFJlF8kgOZ3QktIvUHTAJaH1hWA,5533
+tests/test_directory_permissions.py,sha256=-9h7W1VO0LekPLCxEqIAGgebquNks2F8M02BdZDLlQY,2815
+tests/test_input_adaptors.py,sha256=sle9zrumq3CUVGtDPZi2pf0om-Z7v4SI6khnTf7Rz4c,918
+tests/test_integration.py,sha256=XbI6abGeoZm3r_BqpQyhxhF36N7VYtNGcJ9-xNxZysM,9044
+tests/test_orchestrator.py,sha256=fWeZzTF_cQj6nbeEVh0cC5uKwgWP56deDQxkcCO1uNk,31001
+tests/test_tools.py,sha256=Yc6AKCz79XJwHqiRV8dUBE6GVNdspUU0hIeGCXx-Rvc,936
+quick_agent-0.1.2.dist-info/METADATA,sha256=1xL8o4mz4qW2dLuotIPTGJxuHRHm1Uxp42j-w6nsQ-8,47103
+quick_agent-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+quick_agent-0.1.2.dist-info/entry_points.txt,sha256=bij-xFaQMSrMj7zearzi-bMfcyweum_GvURFMVZGde8,53
+quick_agent-0.1.2.dist-info/top_level.txt,sha256=KT1ID0FVC0OLzQnoBKRIHbXLRNugiU2gcgj_f4DtAsw,18
+quick_agent-0.1.2.dist-info/RECORD,,

tests/test_directory_permissions.py

@@ -45,6 +45,16 @@ def test_directory_permissions_can_read_write(tmp_path: Path) -> None:
     assert perms.can_write(Path("../nope.txt")) is False
 
 
+def test_directory_permissions_without_root_denies_all() -> None:
+    perms = DirectoryPermissions(None)
+
+    with pytest.raises(PermissionError):
+        perms.resolve(Path("anything.txt"), for_write=False)
+
+    assert perms.can_read(Path("anything.txt")) is False
+    assert perms.can_write(Path("anything.txt")) is False
+
+
 def test_agent_cannot_write_outside_scoped_directory(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,

tests/test_input_adaptors.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+import pytest
+
+from quick_agent.directory_permissions import DirectoryPermissions
+from quick_agent.input_adaptors import FileInput
+
+
+def test_file_input_checks_permissions_at_creation(tmp_path: Path) -> None:
+    safe_root = tmp_path / "safe"
+    safe_root.mkdir(parents=True, exist_ok=True)
+    input_path = safe_root / "input.txt"
+    input_path.write_text("ok", encoding="utf-8")
+
+    permissions = DirectoryPermissions(safe_root)
+
+    adaptor = FileInput(input_path, permissions)
+
+    run_input = adaptor.load()
+    assert run_input.text == "ok"
+    assert run_input.source_path == str(input_path)
+
+
+def test_file_input_denies_without_root(tmp_path: Path) -> None:
+    input_path = tmp_path / "input.txt"
+    input_path.write_text("nope", encoding="utf-8")
+
+    permissions = DirectoryPermissions(None)
+
+    with pytest.raises(PermissionError):
+        FileInput(input_path, permissions)