pi-agent-cli-lc 0.2.0__tar.gz

pi_agent_cli_lc-0.2.0/.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.venv/
+.venv-*/
+venv/
+.env
+# Rust TUI workspace (Apache-2.0 fork under tui/)
+tui/target/
+**/*.rs.bk

pi_agent_cli_lc-0.2.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,18 @@
+# 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/agent.example.toml

@@ -0,0 +1,22 @@
+# Copy to ~/.pi-python/agent.toml (or set PI_HOME).
+# Python ACP agent settings ONLY — do not duplicate these keys in config.toml
+# (the Rust TUI parses config.toml as grok-shell config).
+# LLM keys are read from environment variables — never put secrets in this file.
+
+permission = "ask" # ask | auto | always-approve
+
+thinking_level = "off" # off | minimal | low | medium | high | xhigh
+max_turns = 50
+
+[model]
+provider = "deepseek"
+id = "deepseek-ai/DeepSeek-V4-Flash"
+base_url = "https://api.siliconflow.cn/v1"
+api_key_env = "REAL_LLM_API_KEY"
+
+[skills]
+paths = ["~/.pi-python/skills", ".pi/skills"]
+
+[agent]
+# Used by the Rust TUI when PI_AGENT_COMMAND is unset (Windows: prefer a venv python.exe).
+command = "python -m pi_agent_cli"

pi_agent_cli_lc-0.2.0/config.toml.example

@@ -0,0 +1,7 @@
+# Rust TUI (grok-shell) config for ~/.pi-python/config.toml
+#
+# Leave this file empty or use grok-compatible keys only.
+# Python agent settings belong in agent.toml — NOT here.
+#
+# Top-level ``permission = "ask"`` will break TUI startup (grok expects a
+# ``[permission]`` table, not a string).

pi_agent_cli_lc-0.2.0/local.env.example

@@ -0,0 +1,3 @@
+# Copy to ~/.pi-python/local.env (not in git). Loaded by pi_agent_cli on startup.
+# WSL: this file is read by the Windows Python child when pi spawns from Linux.
+REAL_LLM_API_KEY=sk-...

pi_agent_cli_lc-0.2.0/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_lc-0.2.0/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_lc-0.2.0/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_lc-0.2.0/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_lc-0.2.0/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