pi-agent-cli-lc 0.2.0__py3-none-any.whl

pi_agent_cli/__init__.py

@@ -0,0 +1,19 @@
+"""Standard ACP agent over AgentHarness. Vendor extension RPCs are not implemented."""
+
+from pi_agent_cli.agent import PiAcpAgent
+from pi_agent_cli.config import (
+    CliConfig,
+    expand_config_path,
+    load_config,
+    make_get_api_key,
+    pi_home,
+)
+
+__all__ = [
+    "CliConfig",
+    "PiAcpAgent",
+    "expand_config_path",
+    "load_config",
+    "make_get_api_key",
+    "pi_home",
+]

pi_agent_cli/__main__.py

@@ -0,0 +1,81 @@
+"""stdio entry: python -m pi_agent_cli
+
+Default: ACP agent on stdio.
+`python -m pi_agent_cli -p "..."`: one-shot headless turn (no TUI).
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+from acp import run_agent
+
+from pi_agent_cli.agent import PiAcpAgent
+from pi_agent_cli.config import load_local_env
+from pi_agent_cli.headless import resolve_print_prompt, run_print
+
+
+async def _amain() -> None:
+    await run_agent(PiAcpAgent())
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pi-agent-cli",
+        description="Standard ACP agent over AgentHarness (stdio), or one-shot -p print.",
+    )
+    src = parser.add_mutually_exclusive_group()
+    src.add_argument(
+        "-p",
+        "--print",
+        dest="print_prompt",
+        metavar="PROMPT",
+        help="Run one prompt, print the assistant text, and exit (no TUI, no ACP stdio).",
+    )
+    src.add_argument(
+        "--prompt-json",
+        metavar="JSON",
+        help="Single-turn prompt as a JSON string or list of content blocks.",
+    )
+    src.add_argument(
+        "--prompt-file",
+        metavar="PATH",
+        type=Path,
+        help="Read the single-turn prompt from a file.",
+    )
+    parser.add_argument(
+        "--cwd",
+        metavar="PATH",
+        type=Path,
+        help="Working directory for the headless session (default: process cwd).",
+    )
+    return parser
+
+
+def main() -> None:
+    load_local_env()
+    parser = _build_parser()
+    args = parser.parse_args()
+    headless = any(
+        value is not None for value in (args.print_prompt, args.prompt_json, args.prompt_file)
+    )
+    if headless:
+        try:
+            prompt = resolve_print_prompt(
+                print_prompt=args.print_prompt,
+                prompt_json=args.prompt_json,
+                prompt_file=args.prompt_file,
+            )
+        except (OSError, ValueError, json.JSONDecodeError) as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            raise SystemExit(2) from exc
+        raise SystemExit(asyncio.run(run_print(prompt, cwd=args.cwd)))
+    asyncio.run(_amain())
+
+
+if __name__ == "__main__":
+    main()

pi_agent_cli/agent.py

@@ -0,0 +1,297 @@
+"""ACP Agent: standard methods only; AgentHarness is the engine."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any
+
+from acp import PROTOCOL_VERSION, RequestError
+from acp.interfaces import Agent, Client
+from acp.schema import (
+    AgentCapabilities,
+    AudioContentBlock,
+    ClientCapabilities,
+    CloseSessionResponse,
+    EmbeddedResourceContentBlock,
+    HttpMcpServer,
+    ImageContentBlock,
+    Implementation,
+    InitializeResponse,
+    ListSessionsResponse,
+    LoadSessionResponse,
+    McpServerStdio,
+    NewSessionResponse,
+    PromptCapabilities,
+    PromptResponse,
+    ResourceContentBlock,
+    SessionCapabilities,
+    SessionCloseCapabilities,
+    SessionInfo,
+    SessionListCapabilities,
+    SessionResumeCapabilities,
+    SseMcpServer,
+    TextContentBlock,
+)
+
+from pi_agent_cli.config import CliConfig, load_config, pi_home
+from pi_agent_cli.events import project_event
+from pi_agent_cli.factory import create_session_harness, default_stream_fn, load_session_resources
+from pi_agent_cli.permissions import (
+    PERMISSION_OPTIONS,
+    needs_permission,
+    outcome_allows,
+    permission_tool_call,
+)
+from pi_agent_core.coding_tools.path_utils import normalize_host_path
+from pi_agent_core.messages import ImageContent
+from pi_agent_core.types import StreamFn
+from pi_agent_harness import AgentHarness, JsonlSessionRepo, Session
+
+_AGENT_INFO = Implementation(name="pi-agent-cli", title="pi-python ACP agent", version="0.1.0")
+
+
+class PiAcpAgent(Agent):
+    """Standard-ACP-only agent. Does not register any vendor extension methods."""
+
+    _conn: Client | None
+
+    def __init__(
+        self,
+        *,
+        stream_fn: StreamFn | None = None,
+        home: Path | str | None = None,
+        config: CliConfig | None = None,
+        repo: JsonlSessionRepo | None = None,
+    ) -> None:
+        self._conn = None
+        self._home = pi_home(home)
+        self._config = config if config is not None else load_config(self._home)
+        self._stream_fn = stream_fn if stream_fn is not None else default_stream_fn()
+        sessions_dir = self._home / "sessions"
+        sessions_dir.mkdir(parents=True, exist_ok=True)
+        self._repo = repo if repo is not None else JsonlSessionRepo(sessions_dir)
+        self._harnesses: dict[str, AgentHarness] = {}
+        self._abort_tasks: set[asyncio.Task[Any]] = set()
+
+    def on_connect(self, conn: Client) -> None:
+        self._conn = conn
+
+    async def initialize(
+        self,
+        protocol_version: int,
+        client_capabilities: ClientCapabilities | None = None,
+        client_info: Implementation | None = None,
+        **kwargs: Any,
+    ) -> InitializeResponse:
+        return InitializeResponse(
+            protocol_version=min(protocol_version, PROTOCOL_VERSION),
+            agent_capabilities=AgentCapabilities(
+                load_session=True,
+                prompt_capabilities=PromptCapabilities(
+                    image=True, audio=False, embedded_context=False
+                ),
+                session_capabilities=SessionCapabilities(
+                    list=SessionListCapabilities(),
+                    resume=SessionResumeCapabilities(),
+                    close=SessionCloseCapabilities(),
+                ),
+            ),
+            auth_methods=[],
+            agent_info=_AGENT_INFO,
+        )
+
+    async def new_session(
+        self,
+        cwd: str,
+        additional_directories: list[str] | None = None,
+        mcp_servers: list[HttpMcpServer | SseMcpServer | McpServerStdio] | None = None,
+        **kwargs: Any,
+    ) -> NewSessionResponse:
+        session = await self._repo.create({"cwd": cwd})
+        session_id = (await session.get_metadata()).id
+        await self._bind_session(session_id, session, cwd)
+        return NewSessionResponse(session_id=session_id)
+
+    async def load_session(
+        self,
+        cwd: str,
+        session_id: str,
+        mcp_servers: list[HttpMcpServer | SseMcpServer | McpServerStdio] | None = None,
+        additional_directories: list[str] | None = None,
+        **kwargs: Any,
+    ) -> LoadSessionResponse | None:
+        metadata = await self._find_metadata(session_id)
+        if metadata is None:
+            raise RequestError.resource_not_found(session_id)
+        session = await self._repo.open(metadata)
+        await self._bind_session(session_id, session, metadata.cwd or cwd)
+        return LoadSessionResponse()
+
+    async def list_sessions(
+        self, cwd: str | None = None, cursor: str | None = None, **kwargs: Any
+    ) -> ListSessionsResponse:
+        listed = await self._repo.list({"cwd": cwd} if cwd is not None else None)
+        sessions = [
+            SessionInfo(
+                session_id=item.id,
+                cwd=item.cwd,
+                title=_session_title(item.id, item.createdAt),
+                updated_at=item.createdAt,
+            )
+            for item in listed
+        ]
+        return ListSessionsResponse(sessions=sessions)
+
+    async def close_session(self, session_id: str, **kwargs: Any) -> CloseSessionResponse | None:
+        self._harnesses.pop(session_id, None)
+        return CloseSessionResponse()
+
+    async def prompt(
+        self,
+        session_id: str,
+        prompt: list[
+            TextContentBlock
+            | ImageContentBlock
+            | AudioContentBlock
+            | ResourceContentBlock
+            | EmbeddedResourceContentBlock
+        ],
+        **kwargs: Any,
+    ) -> PromptResponse:
+        harness = self._require_harness(session_id)
+        text, images = _prompt_to_text_images(prompt)
+        try:
+            message = await harness.prompt(text, images or None)
+        except Exception as exc:
+            if type(exc).__name__ == "AgentHarnessError" and getattr(exc, "code", None) == "busy":
+                raise RequestError.invalid_params({"reason": "busy"}) from exc
+            raise
+        return PromptResponse(stop_reason=_stop_reason(message))
+
+    async def cancel(self, session_id: str, **kwargs: Any) -> None:
+        harness = self._harnesses.get(session_id)
+        if harness is None:
+            return
+        task = asyncio.create_task(harness.abort())
+        self._abort_tasks.add(task)
+        task.add_done_callback(self._abort_tasks.discard)
+
+    async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        raise RequestError.method_not_found(method)
+
+    async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
+        return None
+
+    def _require_harness(self, session_id: str) -> AgentHarness:
+        harness = self._harnesses.get(session_id)
+        if harness is None:
+            raise RequestError.invalid_params(
+                {"sessionId": session_id, "reason": "unknown session"}
+            )
+        return harness
+
+    async def _find_metadata(self, session_id: str) -> Any:
+        for item in await self._repo.list():
+            if item.id == session_id:
+                return item
+        return None
+
+    async def _bind_session(self, session_id: str, session: Session, cwd: str) -> None:
+        cwd = normalize_host_path(cwd)
+
+        async def on_tool_call(event: Any) -> dict[str, Any] | None:
+            return await self._handle_tool_call(session_id, event)
+
+        resources = await load_session_resources(cwd=cwd, config=self._config)
+        harness = create_session_harness(
+            session=session,
+            cwd=cwd,
+            config=self._config,
+            stream_fn=self._stream_fn,
+            resources=resources,
+            on_tool_call=on_tool_call,
+        )
+
+        async def on_event(event: Any, signal: Any | None = None) -> None:
+            await self._emit_updates(session_id, event)
+
+        harness.subscribe(on_event)
+        self._harnesses[session_id] = harness
+
+    async def _emit_updates(self, session_id: str, event: Any) -> None:
+        if self._conn is None:
+            return
+        for update in project_event(event):
+            await self._conn.session_update(session_id=session_id, update=update)
+
+    async def _handle_tool_call(self, session_id: str, event: Any) -> dict[str, Any] | None:
+        name = event.toolName
+        if not needs_permission(name, self._config.permission):
+            return None
+        if self._conn is None:
+            return {"block": True, "reason": "No ACP client connected"}
+        raw_input = dict(event.input or {})
+        response = await self._conn.request_permission(
+            session_id=session_id,
+            tool_call=permission_tool_call(event.toolCallId, name, raw_input),
+            options=list(PERMISSION_OPTIONS),
+        )
+        if outcome_allows(response.outcome):
+            return None
+        return {"block": True, "reason": "User denied permission"}
+
+
+def _session_title(session_id: str, created_at: str) -> str:
+    short = session_id[:8] if len(session_id) > 8 else session_id
+    return f"{created_at} ({short})"
+
+
+def _prompt_to_text_images(
+    prompt: list[Any],
+) -> tuple[str, list[ImageContent]]:
+    texts: list[str] = []
+    images: list[ImageContent] = []
+    for block in prompt:
+        if isinstance(block, dict):
+            btype = block.get("type")
+            if btype == "text":
+                texts.append(str(block.get("text") or ""))
+            elif btype == "image":
+                images.append(
+                    {
+                        "type": "image",
+                        "data": str(block.get("data") or ""),
+                        "mimeType": str(
+                            block.get("mimeType") or block.get("mime_type") or "image/png"
+                        ),
+                    }
+                )
+            continue
+        btype = getattr(block, "type", None)
+        if btype == "text":
+            texts.append(str(getattr(block, "text", "") or ""))
+        elif btype == "image":
+            images.append(
+                {
+                    "type": "image",
+                    "data": str(getattr(block, "data", "") or ""),
+                    "mimeType": str(
+                        getattr(block, "mime_type", None)
+                        or getattr(block, "mimeType", None)
+                        or "image/png"
+                    ),
+                }
+            )
+    return "".join(texts), images
+
+
+def _stop_reason(message: Any) -> str:
+    reason = getattr(message, "stopReason", None) or "stop"
+    if reason == "aborted":
+        return "cancelled"
+    if reason == "length":
+        return "max_tokens"
+    if reason == "error":
+        return "refusal"
+    return "end_turn"

