pidriver 0.4.2__tar.gz → 0.5.0__tar.gz

{pidriver-0.4.2 → pidriver-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pidriver
-Version: 0.4.2
+Version: 0.5.0
 Summary: Async Python driver for the pi coding agent (pi --mode rpc), built for isolated, headless project work.
 Project-URL: Homepage, https://github.com/bobuk/pidriver
 Project-URL: Repository, https://github.com/bobuk/pidriver
@@ -154,7 +154,7 @@ PiConfig(provider="anthropic", model="claude-sonnet-4-6",
 | `install_dir` | `None` | Where to `npm install`/look for a managed `pi` binary. |
 | `auto_install` | `True` | `npm install` `pi` into `install_dir` if the binary can't be resolved. |
 | `npm_package` | `"@earendil-works/pi-coding-agent"` | The npm package that provides `pi`. |
-| `pi_version` | `"0.87.1"` | Pinned pi version to install (overridable). |
+| `pi_version` | `"1.5.0"` | Pinned pi version to install (overridable). |
 | `extensions` | `()` | Add-on sources (`npm:…`, `git:…`, path) installed via `pi install` before start. |
 
 **Model / provider**
@@ -421,7 +421,7 @@ the driver. Every event carries `.type` (the raw tag) and `.raw` (the decoded di
 | `ToolUpdate` | `tool_call_id`, `name`, `output` | Partial output while a tool runs. |
 | `ToolEnd` | `tool_call_id`, `name`, `result`, `is_error` | A tool finished. |
 | `Usage` | `totals` (a `UsageTotals`) | Token/cost for a step; also folded into `session.usage`. |
-| `AgentEnd` | `reason`, `final_text` | The run finished (`completed` / `cancelled` / `error` / `limit`). |
+| `AgentEnd` | `reason`, `final_text` | The turn finished (`completed` / `cancelled` / `error` / `limit`): on upstream pi, at `agent_settled`, after any retries or compaction. |
 | `Error` | `message`, `code`, `fatal` | An error (or a failed command ack) surfaced by pi. |
 | `InteractionRequest` | `request_id`, `kind`, `prompt`, `options`, `tool_call_id`, `default` | The agent is blocked waiting for the host. |
 | `Event` | `type`, `raw` | Base / fallback for unrecognized records. |
@@ -604,7 +604,7 @@ for m in models:
 ## Provider OAuth login
 
 Some providers authenticate via OAuth (Claude Pro/Max, Codex, …) instead of an API key. `PiOAuthLogin`
-drives a bundled Node helper that reuses pi's own `AuthStorage` (no version skew), writing
+drives a bundled Node helper that reuses pi's own login code (no version skew), writing
 credentials into the isolated `<agent_dir>/auth.json`. Requires `node` on PATH and a resolvable pi
 install.
 

{pidriver-0.4.2 → pidriver-0.5.0}/README.md

@@ -128,7 +128,7 @@ PiConfig(provider="anthropic", model="claude-sonnet-4-6",
 | `install_dir` | `None` | Where to `npm install`/look for a managed `pi` binary. |
 | `auto_install` | `True` | `npm install` `pi` into `install_dir` if the binary can't be resolved. |
 | `npm_package` | `"@earendil-works/pi-coding-agent"` | The npm package that provides `pi`. |
-| `pi_version` | `"0.87.1"` | Pinned pi version to install (overridable). |
+| `pi_version` | `"1.5.0"` | Pinned pi version to install (overridable). |
 | `extensions` | `()` | Add-on sources (`npm:…`, `git:…`, path) installed via `pi install` before start. |
 
 **Model / provider**
@@ -395,7 +395,7 @@ the driver. Every event carries `.type` (the raw tag) and `.raw` (the decoded di
 | `ToolUpdate` | `tool_call_id`, `name`, `output` | Partial output while a tool runs. |
 | `ToolEnd` | `tool_call_id`, `name`, `result`, `is_error` | A tool finished. |
 | `Usage` | `totals` (a `UsageTotals`) | Token/cost for a step; also folded into `session.usage`. |
-| `AgentEnd` | `reason`, `final_text` | The run finished (`completed` / `cancelled` / `error` / `limit`). |
+| `AgentEnd` | `reason`, `final_text` | The turn finished (`completed` / `cancelled` / `error` / `limit`): on upstream pi, at `agent_settled`, after any retries or compaction. |
 | `Error` | `message`, `code`, `fatal` | An error (or a failed command ack) surfaced by pi. |
 | `InteractionRequest` | `request_id`, `kind`, `prompt`, `options`, `tool_call_id`, `default` | The agent is blocked waiting for the host. |
 | `Event` | `type`, `raw` | Base / fallback for unrecognized records. |
@@ -578,7 +578,7 @@ for m in models:
 ## Provider OAuth login
 
 Some providers authenticate via OAuth (Claude Pro/Max, Codex, …) instead of an API key. `PiOAuthLogin`
-drives a bundled Node helper that reuses pi's own `AuthStorage` (no version skew), writing
+drives a bundled Node helper that reuses pi's own login code (no version skew), writing
 credentials into the isolated `<agent_dir>/auth.json`. Requires `node` on PATH and a resolvable pi
 install.
 

{pidriver-0.4.2 → pidriver-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pidriver"
-version = "0.4.2"
+version = "0.5.0"
 description = "Async Python driver for the pi coding agent (pi --mode rpc), built for isolated, headless project work."
 readme = "README.md"
 license = { text = "MIT" }

{pidriver-0.4.2 → pidriver-0.5.0}/src/pidriver/__init__.py

@@ -123,7 +123,7 @@ from .supervisor import PiInstanceSupervisor
 from .usage import UsageTotals
 from .workspace import ProjectDir, list_candidate_projects, list_projects, resolve_project
 
-__version__ = "0.4.2"
+__version__ = "0.5.0"
 
 __all__ = [
     "__version__",

{pidriver-0.4.2 → pidriver-0.5.0}/src/pidriver/_install.py

@@ -286,7 +286,7 @@ def resolve_node_modules(config: PiConfig, *, runner: Runner = subprocess.run) -
     bin to its node_modules). Package identity comes from ``config.npm_package`` so this
     works for the omp/oh-my-pi fork too. Returns ``None`` when no install is found.
 
-    Useful for tools that need pi's *bundled* Node libraries (e.g. its ``AuthStorage``
+    Useful for tools that need pi's *bundled* Node libraries (e.g. its login code
     for the OAuth flow — see :mod:`pidriver.auth`), not just the ``pi`` executable.
     """
     package = _package_components(config.npm_package)

pidriver-0.5.0/src/pidriver/assets/pi_login.mjs

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+// pi OAuth/login helper for pidriver (driven by pidriver.auth).
+//
+// Reuses pi's own login code (public exports of @earendil-works/pi-coding-agent, which bundles the
+// pi-ai OAuth providers — so there is no version skew and nothing extra to install): ModelRuntime
+// on pi 1.x, AuthStorage before it. The package is found at PI_NODE_MODULES
+// (<pi install_dir>/lib/node_modules). Credentials are read/written at PI_AUTH_PATH (the isolated
+// <agent_dir>/auth.json).
+//
+// Commands:
+//   node pi_login.mjs list                 -> {"providers":[{id,name}], "status":{provider:type}}
+//   node pi_login.mjs logout <provider>    -> {"ok":true}
+//   node pi_login.mjs login  <provider>    -> JSONL events on stdout; reads the auth code from stdin
+//
+// login protocol (one JSON object per line on stdout):
+//   {"event":"auth","url":"...","instructions":"..."}   # open this URL in a browser
+//   {"event":"need_code","message":"...","placeholder":"..."}  # then write the code as one stdin line
+//   {"event":"progress","message":"..."}
+//   {"event":"done"}                                     # credentials saved to PI_AUTH_PATH
+//   {"event":"error","message":"..."}
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import readline from "node:readline";
+import { pathToFileURL } from "node:url";
+
+function emit(o) {
+  process.stdout.write(JSON.stringify(o) + "\n");
+}
+
+// Import pi from the managed install (PI_NODE_MODULES = <install>/lib/node_modules). We import the
+// package's entry by absolute path: its `exports` map only declares the ESM `import` condition, so
+// require.resolve can't find it, but a direct file import resolves its nested pi-ai too.
+async function loadPi() {
+  const nm = process.env.PI_NODE_MODULES;
+  if (!nm) throw new Error("PI_NODE_MODULES is not set");
+  const pkgDir = join(nm, "@earendil-works", "pi-coding-agent");
+  const pkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"));
+  const rel = pkg?.exports?.["."]?.import || pkg.main || "./dist/index.js";
+  return await import(pathToFileURL(join(pkgDir, rel)).href);
+}
+
+async function readLine() {
+  return await new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin });
+    rl.once("line", (line) => {
+      rl.close();
+      resolve(String(line).trim());
+    });
+  });
+}
+
+function selectLoginOption(prompt) {
+  const options = Array.isArray(prompt?.options) ? prompt.options : [];
+  const selected = options.find((option) => {
+    const haystack = String(`${option?.id || ""} ${option?.label || ""}`).toLowerCase();
+    return haystack.includes("browser") || haystack.includes("default");
+  }) || options[0];
+  emit({
+    event: "select",
+    message: prompt?.message || "Select login method",
+    options: options.map((option) => ({ id: option.id, label: option.label })),
+    selected: selected?.id || "",
+  });
+  return selected?.id;
+}
+
+async function askCode(prompt) {
+  emit({ event: "need_code", message: (prompt && prompt.message) || "Paste the authorization code",
+         placeholder: (prompt && prompt.placeholder) || "" });
+  return await readLine();
+}
+
+// pi 1.x: provider auth belongs to ModelRuntime, AuthStorage only keeps the credentials.
+async function modelRuntimeAuth(pi) {
+  const runtime = await pi.ModelRuntime.create({
+    authPath: process.env.PI_AUTH_PATH,
+    allowModelNetwork: false,
+    refreshOnCreate: false,
+  });
+  return {
+    providers: () => runtime.getProviders()
+      .filter((p) => p.auth.oauth)
+      .map((p) => ({ id: p.id, name: p.auth.oauth.name || p.name })),
+    status: async () => Object.fromEntries(
+      (await runtime.listCredentials()).map((c) => [c.providerId, c.type])),
+    logout: (id) => runtime.logout(id),
+    login: (id) => runtime.login(id, "oauth", {
+      prompt: async (prompt) => (prompt.type === "select" ? selectLoginOption(prompt) : askCode(prompt)),
+      notify: (event) => {
+        if (event.type === "auth_url") emit({ event: "auth", url: event.url, instructions: event.instructions || "" });
+        else if (event.type === "device_code") emit({ event: "device_code", ...event, type: undefined });
+        else emit({ event: "progress", message: String(event.message) });
+      },
+    }, { getDeviceId: () => pi.SettingsManager.create(process.cwd(), pi.getAgentDir()).getOrCreateDeviceId() }),
+  };
+}
+
+// Before pi 1.x AuthStorage ran the logins itself.
+function authStorageAuth(pi) {
+  const storage = pi.AuthStorage.create(process.env.PI_AUTH_PATH);
+  return {
+    providers: () => storage.getOAuthProviders().map((p) => ({ id: p.id, name: p.name })),
+    status: () => Object.fromEntries(
+      Object.entries(storage.getAll() || {}).map(([k, v]) => [k, v && v.type ? v.type : "unknown"])),
+    logout: (id) => storage.logout(id),
+    login: (id) => storage.login(id, {
+      onAuth: (info) => emit({ event: "auth", url: info.url, instructions: info.instructions || "" }),
+      onDeviceCode: (info) => emit({ event: "device_code", ...info }),
+      onProgress: (m) => emit({ event: "progress", message: String(m) }),
+      onManualCodeInput: async () => askCode(),
+      onPrompt: async (prompt) => askCode(prompt),
+      onSelect: async (prompt) => selectLoginOption(prompt),
+    }),
+  };
+}
+
+async function main() {
+  const pi = await loadPi();
+  if (!pi.ModelRuntime && !pi.AuthStorage) throw new Error("no login API exported by pi-coding-agent");
+  const auth = pi.ModelRuntime ? await modelRuntimeAuth(pi) : authStorageAuth(pi);
+  const [cmd, providerId] = process.argv.slice(2);
+
+  if (cmd === "list") {
+    emit({ providers: auth.providers(), status: await auth.status() });
+    return;
+  }
+
+  if (cmd === "logout") {
+    if (!providerId) throw new Error("logout requires a provider id");
+    await auth.logout(providerId);
+    emit({ ok: true });
+    return;
+  }
+
+  if (cmd === "login") {
+    if (!providerId) throw new Error("login requires a provider id");
+    await auth.login(providerId);
+    emit({ event: "done" });
+    return;
+  }
+
+  throw new Error(`unknown command: ${cmd}`);
+}
+
+main().then(() => process.exit(0)).catch((e) => {
+  emit({ event: "error", message: (e && e.message) || String(e) });
+  process.exit(1);
+});

{pidriver-0.4.2 → pidriver-0.5.0}/src/pidriver/auth.py

@@ -3,9 +3,10 @@
 Some providers (Claude Pro/Max subscriptions, Codex, …) authenticate the agent
 via OAuth rather than an API key, writing credentials into the *isolated* pi
 config (``<agent_dir>/auth.json``). pidriver drives that flow through a bundled
-Node helper (``assets/pi_login.mjs``) that reuses pi's OWN ``AuthStorage`` — a
-public export of the pi npm package — so there is never any version skew and
-nothing extra to install beyond pi itself.
+Node helper (``assets/pi_login.mjs``) that reuses pi's OWN login code — public
+exports of the pi npm package (``ModelRuntime`` on pi 1.x, ``AuthStorage`` before
+it) — so there is never any version skew and nothing extra to install beyond pi
+itself.
 
 The browser-authorize → paste-code handshake is exposed as a small async API so a
 host (a web app, a chat bot) can surface the authorize URL and feed the code back::
@@ -16,7 +17,7 @@ host (a web app, a chat bot) can surface the authorize URL and feed the code bac
     await login.submit_code(info["session"], code)   # credentials now in auth.json
 
 Requires Node (the ``node`` binary) on PATH and a resolvable pi install (so its
-bundled ``AuthStorage`` can be imported). Both are *runtime* requirements checked
+login code can be imported). Both are *runtime* requirements checked
 when a flow runs — importing this module never fails and never needs Node.
 """
 
@@ -73,7 +74,7 @@ def auth_context(config: PiConfig) -> tuple[Path, dict[str, str]]:
     """``(auth.json path, helper env)`` for running the login helper under ``config``.
 
     The env is ``config.to_env()`` plus ``PI_NODE_MODULES`` (where pi's bundled
-    ``AuthStorage`` lives) and ``PI_AUTH_PATH`` (the isolated ``<agent_dir>/auth.json``
+    login code lives) and ``PI_AUTH_PATH`` (the isolated ``<agent_dir>/auth.json``
     to read/write) — so the OAuth credentials land in the same isolated config the
     driven agent reads. Raises :class:`PiInstallError` if ``agent_dir`` is unset or no
     pi install can be located.
@@ -86,7 +87,7 @@ def auth_context(config: PiConfig) -> tuple[Path, dict[str, str]]:
     node_modules = resolve_node_modules(config)
     if node_modules is None:
         raise PiInstallError(
-            "pi install not found — install pi (it carries AuthStorage), or run a job once "
+            "pi install not found — install pi (it carries the login code), or run a job once "
             "so pidriver installs it, before attempting OAuth login."
         )
     env = dict(config.to_env())

{pidriver-0.4.2 → pidriver-0.5.0}/src/pidriver/config.py

@@ -110,7 +110,7 @@ class PiConfig:
     install_dir: Path | None = None  # where to install/look for a managed pi
     auto_install: bool = True  # npm-install pi into install_dir if missing
     npm_package: str = "@earendil-works/pi-coding-agent"  # the npm package providing `pi`
-    pi_version: str = "0.87.1"  # known-good pin; overridable
+    pi_version: str = "1.5.0"  # known-good pin; overridable
 
     # --- extensions / skills / packages ------------------------------------
     # User-chosen add-ons installed into the (isolated) pi config dir via
@@ -177,7 +177,7 @@ class PiConfig:
         """Build the full command line: ``[binary, "--mode", mode, ...]``."""
         argv: list[str] = [self.binary, "--mode", self.mode]
 
-        if self.provider:
+        if self.provider and self.model:  # pi >= 1.0 refuses --provider without --model
             argv += ["--provider", self.provider]
         if self.model:
             argv += ["--model", self.model]

{pidriver-0.4.2 → pidriver-0.5.0}/src/pidriver/events.py

@@ -128,6 +128,8 @@ class Usage(Event):
 
 @dataclass(frozen=True, slots=True)
 class AgentEnd(Event):
+    # The end of a whole turn: on upstream pi the session emits it at agent_settled, once retries,
+    # compaction recovery and queued work are over.
     # completed | cancelled | error | limit (kept a free str for forward-compat)
     reason: str = "completed"
     final_text: str = ""

{pidriver-0.4.2 → pidriver-0.5.0}/src/pidriver/session.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 import time
 import uuid
 from collections.abc import AsyncIterator, Callable
+from dataclasses import replace
 from typing import Any
 
 from .events import (
@@ -78,6 +79,7 @@ class PiSession:
         self._consumed = False
         self._ended = False
         self._closed = False
+        self._unsettled: AgentEnd | None = None
 
     # ── ManagedSession surface ─────────────────────────────────────────────
 
@@ -144,6 +146,15 @@ class PiSession:
 
             event = parse_event(record)
 
+            # Upstream pi's agent_end closes one low-level run: a retry, overflow recovery,
+            # compaction or queued work can still follow. The turn is over at agent_settled, so
+            # the run's end waits for it. omp's agent_end carries no willRetry and is final.
+            if isinstance(event, AgentEnd) and "willRetry" in record:
+                self._unsettled = _latest_end(self._unsettled, event)
+                continue
+            if rtype == "agent_settled":
+                event = self._settled_end(record)
+
             if isinstance(event, AgentStart) and event.session_id:
                 self._pi_session_id = event.session_id
             if isinstance(event, AgentEnd):
@@ -165,6 +176,16 @@ class PiSession:
             fatal=False,
         )
 
+    def _settled_end(self, record: dict[str, Any]) -> AgentEnd:
+        """The :class:`AgentEnd` of a settled turn: its last run's end, ``cancelled`` if aborted.
+
+        Without a held end (a session attached after pi's ``agent_end`` was read by a previous
+        one) it still ends the turn, with no text — a turn left open would never finish.
+        """
+        held, self._unsettled = self._unsettled, None
+        end = held or AgentEnd(type=str(record.get("type", "")), raw=record)
+        return replace(end, reason="cancelled") if record.get("aborted") else end
+
     async def _on_interaction(self, request: InteractionRequest) -> None:
         """Let the handler try to auto-answer; otherwise mark it pending."""
         response = await self._handler(request, self)
@@ -253,3 +274,10 @@ class PiSession:
 
 def _opt_str(value: Any) -> str | None:
     return None if value is None else str(value)
+
+
+def _latest_end(previous: AgentEnd | None, end: AgentEnd) -> AgentEnd:
+    """The newer run's end, keeping the last text a run produced (a failed retry has none)."""
+    if previous is not None and not end.final_text:
+        return replace(end, final_text=previous.final_text)
+    return end

{pidriver-0.4.2 → pidriver-0.5.0}/tests/fixtures/README.md

@@ -16,6 +16,13 @@ git repo, for use as test fixtures for the pidriver ↔ omp-rpc mapping.
 > agent's **stdin**, so they do not appear on stdout. The two response fixtures under
 > `frames/` are reconstructed from what the driver sent (id matches the paired request).
 
+## Upstream pi
+
+`pi-1.5.0/turns_and_abort.rpc.jsonl` is a real `pi --mode rpc` session of
+`@earendil-works/pi-coding-agent@1.5.0` (OpenRouter, captured 2026-11-08, paths scrubbed): a turn with a
+`write`, a follow-up turn with an edit, and a turn aborted during `bash`. Upstream pi ends each low-level
+run with `agent_end` (`willRetry`) and the turn with `agent_settled` (`aborted` since 1.1.0).
+
 ## Layout
 
 ### `sessions/` — full real sessions (verbatim stdout)

pidriver-0.5.0/tests/test_auth.py

@@ -0,0 +1,150 @@
+"""Tests for pidriver.auth — OAuth context, code extraction, and node guard."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+import pytest
+
+from pidriver import PiConfig
+from pidriver.auth import (
+    PiOAuthLogin,
+    auth_context,
+    extract_oauth_code,
+    helper_script_path,
+)
+from pidriver.errors import PiInstallError
+
+
+@pytest.mark.parametrize(
+    ("raw", "expected"),
+    [
+        ("abc123", "abc123"),
+        ("  abc123  ", "abc123"),
+        ("http://localhost/callback?code=xyz&state=1", "xyz"),
+        ("code=xyz", "xyz"),
+        ("foo?code=deep", "deep"),
+        ("", ""),
+    ],
+)
+def test_extract_oauth_code(raw: str, expected: str) -> None:
+    assert extract_oauth_code(raw) == expected
+
+
+def test_helper_script_ships_and_is_readable() -> None:
+    path = helper_script_path()
+    assert path.name == "pi_login.mjs"
+    assert "AuthStorage" in path.read_text(encoding="utf-8")
+
+
+def _seed_install(tmp_path: Path) -> Path:
+    install_dir = tmp_path / "pi"
+    pkg = install_dir / "lib" / "node_modules" / "@earendil-works" / "pi-coding-agent"
+    pkg.mkdir(parents=True)
+    return install_dir
+
+
+def test_auth_context_builds_env(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("pidriver._install.shutil.which", lambda name, **kw: None)
+    install_dir = _seed_install(tmp_path)
+    agent_dir = tmp_path / "agent"
+    config = PiConfig(install_dir=install_dir, agent_dir=agent_dir)
+
+    auth_path, env = auth_context(config)
+    assert auth_path == agent_dir / "auth.json"
+    assert env["PI_NODE_MODULES"] == str(install_dir / "lib" / "node_modules")
+    assert env["PI_AUTH_PATH"] == str(agent_dir / "auth.json")
+
+
+def test_auth_context_requires_agent_dir(tmp_path: Path) -> None:
+    with pytest.raises(PiInstallError):
+        auth_context(PiConfig(install_dir=_seed_install(tmp_path)))
+
+
+def test_auth_context_requires_install(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("pidriver._install.shutil.which", lambda name, **kw: None)
+    config = PiConfig(install_dir=tmp_path / "empty", agent_dir=tmp_path / "agent")
+    with pytest.raises(PiInstallError):
+        auth_context(config)
+
+
+async def test_start_without_node_raises(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("pidriver.auth.shutil.which", lambda name, **kw: None)
+    login = PiOAuthLogin(PiConfig(agent_dir=tmp_path / "agent"))
+    with pytest.raises(PiInstallError):
+        await login.start("anthropic")
+
+
+async def test_submit_code_unknown_session(tmp_path: Path) -> None:
+    login = PiOAuthLogin(PiConfig(agent_dir=tmp_path / "agent"))
+    with pytest.raises(KeyError):
+        await login.submit_code("nope", "code")
+
+
+# The helper against stand-ins for pi's two login APIs: ModelRuntime (pi 1.x), AuthStorage (before).
+_MODEL_RUNTIME = """
+export class ModelRuntime {
+  static async create() { return new ModelRuntime(); }
+  getProviders() {
+    return [{ id: "sub", name: "Sub", auth: { oauth: { name: "Sub login" } } },
+            { id: "key", name: "Key", auth: { apiKey: { name: "Key" } } }];
+  }
+  async listCredentials() { return [{ providerId: "sub", type: "oauth" }]; }
+  async logout() {}
+  async login(id, type, interaction) {
+    if (id !== "sub" || type !== "oauth") throw new Error("wrong login: " + id + " " + type);
+    const method = await interaction.prompt({ type: "select", message: "How?", options: [
+      { id: "device", label: "Device code" }, { id: "web", label: "Browser" }] });
+    if (method !== "web") throw new Error("wrong method: " + method);
+    interaction.notify({ type: "progress", message: "starting" });
+    interaction.notify({ type: "auth_url", url: "https://auth.test/go", instructions: "Open it" });
+    const code = await interaction.prompt({ type: "manual_code", message: "Paste it" });
+    if (code !== "abc") throw new Error("wrong code: " + code);
+  }
+}
+"""
+
+_AUTH_STORAGE = """
+export class AuthStorage {
+  static create() { return new AuthStorage(); }
+  getOAuthProviders() { return [{ id: "old", name: "Old" }]; }
+  getAll() { return { old: { type: "oauth" } }; }
+  logout() {}
+}
+"""
+
+_needs_node = pytest.mark.skipif(shutil.which("node") is None, reason="node is not installed")
+
+
+def _login_with(tmp_path: Path, source: str) -> PiOAuthLogin:
+    install_dir = _seed_install(tmp_path)
+    pkg = install_dir / "lib" / "node_modules" / "@earendil-works" / "pi-coding-agent"
+    (pkg / "package.json").write_text('{"type": "module", "main": "./index.js"}')
+    (pkg / "index.js").write_text(source)
+    return PiOAuthLogin(PiConfig(install_dir=install_dir, agent_dir=tmp_path / "agent"))
+
+
+@_needs_node
+async def test_helper_lists_oauth_providers_of_model_runtime(tmp_path: Path) -> None:
+    assert await _login_with(tmp_path, _MODEL_RUNTIME).list_providers() == {
+        "providers": [{"id": "sub", "name": "Sub login"}],
+        "status": {"sub": "oauth"},
+    }
+
+
+@_needs_node
+async def test_helper_logs_in_through_model_runtime(tmp_path: Path) -> None:
+    login = _login_with(tmp_path, _MODEL_RUNTIME)
+    info = await login.start("sub")
+    assert info["url"] == "https://auth.test/go"
+    assert info["instructions"] == "Open it"
+    await login.submit_code(info["session"], "http://localhost/?code=abc")
+
+
+@_needs_node
+async def test_helper_still_works_with_auth_storage(tmp_path: Path) -> None:
+    assert await _login_with(tmp_path, _AUTH_STORAGE).list_providers() == {
+        "providers": [{"id": "old", "name": "Old"}],
+        "status": {"old": "oauth"},
+    }

{pidriver-0.4.2 → pidriver-0.5.0}/tests/test_config.py

@@ -158,3 +158,9 @@ def test_offline_env() -> None:
 def test_extra_env_wins_over_defaults() -> None:
     env = PiConfig(extra_env={"PI_SKIP_VERSION_CHECK": "0"}).to_env(base_environ={})
     assert env["PI_SKIP_VERSION_CHECK"] == "0"
+
+
+def test_provider_is_passed_only_with_a_model() -> None:
+    assert "--provider" not in PiConfig(provider="openrouter").to_argv()
+    argv = PiConfig(provider="openrouter", model="deepseek/x").to_argv()
+    assert argv[argv.index("--provider") + 1] == "openrouter"

{pidriver-0.4.2 → pidriver-0.5.0}/tests/test_install.py

@@ -14,7 +14,7 @@ from pidriver.errors import PiInstallError, PiNotFoundError
 
 
 def make_runner(
-    install_dir: Path | None = None, *, version: str = "0.87.1", record: list | None = None
+    install_dir: Path | None = None, *, version: str = "1.5.0", record: list | None = None
 ):
     """A subprocess.run stand-in covering: npm install (creates the pi shim), `pi --version`
     (returns the version), and `pi install <source>` (records, succeeds)."""
@@ -53,20 +53,20 @@ def _npm_on_path(monkeypatch: pytest.MonkeyPatch):
 
 def test_install_pi_runs_npm_and_verifies(tmp_path: Path) -> None:
     rec: list = []
-    dest = install_pi(tmp_path / "pi", "0.87.1", runner=make_runner(tmp_path / "pi", record=rec))
+    dest = install_pi(tmp_path / "pi", "1.5.0", runner=make_runner(tmp_path / "pi", record=rec))
     assert dest == managed_binary_path(tmp_path / "pi")
     assert dest.exists()
     npm_cmd = next(c for c in rec if "--prefix" in c)
     assert npm_cmd[:3] == ["/usr/bin/npm", "install", "-g"]
     assert "--ignore-scripts" in npm_cmd and "--min-release-age=0" in npm_cmd
     assert str(tmp_path / "pi") in npm_cmd
-    assert "@earendil-works/pi-coding-agent@0.87.1" in npm_cmd
+    assert "@earendil-works/pi-coding-agent@1.5.0" in npm_cmd
 
 
 def test_install_pi_missing_npm_raises(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr("pidriver._install.shutil.which", lambda name: None)
     with pytest.raises(PiInstallError, match="npm not found"):
-        install_pi(tmp_path / "pi", "0.87.1", runner=boom)
+        install_pi(tmp_path / "pi", "1.5.0", runner=boom)
 
 
 def test_install_pi_npm_failure_raises(tmp_path: Path) -> None:
@@ -74,13 +74,13 @@ def test_install_pi_npm_failure_raises(tmp_path: Path) -> None:
         return subprocess.CompletedProcess(cmd, 1, stdout="", stderr="EACCES")
 
     with pytest.raises(PiInstallError, match="npm install .* failed"):
-        install_pi(tmp_path / "pi", "0.87.1", runner=runner)
+        install_pi(tmp_path / "pi", "1.5.0", runner=runner)
 
 
 def test_install_pi_version_mismatch_raises(tmp_path: Path) -> None:
     with pytest.raises(PiInstallError, match="unexpected version"):
         install_pi(
-            tmp_path / "pi", "0.87.1",
+            tmp_path / "pi", "1.5.0",
             runner=make_runner(tmp_path / "pi", version="0.1.0"),
         )
 
@@ -130,12 +130,12 @@ def test_ensure_binary_upgrades_outdated_managed_copy(tmp_path: Path) -> None:
 
     assert ensure_binary(cfg, runner=runner) == str(managed)
     assert any("--prefix" in cmd for cmd in calls)
-    assert version == "0.87.1"
+    assert version == "1.5.0"
 
 
 def test_ensure_binary_auto_installs_when_missing(tmp_path: Path) -> None:
     install_dir = tmp_path / "pi"
-    cfg = PiConfig(binary="pi", install_dir=install_dir, auto_install=True, pi_version="0.87.1")
+    cfg = PiConfig(binary="pi", install_dir=install_dir, auto_install=True, pi_version="1.5.0")
     resolved = ensure_binary(cfg, runner=make_runner(install_dir))
     assert resolved == str(managed_binary_path(install_dir))
     assert Path(resolved).exists()

{pidriver-0.4.2 → pidriver-0.5.0}/tests/test_replay_session.py

@@ -137,3 +137,11 @@ async def test_session_replay_emits_text_and_tool_events():
             final_text = event.final_text
     assert {"ToolStart", "ToolEnd", "MessageDelta"} <= types
     assert final_text  # agent_end carried a final assistant message
+
+
+async def test_real_pi_turns_end_when_settled():
+    """pi 1.5.0: two finished turns and an aborted one, each one AgentEnd after agent_settled."""
+    frames = _load(FIXTURES / "pi-1.5.0" / "turns_and_abort.rpc.jsonl")
+    session = PiSession(ReplayTransport(frames))
+    ends = [(e.reason, e.final_text) async for e in session if isinstance(e, AgentEnd)]
+    assert ends == [("completed", "DONE-1"), ("completed", "DONE-2"), ("cancelled", "")]

{pidriver-0.4.2 → pidriver-0.5.0}/tests/test_session.py

@@ -8,6 +8,7 @@ from typing import Any
 import pytest
 
 from pidriver import (
+    AgentEnd,
     AskHost,
     AutoApprove,
     Decision,
@@ -281,3 +282,69 @@ async def test_client_send_initial_false_skips_prompt():
     client = PiClient(config=None, transport_factory=lambda cfg: transport)
     await client.start("ignored", cwd="/proj", send_initial=False)
     assert transport.sent == []
+
+
+# ── End of a turn (upstream pi: agent_end, then agent_settled) ─────────────────
+
+
+def _end(text: str = "", *, will_retry: bool = False) -> dict[str, Any]:
+    messages = [{"role": "assistant", "content": [{"type": "text", "text": text}]}] if text else []
+    return {"type": "agent_end", "messages": messages, "willRetry": will_retry}
+
+
+async def _ends(records: list[dict[str, Any]]) -> tuple[PiSession, list[tuple[str, str]]]:
+    session = PiSession(FakeTransport(records))
+    ends = [(e.reason, e.final_text) async for e in session if isinstance(e, AgentEnd)]
+    return session, ends
+
+
+async def test_turn_ends_at_settled_not_at_agent_end():
+    transport = FakeTransport([_end("done"), {"type": "agent_settled"}])
+    session = PiSession(transport)
+    ends = []
+    async for event in session:
+        if isinstance(event, AgentEnd):
+            assert not transport._records  # agent_settled has already been read
+            ends.append((event.reason, event.final_text))
+    assert ends == [("completed", "done")]
+    assert session.ended
+
+
+async def test_a_retry_is_one_turn_with_the_retrys_text():
+    _, ends = await _ends(
+        [_end(will_retry=True), {"type": "agent_start"}, _end("fixed"), {"type": "agent_settled"}]
+    )
+    assert ends == [("completed", "fixed")]
+
+
+async def test_the_last_text_survives_a_run_that_has_none():
+    _, ends = await _ends([_end("answer", will_retry=True), _end(), {"type": "agent_settled"}])
+    assert ends == [("completed", "answer")]
+
+
+async def test_two_turns_end_separately():
+    _, ends = await _ends(
+        [_end("one"), {"type": "agent_settled"}, _end("two"), {"type": "agent_settled"}]
+    )
+    assert ends == [("completed", "one"), ("completed", "two")]
+
+
+async def test_an_aborted_turn_is_cancelled():
+    _, ends = await _ends([_end("partial"), {"type": "agent_settled", "aborted": True}])
+    assert ends == [("cancelled", "partial")]
+
+
+async def test_settled_without_an_end_still_ends_the_turn():
+    _, ends = await _ends([{"type": "agent_settled"}])
+    assert ends == [("completed", "")]
+
+
+async def test_a_process_that_dies_before_settling_has_not_finished():
+    session, ends = await _ends([_end("half")])
+    assert ends == []
+    assert not session.ended
+
+
+async def test_agent_end_without_will_retry_is_final():  # omp
+    _, ends = await _ends([{"type": "agent_end", "messages": []}])
+    assert ends == [("completed", "")]

pidriver-0.4.2/src/pidriver/assets/pi_login.mjs

@@ -1,115 +0,0 @@
-#!/usr/bin/env node
-// pi OAuth/login helper for pidriver (driven by pidriver.auth).
-//
-// Reuses pi's own AuthStorage (public export of @earendil-works/pi-coding-agent, which bundles
-// the pi-ai OAuth providers — so there is no version skew and nothing extra to install). Resolve
-// it by running with NODE_PATH=<pi install_dir>/lib/node_modules. Credentials are read/written at
-// PI_AUTH_PATH (the isolated <agent_dir>/auth.json).
-//
-// Commands:
-//   node pi_login.mjs list                 -> {"providers":[{id,name}], "status":{provider:type}}
-//   node pi_login.mjs logout <provider>    -> {"ok":true}
-//   node pi_login.mjs login  <provider>    -> JSONL events on stdout; reads the auth code from stdin
-//
-// login protocol (one JSON object per line on stdout):
-//   {"event":"auth","url":"...","instructions":"..."}   # open this URL in a browser
-//   {"event":"need_code","message":"...","placeholder":"..."}  # then write the code as one stdin line
-//   {"event":"progress","message":"..."}
-//   {"event":"done"}                                     # credentials saved to PI_AUTH_PATH
-//   {"event":"error","message":"..."}
-
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import readline from "node:readline";
-import { pathToFileURL } from "node:url";
-
-function emit(o) {
-  process.stdout.write(JSON.stringify(o) + "\n");
-}
-
-// Import pi's bundled AuthStorage from the managed install (PI_NODE_MODULES = <install>/lib/node_modules).
-// We import the package's entry by absolute path: its `exports` map only declares the ESM `import`
-// condition, so require.resolve can't find it, but a direct file import resolves its nested pi-ai too.
-async function loadAuthStorage() {
-  const nm = process.env.PI_NODE_MODULES;
-  if (!nm) throw new Error("PI_NODE_MODULES is not set");
-  const pkgDir = join(nm, "@earendil-works", "pi-coding-agent");
-  const pkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"));
-  const rel = pkg?.exports?.["."]?.import || pkg.main || "./dist/index.js";
-  const mod = await import(pathToFileURL(join(pkgDir, rel)).href);
-  if (!mod.AuthStorage) throw new Error("AuthStorage not exported by pi-coding-agent");
-  return mod.AuthStorage;
-}
-
-async function readLine() {
-  return await new Promise((resolve) => {
-    const rl = readline.createInterface({ input: process.stdin });
-    rl.once("line", (line) => {
-      rl.close();
-      resolve(String(line).trim());
-    });
-  });
-}
-
-function selectLoginOption(prompt) {
-  const options = Array.isArray(prompt?.options) ? prompt.options : [];
-  const selected = options.find((option) => {
-    const haystack = String(`${option?.id || ""} ${option?.label || ""}`).toLowerCase();
-    return haystack.includes("browser") || haystack.includes("default");
-  }) || options[0];
-  emit({
-    event: "select",
-    message: prompt?.message || "Select login method",
-    options: options.map((option) => ({ id: option.id, label: option.label })),
-    selected: selected?.id || "",
-  });
-  return selected?.id;
-}
-
-async function main() {
-  const AuthStorage = await loadAuthStorage();
-  const storage = AuthStorage.create(process.env.PI_AUTH_PATH);
-  const [cmd, providerId] = process.argv.slice(2);
-
-  if (cmd === "list") {
-    const providers = storage.getOAuthProviders().map((p) => ({ id: p.id, name: p.name }));
-    const all = storage.getAll() || {};
-    const status = {};
-    for (const [k, v] of Object.entries(all)) status[k] = v && v.type ? v.type : "unknown";
-    emit({ providers, status });
-    return;
-  }
-
-  if (cmd === "logout") {
-    if (!providerId) throw new Error("logout requires a provider id");
-    storage.logout(providerId);
-    emit({ ok: true });
-    return;
-  }
-
-  if (cmd === "login") {
-    if (!providerId) throw new Error("login requires a provider id");
-    const askCode = async (prompt) => {
-      emit({ event: "need_code", message: (prompt && prompt.message) || "Paste the authorization code",
-             placeholder: (prompt && prompt.placeholder) || "" });
-      return await readLine();
-    };
-    await storage.login(providerId, {
-      onAuth: (info) => emit({ event: "auth", url: info.url, instructions: info.instructions || "" }),
-      onDeviceCode: (info) => emit({ event: "device_code", ...info }),
-      onProgress: (m) => emit({ event: "progress", message: String(m) }),
-      onManualCodeInput: async () => askCode(),
-      onPrompt: async (prompt) => askCode(prompt),
-      onSelect: async (prompt) => selectLoginOption(prompt),
-    });
-    emit({ event: "done" });
-    return;
-  }
-
-  throw new Error(`unknown command: ${cmd}`);
-}
-
-main().catch((e) => {
-  emit({ event: "error", message: (e && e.message) || String(e) });
-  process.exit(1);
-});

pidriver-0.4.2/tests/test_auth.py

@@ -1,81 +0,0 @@
-"""Tests for pidriver.auth — OAuth context, code extraction, and node guard."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-
-from pidriver import PiConfig
-from pidriver.auth import (
-    PiOAuthLogin,
-    auth_context,
-    extract_oauth_code,
-    helper_script_path,
-)
-from pidriver.errors import PiInstallError
-
-
-@pytest.mark.parametrize(
-    ("raw", "expected"),
-    [
-        ("abc123", "abc123"),
-        ("  abc123  ", "abc123"),
-        ("http://localhost/callback?code=xyz&state=1", "xyz"),
-        ("code=xyz", "xyz"),
-        ("foo?code=deep", "deep"),
-        ("", ""),
-    ],
-)
-def test_extract_oauth_code(raw: str, expected: str) -> None:
-    assert extract_oauth_code(raw) == expected
-
-
-def test_helper_script_ships_and_is_readable() -> None:
-    path = helper_script_path()
-    assert path.name == "pi_login.mjs"
-    assert "AuthStorage" in path.read_text(encoding="utf-8")
-
-
-def _seed_install(tmp_path: Path) -> Path:
-    install_dir = tmp_path / "pi"
-    pkg = install_dir / "lib" / "node_modules" / "@earendil-works" / "pi-coding-agent"
-    pkg.mkdir(parents=True)
-    return install_dir
-
-
-def test_auth_context_builds_env(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("pidriver._install.shutil.which", lambda name, **kw: None)
-    install_dir = _seed_install(tmp_path)
-    agent_dir = tmp_path / "agent"
-    config = PiConfig(install_dir=install_dir, agent_dir=agent_dir)
-
-    auth_path, env = auth_context(config)
-    assert auth_path == agent_dir / "auth.json"
-    assert env["PI_NODE_MODULES"] == str(install_dir / "lib" / "node_modules")
-    assert env["PI_AUTH_PATH"] == str(agent_dir / "auth.json")
-
-
-def test_auth_context_requires_agent_dir(tmp_path: Path) -> None:
-    with pytest.raises(PiInstallError):
-        auth_context(PiConfig(install_dir=_seed_install(tmp_path)))
-
-
-def test_auth_context_requires_install(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("pidriver._install.shutil.which", lambda name, **kw: None)
-    config = PiConfig(install_dir=tmp_path / "empty", agent_dir=tmp_path / "agent")
-    with pytest.raises(PiInstallError):
-        auth_context(config)
-
-
-async def test_start_without_node_raises(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("pidriver.auth.shutil.which", lambda name, **kw: None)
-    login = PiOAuthLogin(PiConfig(agent_dir=tmp_path / "agent"))
-    with pytest.raises(PiInstallError):
-        await login.start("anthropic")
-
-
-async def test_submit_code_unknown_session(tmp_path: Path) -> None:
-    login = PiOAuthLogin(PiConfig(agent_dir=tmp_path / "agent"))
-    with pytest.raises(KeyError):
-        await login.submit_code("nope", "code")