pi-orchestrator-config 4.1.5

package/extensions/cli-provider/agents/gemini.ts

@@ -0,0 +1,100 @@
+/**
+ * Gemini CLI agent — flags + installed-bundle discovery (isVisible models).
+ */
+
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { cliProviderLog } from "../../shared/file-logger.js";
+import type { CliProviderDef, DiscoveredCliModel } from "../types.js";
+import {
+  cacheKeyForFile,
+  modelIdToDisplayName,
+  readModelCache,
+  resolveBinary,
+  writeModelCache,
+} from "../shared/discover-cache.js";
+
+/**
+ * Parse user-facing models from gemini-cli bundle source.
+ * Matches entries like: "gemini-2.5-pro": { ... isVisible: true ... }
+ */
+export function parseGeminiCliVisibleModels(bundleText: string): DiscoveredCliModel[] {
+  const re =
+    /"((?:gemini|gemma|auto)[^"]+)"\s*:\s*\{[^}]{0,500}?isVisible:\s*true/g;
+  const models: DiscoveredCliModel[] = [];
+  const seen = new Set<string>();
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(bundleText))) {
+    const id = m[1];
+    if (id.endsWith("-base") || seen.has(id)) continue;
+    seen.add(id);
+    models.push({ id, name: modelIdToDisplayName(id) });
+  }
+  return models;
+}
+
+function discoverGeminiModels(): DiscoveredCliModel[] {
+  const binary = resolveBinary("gemini");
+  if (!binary) return [];
+
+  try {
+    const key = cacheKeyForFile("gemini", binary);
+    const cached = readModelCache(key);
+    if (cached && cached.length > 0) return cached;
+
+    const bundleDir = dirname(binary);
+    const candidates = readdirSync(bundleDir)
+      .filter((f) => f.endsWith(".js") && (f.startsWith("chunk-") || f === "gemini.js"))
+      .map((f) => join(bundleDir, f))
+      .filter((p) => existsSync(p))
+      .map((p) => ({ path: p, size: statSync(p).size }))
+      .filter((f) => f.size > 0 && f.size <= 80 * 1024 * 1024)
+      .sort((a, b) => b.size - a.size);
+
+    const models: DiscoveredCliModel[] = [];
+    const seen = new Set<string>();
+    for (const { path } of candidates) {
+      const text = readFileSync(path, "utf-8");
+      for (const m of parseGeminiCliVisibleModels(text)) {
+        if (seen.has(m.id)) continue;
+        seen.add(m.id);
+        models.push(m);
+      }
+      if (models.length > 0) break;
+    }
+
+    if (models.length > 0) writeModelCache(key, models);
+    return models;
+  } catch (err) {
+    cliProviderLog("error", "gemini: CLI bundle parse failed", err);
+    return [];
+  }
+}
+
+export const geminiProvider: CliProviderDef = {
+  name: "gemini",
+  binary: "gemini",
+  buildBaseArgs: (model) => {
+    // --skip-trust: workspace; --yolo: auto-approve all tool actions
+    const args = [
+      "--skip-trust",
+      "--yolo",
+      "--output-format",
+      "stream-json",
+    ];
+    if (model && model !== "default") {
+      args.unshift("--model", model);
+    }
+    return args;
+  },
+  resumeFlag: "--resume",
+  continueFlags: ["--resume"],
+  outputFormat: "stream-json",
+  promptOnStdin: true,
+  discoverModels: discoverGeminiModels,
+};

package/extensions/cli-provider/discover.ts