pi_agent_cli/benchmarks/__init__.py

@@ -0,0 +1,15 @@
+"""Product-level smoke benchmarks for pi-agent-cli / pi TUI."""
+
+from pi_agent_cli.benchmarks.pelican import (
+    PELICAN_PROMPT,
+    PelicanSvgReport,
+    extract_svg,
+    validate_pelican_svg,
+)
+
+__all__ = [
+    "PELICAN_PROMPT",
+    "PelicanSvgReport",
+    "extract_svg",
+    "validate_pelican_svg",
+]

pi_agent_cli/benchmarks/pelican.py

@@ -0,0 +1,90 @@
+"""Pelican-on-a-bicycle benchmark (Simon Willison / Karpathy-style SVG smoke test).
+
+See docs/benchmarks/PELCAN-BICYCLE.md.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+
+PELICAN_PROMPT = (
+    "Generate an SVG of a pelican riding a bicycle. "
+    "Output only valid SVG markup with xmlns and a viewBox, no markdown fences or explanation."
+)
+
+_FENCE_RE = re.compile(r"```(?:svg|xml)?\s*\n?(.*?)```", re.DOTALL | re.IGNORECASE)
+_SVG_RE = re.compile(r"(<svg[\s\S]*?</svg>)", re.IGNORECASE)
+
+
+@dataclass(frozen=True)
+class PelicanSvgReport:
+    ok: bool
+    checks: dict[str, bool]
+    svg: str | None
+    notes: tuple[str, ...] = ()
+
+
+def extract_svg(text: str) -> str | None:
+    """Pull the first SVG document from model text (raw or fenced)."""
+    raw = text.strip()
+    if not raw:
+        return None
+    for match in _FENCE_RE.finditer(raw):
+        inner = match.group(1).strip()
+        svg = _SVG_RE.search(inner)
+        if svg:
+            return svg.group(1).strip()
+        if inner.lower().startswith("<svg"):
+            return inner
+    svg = _SVG_RE.search(raw)
+    if svg:
+        return svg.group(1).strip()
+    if raw.lower().startswith("<svg"):
+        return raw
+    return None
+
+
+def validate_pelican_svg(svg: str | None) -> PelicanSvgReport:
+    """Heuristic pass/fail for the pelican bicycle benchmark (not artistic scoring)."""
+    notes: list[str] = []
+    if svg is None:
+        return PelicanSvgReport(
+            ok=False,
+            checks={"extracted": False},
+            svg=None,
+            notes=("no SVG found in model output",),
+        )
+    lower = svg.lower()
+    checks = {
+        "extracted": True,
+        "svg_root": "<svg" in lower and "</svg>" in lower,
+        "xmlns": "xmlns" in lower,
+        "viewbox": "viewbox" in lower,
+        "geometry": any(
+            tag in lower for tag in ("<path", "<circle", "<rect", "<ellipse", "<polygon")
+        ),
+        "min_size": len(svg.strip()) >= 200,
+    }
+    if not checks["geometry"]:
+        notes.append("no path/circle/rect/ellipse/polygon elements")
+    if not checks["min_size"]:
+        notes.append("SVG shorter than 200 characters")
+    return PelicanSvgReport(ok=all(checks.values()), checks=checks, svg=svg, notes=tuple(notes))
+
+
+def default_artifact_dir(home: Path | str | None = None) -> Path:
+    from pi_agent_cli.config import pi_home
+
+    return pi_home(home) / "benchmarks" / "pelican"
+
+
+def save_pelican_artifact(svg: str, *, home: Path | str | None = None) -> Path:
+    out_dir = default_artifact_dir(home)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+    path = out_dir / f"pelican-{stamp}.svg"
+    path.write_text(svg, encoding="utf-8")
+    return path

pi_agent_cli/config.py

@@ -0,0 +1,146 @@
+"""`~/.pi-python/agent.toml` (Python ACP agent). Override with PI_HOME.
+
+Do not put Python agent settings in ``config.toml`` — the Rust TUI parses that
+file as grok-shell config and will fail on keys like ``permission = \"ask\"``.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal
+
+from pi_agent_core.types import ThinkingLevel
+
+PermissionMode = Literal["ask", "auto", "always-approve"]
+
+_VALID_PERMISSION: set[str] = {"ask", "auto", "always-approve"}
+_VALID_THINKING: set[str] = {"off", "minimal", "low", "medium", "high", "xhigh"}
+
+
+def pi_home(override: Path | str | None = None) -> Path:
+    if override is not None:
+        return Path(override).expanduser()
+    raw = os.environ.get("PI_HOME")
+    if raw:
+        return Path(raw).expanduser()
+    return Path.home() / ".pi-python"
+
+
+def load_local_env(home: Path | str | None = None) -> None:
+    """Load ``~/.pi-python/local.env`` (KEY=value) without overwriting existing env."""
+    path = pi_home(home) / "local.env"
+    if not path.is_file():
+        return
+    for raw_line in path.read_text(encoding="utf-8").splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.startswith("export "):
+            line = line[7:].strip()
+        key, sep, value = line.partition("=")
+        if not sep:
+            continue
+        key = key.strip()
+        value = value.strip()
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in "\"'":
+            value = value[1:-1]
+        if key and key not in os.environ:
+            os.environ[key] = value
+
+
+def agent_config_path(home: Path | str | None = None) -> Path:
+    return pi_home(home) / "agent.toml"
+
+
+def legacy_config_path(home: Path | str | None = None) -> Path:
+    """Legacy path; breaks the Rust TUI if it contains Python-only keys."""
+    return pi_home(home) / "config.toml"
+
+
+def expand_config_path(raw: str, *, cwd: str | Path) -> str:
+    """Expand ~ and resolve relative skill/config paths against cwd."""
+    expanded = os.path.expanduser(raw)
+    path = Path(expanded)
+    if not path.is_absolute():
+        path = Path(cwd) / path
+    return str(path.resolve())
+
+
+@dataclass(frozen=True)
+class CliConfig:
+    permission: PermissionMode = "ask"
+    provider: str = "mock"
+    model_id: str = "mock"
+    base_url: str | None = None
+    thinking_level: ThinkingLevel = "off"
+    max_turns: int | None = None
+    api_key_env: str | None = None
+    skills_dirs: tuple[str, ...] = ()
+    agent_command: str | None = None
+
+
+def load_config(home: Path | str | None = None) -> CliConfig:
+    import tomllib
+
+    agent_path = agent_config_path(home)
+    if agent_path.is_file():
+        data = tomllib.loads(agent_path.read_text(encoding="utf-8"))
+        return _from_toml(data)
+    legacy = legacy_config_path(home)
+    if legacy.is_file():
+        data = tomllib.loads(legacy.read_text(encoding="utf-8"))
+        return _from_toml(data)
+    return CliConfig()
+
+
+def make_get_api_key(
+    config: CliConfig,
+) -> Callable[[str], str | None] | None:
+    env_name = config.api_key_env
+    if not env_name:
+        return None
+
+    def get_api_key(_provider: str) -> str | None:
+        return os.environ.get(env_name) or None
+
+    return get_api_key
+
+
+def _from_toml(data: dict[str, Any]) -> CliConfig:
+    model = data.get("model") if isinstance(data.get("model"), dict) else {}
+    skills = data.get("skills") if isinstance(data.get("skills"), dict) else {}
+    agent = data.get("agent") if isinstance(data.get("agent"), dict) else {}
+
+    permission = data.get("permission", "ask")
+    if permission not in _VALID_PERMISSION:
+        permission = "ask"
+    thinking = data.get("thinking_level", "off")
+    if thinking not in _VALID_THINKING:
+        thinking = "off"
+    max_turns = data.get("max_turns")
+    if max_turns is not None:
+        max_turns = int(max_turns)
+
+    raw_paths = skills.get("paths") or skills.get("dirs") or []
+    skills_dirs: tuple[str, ...] = ()
+    if isinstance(raw_paths, list):
+        skills_dirs = tuple(str(item) for item in raw_paths if str(item).strip())
+
+    agent_command = agent.get("command")
+    if agent_command is not None:
+        agent_command = str(agent_command).strip() or None
+
+    return CliConfig(
+        permission=permission,  # type: ignore[arg-type]
+        provider=str(model.get("provider") or data.get("provider") or "mock"),
+        model_id=str(model.get("id") or model.get("model_id") or data.get("model_id") or "mock"),
+        base_url=model.get("base_url") or data.get("base_url"),
+        thinking_level=thinking,  # type: ignore[arg-type]
+        max_turns=max_turns,
+        api_key_env=model.get("api_key_env") or data.get("api_key_env"),
+        skills_dirs=skills_dirs,
+        agent_command=agent_command,
+    )

