ouroboros-ai 0.40.2.dev13__tar.gz → 0.40.2.dev14__tar.gz

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.40.2.dev13
+Version: 0.40.2.dev14
 Summary: Specification-first workflow engine for AI coding agents. Works with Claude Code and Codex CLI.
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.40.2.dev13'
-__version_tuple__ = version_tuple = (0, 40, 2, 'dev13')
+__version__ = version = '0.40.2.dev14'
+__version_tuple__ = version_tuple = (0, 40, 2, 'dev14')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/src/ouroboros/backends/capabilities.py

@@ -242,8 +242,8 @@ _CAPABILITIES: tuple[BackendCapability, ...] = (
         name="pi",
         aliases=("pi_cli",),
         supports_runtime=True,
-        supports_llm=False,
-        supports_interview_driver=False,
+        supports_llm=True,
+        supports_interview_driver=True,
         cli_name="pi",
         cli_config_key="pi_cli_path",
         supports_tool_envelope=False,

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/src/ouroboros/config/loader.py

@@ -68,11 +68,13 @@ _CODEX_LLM_BACKENDS = frozenset({"codex", "codex_cli", "opencode", "opencode_cli
 _KIRO_LLM_BACKENDS = frozenset({"kiro", "kiro_cli"})
 _COPILOT_LLM_BACKENDS = frozenset({"copilot", "copilot_cli"})
 _HERMES_LLM_BACKENDS = frozenset({"hermes", "hermes_cli"})
+_PI_LLM_BACKENDS = frozenset({"pi", "pi_cli"})
 _OPENCODE_BACKENDS = frozenset({"opencode", "opencode_cli"})
 _CODEX_DEFAULT_MODEL = "default"
 _KIRO_DEFAULT_MODEL = "default"
 _COPILOT_DEFAULT_MODEL = "default"
 _HERMES_DEFAULT_MODEL = "default"
+_PI_DEFAULT_MODEL = "default"
 _PLACEHOLDER_API_KEY_PREFIX = "YOUR_"
 _PLACEHOLDER_API_KEY_SUFFIX = "_API_KEY"
 _DEFAULT_MAX_PARALLEL_WORKERS = 3
@@ -1253,6 +1255,8 @@ def _default_model_for_backend(
         return _COPILOT_DEFAULT_MODEL
     if resolved in _HERMES_LLM_BACKENDS:
         return _HERMES_DEFAULT_MODEL
+    if resolved in _PI_LLM_BACKENDS:
+        return _PI_DEFAULT_MODEL
     return default_model
 
 
@@ -1291,6 +1295,8 @@ def _normalize_configured_model_for_backend(
         return _COPILOT_DEFAULT_MODEL
     if resolved in _HERMES_LLM_BACKENDS and is_shipped_default:
         return _HERMES_DEFAULT_MODEL
+    if resolved in _PI_LLM_BACKENDS and candidate == default_model:
+        return _PI_DEFAULT_MODEL
 
     return candidate
 

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/src/ouroboros/config/models.py

@@ -133,6 +133,7 @@ class LLMConfig(BaseModel, frozen=True):
         "kiro",
         "hermes",
         "goose",
+        "pi",
     ] = "claude_code"
     permission_mode: Literal["default", "acceptEdits", "bypassPermissions"] = "default"
     opencode_permission_mode: Literal["default", "acceptEdits", "bypassPermissions"] = "acceptEdits"

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/src/ouroboros/providers/codex_cli_adapter.py

@@ -406,6 +406,7 @@ class CodexCliLLMAdapter:
         output_schema_path: str | None,
         model: str | None,
         profile: str | None = None,
+        prompt: str | None = None,
     ) -> list[str]:
         """Build the `codex exec` command for a one-shot completion.
 
@@ -766,6 +767,10 @@ class CodexCliLLMAdapter:
             shutdown_timeout=self._process_shutdown_timeout_seconds,
         )
 
+    def _prompt_stdin_bytes(self, prompt: str) -> bytes | None:
+        """Return bytes to write to process stdin for the prompt, if any."""
+        return prompt.encode("utf-8")
+
     def _update_last_content(self, last_content: str, event_content: str) -> str:
         """Return the fallback completion content after a streamed event.
 
@@ -883,9 +888,10 @@ class CodexCliLLMAdapter:
             output_schema_path=str(schema_path) if schema_path else None,
             model=normalized_model,
             profile=resolved.backend_profile,
+            prompt=prompt,
         )
 
-        prompt_bytes = prompt.encode("utf-8")
+        prompt_stdin_bytes = self._prompt_stdin_bytes(prompt)
 
         try:
             process = await asyncio.create_subprocess_exec(
@@ -923,11 +929,13 @@ class CodexCliLLMAdapter:
                 )
             )
 
-        # Feed prompt via stdin to avoid ARG_MAX limits
-        if process.stdin is not None:
-            process.stdin.write(prompt_bytes)
+        # Feed prompt via stdin when the backend expects stdin delivery.
+        if process.stdin is not None and prompt_stdin_bytes is not None:
+            process.stdin.write(prompt_stdin_bytes)
             await process.stdin.drain()
             process.stdin.close()
+        elif process.stdin is not None:
+            process.stdin.close()
 
         if not hasattr(process, "stdout") or not callable(getattr(process, "wait", None)):
             (

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/src/ouroboros/providers/factory.py

@@ -16,6 +16,7 @@ from ouroboros.config import (
     get_hermes_cli_path,
     get_llm_backend,
     get_llm_permission_mode,
+    get_pi_cli_path,
     get_runtime_profile,
 )
 from ouroboros.providers.base import LLMAdapter
@@ -25,6 +26,7 @@ from ouroboros.providers.copilot_cli_adapter import CopilotCliLLMAdapter
 from ouroboros.providers.gemini_cli_adapter import GeminiCLIAdapter
 from ouroboros.providers.goose_cli_adapter import GooseCliLLMAdapter
 from ouroboros.providers.opencode_adapter import OpenCodeLLMAdapter
+from ouroboros.providers.pi_llm_adapter import PiLLMAdapter
 
 if TYPE_CHECKING:
     from ouroboros.events.io_recorder import IOJournalRecorder
@@ -101,6 +103,7 @@ def resolve_llm_permission_mode(
         "goose",
         "hermes",
         "opencode",
+        "pi",
     ):
         # Interview uses LLM to generate questions — no file writes, but
         # CLI sandbox modes block LLM output entirely. Must bypass.
@@ -245,6 +248,17 @@ def create_llm_adapter(
             timeout=timeout,
             max_retries=max_retries,
         )
+    if resolved_backend == "pi":
+        return PiLLMAdapter(
+            cli_path=cli_path or get_pi_cli_path(),
+            cwd=cwd,
+            permission_mode=resolved_permission_mode,
+            allowed_tools=allowed_tools,
+            max_turns=max_turns,
+            on_message=on_message,
+            timeout=timeout,
+            max_retries=max_retries,
+        )
     if resolved_backend == "kiro":
         from ouroboros.config import get_kiro_cli_path
         from ouroboros.providers.kiro_adapter import KiroCodeAdapter

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/src/ouroboros/providers/goose_cli_adapter.py

@@ -229,9 +229,10 @@ class GooseCliLLMAdapter(CodexCliLLMAdapter):
         output_schema_path: str | None,
         model: str | None,
         profile: str | None = None,
+        prompt: str | None = None,
     ) -> list[str]:
         """Build the ``goose run`` command; prompt is fed via stdin."""
-        del output_last_message_path, output_schema_path, profile
+        del output_last_message_path, output_schema_path, profile, prompt
         command = [
             self._cli_path,
             "run",

ouroboros_ai-0.40.2.dev14/src/ouroboros/providers/pi_llm_adapter.py

@@ -0,0 +1,220 @@
+"""Pi CLI adapter for LLM completion via pi.dev JSON mode."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from ouroboros.config import get_pi_cli_path
+from ouroboros.core.errors import ProviderError
+from ouroboros.core.types import Result
+from ouroboros.providers.base import CompletionConfig, CompletionResponse, Message
+from ouroboros.providers.codex_cli_adapter import CodexCliLLMAdapter
+
+
+class PiLLMAdapter(CodexCliLLMAdapter):
+    """LLM adapter backed by ``pi --mode json``.
+
+    Pi uses the same JSONL event stream family as the runtime adapter but is
+    exposed here as an LLM-only provider so interview/planning/evaluation roles
+    can select ``--llm-backend pi``.
+    """
+
+    _provider_name = "pi"
+    _display_name = "Pi CLI"
+    _default_cli_name = "pi"
+    _tempfile_prefix = "ouroboros-pi-llm-"
+    _schema_tempfile_prefix = "ouroboros-pi-schema-"
+    _log_namespace = "pi_llm_adapter"
+    _completion_profile_backend = "pi"
+
+    def __init__(
+        self,
+        *,
+        cli_path: str | Path | None = None,
+        cwd: str | Path | None = None,
+        permission_mode: str | None = None,
+        allowed_tools: list[str] | None = None,
+        max_turns: int = 1,
+        on_message: Any | None = None,
+        max_retries: int = 3,
+        ephemeral: bool = True,
+        timeout: float | None = None,
+        runtime_profile: str | None = None,
+    ) -> None:
+        del runtime_profile
+        super().__init__(
+            cli_path=cli_path,
+            cwd=cwd,
+            permission_mode=permission_mode,
+            allowed_tools=allowed_tools,
+            max_turns=max_turns,
+            on_message=on_message,
+            max_retries=max_retries,
+            ephemeral=ephemeral,
+            timeout=timeout,
+            runtime_profile=None,
+        )
+        self._last_pi_event_kind: str | None = None
+
+    def _get_configured_cli_path(self) -> str | None:
+        """Resolve Pi CLI path from config helpers."""
+        return get_pi_cli_path()
+
+    def _resolve_permission_mode(self, permission_mode: str | None) -> str:
+        """Pi currently has no separate permission-mode flag surface."""
+        return (permission_mode or "default").strip() or "default"
+
+    def _build_permission_args(self) -> list[str]:
+        """Pi JSON mode does not currently expose Codex-style permission flags."""
+        return []
+
+    def _prompt_stdin_bytes(self, prompt: str) -> bytes | None:
+        """Pi JSON mode receives the prompt as a positional argument."""
+        del prompt
+        return None
+
+    def _build_command(
+        self,
+        *,
+        output_last_message_path: str,
+        output_schema_path: str | None,
+        model: str | None,
+        profile: str | None = None,
+        prompt: str | None = None,
+    ) -> list[str]:
+        """Build ``pi --mode json <prompt>``.
+
+        ``output_last_message_path`` and schema/profile parameters are accepted
+        for factory compatibility with :class:`CodexCliLLMAdapter`; Pi emits its
+        response on JSONL stdout instead.
+        """
+        del output_last_message_path, output_schema_path, profile
+        command = [self._cli_path, "--mode", "json"]
+        # Ouroboros normalizes generic cross-provider defaults to the local-CLI
+        # sentinel "default". Pi should use its own backend default in that case
+        # rather than forwarding Anthropic-oriented or sentinel model names.
+        if model and model != "default":
+            command.extend(["--model", model])
+        command.append(prompt or "")
+        return command
+
+    def _update_last_content(self, last_content: str, event_content: str) -> str:
+        """Accumulate streaming deltas but replace them with terminal Pi content.
+
+        Pi JSON mode can emit both whitespace-preserving ``message_update``
+        deltas and a final ``agent_end`` / ``message_end`` full message. The
+        inherited Codex loop only passes extracted text into this hook, so this
+        adapter records the most recent Pi event kind in ``_extract_text`` and
+        uses it here to avoid returning duplicated ``delta + final`` content.
+        """
+        if not event_content:
+            return last_content
+        if self._last_pi_event_kind == "final":
+            return event_content
+        return f"{last_content}{event_content}" if last_content else event_content
+
+    async def complete(
+        self,
+        messages: list[Message],
+        config: CompletionConfig,
+    ) -> Result[CompletionResponse, ProviderError]:
+        """Make a Pi completion request, failing closed on unsupported schemas."""
+        self._last_pi_event_kind = None
+        if config.response_format:
+            response_format_type = config.response_format.get("type")
+            return Result.err(
+                ProviderError(
+                    message=(
+                        "Pi CLI LLM backend does not currently support structured "
+                        "response_format requests"
+                    ),
+                    provider=self._provider_name,
+                    details={"response_format_type": response_format_type},
+                )
+            )
+        return await super().complete(messages, config)
+
+    def _extract_session_id_from_event(self, event: dict[str, Any]) -> str | None:
+        if event.get("type") == "session" and isinstance(event.get("id"), str):
+            return event["id"]
+        return None
+
+    def _extract_text_from_message(self, message: dict[str, Any]) -> str:
+        """Extract assistant text from a Pi transcript message."""
+        content = message.get("content") or message.get("text") or ""
+        if isinstance(content, str) and content.strip():
+            return content.strip()
+        if isinstance(content, list):
+            texts: list[str] = []
+            for item in content:
+                if isinstance(item, str):
+                    texts.append(item)
+                elif isinstance(item, dict):
+                    text = item.get("text") or item.get("content")
+                    if isinstance(text, str) and item.get("type") in {None, "text"}:
+                        texts.append(text)
+            return "".join(texts).strip()
+        return ""
+
+    def _extract_content_delta(self, event: dict[str, Any]) -> str:
+        """Extract streaming text with parity to ``PiRuntime`` JSON parsing."""
+        if event.get("type") != "message_update":
+            return ""
+
+        assistant_event = event.get("assistantMessageEvent")
+        if isinstance(assistant_event, dict):
+            delta = assistant_event.get("delta")
+            if isinstance(delta, str):
+                return delta
+            text = assistant_event.get("text") or assistant_event.get("content")
+            if isinstance(text, str):
+                return text
+
+        delta = event.get("delta") or event.get("content") or event.get("text")
+        if isinstance(delta, str):
+            return delta
+        if isinstance(delta, dict):
+            text = delta.get("text") or delta.get("content")
+            return text if isinstance(text, str) else ""
+        return ""
+
+    def _extract_final_text(self, event: dict[str, Any]) -> str:
+        """Extract only terminal assistant content from Pi final events."""
+        event_type = event.get("type")
+        if event_type in {"message_end", "turn_end"}:
+            message = event.get("message")
+            if isinstance(message, dict) and message.get("role") == "assistant":
+                return self._extract_text_from_message(message)
+            return ""
+        if event_type == "agent_end":
+            messages = event.get("messages")
+            if isinstance(messages, list):
+                for message in reversed(messages):
+                    if isinstance(message, dict) and message.get("role") == "assistant":
+                        text = self._extract_text_from_message(message)
+                        if text:
+                            return text
+            return ""
+        return ""
+
+    def _extract_text(self, value: object) -> str:
+        """Extract content from documented Pi JSONL events."""
+        if isinstance(value, dict):
+            event_type = value.get("type")
+            self._last_pi_event_kind = None
+            if event_type == "message_update":
+                self._last_pi_event_kind = "delta"
+                return self._extract_content_delta(value)
+            if event_type in {"message_end", "turn_end", "agent_end"}:
+                self._last_pi_event_kind = "final"
+                return self._extract_final_text(value)
+            # Pi control/metadata events (for example `session`) must never fall
+            # through to the broad Codex extractor, which treats shallow string
+            # fields such as `type` and `id` as user-visible completion text.
+            return ""
+        self._last_pi_event_kind = None
+        return super()._extract_text(value)
+
+
+__all__ = ["PiLLMAdapter"]

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/src/ouroboros/providers/profiles.py

@@ -27,6 +27,8 @@ _BACKEND_ALIASES = {
     "hermes_cli": "hermes",
     "opencode": "opencode",
     "opencode_cli": "opencode",
+    "pi": "pi",
+    "pi_cli": "pi",
     "litellm": "litellm",
     "openai": "litellm",
     "openrouter": "litellm",

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/tests/unit/backends/test_capabilities.py

@@ -45,7 +45,7 @@ def test_llm_choices_include_hermes_adapter() -> None:
     choices = llm_backend_choices()
     assert "codex" in choices
     assert "hermes" in choices
-    assert "pi" not in choices
+    assert "pi" in choices
 
 
 def test_capability_specific_resolution_rejects_wrong_surface() -> None:

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/tests/unit/config/test_loader.py

@@ -1260,6 +1260,37 @@ class TestLLMHelperLookups:
             assert get_semantic_model(backend="hermes") == "default"
             assert get_assertion_extraction_model(backend="hermes") == "default"
 
+    def test_pi_backend_uses_default_model_sentinel(self) -> None:
+        """Backend-aware defaults avoid cross-provider model names for Pi."""
+        with (
+            patch.dict(os.environ, {}, clear=True),
+            patch(
+                "ouroboros.config.loader.load_config",
+                side_effect=ConfigError("missing config"),
+            ),
+        ):
+            assert get_clarification_model(backend="pi") == "default"
+            assert get_wonder_model(backend="pi") == "default"
+            assert get_reflect_model(backend="pi") == "default"
+            assert get_semantic_model(backend="pi") == "default"
+            assert get_assertion_extraction_model(backend="pi") == "default"
+
+    def test_pi_backend_normalizes_config_default_models_to_default_sentinel(self) -> None:
+        """Existing default configs should remain usable after switching to Pi."""
+        with (
+            patch.dict(os.environ, {}, clear=True),
+            patch(
+                "ouroboros.config.loader.load_config",
+                return_value=OuroborosConfig(),
+            ),
+        ):
+            assert get_clarification_model(backend="pi") == "default"
+            assert get_qa_model(backend="pi") == "default"
+            assert get_wonder_model(backend="pi") == "default"
+            assert get_reflect_model(backend="pi") == "default"
+            assert get_semantic_model(backend="pi") == "default"
+            assert get_assertion_extraction_model(backend="pi") == "default"
+
     def test_codex_backend_preserves_explicit_non_default_models_from_config(self) -> None:
         """Explicit config overrides should survive backend normalization."""
         custom_config = OuroborosConfig(

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/tests/unit/config/test_models.py

@@ -221,6 +221,11 @@ class TestLLMConfig:
         config = LLMConfig(backend="opencode")
         assert config.backend == "opencode"
 
+    def test_llm_config_accepts_pi_backend(self) -> None:
+        """LLMConfig accepts Pi as a local CLI backend."""
+        config = LLMConfig(backend="pi")
+        assert config.backend == "pi"
+
 
 class TestLLMTaskProfileConfig:
     """Test provider-neutral LLM task profile configuration."""

{ouroboros_ai-0.40.2.dev13 → ouroboros_ai-0.40.2.dev14}/tests/unit/providers/test_factory.py

@@ -19,6 +19,7 @@ from ouroboros.providers.goose_cli_adapter import GooseCliLLMAdapter
 from ouroboros.providers.hermes_cli_adapter import HermesCliLLMAdapter
 from ouroboros.providers.litellm_adapter import LiteLLMAdapter
 from ouroboros.providers.opencode_adapter import OpenCodeLLMAdapter
+from ouroboros.providers.pi_llm_adapter import PiLLMAdapter
 
 
 class _FakeEventStore:
@@ -75,6 +76,11 @@ class TestResolveLLMBackend:
         assert resolve_llm_backend("goose") == "goose"
         assert resolve_llm_backend("goose_cli") == "goose"
 
+    def test_resolves_pi_aliases(self) -> None:
+        """Pi aliases normalize to pi."""
+        assert resolve_llm_backend("pi") == "pi"
+        assert resolve_llm_backend("pi_cli") == "pi"
+
 
 class TestCreateLLMAdapter:
     """Tests for adapter construction."""
@@ -135,6 +141,18 @@ class TestCreateLLMAdapter:
         assert isinstance(adapter, ClaudeCodeAdapter)
         assert adapter._strict_mcp_config is False
 
+    def test_creates_pi_adapter(self) -> None:
+        """Pi backend returns PiLLMAdapter."""
+        adapter = create_llm_adapter(backend="pi", cli_path="/tmp/pi")
+        assert isinstance(adapter, PiLLMAdapter)
+        assert adapter._cli_path == "/tmp/pi"
+
+    def test_pi_interview_use_case_bypasses_permissions(self) -> None:
+        """Pi interview driver uses the text-only bypass permission convention."""
+        assert (
+            resolve_llm_permission_mode(backend="pi", use_case="interview") == "bypassPermissions"
+        )
+
     def test_creates_litellm_adapter(self) -> None:
         """LiteLLM backend returns LiteLLMAdapter."""
         adapter = create_llm_adapter(backend="litellm")