@@ -0,0 +1,77 @@
+/**
+ * Dynamic model discovery facade — dispatches to per-agent drivers.
+ * CLI only, no API keys / cloud APIs.
+ *
+ * IMPORTANT: These IDs are CLI `--model` values, NOT acpx model ids.
+ */
+
+import { cliProviderLog } from "../shared/file-logger.js";
+import { CLI_PROVIDERS, isCliAgentName, type CliAgentName } from "./providers.js";
+import type { DiscoveredCliModel } from "./types.js";
+import { modelIdToDisplayName, resolveBinary } from "./shared/discover-cache.js";
+
+export type { DiscoveredCliModel } from "./types.js";
+export { modelIdToDisplayName } from "./shared/discover-cache.js";
+export { parseAgentListModels } from "./agents/cursor.js";
+export {
+  parseClaudeBinaryCatalog,
+  scanClaudeBinaryCatalog,
+} from "./agents/claude.js";
+export { parseGeminiCliVisibleModels } from "./agents/gemini.js";
+
+/** True if the CLI binary is on PATH. */
+export function isCliBinaryAvailable(agent: CliAgentName): boolean {
+  return !!resolveBinary(CLI_PROVIDERS[agent].binary);
+}
+
+/**
+ * Discover models for a CLI agent (id + display name).
+ * CLI-only — never uses API keys or cloud list endpoints.
+ */
+export async function discoverCliModelsDetailed(
+  agent: string,
+): Promise<DiscoveredCliModel[]> {
+  if (!isCliAgentName(agent)) return [];
+  if (!isCliBinaryAvailable(agent)) {
+    cliProviderLog(
+      "warn",
+      `${agent}: binary not found (${CLI_PROVIDERS[agent].binary})`,
+    );
+    return [];
+  }
+
+  let discovered: DiscoveredCliModel[] = [];
+  try {
+    discovered = CLI_PROVIDERS[agent].discoverModels();
+  } catch (err) {
+    cliProviderLog("error", `${agent}: discovery error`, err);
+  }
+
+  if (discovered.length > 0) {
+    cliProviderLog("info", `${agent}: discovered ${discovered.length} model(s)`);
+  } else {
+    cliProviderLog("warn", `${agent}: discovery returned no models`);
+  }
+  return discovered;
+}
+
+/** Discover model ids for a CLI agent. */
+export async function discoverCliModelIds(agent: string): Promise<string[]> {
+  const models = await discoverCliModelsDetailed(agent);
+  return models.map((m) => m.id);
+}
+
+/** Discover models ready for registries (sidecar / external tools). */
+export async function discoverCliModels(
+  agent: string,
+): Promise<Array<{ id: string; name: string; provider: string }>> {
+  if (!/^[a-z0-9_-]+$/i.test(agent)) {
+    throw new Error(`Invalid agent name: ${agent}`);
+  }
+  const models = await discoverCliModelsDetailed(agent);
+  return models.map((m) => ({
+    id: `${agent}:${m.id}`,
+    name: `${m.name} (${agent})`,
+    provider: `cli-${agent}`,
+  }));
+}

package/extensions/cli-provider/index.ts

@@ -0,0 +1,57 @@
+/**
+ * CLI Provider Extension — Backward-Compatible Shim
+ *
+ * This file exists solely for backward compatibility with consumers that
+ * resolve `extensions/cli-provider/index.ts` from the pi-orchestrator-config
+ * package (e.g. pi-sidecar).
+ *
+ * Delegates provider registration to the unified driver extension at
+ * `extensions/providers/index.ts`. Re-exports all public APIs so existing
+ * import paths continue to work.
+ *
+ * DO NOT add new logic here — add it to the driver or shared modules.
+ *
+ * @module cli-provider (shim)
+ */
+
+// Re-export discovery APIs (consumed by pi-sidecar via jiti)
+export {
+  discoverCliModels,
+  discoverCliModelIds,
+  discoverCliModelsDetailed,
+  modelIdToDisplayName,
+  isCliBinaryAvailable,
+} from "./discover.js";
+
+// Re-export parsers (consumed by tests)
+export {
+  parseAgentListModels,
+} from "./agents/cursor.js";
+export {
+  parseClaudeBinaryCatalog,
+  scanClaudeBinaryCatalog,
+} from "./agents/claude.js";
+export {
+  parseGeminiCliVisibleModels,
+} from "./agents/gemini.js";
+
+// Re-export session management (consumed by drivers and tests)
+export {
+  resolveCliHistorySeed,
+} from "./sessions.js";
+
+// Re-export model mapping (consumed by tests and unified extension)
+export {
+  mapCliDiscoveredModels,
+} from "./runtime-models.js";
+
+/**
+ * No-op extension entry point.
+ *
+ * Registration is now handled by the unified provider extension at
+ * `extensions/providers/index.ts`. This default export exists only so
+ * pi's extension loader does not throw when loading this directory.
+ */
+export default async function (_pi: unknown) {
+  // Intentional no-op — registration moved to extensions/providers/index.ts
+}

package/extensions/cli-provider/parsers.ts