pi_agent_cli/events.py

@@ -0,0 +1,141 @@
+"""Project AgentEvent onto standard ACP session/update payloads."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any
+
+from acp.helpers import (
+    start_tool_call,
+    text_block,
+    tool_content,
+    tool_diff_content,
+    update_agent_message_text,
+    update_agent_thought_text,
+    update_tool_call,
+)
+from acp.schema import AgentMessageChunk, AgentThoughtChunk, ToolCallProgress, ToolCallStart
+
+from pi_agent_core.types import AgentEvent
+
+_KIND: dict[str, str] = {
+    "read": "read",
+    "edit": "edit",
+    "write": "edit",
+    "bash": "execute",
+    "grep": "search",
+    "find": "search",
+    "ls": "search",
+}
+
+SessionUpdate = AgentMessageChunk | AgentThoughtChunk | ToolCallStart | ToolCallProgress
+
+
+def tool_kind(name: str) -> str:
+    return _KIND.get(name, "other")
+
+
+def project_event(event: AgentEvent) -> Iterator[SessionUpdate]:
+    etype = getattr(event, "type", None)
+    if etype == "message_end":
+        message = getattr(event, "message", None)
+        stop = getattr(message, "stopReason", None)
+        err = getattr(message, "errorMessage", None)
+        if stop in ("error", "aborted") and err:
+            yield update_agent_message_text(f"Error: {err}")
+        return
+
+    if etype == "message_update":
+        ame = getattr(event, "assistant_message_event", None)
+        ame_type = getattr(ame, "type", None)
+        if ame_type == "text_delta":
+            delta = getattr(ame, "delta", "") or ""
+            if delta:
+                yield update_agent_message_text(delta)
+        elif ame_type == "thinking_delta":
+            delta = getattr(ame, "delta", "") or ""
+            if delta:
+                yield update_agent_thought_text(delta)
+        return
+
+    if etype == "tool_execution_start":
+        name = event.tool_name
+        yield start_tool_call(
+            event.tool_call_id,
+            name,
+            kind=tool_kind(name),  # type: ignore[arg-type]
+            status="pending",
+            raw_input=event.args,
+        )
+        return
+
+    if etype == "tool_execution_update":
+        content = _partial_content(event.partial_result)
+        yield update_tool_call(
+            event.tool_call_id,
+            status="in_progress",
+            content=content,
+        )
+        return
+
+    if etype == "tool_execution_end":
+        status = "failed" if event.is_error else "completed"
+        args = getattr(event, "args", None)
+        yield update_tool_call(
+            event.tool_call_id,
+            status=status,
+            content=_result_content(event.tool_name, args, event.result),
+            raw_output=_raw_output(event.result),
+        )
+
+
+def _text_from_result(result: Any) -> str:
+    if result is None:
+        return ""
+    content = getattr(result, "content", None)
+    if isinstance(content, list):
+        parts: list[str] = []
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                parts.append(str(block.get("text") or ""))
+            elif getattr(block, "type", None) == "text":
+                parts.append(str(getattr(block, "text", "") or ""))
+        return "".join(parts)
+    return str(result)
+
+
+def _partial_content(partial: Any) -> list[Any] | None:
+    text = _text_from_result(partial)
+    if not text:
+        return None
+    return [tool_content(text_block(text))]
+
+
+def _result_content(tool_name: str, args: Any, result: Any) -> list[Any] | None:
+    details = getattr(result, "details", None) if result is not None else None
+    path = None
+    if isinstance(args, dict):
+        path = args.get("path")
+    if path is None and isinstance(details, dict):
+        path = details.get("path")
+    if tool_name in {"edit", "write"} and path:
+        patch = None
+        if isinstance(details, dict):
+            patch = details.get("diff") or details.get("patch")
+        if patch:
+            return [tool_diff_content(str(path), str(patch))]
+        text = _text_from_result(result)
+        if text:
+            return [tool_diff_content(str(path), text)]
+    text = _text_from_result(result)
+    if not text:
+        return None
+    return [tool_content(text_block(text))]
+
+
+def _raw_output(result: Any) -> Any:
+    if result is None:
+        return None
+    if hasattr(result, "model_dump"):
+        return result.model_dump(exclude_none=True)
+    return result

pi_agent_cli/factory.py

@@ -0,0 +1,70 @@
+"""Build an AgentHarness bound to coding tools and a JSONL session."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Any
+
+from pi_agent_cli.config import CliConfig, expand_config_path, make_get_api_key
+from pi_agent_cli.prompt import CODING_SYSTEM_PROMPT
+from pi_agent_core.coding_tools import create_all_tools
+from pi_agent_core.coding_tools.path_utils import normalize_host_path
+from pi_agent_core.types import Model, StreamFn
+from pi_agent_harness import AgentHarness, AgentHarnessResources, LocalExecutionEnv, Session
+from pi_agent_harness.skills import load_skills
+
+
+def default_stream_fn() -> StreamFn:
+    import os
+
+    if os.environ.get("PI_USE_MOCK") == "1":
+        from pi_agent_core.tests.mock_stream import mock_text_stream
+
+        return mock_text_stream
+    from pi_agent_core.adapters.langchain_stream import langchain_stream
+
+    return langchain_stream
+
+
+async def load_session_resources(*, cwd: str | Path, config: CliConfig) -> AgentHarnessResources:
+    if not config.skills_dirs:
+        return AgentHarnessResources()
+    cwd_s = str(Path(normalize_host_path(str(cwd))).resolve())
+    env = LocalExecutionEnv(cwd_s)
+    paths = [expand_config_path(item, cwd=cwd_s) for item in config.skills_dirs]
+    result = await load_skills(env, paths)
+    return AgentHarnessResources(skills=result.skills)
+
+
+def create_session_harness(
+    *,
+    session: Session,
+    cwd: str | Path,
+    config: CliConfig,
+    stream_fn: StreamFn,
+    resources: AgentHarnessResources | None = None,
+    on_tool_call: Callable[[Any], Any | Awaitable[Any]] | None = None,
+) -> AgentHarness:
+    cwd_s = str(Path(normalize_host_path(str(cwd))).resolve())
+    tools = list(create_all_tools(cwd_s).values())
+    model = Model(
+        provider=config.provider,
+        model_id=config.model_id,
+        base_url=config.base_url,
+    )
+    harness = AgentHarness(
+        session=session,
+        model=model,
+        stream_fn=stream_fn,
+        env=LocalExecutionEnv(cwd_s),
+        tools=tools,
+        resources=resources or AgentHarnessResources(),
+        get_api_key=make_get_api_key(config),
+        system_prompt=CODING_SYSTEM_PROMPT,
+        thinking_level=config.thinking_level,
+        max_turns=config.max_turns,
+    )
+    if on_tool_call is not None:
+        harness.on("tool_call", on_tool_call)
+    return harness

