From 4f7cfc04180ce62b209bd2161f2c163c4f8527fc Mon Sep 17 00:00:00 2001 From: codex Date: Tue, 9 Jun 2026 08:31:48 +0000 Subject: [PATCH] feat: add pi agent provider --- bot_bottle/agent_provider.py | 13 +- bot_bottle/backend/__init__.py | 1 + bot_bottle/contrib/claude/agent_provider.py | 3 +- bot_bottle/contrib/codex/agent_provider.py | 3 +- bot_bottle/contrib/pi/Dockerfile | 23 ++ bot_bottle/contrib/pi/__init__.py | 1 + bot_bottle/contrib/pi/agent_provider.py | 233 ++++++++++++++++++++ bot_bottle/manifest_agent.py | 73 +++++- tests/unit/test_agent_provider.py | 68 ++++++ tests/unit/test_contrib_pi_provider.py | 195 ++++++++++++++++ tests/unit/test_manifest_egress.py | 45 ++++ 11 files changed, 651 insertions(+), 7 deletions(-) create mode 100644 bot_bottle/contrib/pi/Dockerfile create mode 100644 bot_bottle/contrib/pi/__init__.py create mode 100644 bot_bottle/contrib/pi/agent_provider.py create mode 100644 tests/unit/test_contrib_pi_provider.py diff --git a/bot_bottle/agent_provider.py b/bot_bottle/agent_provider.py index c3d6ea9..f455d68 100644 --- a/bot_bottle/agent_provider.py +++ b/bot_bottle/agent_provider.py @@ -38,13 +38,14 @@ if TYPE_CHECKING: PROVIDER_CLAUDE = "claude" PROVIDER_CODEX = "codex" -PROVIDER_TEMPLATES = frozenset({PROVIDER_CLAUDE, PROVIDER_CODEX}) +PROVIDER_PI = "pi" +PROVIDER_TEMPLATES = frozenset({PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_PI}) # Hosts that egress injects the host ChatGPT bearer on when Codex # forward_host_credentials is enabled. Pipelock must pass these through # (no TLS MITM) or its header DLP blocks the injected JWT. CODEX_HOST_CREDENTIAL_HOSTS = ("api.openai.com", "chatgpt.com") -PromptMode = Literal["append_file", "read_prompt_file"] +PromptMode = Literal["append_file", "read_prompt_file", "print_read_prompt_file"] @dataclass(frozen=True) @@ -163,6 +164,7 @@ class AgentProvider(ABC): trusted_project_path: str = "", label: str = "", color: str = "", + provider_settings: dict[str, object] | None = None, ) -> AgentProvisionPlan: """Build the declarative AgentProvisionPlan for one launch. Backends call this during `prepare` and consume the result as @@ -319,6 +321,9 @@ def get_provider(template: str) -> AgentProvider: if template == PROVIDER_CODEX: from .contrib.codex.agent_provider import CodexAgentProvider return CodexAgentProvider() + if template == PROVIDER_PI: + from .contrib.pi.agent_provider import PiAgentProvider + return PiAgentProvider() raise ValueError(f"unknown agent provider template: {template!r}") @@ -340,6 +345,7 @@ def build_agent_provision_plan( trusted_project_path: str = "", label: str = "", color: str = "", + provider_settings: dict[str, object] | None = None, ) -> AgentProvisionPlan: """Back-compat shim — `prepare` callers stay the same; the work now lives on the provider plugin.""" @@ -355,6 +361,7 @@ def build_agent_provision_plan( trusted_project_path=trusted_project_path, label=label, color=color, + provider_settings=provider_settings, ) @@ -372,4 +379,6 @@ def prompt_args( if argv and "resume" in argv: return [] return [f"Read and follow the instructions in {prompt_path}."] + if prompt_mode == "print_read_prompt_file": + return ["-p", f"Read and follow the instructions in {prompt_path}."] raise ValueError(f"unknown provider prompt mode: {prompt_mode}") diff --git a/bot_bottle/backend/__init__.py b/bot_bottle/backend/__init__.py index 501379d..aea3343 100644 --- a/bot_bottle/backend/__init__.py +++ b/bot_bottle/backend/__init__.py @@ -327,6 +327,7 @@ class BottleBackend(ABC, Generic[PlanT, CleanupT]): trusted_project_path=workspace.workdir, label=spec.label, color=spec.color, + provider_settings=manifest_agent_provider.settings, ) agent_provision_plan = merge_provision_env_vars(agent_provision_plan) egress_plan = prepare_egress(manifest_bottle, slug, agent_provision_plan) diff --git a/bot_bottle/contrib/claude/agent_provider.py b/bot_bottle/contrib/claude/agent_provider.py index 113849b..1f98465 100644 --- a/bot_bottle/contrib/claude/agent_provider.py +++ b/bot_bottle/contrib/claude/agent_provider.py @@ -135,8 +135,9 @@ class ClaudeAgentProvider(AgentProvider): trusted_project_path: str = "", label: str = "", color: str = "", + provider_settings: dict[str, object] | None = None, ) -> AgentProvisionPlan: - del forward_host_credentials, host_env # Codex-only knobs + del forward_host_credentials, host_env, provider_settings resolved_guest_env = dict(guest_env or {}) guest_home = self.guest_home trusted_path = trusted_project_path or guest_home diff --git a/bot_bottle/contrib/codex/agent_provider.py b/bot_bottle/contrib/codex/agent_provider.py index 030aa85..7207eb1 100644 --- a/bot_bottle/contrib/codex/agent_provider.py +++ b/bot_bottle/contrib/codex/agent_provider.py @@ -77,8 +77,9 @@ class CodexAgentProvider(AgentProvider): trusted_project_path: str = "", label: str = "", color: str = "", + provider_settings: dict[str, object] | None = None, ) -> AgentProvisionPlan: - del auth_token, label, color # Claude-only / title-only knobs + del auth_token, label, color, provider_settings resolved_guest_env = dict(guest_env or {}) guest_home = self.guest_home trusted_path = trusted_project_path or guest_home diff --git a/bot_bottle/contrib/pi/Dockerfile b/bot_bottle/contrib/pi/Dockerfile new file mode 100644 index 0000000..af91faa --- /dev/null +++ b/bot_bottle/contrib/pi/Dockerfile @@ -0,0 +1,23 @@ +# bot-bottle Pi provider image. +# +# Node LTS, git/network tooling, and the Pi coding-agent CLI installed globally. + +FROM node:22-slim + +RUN apt-get update \ + && apt-get install -y --no-install-recommends git ca-certificates curl \ + && rm -rf /var/lib/apt/lists/* + +RUN apt-get update \ + && apt-get install -y --no-install-recommends python3 python3-pip python3-venv \ + && rm -rf /var/lib/apt/lists/* + +RUN npm install -g --ignore-scripts --no-fund --no-audit @earendil-works/pi-coding-agent \ + && npm cache clean --force + +USER node +WORKDIR /home/node + +RUN mkdir -p /home/node/.pi/agent + +CMD ["pi"] diff --git a/bot_bottle/contrib/pi/__init__.py b/bot_bottle/contrib/pi/__init__.py new file mode 100644 index 0000000..9352882 --- /dev/null +++ b/bot_bottle/contrib/pi/__init__.py @@ -0,0 +1 @@ +"""Pi agent provider package.""" diff --git a/bot_bottle/contrib/pi/agent_provider.py b/bot_bottle/contrib/pi/agent_provider.py new file mode 100644 index 0000000..5c6fdae --- /dev/null +++ b/bot_bottle/contrib/pi/agent_provider.py @@ -0,0 +1,233 @@ +"""Pi agent provider plugin (PRD 0058, contrib). + +Pi uses ~/.pi/agent/models.json for custom provider/model settings. +This provider writes an Ollama-compatible default configuration and +lets bottles override the model endpoint and model ids via +agent_provider.settings. +""" + +from __future__ import annotations + +import json +import os +import shlex +from pathlib import Path +from typing import TYPE_CHECKING +from urllib.parse import urlparse + +from ...agent_provider import ( + AgentProvider, + AgentProviderRuntime, + AgentProvisionDir, + AgentProvisionFile, + AgentProvisionPlan, +) +from ...egress import EgressRoute +from ...log import die, info + + +if TYPE_CHECKING: + from ...backend import Bottle, BottlePlan + + +_DEFAULT_BASE_URL = "http://ollama:11434/v1" +_DEFAULT_MODEL = "qwen2.5-coder:7b" +_PROVIDER_NAME = "ollama" + + +def _skills_dir(guest_home: str) -> str: + return f"{guest_home}/.pi/agent/skills" + + +def _prompt_path(guest_home: str) -> str: + return f"{guest_home}/.bot-bottle-prompt.txt" + + +def _models_path(guest_home: str) -> str: + return f"{guest_home}/.pi/agent/models.json" + + +def _settings_value( + settings: dict[str, object], + key: str, + default: object, +) -> object: + value = settings.get(key) + return default if value is None else value + + +def _pi_models_json(settings: dict[str, object]) -> tuple[dict[str, object], str]: + base_url = str(_settings_value(settings, "base_url", _DEFAULT_BASE_URL)) + api = str(_settings_value(settings, "api", "openai-completions")) + api_key = str(_settings_value(settings, "api_key", "ollama")) + models_raw = _settings_value(settings, "models", [_DEFAULT_MODEL]) + models = [str(model) for model in models_raw] # type: ignore[union-attr] + supports_developer_role = bool( + _settings_value(settings, "supports_developer_role", False) + ) + supports_reasoning_effort = bool( + _settings_value(settings, "supports_reasoning_effort", False) + ) + payload: dict[str, object] = { + "providers": { + _PROVIDER_NAME: { + "baseUrl": base_url, + "api": api, + "apiKey": api_key, + "compat": { + "supportsDeveloperRole": supports_developer_role, + "supportsReasoningEffort": supports_reasoning_effort, + }, + "models": [{"id": model} for model in models], + } + } + } + return payload, base_url + + +def _route_host(base_url: str) -> str: + parsed = urlparse(base_url) + if not parsed.scheme or not parsed.hostname: + die( + "agent provider provisioning: pi settings base_url must be an " + f"absolute URL (was {base_url!r})" + ) + return parsed.hostname + + +_RUNTIME = AgentProviderRuntime( + template="pi", + command="pi", + image="bot-bottle-pi:latest", + prompt_mode="print_read_prompt_file", + bypass_args=(), + resume_args=(), + remote_control_args=(), +) + + +class PiAgentProvider(AgentProvider): + @property + def runtime(self) -> AgentProviderRuntime: + return _RUNTIME + + def provision_plan( + self, + *, + dockerfile: str, + state_dir: Path, + instance_name: str, + prompt_file: Path, + guest_env: dict[str, str] | None = None, + auth_token: str = "", + forward_host_credentials: bool = False, + host_env: dict[str, str] | None = None, + trusted_project_path: str = "", + label: str = "", + color: str = "", + provider_settings: dict[str, object] | None = None, + ) -> AgentProvisionPlan: + del auth_token, forward_host_credentials, host_env, trusted_project_path + del label, color + resolved_guest_env = dict(guest_env or {}) + guest_home = self.guest_home + settings = dict(provider_settings or {}) + + models_payload, base_url = _pi_models_json(settings) + models_file = state_dir / "pi-models.json" + models_file.write_text(json.dumps(models_payload, indent=2) + "\n") + models_file.chmod(0o600) + + has_prompt = prompt_file.exists() and bool(prompt_file.read_text()) + return AgentProvisionPlan( + template=_RUNTIME.template, + command=_RUNTIME.command, + prompt_mode=_RUNTIME.prompt_mode, + image=_RUNTIME.image, + dockerfile=dockerfile, + guest_home=guest_home, + instance_name=instance_name, + prompt_file=prompt_file, + guest_env=resolved_guest_env, + has_prompt=has_prompt, + dirs=(AgentProvisionDir(f"{guest_home}/.pi/agent"),), + files=(AgentProvisionFile(models_file, _models_path(guest_home)),), + egress_routes=(EgressRoute(host=_route_host(base_url)),), + ) + + def provision_skills(self, plan: "BottlePlan", bottle: "Bottle") -> None: + from ...backend.util import host_skill_dir + + agent = plan.spec.manifest.agents[plan.spec.agent_name] + if not agent.skills: + return + skills_dir = _skills_dir(plan.guest_home) + bottle.exec(f"mkdir -p {skills_dir}", user="root") + for name in agent.skills: + src = host_skill_dir(name) + if not os.path.isdir(src): + die( + f"skill {name!r} disappeared from host between " + f"validation and copy at {src}." + ) + dst = f"{skills_dir}/{name}" + info(f"copying skill {name} into {bottle.name}:{dst}") + bottle.exec(f"rm -rf {dst} && mkdir -p {dst}", user="root") + bottle.cp_in(f"{src}/.", f"{dst}/") + bottle.exec(f"chown -R node:node {dst}", user="root") + + def provision_prompt(self, plan: "BottlePlan", bottle: "Bottle") -> str | None: + prompt_path = _prompt_path(plan.guest_home) + bottle.cp_in(str(plan.prompt_file), prompt_path) # type: ignore + bottle.exec( + f"chown node:node {prompt_path} && chmod 600 {prompt_path}", + user="root", + ) + agent = plan.spec.manifest.agents[plan.spec.agent_name] + return prompt_path if plan.agent_provision.has_prompt or agent.prompt else None + + def provision(self, plan: "BottlePlan", bottle: "Bottle") -> None: + provision = plan.agent_provision + for d in provision.dirs: + path = shlex.quote(d.guest_path) + _exec(bottle, f"mkdir -p {path}", f"could not create {d.guest_path}") + _exec( + bottle, + f"chown {shlex.quote(d.owner)} {path}", + f"could not chown {d.guest_path}", + ) + _exec( + bottle, + f"chmod {shlex.quote(d.mode)} {path}", + f"could not chmod {d.guest_path}", + ) + for f in provision.files: + bottle.cp_in(str(f.host_path), f.guest_path) + path = shlex.quote(f.guest_path) + _exec( + bottle, + f"chown {shlex.quote(f.owner)} {path}", + f"could not chown {f.guest_path}", + ) + _exec( + bottle, + f"chmod {shlex.quote(f.mode)} {path}", + f"could not chmod {f.guest_path}", + ) + + def provision_supervise_mcp( + self, + plan: "BottlePlan", + bottle: "Bottle", + supervise_url: str, + ) -> None: + del plan, bottle, supervise_url + + +def _exec(bottle: "Bottle", script: str, error: str) -> None: + result = bottle.exec(script, user="root") + if result.returncode != 0: + detail = (result.stderr or result.stdout).strip() + if detail: + detail = f": {detail}" + die(f"agent provider provisioning: {error}{detail}") diff --git a/bot_bottle/manifest_agent.py b/bot_bottle/manifest_agent.py index 927df42..3f60ccc 100644 --- a/bot_bottle/manifest_agent.py +++ b/bot_bottle/manifest_agent.py @@ -2,7 +2,7 @@ from __future__ import annotations -from dataclasses import dataclass +from dataclasses import dataclass, field from typing import cast from .agent_provider import PROVIDER_TEMPLATES @@ -33,15 +33,23 @@ class ManifestAgentProvider: dockerfile: str = "" auth_token: str = "" forward_host_credentials: bool = False + settings: dict[str, object] = field(default_factory=dict) @classmethod def from_dict(cls, bottle_name: str, raw: object) -> "ManifestAgentProvider": d = as_json_object(raw, f"bottle '{bottle_name}' agent_provider") for k in d: - if k not in {"template", "dockerfile", "auth_token", "forward_host_credentials"}: + if k not in { + "template", + "dockerfile", + "auth_token", + "forward_host_credentials", + "settings", + }: raise ManifestError( f"bottle '{bottle_name}' agent_provider has unknown key {k!r}; " - f"allowed: template, dockerfile, auth_token, forward_host_credentials" + "allowed: template, dockerfile, auth_token, " + "forward_host_credentials, settings" ) template = d.get("template", "claude") if not isinstance(template, str) or not template: @@ -89,11 +97,13 @@ class ManifestAgentProvider: f"bottle '{bottle_name}' agent_provider.forward_host_credentials " "is currently only supported for template 'codex'" ) + settings = _parse_provider_settings(bottle_name, template, d.get("settings")) return cls( template=template, dockerfile=dockerfile, auth_token=auth_token, forward_host_credentials=forward_host_credentials, + settings=settings, ) @@ -180,3 +190,60 @@ class ManifestAgent: git_user = ManifestGitUser.from_dict(name, gd["user"]) return cls(bottle=bottle, skills=skills, prompt=prompt, git_user=git_user) + + +def _parse_provider_settings( + bottle_name: str, + template: str, + raw: object, +) -> dict[str, object]: + if raw is None: + return {} + if template != "pi": + raise ManifestError( + f"bottle '{bottle_name}' agent_provider.settings is only " + "supported for template 'pi'" + ) + settings = as_json_object(raw, f"bottle '{bottle_name}' agent_provider.settings") + allowed = { + "base_url", + "api", + "api_key", + "models", + "supports_developer_role", + "supports_reasoning_effort", + } + for key in settings: + if key not in allowed: + raise ManifestError( + f"bottle '{bottle_name}' agent_provider.settings has unknown " + f"key {key!r}; allowed: {', '.join(sorted(allowed))}" + ) + for key in ("base_url", "api", "api_key"): + value = settings.get(key) + if value is not None and (not isinstance(value, str) or not value): + raise ManifestError( + f"bottle '{bottle_name}' agent_provider.settings.{key} must " + "be a non-empty string" + ) + models = settings.get("models") + if models is not None: + if not isinstance(models, list) or not models: + raise ManifestError( + f"bottle '{bottle_name}' agent_provider.settings.models must " + "be a non-empty array of strings" + ) + for i, model in enumerate(models): + if not isinstance(model, str) or not model: + raise ManifestError( + f"bottle '{bottle_name}' agent_provider.settings.models[{i}] " + "must be a non-empty string" + ) + for key in ("supports_developer_role", "supports_reasoning_effort"): + value = settings.get(key) + if value is not None and not isinstance(value, bool): + raise ManifestError( + f"bottle '{bottle_name}' agent_provider.settings.{key} must " + f"be a boolean (was {type(value).__name__})" + ) + return dict(settings) diff --git a/tests/unit/test_agent_provider.py b/tests/unit/test_agent_provider.py index 884c37f..0fe3659 100644 --- a/tests/unit/test_agent_provider.py +++ b/tests/unit/test_agent_provider.py @@ -11,6 +11,7 @@ from pathlib import Path from bot_bottle.agent_provider import ( CODEX_HOST_CREDENTIAL_HOSTS, build_agent_provision_plan, + prompt_args, ) from bot_bottle.egress import CODEX_HOST_CREDENTIAL_TOKEN_REF @@ -260,6 +261,73 @@ class TestAgentProviderRuntime(unittest.TestCase): ) self.assertEqual({}, plan.provisioned_env) + def test_pi_plan_writes_default_ollama_models(self): + with tempfile.TemporaryDirectory(prefix="bb-provider.") as tmp: + plan = build_agent_provision_plan( + template="pi", + dockerfile="/tmp/Dockerfile.pi", + state_dir=Path(tmp), + instance_name="bot-bottle-test", + prompt_file=Path(tmp) / "prompt.txt", + ) + models = json.loads(Path(tmp, "pi-models.json").read_text()) + self.assertEqual("pi", plan.template) + self.assertEqual("pi", plan.command) + self.assertEqual("print_read_prompt_file", plan.prompt_mode) + self.assertEqual("/tmp/Dockerfile.pi", plan.dockerfile) + self.assertEqual("bot-bottle-pi:latest", plan.image) + self.assertEqual( + ("/home/node/.pi/agent",), + tuple(d.guest_path for d in plan.dirs), + ) + self.assertEqual( + ("/home/node/.pi/agent/models.json",), + tuple(f.guest_path for f in plan.files), + ) + provider = models["providers"]["ollama"] + self.assertEqual("http://ollama:11434/v1", provider["baseUrl"]) + self.assertEqual("openai-completions", provider["api"]) + self.assertEqual("ollama", provider["apiKey"]) + self.assertEqual([{"id": "qwen2.5-coder:7b"}], provider["models"]) + self.assertEqual("ollama", plan.egress_routes[0].host) + self.assertEqual("", plan.egress_routes[0].auth_scheme) + self.assertEqual("", plan.egress_routes[0].token_ref) + + def test_pi_plan_uses_provider_settings(self): + with tempfile.TemporaryDirectory(prefix="bb-provider.") as tmp: + build_agent_provision_plan( + template="pi", + dockerfile="", + state_dir=Path(tmp), + instance_name="bot-bottle-test", + prompt_file=Path(tmp) / "prompt.txt", + provider_settings={ + "base_url": "http://host.docker.internal:11434/v1", + "api": "openai-responses", + "api_key": "local", + "models": ["gpt-oss:20b", "qwen3:14b"], + "supports_developer_role": True, + "supports_reasoning_effort": True, + }, + ) + models = json.loads(Path(tmp, "pi-models.json").read_text()) + provider = models["providers"]["ollama"] + self.assertEqual("http://host.docker.internal:11434/v1", provider["baseUrl"]) + self.assertEqual("openai-responses", provider["api"]) + self.assertEqual("local", provider["apiKey"]) + self.assertEqual( + [{"id": "gpt-oss:20b"}, {"id": "qwen3:14b"}], + provider["models"], + ) + self.assertTrue(provider["compat"]["supportsDeveloperRole"]) + self.assertTrue(provider["compat"]["supportsReasoningEffort"]) + + def test_pi_prompt_mode_uses_print_flag(self): + self.assertEqual( + ["-p", "Read and follow the instructions in /home/node/.bot-bottle-prompt.txt."], + prompt_args("print_read_prompt_file", "/home/node/.bot-bottle-prompt.txt"), + ) + if __name__ == "__main__": unittest.main() diff --git a/tests/unit/test_contrib_pi_provider.py b/tests/unit/test_contrib_pi_provider.py new file mode 100644 index 0000000..143f216 --- /dev/null +++ b/tests/unit/test_contrib_pi_provider.py @@ -0,0 +1,195 @@ +"""Unit: PiAgentProvider provisioning (PRD 0058, contrib/pi).""" + +from __future__ import annotations + +import unittest +from pathlib import Path +from unittest.mock import MagicMock, patch + +from bot_bottle.agent_provider import ( + AgentProvisionDir, + AgentProvisionFile, + AgentProvisionPlan, +) +from bot_bottle.backend import Bottle, BottleSpec, ExecResult +from bot_bottle.backend.docker.bottle_plan import DockerBottlePlan +from bot_bottle.contrib.pi.agent_provider import PiAgentProvider +from bot_bottle.egress import EgressPlan +from bot_bottle.git_gate import GitGatePlan +from bot_bottle.manifest import Manifest + + +_URL = "http://supervise:9100/" + + +def _make_bottle(exec_result: ExecResult | None = None) -> MagicMock: + bottle = MagicMock(spec=Bottle) + bottle.name = "bot-bottle-demo-abc12" + bottle.exec.return_value = ( + exec_result if exec_result is not None + else ExecResult(returncode=0, stdout="", stderr="") + ) + return bottle + + +def _exec_scripts(bottle: MagicMock) -> list[str]: + return [c.args[0] for c in bottle.exec.call_args_list] + + +def _plan( + *, + agent_prompt: str = "", + skills: list[str] | None = None, + agent_provision: AgentProvisionPlan | None = None, +) -> DockerBottlePlan: + manifest = Manifest.from_json_obj({ + "bottles": {"dev": {"agent_provider": {"template": "pi"}}}, + "agents": { + "demo": { + "skills": list(skills or []), + "prompt": agent_prompt, + "bottle": "dev", + }, + }, + }) + spec = BottleSpec( + manifest=manifest, agent_name="demo", + copy_cwd=False, user_cwd="/tmp/x", + ) + return DockerBottlePlan( + spec=spec, + stage_dir=Path("/tmp/stage"), + slug="demo-abc12", + forwarded_env={}, + git_gate_plan=GitGatePlan( + slug="demo-abc12", + entrypoint_script=Path("/tmp/git-gate-entrypoint.sh"), + hook_script=Path("/tmp/git-gate-hook"), + access_hook_script=Path("/tmp/git-gate-access-hook"), + upstreams=(), + ), + egress_plan=EgressPlan( + slug="demo-abc12", + routes_path=Path("/tmp/routes.yaml"), + routes=(), + token_env_map={}, + ), + supervise_plan=None, + use_runsc=False, + agent_provision=agent_provision or AgentProvisionPlan( + template="pi", command="pi", prompt_mode="print_read_prompt_file", + image="bot-bottle-pi:latest", dockerfile="", + guest_home="/home/node", + instance_name="bot-bottle-demo-abc12", + prompt_file=Path("/tmp/state/demo-abc12/agent/prompt.txt"), + guest_env={}, + ), + ) + + +class TestPiProvisionPrompt(unittest.TestCase): + def test_cp_uses_bottle_cp_in_and_chowns(self): + bottle = _make_bottle() + result = PiAgentProvider().provision_prompt( + _plan(agent_prompt="hello"), bottle, + ) + self.assertEqual("/home/node/.bot-bottle-prompt.txt", result) + bottle.cp_in.assert_called_once_with( + "/tmp/state/demo-abc12/agent/prompt.txt", + "/home/node/.bot-bottle-prompt.txt", + ) + scripts = _exec_scripts(bottle) + self.assertTrue( + any("chown node:node" in s + and "/home/node/.bot-bottle-prompt.txt" in s + for s in scripts) + ) + + def test_returns_none_when_agent_has_no_prompt(self): + bottle = _make_bottle() + result = PiAgentProvider().provision_prompt(_plan(agent_prompt=""), bottle) + self.assertIsNone(result) + bottle.cp_in.assert_called_once() + + +class TestPiProvisionSkills(unittest.TestCase): + def test_noop_when_agent_has_no_skills(self): + bottle = _make_bottle() + PiAgentProvider().provision_skills(_plan(skills=[]), bottle) + bottle.cp_in.assert_not_called() + bottle.exec.assert_not_called() + + def test_mkdir_plus_cp_per_skill(self): + bottle = _make_bottle() + with patch( + "bot_bottle.backend.util.host_skill_dir", + side_effect=lambda n: f"/host/skills/{n}", # type: ignore + ), patch( + "bot_bottle.contrib.pi.agent_provider.os.path.isdir", + return_value=True, + ): + PiAgentProvider().provision_skills(_plan(skills=["search"]), bottle) + scripts = _exec_scripts(bottle) + self.assertTrue( + any("mkdir -p" in s and "/home/node/.pi/agent/skills" in s + for s in scripts) + ) + bottle.cp_in.assert_called_once() + self.assertEqual( + "/home/node/.pi/agent/skills/search/", + bottle.cp_in.call_args.args[1], + ) + + +class TestPiProvision(unittest.TestCase): + def test_creates_dir_and_copies_models_config(self): + provision = AgentProvisionPlan( + template="pi", command="pi", prompt_mode="print_read_prompt_file", + image="", dockerfile="", guest_home="/home/node", + instance_name="bot-bottle-demo-abc12", + prompt_file=Path("/tmp/prompt.txt"), + guest_env={}, + dirs=(AgentProvisionDir("/home/node/.pi/agent"),), + files=(AgentProvisionFile( + Path("/tmp/pi-models.json"), + "/home/node/.pi/agent/models.json", + ),), + ) + bottle = _make_bottle() + PiAgentProvider().provision(_plan(agent_provision=provision), bottle) + bottle.cp_in.assert_called_once_with( + "/tmp/pi-models.json", + "/home/node/.pi/agent/models.json", + ) + scripts = _exec_scripts(bottle) + self.assertTrue( + any("mkdir -p" in s and "/home/node/.pi/agent" in s for s in scripts) + ) + self.assertTrue( + any("chown" in s and "/home/node/.pi/agent/models.json" in s + for s in scripts) + ) + + def test_dies_when_dir_creation_fails(self): + provision = AgentProvisionPlan( + template="pi", command="pi", prompt_mode="print_read_prompt_file", + image="", dockerfile="", guest_home="/home/node", + instance_name="bot-bottle-demo-abc12", + prompt_file=Path("/tmp/prompt.txt"), + guest_env={}, + dirs=(AgentProvisionDir("/home/node/.pi/agent"),), + ) + bottle = _make_bottle(exec_result=ExecResult(1, "", "mkdir: nope\n")) + with self.assertRaises(SystemExit): + PiAgentProvider().provision(_plan(agent_provision=provision), bottle) + + +class TestPiSuperviseMcp(unittest.TestCase): + def test_noop(self): + bottle = _make_bottle() + PiAgentProvider().provision_supervise_mcp(_plan(), bottle, _URL) + bottle.exec.assert_not_called() + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/unit/test_manifest_egress.py b/tests/unit/test_manifest_egress.py index d41863f..fe4973b 100644 --- a/tests/unit/test_manifest_egress.py +++ b/tests/unit/test_manifest_egress.py @@ -111,6 +111,51 @@ class TestAgentProviderHostCredentials(unittest.TestCase): "auth_token": "SOME_TOKEN", }) + def test_settings_allowed_for_pi(self): + b = _provider_config_bottle({ + "template": "pi", + "settings": { + "base_url": "http://ollama:11434/v1", + "api": "openai-completions", + "api_key": "ollama", + "models": ["qwen2.5-coder:7b"], + "supports_developer_role": False, + "supports_reasoning_effort": False, + }, + }) + self.assertEqual( + { + "base_url": "http://ollama:11434/v1", + "api": "openai-completions", + "api_key": "ollama", + "models": ["qwen2.5-coder:7b"], + "supports_developer_role": False, + "supports_reasoning_effort": False, + }, + b.agent_provider.settings, + ) + + def test_settings_rejected_for_claude(self): + with self.assertRaises(ManifestError): + _provider_config_bottle({ + "template": "claude", + "settings": {"models": ["qwen2.5-coder:7b"]}, + }) + + def test_settings_models_must_be_non_empty_string_array(self): + with self.assertRaises(ManifestError): + _provider_config_bottle({ + "template": "pi", + "settings": {"models": []}, + }) + + def test_settings_boolean_flags_must_be_boolean(self): + with self.assertRaises(ManifestError): + _provider_config_bottle({ + "template": "pi", + "settings": {"supports_developer_role": "no"}, + }) + class TestMatches(unittest.TestCase): def test_optional(self):