@@ -0,0 +1,304 @@
+/**
+ * Parse CLI JSON / stream-json stdout into text + session id.
+ * Also supports incremental NDJSON event parsing for live streaming.
+ */
+
+/** Per-turn usage extracted from CLI result events. */
+export interface CliUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  cachedReadTokens?: number;
+  cachedWriteTokens?: number;
+  totalTokens?: number;
+  costUsd?: number;
+}
+
+export interface CliParseResult {
+  text: string;
+  sessionId?: string;
+  thinking?: string;
+  usage?: CliUsage;
+}
+
+export type CliStreamEvent =
+  | { kind: "session"; sessionId: string }
+  | { kind: "thinking_delta"; text: string }
+  | { kind: "text_delta"; text: string }
+  | { kind: "done"; text?: string; sessionId?: string };
+
+/** Parse Claude-style single JSON object. */
+export function parseClaudeJson(stdout: string): CliParseResult {
+  const data = JSON.parse(stdout.trim());
+  const text =
+    typeof data.result === "string"
+      ? data.result
+      : typeof data.content === "string"
+        ? data.content
+        : Array.isArray(data.content)
+          ? data.content
+              .filter((b: any) => b?.type === "text" && typeof b.text === "string")
+              .map((b: any) => b.text)
+              .join("")
+          : "";
+  const sessionId =
+    typeof data.session_id === "string"
+      ? data.session_id
+      : typeof data.sessionId === "string"
+        ? data.sessionId
+        : undefined;
+  return { text: text || "", sessionId };
+}
+
+/** Parse Gemini-style JSON. */
+export function parseGeminiJson(stdout: string): CliParseResult {
+  const data = JSON.parse(stdout.trim());
+  let text = "";
+  if (typeof data.response === "string") text = data.response;
+  else if (typeof data.text === "string") text = data.text;
+  else if (typeof data.result === "string") text = data.result;
+  const sessionId =
+    typeof data.session_id === "string"
+      ? data.session_id
+      : typeof data.sessionId === "string"
+        ? data.sessionId
+        : undefined;
+  return { text, sessionId };
+}
+
+function assistantTextFromEvent(ev: any): string {
+  if (ev?.type === "assistant" && Array.isArray(ev.message?.content)) {
+    return ev.message.content
+      .filter((b: any) => b?.type === "text" && typeof b.text === "string")
+      .map((b: any) => b.text)
+      .join("");
+  }
+  if (ev?.type === "assistant" && typeof ev.message?.content === "string") {
+    return ev.message.content;
+  }
+  if (ev?.type === "text" && typeof ev.text === "string") return ev.text;
+  if (ev?.type === "content_block_delta" && typeof ev.delta?.text === "string") {
+    return ev.delta.text;
+  }
+  return "";
+}
+
+/**
+ * Incremental parser state for stream-json NDJSON (cursor / claude / gemini).
+ * Handles both pure deltas and cumulative snapshots (cursor emits both).
+ */
+export class StreamJsonAccumulator {
+  text = "";
+  thinking = "";
+  sessionId?: string;
+  usage?: CliUsage;
+
+  /** Feed one NDJSON object; returns events to emit to pi. */
+  push(ev: any): CliStreamEvent[] {
+    const out: CliStreamEvent[] = [];
+    if (!ev || typeof ev !== "object") return out;
+
+    if (typeof ev.session_id === "string") {
+      this.sessionId = ev.session_id;
+      out.push({ kind: "session", sessionId: ev.session_id });
+    } else if (typeof ev.sessionId === "string") {
+      this.sessionId = ev.sessionId;
+      out.push({ kind: "session", sessionId: ev.sessionId });
+    }
+
+    if (ev.type === "thinking" && ev.subtype === "delta" && typeof ev.text === "string") {
+      this.thinking += ev.text;
+      out.push({ kind: "thinking_delta", text: ev.text });
+    }
+
+    if (ev.type === "content_block_delta" && typeof ev.delta?.text === "string") {
+      const delta = ev.delta.text;
+      this.text += delta;
+      out.push({ kind: "text_delta", text: delta });
+      return out;
+    }
+
+    // Gemini CLI: {"type":"message","role":"assistant","content":"...","delta":true}
+    if (
+      ev.type === "message" &&
+      ev.role === "assistant" &&
+      typeof ev.content === "string" &&
+      ev.content.length > 0
+    ) {
+      if (ev.delta === true) {
+        this.text += ev.content;
+        out.push({ kind: "text_delta", text: ev.content });
+      } else if (ev.content.startsWith(this.text)) {
+        const delta = ev.content.slice(this.text.length);
+        this.text = ev.content;
+        if (delta) out.push({ kind: "text_delta", text: delta });
+      } else if (!this.text) {
+        this.text = ev.content;
+        out.push({ kind: "text_delta", text: ev.content });
+      }
+      return out;
+    }
+
+    const piece = assistantTextFromEvent(ev);
+    if (piece) {
+      if (piece.startsWith(this.text)) {
+        const delta = piece.slice(this.text.length);
+        this.text = piece;
+        if (delta) out.push({ kind: "text_delta", text: delta });
+      } else if (!this.text.endsWith(piece)) {
+        this.text += piece;
+        out.push({ kind: "text_delta", text: piece });
+      }
+    }
+
+    if (ev.type === "result") {
+      const finalText =
+        typeof ev.result === "string"
+          ? ev.result
+          : typeof ev.text === "string"
+            ? ev.text
+            : undefined;
+      if (finalText !== undefined) {
+        if (finalText.startsWith(this.text)) {
+          const delta = finalText.slice(this.text.length);
+          this.text = finalText;
+          if (delta) out.push({ kind: "text_delta", text: delta });
+        } else if (this.text !== finalText) {
+          // Prefer authoritative result if stream was wrong/empty
+          if (!this.text) {
+            this.text = finalText;
+            out.push({ kind: "text_delta", text: finalText });
+          } else {
+            this.text = finalText;
+          }
+        }
+      }
+      // Extract usage from result event (format varies by CLI agent)
+      this.usage = extractCliUsage(ev);
+
+      out.push({
+        kind: "done",
+        text: this.text,
+        sessionId: this.sessionId,
+      });
+    }
+
+    return out;
+  }
+
+  /** Feed a chunk of stdout (may contain partial lines). */
+  feedChunk(chunk: string, lineBuffer: { value: string }): CliStreamEvent[] {
+    lineBuffer.value += chunk;
+    const events: CliStreamEvent[] = [];
+    const lines = lineBuffer.value.split("\n");
+    lineBuffer.value = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        events.push(...this.push(JSON.parse(trimmed)));
+      } catch {
+        /* incomplete / non-json line */
+      }
+    }
+    return events;
+  }
+
+  flush(lineBuffer: { value: string }): CliStreamEvent[] {
+    const trimmed = lineBuffer.value.trim();
+    lineBuffer.value = "";
+    if (!trimmed) return [];
+    try {
+      return this.push(JSON.parse(trimmed));
+    } catch {
+      return [];
+    }
+  }
+}
+
+/**
+ * Parse Cursor agent stream-json (NDJSON). Accumulate assistant text deltas
+ * and last session id.
+ */
+export function parseCursorStreamJson(stdout: string): CliParseResult {
+  const acc = new StreamJsonAccumulator();
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      acc.push(JSON.parse(trimmed));
+    } catch {
+      /* skip */
+    }
+  }
+  return {
+    text: acc.text,
+    sessionId: acc.sessionId,
+    thinking: acc.thinking || undefined,
+    usage: acc.usage,
+  };
+}
+
+/**
+ * Extract usage from a CLI result event. Handles three formats:
+ * - Cursor: result.usage.{inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens}
+ * - Claude: result.usage.{input_tokens, output_tokens, cache_read_input_tokens, cache_creation_input_tokens} + result.total_cost_usd
+ * - Gemini: result.stats.{input_tokens, output_tokens, total_tokens, cached}
+ */
+export function extractCliUsage(ev: any): CliUsage | undefined {
+  if (!ev || typeof ev !== "object") return undefined;
+
+  // Cursor format: result.usage.{inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens}
+  if (ev.usage && typeof ev.usage === "object" && typeof ev.usage.inputTokens === "number") {
+    const u = ev.usage;
+    return {
+      inputTokens: u.inputTokens ?? undefined,
+      outputTokens: u.outputTokens ?? undefined,
+      cachedReadTokens: u.cacheReadTokens ?? undefined,
+      cachedWriteTokens: u.cacheWriteTokens ?? undefined,
+      totalTokens: (u.inputTokens ?? 0) + (u.outputTokens ?? 0),
+    };
+  }
+
+  // Claude format: result.usage.{input_tokens, output_tokens, cache_read_input_tokens, cache_creation_input_tokens}
+  if (ev.usage && typeof ev.usage === "object" && typeof ev.usage.input_tokens === "number") {
+    const u = ev.usage;
+    const cost = typeof ev.total_cost_usd === "number" ? ev.total_cost_usd : undefined;
+    return {
+      inputTokens: u.input_tokens ?? undefined,
+      outputTokens: u.output_tokens ?? undefined,
+      cachedReadTokens: u.cache_read_input_tokens ?? undefined,
+      cachedWriteTokens: u.cache_creation_input_tokens ?? undefined,
+      totalTokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0),
+      costUsd: cost,
+    };
+  }
+
+  // Gemini format: result.stats.{input_tokens, output_tokens, total_tokens, cached}
+  if (ev.stats && typeof ev.stats === "object" && typeof ev.stats.input_tokens === "number") {
+    const s = ev.stats;
+    return {
+      inputTokens: s.input_tokens ?? undefined,
+      outputTokens: s.output_tokens ?? undefined,
+      cachedReadTokens: s.cached ?? undefined,
+      totalTokens: s.total_tokens ?? undefined,
+    };
+  }
+
+  return undefined;
+}
+
+export function parseCliOutput(agent: string, stdout: string): CliParseResult {
+  if (agent === "cursor") return parseCursorStreamJson(stdout);
+  // Prefer stream-json NDJSON when present; fall back to single JSON object
+  if (stdout.includes("\n") && stdout.trim().startsWith("{")) {
+    const first = stdout.trim().split("\n")[0];
+    try {
+      const ev = JSON.parse(first);
+      if (ev?.type) return parseCursorStreamJson(stdout);
+    } catch {
+      /* fall through */
+    }
+  }
+  if (agent === "gemini") return parseGeminiJson(stdout);
+  return parseClaudeJson(stdout);
+}