pi_agent_cli/headless.py

@@ -0,0 +1,79 @@
+"""Single-turn headless prompt (`python -m pi_agent_cli -p`). No TUI, no ACP stdio."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import replace
+from pathlib import Path
+
+from pi_agent_cli.config import load_config, pi_home
+from pi_agent_cli.factory import create_session_harness, default_stream_fn, load_session_resources
+from pi_agent_harness import JsonlSessionRepo
+
+
+def assistant_text(message: object) -> str:
+    parts: list[str] = []
+    for block in getattr(message, "content", None) or []:
+        if isinstance(block, dict) and block.get("type") == "text":
+            parts.append(str(block.get("text") or ""))
+    return "".join(parts)
+
+
+def prompt_from_json(raw: str) -> str:
+    data = json.loads(raw)
+    if isinstance(data, str):
+        return data
+    if isinstance(data, list):
+        return "".join(
+            str(block.get("text") or "")
+            for block in data
+            if isinstance(block, dict) and block.get("type") == "text"
+        )
+    raise ValueError("prompt JSON must be a string or a list of content blocks")
+
+
+def resolve_print_prompt(
+    *,
+    print_prompt: str | None,
+    prompt_json: str | None,
+    prompt_file: str | Path | None,
+) -> str:
+    if print_prompt is not None:
+        return print_prompt
+    if prompt_json is not None:
+        return prompt_from_json(prompt_json)
+    if prompt_file is not None:
+        return Path(prompt_file).read_text(encoding="utf-8")
+    raise ValueError("one of -p/--print, --prompt-json, or --prompt-file is required")
+
+
+async def run_print(
+    prompt: str,
+    *,
+    cwd: str | Path | None = None,
+    home: str | Path | None = None,
+) -> int:
+    """Create a JSONL session, run one harness turn, print assistant text."""
+    text = prompt.strip()
+    if not text:
+        print("error: empty prompt", flush=True)
+        return 2
+    home_path = pi_home(home)
+    sessions_dir = home_path / "sessions"
+    sessions_dir.mkdir(parents=True, exist_ok=True)
+    cwd_s = str(Path(cwd).resolve() if cwd is not None else Path.cwd())
+    config = replace(load_config(home_path), permission="auto")
+    repo = JsonlSessionRepo(sessions_dir)
+    session = await repo.create({"cwd": cwd_s})
+    resources = await load_session_resources(cwd=cwd_s, config=config)
+    harness = create_session_harness(
+        session=session,
+        cwd=cwd_s,
+        config=config,
+        stream_fn=default_stream_fn(),
+        resources=resources,
+    )
+    message = await harness.prompt(text)
+    out = assistant_text(message)
+    print(out, end="" if out.endswith("\n") else "\n")
+    return 0

pi_agent_cli/permissions.py

@@ -0,0 +1,52 @@
+"""Map bash/edit/write tool_call hooks to ACP session/request_permission."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from acp.schema import AllowedOutcome, DeniedOutcome, PermissionOption, ToolCallUpdate
+
+from pi_agent_cli.config import PermissionMode
+from pi_agent_cli.events import tool_kind
+
+PERMISSION_TOOLS = frozenset({"bash", "edit", "write"})
+
+PERMISSION_OPTIONS = [
+    PermissionOption(option_id="allow-once", name="Allow once", kind="allow_once"),
+    PermissionOption(option_id="reject-once", name="Reject", kind="reject_once"),
+]
+
+
+def needs_permission(tool_name: str, mode: PermissionMode) -> bool:
+    if mode in {"auto", "always-approve"}:
+        return False
+    return tool_name in PERMISSION_TOOLS
+
+
+def permission_tool_call(
+    tool_call_id: str, tool_name: str, raw_input: dict[str, Any]
+) -> ToolCallUpdate:
+    return ToolCallUpdate(
+        tool_call_id=tool_call_id,
+        title=tool_name,
+        kind=tool_kind(tool_name),  # type: ignore[arg-type]
+        status="pending",
+        raw_input=raw_input,
+    )
+
+
+def outcome_allows(outcome: AllowedOutcome | DeniedOutcome | Any) -> bool:
+    if isinstance(outcome, DeniedOutcome):
+        return False
+    if isinstance(outcome, AllowedOutcome):
+        return not str(outcome.option_id).startswith("reject")
+    if isinstance(outcome, dict):
+        if outcome.get("outcome") == "cancelled":
+            return False
+        option_id = str(outcome.get("optionId") or outcome.get("option_id") or "")
+        return not option_id.startswith("reject")
+    option_id = str(getattr(outcome, "option_id", "") or "")
+    kind = str(getattr(outcome, "outcome", "") or "")
+    if kind == "cancelled":
+        return False
+    return not option_id.startswith("reject")

