openshell-agent-runner 0.0.1__tar.gz → 0.0.3__tar.gz

openshell_agent_runner-0.0.3/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.5
+Name: openshell-agent-runner
+Version: 0.0.3
+Summary: Launch ephemeral agents for single tasks in OpenShell sandboxes.
+Project-URL: Repository, https://github.com/NVIDIA/OpenShell-Research
+Project-URL: Documentation, https://nvidia.github.io/OpenShell-Research/documentation/openshell-agent-runner/
+Author: NVIDIA CORPORATION & AFFILIATES
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Requires-Python: >=3.12
+Requires-Dist: jsonschema<5,>=4.25
+Requires-Dist: pydantic<3,>=2.11
+Requires-Dist: pyyaml<7,>=6
+Requires-Dist: typer<1,>=0.16
+Description-Content-Type: text/markdown
+
+# OpenShell Agent Runner
+
+OpenShell Agent Runner (OAR) runs an agent task in an isolated OpenShell sandbox
+and saves the result to a file. Use it to review code, review technical writing,
+or run your own tasks from a terminal or CI job.
+
+```text
+Profile + input → OAR → Agent in a temporary sandbox → Result file
+                            sandbox removed when the run ends
+```
+
+A **profile** packages prompts, reusable skills, and settings. A **task** is one
+job in that profile; it selects the prompt and skills to use. OAR includes two
+ready-to-use reviewers:
+
+| Profile | Task | Input |
+| --- | --- | --- |
+| `code-reviewer` | `review-repository` | A local project directory |
+| `technical-writing-reviewer` | `review-document` | A text file, such as Markdown or `.txt` |
+
+## Get started
+
+You need [uv](https://docs.astral.sh/uv/getting-started/installation/) and
+OpenShell 0.0.111 or newer, with a running gateway and configured inference.
+If OpenShell is not ready, follow its
+[quickstart](https://docs.nvidia.com/openshell/latest/get-started/quickstart).
+OAR uses that setup to create sandboxes and reach your model.
+
+**1. Install OAR and check your connection.**
+
+```bash
+uv tool install openshell-agent-runner
+oar doctor
+```
+
+Alternatively, use `uvx --from openshell-agent-runner oar` in place of `oar`.
+
+These commands use your selected OpenShell gateway and its `default` workspace.
+For another target, add `--gateway NAME --workspace NAME` to `doctor` and `run`.
+
+**2. Create your profiles.** Replace `YOUR_MODEL_ID` with the model ID shown in
+the inference output from `oar doctor`.
+
+```bash
+oar init ./profiles --model YOUR_MODEL_ID
+```
+
+This creates editable copies of both reviewers. For a model without reasoning
+support, add `--thinking off`.
+
+**3. Review a document.** Replace `./README.md` with an existing text file.
+
+```bash
+oar run ./profiles/technical-writing-reviewer \
+  --task review-document \
+  --input ./README.md \
+  --output ./review.json
+```
+
+Open `review.json` for the verdict, a score from 0 to 100, and specific findings.
+OAR saves the validated result and removes the sandbox. Add `--dry-run` to
+preview the operation without launching an agent.
+
+## Review code
+
+Pass a local project directory. Optional `focus` and `context` values help the
+reviewer understand what matters for this run:
+
+```bash
+oar run ./profiles/code-reviewer \
+  --task review-repository \
+  --input ./my-project \
+  --prompt-var focus="src/auth and tests/auth" \
+  --prompt-var context="A small internal tool; keep recommendations proportionate." \
+  --output ./code-review.json
+```
+
+The agent works on an uploaded copy. Changes in the sandbox stay there; only the
+result is downloaded. A `focus` value guides attention but does not limit which
+files are uploaded.
+
+## Learn more
+
+- [Get started](https://nvidia.github.io/OpenShell-Research/documentation/openshell-agent-runner/): setup and your first review.
+- [Run reviews](https://nvidia.github.io/OpenShell-Research/documentation/openshell-agent-runner/reviews/): inputs, focus, context, and scores.
+- [Customize profiles](https://nvidia.github.io/OpenShell-Research/documentation/openshell-agent-runner/profiles/): prompts, variables, skills, and output formats.
+- [Command reference](https://nvidia.github.io/OpenShell-Research/documentation/openshell-agent-runner/reference/): options, CI behavior, and troubleshooting.
+
+For help with a specific task:
+
+```bash
+oar run ./profiles/code-reviewer --task review-repository --help
+```
+
+## Develop OAR
+
+From `projects/openshell-agent-runner`, run:
+
+```bash
+make check
+make build
+```
+
+`make check` includes CLI workflows against a simulated OpenShell. With Docker,
+run `make test-runtime` to exercise the real Pi harness without external inference.
+For runtime changes, one live CI task checks input transfer, prompt variables,
+structured output, and sandbox cleanup. It does not grade reviewer opinions.
+
+Use `uv run --frozen oar` in this directory to run the checked-out code instead
+of the installed release. Run a focused test with
+`make test PYTEST_ARGS="tests/test_config.py"`. See
+[RELEASING.md](https://github.com/NVIDIA/OpenShell-Research/blob/main/projects/openshell-agent-runner/RELEASING.md)
+for publishing, and the
+[repository CI guide](https://github.com/NVIDIA/OpenShell-Research/blob/main/docs/development/ci.md)
+for automated project reviews and the live OAR smoke test.

openshell_agent_runner-0.0.3/README.md

@@ -0,0 +1,115 @@
+# OpenShell Agent Runner
+
+OpenShell Agent Runner (OAR) runs an agent task in an isolated OpenShell sandbox
+and saves the result to a file. Use it to review code, review technical writing,
+or run your own tasks from a terminal or CI job.
+
+```text
+Profile + input → OAR → Agent in a temporary sandbox → Result file
+                            sandbox removed when the run ends
+```
+
+A **profile** packages prompts, reusable skills, and settings. A **task** is one
+job in that profile; it selects the prompt and skills to use. OAR includes two
+ready-to-use reviewers:
+
+| Profile | Task | Input |
+| --- | --- | --- |
+| `code-reviewer` | `review-repository` | A local project directory |
+| `technical-writing-reviewer` | `review-document` | A text file, such as Markdown or `.txt` |
+
+## Get started
+
+You need [uv](https://docs.astral.sh/uv/getting-started/installation/) and
+OpenShell 0.0.111 or newer, with a running gateway and configured inference.
+If OpenShell is not ready, follow its
+[quickstart](https://docs.nvidia.com/openshell/latest/get-started/quickstart).
+OAR uses that setup to create sandboxes and reach your model.
+
+**1. Install OAR and check your connection.**
+
+```bash
+uv tool install openshell-agent-runner
+oar doctor
+```
+
+Alternatively, use `uvx --from openshell-agent-runner oar` in place of `oar`.
+
+These commands use your selected OpenShell gateway and its `default` workspace.
+For another target, add `--gateway NAME --workspace NAME` to `doctor` and `run`.
+
+**2. Create your profiles.** Replace `YOUR_MODEL_ID` with the model ID shown in
+the inference output from `oar doctor`.
+
+```bash
+oar init ./profiles --model YOUR_MODEL_ID
+```
+
+This creates editable copies of both reviewers. For a model without reasoning
+support, add `--thinking off`.
+
+**3. Review a document.** Replace `./README.md` with an existing text file.
+
+```bash
+oar run ./profiles/technical-writing-reviewer \
+  --task review-document \
+  --input ./README.md \
+  --output ./review.json
+```
+
+Open `review.json` for the verdict, a score from 0 to 100, and specific findings.
+OAR saves the validated result and removes the sandbox. Add `--dry-run` to
+preview the operation without launching an agent.
+
+## Review code
+
+Pass a local project directory. Optional `focus` and `context` values help the
+reviewer understand what matters for this run:
+
+```bash
+oar run ./profiles/code-reviewer \
+  --task review-repository \
+  --input ./my-project \
+  --prompt-var focus="src/auth and tests/auth" \
+  --prompt-var context="A small internal tool; keep recommendations proportionate." \
+  --output ./code-review.json
+```
+
+The agent works on an uploaded copy. Changes in the sandbox stay there; only the
+result is downloaded. A `focus` value guides attention but does not limit which
+files are uploaded.
+
+## Learn more
+
+- [Get started](https://nvidia.github.io/OpenShell-Research/documentation/openshell-agent-runner/): setup and your first review.
+- [Run reviews](https://nvidia.github.io/OpenShell-Research/documentation/openshell-agent-runner/reviews/): inputs, focus, context, and scores.
+- [Customize profiles](https://nvidia.github.io/OpenShell-Research/documentation/openshell-agent-runner/profiles/): prompts, variables, skills, and output formats.
+- [Command reference](https://nvidia.github.io/OpenShell-Research/documentation/openshell-agent-runner/reference/): options, CI behavior, and troubleshooting.
+
+For help with a specific task:
+
+```bash
+oar run ./profiles/code-reviewer --task review-repository --help
+```
+
+## Develop OAR
+
+From `projects/openshell-agent-runner`, run:
+
+```bash
+make check
+make build
+```
+
+`make check` includes CLI workflows against a simulated OpenShell. With Docker,
+run `make test-runtime` to exercise the real Pi harness without external inference.
+For runtime changes, one live CI task checks input transfer, prompt variables,
+structured output, and sandbox cleanup. It does not grade reviewer opinions.
+
+Use `uv run --frozen oar` in this directory to run the checked-out code instead
+of the installed release. Run a focused test with
+`make test PYTEST_ARGS="tests/test_config.py"`. See
+[RELEASING.md](https://github.com/NVIDIA/OpenShell-Research/blob/main/projects/openshell-agent-runner/RELEASING.md)
+for publishing, and the
+[repository CI guide](https://github.com/NVIDIA/OpenShell-Research/blob/main/docs/development/ci.md)
+for automated project reviews and the live OAR smoke test.

{openshell_agent_runner-0.0.1 → openshell_agent_runner-0.0.3}/pyproject.toml

@@ -31,7 +31,7 @@ openshell-agent-runner = "openshell_agent_runner.cli:app"
 
 [project.urls]
 Repository = "https://github.com/NVIDIA/OpenShell-Research"
-Documentation = "https://github.com/NVIDIA/OpenShell-Research/blob/main/projects/openshell-agent-runner/docs/index.md"
+Documentation = "https://nvidia.github.io/OpenShell-Research/documentation/openshell-agent-runner/"
 
 [dependency-groups]
 dev = [
@@ -51,6 +51,7 @@ source = "uv-dynamic-versioning"
 [tool.uv-dynamic-versioning]
 vcs = "git"
 style = "pep440"
+pattern-prefix = "oar-"
 bump = true
 
 [tool.hatch.build.targets.wheel]

{openshell_agent_runner-0.0.1 → openshell_agent_runner-0.0.3}/src/openshell_agent_runner/cli.py

@@ -120,9 +120,16 @@ def run(
     output: Annotated[
         Path, typer.Option("--output", help="Host path for the agent result.")
     ],
-    input_document: Annotated[
+    input_path: Annotated[
         Path | None,
-        typer.Option("--input", help="Host document required by document tasks."),
+        typer.Option("--input", help="Host input required by the selected task."),
+    ] = None,
+    prompt_variable: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--prompt-var",
+            help="Non-secret NAME=VALUE prompt variable. Repeat for several.",
+        ),
     ] = None,
     upload: Annotated[
         list[str] | None,
@@ -159,7 +166,8 @@ def run(
         profile_directory=profile,
         task_id=task,
         output=output,
-        input_document=input_document,
+        input_path=input_path,
+        prompt_variables=prompt_variable or (),
         uploads=upload or (),
         environments=environment or (),
         gateway=gateway,
@@ -185,12 +193,17 @@ def doctor(
         str, typer.Option("--workspace", help="OpenShell workspace name.")
     ] = "default",
 ) -> None:
-    """Check OpenShell readiness without changing its state."""
+    """Inspect OpenShell connection and configuration without changing its state."""
     try:
         checks = run_doctor(NativeTarget(gateway=gateway, workspace=workspace))
     except OarError as error:
         _fail(error)
     typer.echo("\n\n".join(result for _, result in checks))
+    typer.echo(
+        "\nThese are configuration checks, not an inference request. "
+        "Before running a task, confirm that an inference provider and model "
+        "are listed above."
+    )
 
 
 def _fail(error: OarError) -> NoReturn:
@@ -227,8 +240,10 @@ def _render_task_help(
         _help_command(f"  oar run {shlex.quote(str(profile_directory))} \\"),
         _help_command(f"    --task {shlex.quote(task_id)} \\"),
     ]
-    if task.required_input == "document":
-        usage_lines.append(_help_command("    --input DOCUMENT \\"))
+    if task.required_input is not None:
+        usage_lines.append(
+            _help_command(f"    --input {task.required_input.upper()} \\")
+        )
     usage_lines.append(_help_command("    --output OUTPUT"))
 
     upload_lines = [_help_heading("Additional configured uploads:")]
@@ -244,6 +259,22 @@ def _render_task_help(
         environment_lines.append("  None. Add values with --env KEY=VALUE.")
 
     input_lines = _required_input_help(task.required_input)
+    prompt_variable_lines = [_help_heading("Prompt variables:")]
+    if task.prompt_variables:
+        for name, variable in task.prompt_variables.items():
+            requirement = (
+                f"Default: {variable.default}"
+                if variable.default is not None
+                else "Required."
+            )
+            prompt_variable_lines.extend(
+                [
+                    _help_command(f"  --prompt-var {name}=VALUE"),
+                    f"    {variable.description} {requirement}",
+                ]
+            )
+    else:
+        prompt_variable_lines.append("  None.")
 
     output_description = (
         f"JSON validated against {task.output_schema}."
@@ -260,6 +291,8 @@ def _render_task_help(
             "",
             *input_lines,
             "",
+            *prompt_variable_lines,
+            "",
             *upload_lines,
             "",
             *environment_lines,
@@ -274,10 +307,15 @@ def _render_task_help(
 def _required_input_help(required_input: str | None) -> list[str]:
     if required_input is None:
         return [_help_heading("Required input:"), "  None."]
+    description = (
+        "Host document to review."
+        if required_input == "document"
+        else "Host code repository to review."
+    )
     return [
         _help_heading("Required argument:"),
-        _help_command("  --input DOCUMENT"),
-        "    Host document to review.",
+        _help_command(f"  --input {required_input.upper()}"),
+        f"    {description}",
     ]
 
 

{openshell_agent_runner-0.0.1 → openshell_agent_runner-0.0.3}/src/openshell_agent_runner/config.py

@@ -19,9 +19,15 @@ from pydantic import (
     Field,
     ValidationError,
     field_validator,
+    model_validator,
 )
 
 from openshell_agent_runner.errors import ConfigurationError
+from openshell_agent_runner.prompt_templates import (
+    BUILTIN_PROMPT_VARIABLES,
+    PROMPT_VARIABLE_NAME_PATTERN,
+    validate_prompt_template,
+)
 
 IDENTIFIER_PATTERN = r"^[a-z][a-z0-9-]{0,62}$"
 RESOURCE_IDENTIFIER_PATTERN = r"^[a-z][a-z0-9_-]{0,62}$"
@@ -29,6 +35,8 @@ MODEL_IDENTIFIER_PATTERN = r"^[A-Za-z0-9._:/-]{1,256}$"
 MODELS_FILENAME = "models.json"
 PROFILE_FILENAME = "profile.yaml"
 SETTINGS_FILENAME = "settings.json"
+BUILTIN_PI_TOOLS = frozenset({"bash", "edit", "find", "grep", "ls", "read", "write"})
+SUBMIT_RESULT_TOOL = "submit_result"
 _PI_RUNTIME_SETTING_KEYS = {
     "defaultProvider",
     "defaultModel",
@@ -58,24 +66,86 @@ class SandboxConfig(StrictModel):
         return values
 
 
+ToolName = Annotated[str, Field(pattern=RESOURCE_IDENTIFIER_PATTERN)]
+PromptVariableName = Annotated[str, Field(pattern=PROMPT_VARIABLE_NAME_PATTERN)]
+
+
+class ExtensionConfig(StrictModel):
+    path: Path
+    tools: list[ToolName] = Field(default_factory=list)
+
+    @field_validator("tools")
+    @classmethod
+    def require_unique_tools(cls, values: list[str]) -> list[str]:
+        if len(values) != len(set(values)):
+            raise ValueError("extension tool entries must be unique")
+        return values
+
+
+class PromptVariableConfig(StrictModel):
+    description: str = Field(min_length=1, max_length=1000)
+    default: str | None = Field(default=None, min_length=1)
+
+
 class TaskConfig(StrictModel):
     description: str | None = Field(default=None, min_length=1, max_length=1000)
-    required_input: Literal["document"] | None = None
+    required_input: Literal["document", "repository"] | None = None
     prompt: Path
-    output_schema: Path | None = None
-    tools: list[Annotated[str, Field(pattern=RESOURCE_IDENTIFIER_PATTERN)]] = Field(
-        default_factory=list
+    prompt_variables: dict[PromptVariableName, PromptVariableConfig] = Field(
+        default_factory=dict
     )
+    output_schema: Path | None = None
+    tools: list[ToolName] = Field(default_factory=list)
     skills: list[Path] = Field(default_factory=list)
-    extensions: list[Path] = Field(default_factory=list)
+    extensions: list[ExtensionConfig] = Field(default_factory=list)
 
-    @field_validator("tools", "skills", "extensions")
+    @field_validator("tools", "skills")
     @classmethod
     def require_unique_resources(cls, values: list[object]) -> list[object]:
         if len(values) != len(set(values)):
             raise ValueError("resource entries must be unique")
         return values
 
+    @field_validator("extensions")
+    @classmethod
+    def require_unique_extensions(
+        cls, values: list[ExtensionConfig]
+    ) -> list[ExtensionConfig]:
+        paths = [extension.path for extension in values]
+        if len(paths) != len(set(paths)):
+            raise ValueError("extension paths must be unique")
+        return values
+
+    @model_validator(mode="after")
+    def require_known_tools(self) -> TaskConfig:
+        declared_custom_tools: set[str] = set()
+        for extension in self.extensions:
+            for tool in extension.tools:
+                if tool in BUILTIN_PI_TOOLS or tool == SUBMIT_RESULT_TOOL:
+                    raise ValueError(
+                        f"extension tool {tool!r} conflicts with a reserved tool"
+                    )
+                if tool in declared_custom_tools:
+                    raise ValueError(
+                        f"custom tool {tool!r} is declared by multiple extensions"
+                    )
+                declared_custom_tools.add(tool)
+
+        available_tools = BUILTIN_PI_TOOLS | declared_custom_tools
+        unknown_tools = sorted(set(self.tools) - available_tools)
+        if unknown_tools:
+            raise ValueError(
+                f"unknown tools {unknown_tools}; Pi built-ins are "
+                f"{sorted(BUILTIN_PI_TOOLS)}; declare each custom tool under a "
+                "referenced extension"
+            )
+        if self.skills and "read" not in self.tools:
+            raise ValueError(
+                "tasks with skills must include 'read' in tools so Pi can "
+                "discover and load the skills"
+            )
+        return self
+
 
 class ProfileConfig(StrictModel):
     id: Annotated[str, Field(pattern=IDENTIFIER_PATTERN)]
@@ -155,7 +225,6 @@ def resolve_task(profile_directory: Path, task_id: str) -> ResolvedProfile:
 def validate_upload_mappings(values: Sequence[str]) -> tuple[str, ...]:
     if len(values) != len(set(values)):
         raise ValueError("duplicate upload mapping")
-    destinations: dict[str, str] = {}
     for value in values:
         source, separator, destination = value.rpartition(":")
         if not separator or not source or not destination.startswith("/"):
@@ -169,16 +238,11 @@ def validate_upload_mappings(values: Sequence[str]) -> tuple[str, ...]:
             PurePosixPath("/sandbox/artifacts"),
             PurePosixPath("/sandbox/oar-runtime"),
         ):
-            if path == reserved or path.is_relative_to(reserved):
+            if path.is_relative_to(reserved) or reserved.is_relative_to(path):
                 raise ValueError(
                     "upload destination is reserved for runner resources: "
                     f"{destination}"
                 )
-        normalized = str(path)
-        previous = destinations.get(normalized)
-        if previous is not None and previous != source:
-            raise ValueError(f"conflicting upload destination: {destination}")
-        destinations[normalized] = source
     return tuple(values)
 
 
@@ -300,7 +364,23 @@ def _validate_profile_resources(resolved: ResolvedProfile) -> None:
     directory = resolved.profile_dir
     _inside(directory, directory / resolved.profile.sandbox.policy, "sandbox policy")
     for task_id, task in resolved.profile.tasks.items():
-        _inside(directory, directory / task.prompt, f"prompt for task {task_id}")
+        prompt = _inside(
+            directory, directory / task.prompt, f"prompt for task {task_id}"
+        )
+        available_builtins = (
+            BUILTIN_PROMPT_VARIABLES if task.required_input is not None else frozenset()
+        )
+        try:
+            template = prompt.read_text(encoding="utf-8")
+            validate_prompt_template(
+                template,
+                task.prompt_variables.keys(),
+                available_builtins,
+            )
+        except (OSError, UnicodeError, ValueError) as error:
+            raise ConfigurationError(
+                f"invalid prompt template for task {task_id}: {error}"
+            ) from error
         if task.output_schema is not None:
             schema = _inside(
                 directory,
@@ -326,7 +406,11 @@ def _validate_profile_resources(resolved: ResolvedProfile) -> None:
                         f"skill for task {task_id} contains a symlink: {descendant}"
                     )
         for extension in task.extensions:
-            _inside(directory, directory / extension, f"extension for task {task_id}")
+            _inside(
+                directory,
+                directory / extension.path,
+                f"extension for task {task_id}",
+            )
 
 
 def _validate_output_schema(path: Path) -> None:
@@ -335,10 +419,10 @@ def _validate_output_schema(path: Path) -> None:
         Draft202012Validator.check_schema(document)
     except (OSError, UnicodeError, json.JSONDecodeError, SchemaError) as error:
         raise ConfigurationError(f"invalid output schema {path}: {error}") from error
-    _validate_schema_references(document, path)
+    _validate_schema_references(document)
 
 
-def _validate_schema_references(document: Any, path: Path) -> None:
+def _validate_schema_references(document: Any) -> None:
     if not isinstance(document, dict):
         return
 
@@ -349,23 +433,22 @@ def _validate_schema_references(document: Any, path: Path) -> None:
                 f"({key}) because host and sandbox engines use different dialects"
             )
     for key in {"$ref", "$dynamicRef", "$recursiveRef"}:
-        if key in document and (
-            not isinstance(document[key], str) or not document[key].startswith("#")
-        ):
+        if key in document:
             raise ConfigurationError(
-                f"output schema references must stay inside {path}: {document[key]!r}"
+                "output schemas do not support reference keywords "
+                f"({key}) because the submission tool nests the schema"
             )
 
     for key in {"$defs", "definitions", "properties", "dependentSchemas"}:
         value = document.get(key)
         if isinstance(value, dict):
             for schema in value.values():
-                _validate_schema_references(schema, path)
+                _validate_schema_references(schema)
     for key in {"allOf", "anyOf", "oneOf", "prefixItems"}:
         value = document.get(key)
         if isinstance(value, list):
             for schema in value:
-                _validate_schema_references(schema, path)
+                _validate_schema_references(schema)
     for key in {
         "additionalProperties",
         "contains",
@@ -379,4 +462,4 @@ def _validate_schema_references(document: Any, path: Path) -> None:
         "unevaluatedItems",
         "unevaluatedProperties",
     }:
-        _validate_schema_references(document.get(key), path)
+        _validate_schema_references(document.get(key))

{openshell_agent_runner-0.0.1 → openshell_agent_runner-0.0.3}/src/openshell_agent_runner/harnesses/pi/resources.py

@@ -3,8 +3,10 @@
 
 """Materialize the explicit native-upload runtime bundle for Pi."""
 
+import json
 import shutil
 import tempfile
+from collections.abc import Mapping
 from importlib.resources import files
 from pathlib import Path
 
@@ -14,6 +16,7 @@ from openshell_agent_runner.config import (
     ResolvedProfile,
 )
 from openshell_agent_runner.harnesses.resources import PreparedResources
+from openshell_agent_runner.prompt_templates import render_prompt_template
 
 SANDBOX_RUNTIME_ROOT = "/sandbox/oar-runtime"
 
@@ -22,13 +25,19 @@ def image_directory() -> Path:
     return Path(str(files("openshell_agent_runner.harnesses.pi") / "runtime" / "image"))
 
 
-def prepare_resources(resolved: ResolvedProfile, task_id: str) -> PreparedResources:
+def prepare_resources(
+    resolved: ResolvedProfile,
+    task_id: str,
+    prompt_variables: Mapping[str, str] | None = None,
+) -> PreparedResources:
     temporary = tempfile.TemporaryDirectory(prefix="oar-pi-")
     runtime = Path(temporary.name) / "runtime"
     (runtime / "skills").mkdir(parents=True, exist_ok=True)
     (runtime / "extensions").mkdir(parents=True, exist_ok=True)
     task = resolved.profile.tasks[task_id]
-    shutil.copy2(resolved.profile_dir / task.prompt, runtime / "prompt.md")
+    template = (resolved.profile_dir / task.prompt).read_text(encoding="utf-8")
+    rendered_prompt = render_prompt_template(template, prompt_variables or {})
+    (runtime / "prompt.md").write_text(rendered_prompt, encoding="utf-8")
     shutil.copy2(resolved.profile_dir / MODELS_FILENAME, runtime / MODELS_FILENAME)
     shutil.copy2(resolved.profile_dir / SETTINGS_FILENAME, runtime / SETTINGS_FILENAME)
     arguments = [
@@ -66,15 +75,34 @@ def prepare_resources(resolved: ResolvedProfile, task_id: str) -> PreparedResour
         shutil.copytree(resolved.profile_dir / skill, target)
         arguments.extend(["--skill", f"{SANDBOX_RUNTIME_ROOT}/skills/{target.name}"])
     for index, extension in enumerate(task.extensions):
-        target = runtime / "extensions" / f"{index:02d}-{extension.name}"
-        shutil.copy2(resolved.profile_dir / extension, target)
+        target = runtime / "extensions" / f"{index:02d}-{extension.path.name}"
+        shutil.copy2(resolved.profile_dir / extension.path, target)
         arguments.extend(
             ["--extension", f"{SANDBOX_RUNTIME_ROOT}/extensions/{target.name}"]
         )
+    expected_tools = runtime / "tools.json"
+    expected_tools.write_text(f"{json.dumps(tools)}\n", encoding="utf-8")
+    validate_tools = Path(
+        str(
+            files("openshell_agent_runner.harnesses.pi")
+            / "runtime"
+            / "extensions"
+            / "validate-tools.ts"
+        )
+    )
+    validator_target = runtime / "extensions" / "oar-validate-tools.ts"
+    shutil.copy2(validate_tools, validator_target)
+    arguments.extend(
+        [
+            "--extension",
+            f"{SANDBOX_RUNTIME_ROOT}/extensions/{validator_target.name}",
+        ]
+    )
     uploads = [
         f"{runtime / 'prompt.md'}:{SANDBOX_RUNTIME_ROOT}/prompt.md",
         f"{runtime / 'models.json'}:{SANDBOX_RUNTIME_ROOT}/models.json",
         f"{runtime / 'settings.json'}:{SANDBOX_RUNTIME_ROOT}/settings.json",
+        f"{expected_tools}:{SANDBOX_RUNTIME_ROOT}/tools.json",
     ]
     if task.output_schema is not None:
         uploads.append(