package/extensions/cli-provider/providers.ts

@@ -0,0 +1,58 @@
+/**
+ * CLI provider registry — assembles per-agent drivers (t3-style Drivers/*).
+ * Add a new CLI: create agents/<name>.ts, register here.
+ */
+
+import type { CliAgentName, CliProviderDef } from "./types.js";
+import { claudeProvider } from "./agents/claude.js";
+import { cursorProvider } from "./agents/cursor.js";
+import { geminiProvider } from "./agents/gemini.js";
+
+/**
+ * Headless flags (cli-* is a backend LLM — no TTY for prompts):
+ *
+ * | Concern | cursor | claude | gemini |
+ * |---------|--------|--------|--------|
+ * | Workspace trust | `--trust` | skipped by `-p` | `--skip-trust` |
+ * | Tool/command approve | `--force` (`--yolo` alias) | `--dangerously-skip-permissions` | `--yolo` |
+ *
+ * Trust alone is NOT enough: without auto-approve, tool calls that need
+ * confirmation hang or fail (no interactive user).
+ */
+export const CLI_PROVIDERS: Record<CliAgentName, CliProviderDef> = {
+  claude: claudeProvider,
+  gemini: geminiProvider,
+  cursor: cursorProvider,
+};
+
+export type { CliAgentName, CliProviderDef } from "./types.js";
+
+export const VALID_CLI_AGENTS = new Set<string>(Object.keys(CLI_PROVIDERS));
+
+export function isCliAgentName(name: string): name is CliAgentName {
+  return VALID_CLI_AGENTS.has(name);
+}
+
+/** Build full command argv for a turn. */
+export function buildCliCommand(opts: {
+  agent: CliAgentName;
+  model: string;
+  cwd: string;
+  sessionId?: string | null;
+  continueSession?: boolean;
+  /** Override the default agent binary (from driver config). */
+  binary?: string;
+}): { binary: string; args: string[]; promptOnStdin: boolean } {
+  const def = CLI_PROVIDERS[opts.agent];
+  const args = [...def.buildBaseArgs(opts.model, opts.cwd)];
+  if (opts.sessionId) {
+    args.push(def.resumeFlag, opts.sessionId);
+  } else if (opts.continueSession) {
+    args.push(...def.continueFlags);
+  }
+  return {
+    binary: opts.binary || def.binary,
+    args,
+    promptOnStdin: def.promptOnStdin,
+  };
+}