pi_agent_cli/prompt.py

@@ -0,0 +1,24 @@
+"""Coding-agent system prompt for Phase 4 (deeper prompt work is Phase 5)."""
+
+CODING_SYSTEM_PROMPT = """You are pi, a coding agent working in the user's local workspace.
+
+## Tools
+- Use read, grep, find, and ls to explore before changing code.
+- Prefer the smallest change that solves the request; re-read or run checks to verify.
+- Use bash for builds, tests, and one-off commands — not for bulk file edits.
+
+## Self-correction
+- If a tool fails, read the error, adjust arguments or approach, and retry once with a fix.
+- Do not repeat the same failing call without a concrete change.
+
+## Safety
+- Stay inside the workspace unless the user explicitly asks otherwise.
+- Do not exfiltrate secrets (.env, keys, tokens, credentials).
+- Destructive or irreversible shell commands require clear user intent.
+
+## Skills
+When skill metadata appears below in <skills>...</skills>, follow the matching skill file
+when the task fits.
+
+When finished, answer the user directly without calling more tools.
+"""

pi_agent_cli_lc-0.2.0.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.5
+Name: pi-agent-cli-lc
+Version: 0.2.0
+Summary: Standard ACP agent over AgentHarness (no x.ai extensions)
+Project-URL: Homepage, https://github.com/zy1233/pi-python
+Project-URL: Repository, https://github.com/zy1233/pi-python
+Project-URL: Issues, https://github.com/zy1233/pi-python/issues
+Project-URL: Changelog, https://github.com/zy1233/pi-python/blob/main/CHANGELOG.md
+Author-email: zy1233 <zy1233@users.noreply.github.com>
+License-Expression: MIT
+Keywords: acp,agent,ai,cli,coding-agent,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: agent-client-protocol>=0.12.0
+Requires-Dist: pi-agent-core-lc==0.2.0
+Requires-Dist: pi-agent-harness-lc==0.2.0
+Requires-Dist: pydantic>=2.0
+Description-Content-Type: text/markdown
+
+# pi-agent-cli-lc
+
+Standard [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) agent over `pi-agent-harness`.
+
+- stdio entry: `python -m pi_agent_cli` (or console script `pi-agent-cli`)
+- headless one-shot: `python -m pi_agent_cli -p "..."` 
+- Config: `~/.pi-python/agent.toml` (see `agent.example.toml` in this directory)
+- No `x.ai/*` vendor RPCs — core + harness + ACP only
+
+Install:
+
+```bash
+pip install pi-agent-cli-lc
+# needs a LangChain provider, e.g.:
+pip install pi-agent-core-lc[deepseek]
+```
+
+See the [repository README](https://github.com/zy1233/pi-python#install) for development setup and Windows/WSL notes.

pi_agent_cli_lc-0.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pi_agent_cli/__init__.py,sha256=4i3ERBRV_TfY_2e6hbw5FsYiwgPVg59Bi2kngFLWlWE,391
+pi_agent_cli/__main__.py,sha256=_fElQvUrxctX50eQ_agP8853K7jN9zglzLtnIfDTNN0,2222
+pi_agent_cli/agent.py,sha256=dna2zRao57gd3u5JE_MIHCY9CtUMyNnBw1a4Gq2xaWs,10606
+pi_agent_cli/config.py,sha256=sxYc3zNNWsqmhiQIeeT8adsi9cJE67f7VjwCpIKj3WE,4916
+pi_agent_cli/events.py,sha256=-guskf4IVudKQcMKZgoxAFpR4Xv9y-FF7QlmdxXLmus,4381
+pi_agent_cli/factory.py,sha256=oRdlaCVE4LZVlzCcqOEMSDe7gKpBdHOgOXI4SQO3YF4,2408
+pi_agent_cli/headless.py,sha256=7z8BcBVDOom5nLKpXT_DqiechXEgs9tT5t41Kskx2iQ,2593
+pi_agent_cli/permissions.py,sha256=NfsjkFxCUbX24UmKuvsZCgdAH2kbuJyHjAEhZwIZBXk,1762
+pi_agent_cli/prompt.py,sha256=dhUdWkmMx2sx70Z6EB1G7sU-w9d1TLSPnvZNKhobuOo,1000
+pi_agent_cli/benchmarks/__init__.py,sha256=9cufUT_W5UB88Ho18zDL2kvp2pX2f7V76B5Kh200xEE,306
+pi_agent_cli/benchmarks/pelican.py,sha256=KfGbPpVi9pbMFsl7ZUtMkeSaZV2u76MYJjZFjEtyKz4,2834
+pi_agent_cli_lc-0.2.0.dist-info/METADATA,sha256=MCSc4VnP5py0mf2IBCal5e-uKdVoN5ScjBfZOpxxMGQ,1811
+pi_agent_cli_lc-0.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+pi_agent_cli_lc-0.2.0.dist-info/entry_points.txt,sha256=skflnGQl1PatvwuariTijSYd6xi8PId512LvMT8idp8,60
+pi_agent_cli_lc-0.2.0.dist-info/RECORD,,

pi_agent_cli_lc-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pi_agent_cli_lc-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pi-agent-cli = pi_agent_cli.__main__:main