ai-whisper 0.8.1 → 0.10.0

package/README.md

@@ -1,6 +1,6 @@
 # ai-whisper
 
-ai-whisper pairs two coding agents — mount any two of Claude, Codex, and ezio — into a terminal-native pair that hand work back and forth under a single baton, so one agent implements while the other reviews, and a structured workflow drives the loop to a finished, reviewed deliverable without a human babysitting every round.
+ai-whisper pairs two coding agents — mount any two of Claude, Codex, ezio, and agy — into a terminal-native pair that hand work back and forth under a single baton, so one agent implements while the other reviews, and a structured workflow drives the loop to a finished, reviewed deliverable without a human babysitting every round.
 
 ## Magic moment
 
@@ -52,13 +52,14 @@ It is **not** for:
 
 ## Prerequisites
 
-You pair any two of three agents — `claude`, `codex`, and `ezio`. ai-whisper drives the *real* Claude and Codex CLIs, so install and authenticate whichever of those two you plan to mount first; `ezio` is protocol-native and ships with ai-whisper, so it needs no separate CLI.
+You pair any two of four agents — `claude`, `codex`, `ezio`, and `agy`. ai-whisper drives the *real* Claude, Codex, and Antigravity CLIs, so install and authenticate whichever of those you plan to mount first; `ezio` is protocol-native and ships with ai-whisper.
 
 - **[Claude Code CLI](https://claude.com/claude-code)** — the `claude` command, signed in.
 - **[Codex CLI](https://github.com/openai/codex)** — the `codex` command, signed in.
 - **ezio** *(optional)* — bundled with ai-whisper; mount it with `whisper collab mount ezio`, no separate install.
+- **agy** *(optional)* — the `agy` command (Antigravity CLI), signed in. Mount it with `whisper collab mount agy` (manual-mount parity; no auto-launch via `collab start`).
 - **Node.js 22+**.
-- **An LLM evaluator with credentials** — workflows are gated by it and refuse to start without it. See [Evaluator configuration](docs/evaluator-configuration.md).
+- **An LLM evaluator with credentials** — workflows are gated by it and refuse to start without it. It supports four providers: **Anthropic** (default), a local **Ollama** model, **OpenAI** (and any OpenAI-compatible backend via a `baseURL` — Azure, OpenRouter, vLLM, LM Studio, …), or reusing an **already-mounted agent CLI** (`claude`/`codex`/`agy`) in non-interactive mode (no separate key — it reuses that CLI's own auth). See [Evaluator configuration](docs/evaluator-configuration.md).
 - **tmux** *(optional)* — only for `whisper collab start`, which auto-arranges both agents into panes. The mount flow below does not need it.
 
 > **Platform support:** ai-whisper is terminal-native and Unix-oriented — it drives interactive PTY sessions, so it runs on **macOS and Linux**. It is **not supported natively on Windows**: `whisper collab mount` / `reconnect` require a Unix tty-backed shell and will exit with an error pointing here. On Windows, run ai-whisper inside **[WSL2](https://learn.microsoft.com/windows/wsl/install)** — install Node, your agent CLI, and ai-whisper inside the WSL2 distro and run the commands there, where everything works as-is.
@@ -120,9 +121,9 @@ A run that stops short usually **escalates** — it does not crash. When the eva
 
 ## Core concepts
 
-ai-whisper is **not a swarm**. The agents never type at once — work moves by a single baton, one owner at a time. Mounted sessions are *real* agent sessions in your terminal — Claude or Codex CLIs, or ezio — and those sessions are the source of truth. Autonomy is supervised: every handoff, verdict, and round is inspectable, and runs are resumable rather than fire-and-forget. Work is organized as structured workflows — explicit loops and state transitions, not a free-form chat.
+ai-whisper is **not a swarm**. The agents never type at once — work moves by a single baton, one owner at a time. Mounted sessions are *real* agent sessions in your terminal — Claude or Codex CLIs, ezio, or agy — and those sessions are the source of truth. Autonomy is supervised: every handoff, verdict, and round is inspectable, and runs are resumable rather than fire-and-forget. Work is organized as structured workflows — explicit loops and state transitions, not a free-form chat.
 
-Claude, Codex, and ezio are supported today — you mount any two of them; the architecture is provider-agnostic by design, so other coding-agent CLIs can be added behind the same relay.
+Claude, Codex, ezio, and agy are supported today — you mount any two of them; the architecture is provider-agnostic by design, so other coding-agent CLIs can be added behind the same relay.
 
 For the full mental model, read [Concepts](docs/concepts.md).
 

package/dist/bin/broker-daemon.js

@@ -63,7 +63,7 @@ var threadStates = [
   "failed"
 ];
 var collabStates = ["active", "stopped"];
-var agentTypes = ["codex", "claude", "ezio"];
+var agentTypes = ["codex", "claude", "ezio", "agy"];
 var sessionRegistrationStates = ["registered"];
 var workItemStates = [
   "queued",
@@ -332,7 +332,7 @@ var mockProviderReplySchema = z14.object({
 
 // ../shared/dist/relay-host.js
 import { z as z15 } from "zod";
-var relayTargets = ["codex", "claude", "ezio", "pull"];
+var relayTargets = ["codex", "claude", "ezio", "agy", "pull"];
 var relayDirectiveSchema = z15.object({
   raw: z15.string().min(1),
   target: z15.enum(relayTargets),
@@ -5918,7 +5918,45 @@ function createWorkflowEventBridge(input) {
 import * as crypto3 from "node:crypto";
 import Anthropic from "@anthropic-ai/sdk";
 import { Ollama } from "ollama";
+import OpenAI from "openai";
 import { z as z18 } from "zod";
+
+// src/runtime/agent-cli-presets.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import { accessSync, constants, statSync as statSync3 } from "node:fs";
+import { delimiter, join as join6 } from "node:path";
+var defaultSpawn = (command, args, options) => nodeSpawn(command, [...args], options);
+var PRESETS = {
+  claude: { executable: "claude", execArgs: ["-p"], promptVia: "arg" },
+  codex: { executable: "codex", execArgs: ["exec"], promptVia: "arg" },
+  agy: { executable: "agy", execArgs: ["-p"], promptVia: "arg" }
+};
+function resolveAgentCliInvocation(input) {
+  const preset = PRESETS[input.agent];
+  return {
+    executable: input.executable ?? preset.executable,
+    execArgs: input.execArgs ?? preset.execArgs,
+    promptVia: input.promptVia ?? preset.promptVia
+  };
+}
+function isExecutableOnPath(executable) {
+  const isExecFile = (p) => {
+    try {
+      if (!statSync3(p).isFile()) return false;
+      accessSync(p, constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (executable.includes("/") || executable.includes("\\")) return isExecFile(executable);
+  const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  return dirs.some((dir) => exts.some((ext) => isExecFile(join6(dir, executable + ext))));
+}
+
+// src/runtime/relay-orchestrator-evaluator.ts
+var defaultOpenAIFactory = (opts) => new OpenAI(opts);
 var baseFields = {
   confidence: z18.number().min(0).max(1),
   reason: z18.string()
@@ -6158,7 +6196,10 @@ function selectBranch(payload) {
   }
   return legacyBranch;
 }
+var ProviderUnavailableError = class extends Error {
+};
 function isProviderUnavailableError(error) {
+  if (error instanceof ProviderUnavailableError) return true;
   if (!(error instanceof Error)) return false;
   const code = error.code;
   if (code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "ETIMEDOUT" || code === "ECONNRESET")
@@ -6222,6 +6263,77 @@ function buildOllamaCaller(config) {
     return { raw: response.message.content };
   };
 }
+function buildOpenAICaller(config) {
+  const client = (config.createClient ?? defaultOpenAIFactory)({
+    apiKey: config.apiKey,
+    ...config.baseURL ? { baseURL: config.baseURL } : {}
+  });
+  const model = config.model;
+  return async function(systemPrompt, payload, jsonSchema) {
+    const response = await client.chat.completions.create({
+      model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: JSON.stringify(payload) }
+      ],
+      // Non-strict json_schema: schema-shaped guidance only; branch.parse() is authoritative.
+      // `strict` is intentionally omitted (see spec §5.2.1) — do not set it true.
+      response_format: { type: "json_schema", json_schema: { name: "verdict", schema: jsonSchema } },
+      temperature: 0.3
+    });
+    const raw = response.choices[0]?.message.content ?? "";
+    return {
+      raw,
+      ...typeof response.usage?.prompt_tokens === "number" ? { inputTokens: response.usage.prompt_tokens } : {},
+      ...typeof response.usage?.completion_tokens === "number" ? { outputTokens: response.usage.completion_tokens } : {}
+    };
+  };
+}
+function buildAgentCliCaller(config) {
+  const { executable, execArgs, promptVia } = resolveAgentCliInvocation(config);
+  const spawnImpl = config.spawnImpl ?? defaultSpawn;
+  return function(systemPrompt, payload) {
+    const prompt = `${systemPrompt}
+
+=== INPUT (JSON) ===
+${JSON.stringify(payload)}
+=== END INPUT ===
+
+Reply with ONLY the JSON object described above \u2014 no prose, no code fence.`;
+    return new Promise((resolve2, reject) => {
+      const child = promptVia === "arg" ? spawnImpl(executable, [...execArgs, prompt], { stdio: ["ignore", "pipe", "pipe"] }) : spawnImpl(executable, execArgs, { stdio: ["pipe", "pipe", "pipe"] });
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      child.stdout.on("data", (chunk) => {
+        stdout += String(chunk);
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += String(chunk);
+      });
+      child.on("error", (err) => {
+        if (settled) return;
+        settled = true;
+        reject(new ProviderUnavailableError(`agent-cli spawn failed (${executable}): ${err.message}`));
+      });
+      child.on("close", (code) => {
+        if (settled) return;
+        settled = true;
+        if (code !== 0) {
+          reject(new ProviderUnavailableError(`agent-cli ${executable} exited with code ${code}: ${stderr.trim()}`));
+          return;
+        }
+        resolve2({ raw: stdout });
+      });
+      if (promptVia === "stdin") {
+        child.stdin.on("error", () => {
+        });
+        child.stdin.write(prompt);
+        child.stdin.end();
+      }
+    });
+  };
+}
 function buildSingleProviderCaller(config) {
   if (config.provider === "anthropic") {
     const call2 = buildAnthropicCaller(config);
@@ -6264,6 +6376,46 @@ function buildSingleProviderCaller(config) {
       }
     };
   }
+  if (config.provider === "openai") {
+    const call2 = buildOpenAICaller(config);
+    return async function(payload, branch) {
+      const started = Date.now();
+      let providerResult;
+      try {
+        providerResult = await call2(branch.systemPrompt, payload, branch.jsonSchema);
+      } catch (callErr) {
+        const providerLatencyMs2 = Date.now() - started;
+        return { ok: false, error: callErr instanceof Error ? callErr : new Error(String(callErr)), raw: null, inputTokens: null, outputTokens: null, providerLatencyMs: providerLatencyMs2 };
+      }
+      const providerLatencyMs = Date.now() - started;
+      try {
+        const verdict = branch.parse(providerResult.raw);
+        return { ok: true, verdict, raw: providerResult.raw, inputTokens: providerResult.inputTokens ?? null, outputTokens: providerResult.outputTokens ?? null, providerLatencyMs };
+      } catch (parseErr) {
+        return { ok: false, error: parseErr instanceof Error ? parseErr : new Error(String(parseErr)), raw: providerResult.raw, inputTokens: providerResult.inputTokens ?? null, outputTokens: providerResult.outputTokens ?? null, providerLatencyMs };
+      }
+    };
+  }
+  if (config.provider === "agent-cli") {
+    const call2 = buildAgentCliCaller(config);
+    return async function(payload, branch) {
+      const started = Date.now();
+      let raw;
+      try {
+        ({ raw } = await call2(branch.systemPrompt, payload));
+      } catch (callErr) {
+        const providerLatencyMs2 = Date.now() - started;
+        return { ok: false, error: callErr instanceof Error ? callErr : new Error(String(callErr)), raw: null, inputTokens: null, outputTokens: null, providerLatencyMs: providerLatencyMs2 };
+      }
+      const providerLatencyMs = Date.now() - started;
+      try {
+        const verdict = branch.parse(raw);
+        return { ok: true, verdict, raw, inputTokens: null, outputTokens: null, providerLatencyMs };
+      } catch (parseErr) {
+        return { ok: false, error: parseErr instanceof Error ? parseErr : new Error(String(parseErr)), raw, inputTokens: null, outputTokens: null, providerLatencyMs };
+      }
+    };
+  }
   const call = buildOllamaCaller(config);
   return async function(payload, branch) {
     const started = Date.now();
@@ -6710,8 +6862,8 @@ function writeOwnPidToBrokerDaemon(db, input) {
 }
 
 // src/runtime/evaluator-config.ts
-import { readFileSync as readFileSync2, statSync as statSync3 } from "node:fs";
-import { join as join6 } from "node:path";
+import { readFileSync as readFileSync2, statSync as statSync4 } from "node:fs";
+import { join as join7 } from "node:path";
 
 // src/runtime/state-root.ts
 import os from "node:os";
@@ -6745,7 +6897,7 @@ function warnIfLoosePerms(path2) {
   if (process.platform === "win32") return;
   let mode;
   try {
-    mode = statSync3(path2).mode;
+    mode = statSync4(path2).mode;
   } catch {
     return;
   }
@@ -6773,31 +6925,46 @@ function loadEvaluatorConfig() {
   const root = getStateRoot();
   let dotenv = {};
   try {
-    dotenv = parseDotEnv(readFileSync2(join6(root, ".env"), "utf8"));
+    dotenv = parseDotEnv(readFileSync2(join7(root, ".env"), "utf8"));
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
   const envGet = (k) => process.env[k] ?? dotenv[k];
-  const authPath = join6(root, "auth.json");
+  const authPath = join7(root, "auth.json");
   warnIfLoosePerms(authPath);
   const auth = readJsonFile(authPath, "auth.json");
-  const config = readJsonFile(join6(root, "config.json"), "config.json");
+  const config = readJsonFile(join7(root, "config.json"), "config.json");
   const evalCfg = config?.evaluator ?? {};
   const evalOllama = evalCfg.ollama ?? {};
-  const provider = (envGet("AI_WHISPER_EVALUATOR_PROVIDER") ?? evalCfg.provider) === "ollama" ? "ollama" : "anthropic";
+  const provider = envGet("AI_WHISPER_EVALUATOR_PROVIDER") ?? evalCfg.provider;
+  const resolvedProvider = provider === "ollama" || provider === "openai" || provider === "agent-cli" ? provider : "anthropic";
   const rawFallback = envGet("AI_WHISPER_EVALUATOR_FALLBACK") ?? evalCfg.fallback;
-  const fallback = rawFallback === "anthropic" || rawFallback === "ollama" ? rawFallback : null;
+  const fallback = rawFallback === "anthropic" || rawFallback === "ollama" || rawFallback === "openai" || rawFallback === "agent-cli" ? rawFallback : null;
   const apiKey = envGet("ANTHROPIC_API_KEY") ?? auth?.ANTHROPIC_API_KEY ?? null;
+  const evalOpenai = evalCfg.openai ?? {};
+  const openaiKey = envGet("OPENAI_API_KEY") ?? auth?.OPENAI_API_KEY ?? null;
+  const evalAgentCli = evalCfg.agentCli ?? {};
+  const rawAgent = envGet("AI_WHISPER_EVALUATOR_AGENT_CLI_AGENT") ?? evalAgentCli.agent;
+  const agent = rawAgent === "claude" || rawAgent === "codex" || rawAgent === "agy" ? rawAgent : null;
   return {
-    provider,
+    provider: resolvedProvider,
     fallback,
-    anthropic: {
-      apiKey: apiKey && apiKey.length > 0 ? apiKey : null,
-      model: evalCfg.anthropicModel ?? null
-    },
+    anthropic: { apiKey: apiKey && apiKey.length > 0 ? apiKey : null, model: evalCfg.anthropicModel ?? null },
     ollama: {
       host: envGet("AI_WHISPER_EVALUATOR_OLLAMA_HOST") ?? evalOllama.host ?? null,
       model: envGet("AI_WHISPER_EVALUATOR_OLLAMA_MODEL") ?? evalOllama.model ?? null
+    },
+    openai: {
+      apiKey: openaiKey && openaiKey.length > 0 ? openaiKey : null,
+      model: envGet("AI_WHISPER_EVALUATOR_OPENAI_MODEL") ?? evalOpenai.model ?? null,
+      baseURL: envGet("AI_WHISPER_EVALUATOR_OPENAI_BASE_URL") ?? evalOpenai.baseURL ?? null
+    },
+    agentCli: {
+      agent,
+      executable: evalAgentCli.executable ?? null,
+      execArgs: Array.isArray(evalAgentCli.execArgs) ? evalAgentCli.execArgs : null,
+      promptVia: evalAgentCli.promptVia === "arg" || evalAgentCli.promptVia === "stdin" ? evalAgentCli.promptVia : null,
+      model: evalAgentCli.model ?? null
     }
   };
 }
@@ -6807,6 +6974,21 @@ function computeEvaluatorStatus(cfg, ctx) {
   if (cfg.provider === "anthropic" && cfg.anthropic.apiKey === null) {
     return "missing_anthropic_key";
   }
+  if (cfg.provider === "openai") {
+    if (cfg.openai.apiKey === null) return "missing_openai_key";
+    if (cfg.openai.model === null) return "invalid_config";
+  }
+  if (cfg.provider === "agent-cli") {
+    if (cfg.agentCli.agent === null) return "invalid_config";
+    const { executable } = resolveAgentCliInvocation({
+      agent: cfg.agentCli.agent,
+      executable: cfg.agentCli.executable,
+      execArgs: cfg.agentCli.execArgs,
+      promptVia: cfg.agentCli.promptVia
+    });
+    const exists = (ctx.executableExists ?? isExecutableOnPath)(executable);
+    if (!exists) return "agent_cli_unavailable";
+  }
   return "ready";
 }
 
@@ -6815,7 +6997,9 @@ var NOT_CONFIGURED = {
   provider: "anthropic",
   fallback: null,
   anthropic: { apiKey: null, model: null },
-  ollama: { host: null, model: null }
+  ollama: { host: null, model: null },
+  openai: { apiKey: null, model: null, baseURL: null },
+  agentCli: { agent: null, executable: null, execArgs: null, promptVia: null, model: null }
 };
 function recordEvaluatorStatus(db, input) {
   const status = computeEvaluatorStatus(input.resolved ?? NOT_CONFIGURED, {
@@ -6828,7 +7012,7 @@ function recordEvaluatorStatus(db, input) {
 
 // src/bin/broker-daemon.ts
 import { execFile as execFile2 } from "node:child_process";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/runtime/cli-package-info.ts
 import { readFileSync as readFileSync3 } from "node:fs";
@@ -6878,7 +7062,7 @@ if (collabId) {
     });
     workflowEventBridge.start();
     eventSocket = await createEventSocketServer({
-      socketPath: join7(getStateSocketsDir(), `events-${collabId}.sock`),
+      socketPath: join8(getStateSocketsDir(), `events-${collabId}.sock`),
       events: [broker.events, externalEvents],
       engineVersion: resolveCliVersion()
     });
@@ -6905,10 +7089,30 @@ function providerConfigFrom(kind) {
     if (!resolved || resolved.anthropic.apiKey === null) return null;
     return { provider: "anthropic", apiKey: resolved.anthropic.apiKey };
   }
+  if (kind === "openai") {
+    if (!resolved || resolved.openai.apiKey === null || resolved.openai.model === null) return null;
+    return {
+      provider: "openai",
+      apiKey: resolved.openai.apiKey,
+      model: resolved.openai.model,
+      ...resolved.openai.baseURL ? { baseURL: resolved.openai.baseURL } : {}
+    };
+  }
+  if (kind === "ollama") {
+    return {
+      provider: "ollama",
+      ...resolved?.ollama.host ? { host: resolved.ollama.host } : {},
+      ...resolved?.ollama.model ? { model: resolved.ollama.model } : {}
+    };
+  }
+  if (!resolved || resolved.agentCli.agent === null) return null;
   return {
-    provider: "ollama",
-    ...resolved?.ollama.host ? { host: resolved.ollama.host } : {},
-    ...resolved?.ollama.model ? { model: resolved.ollama.model } : {}
+    provider: "agent-cli",
+    agent: resolved.agentCli.agent,
+    ...resolved.agentCli.executable ? { executable: resolved.agentCli.executable } : {},
+    ...resolved.agentCli.execArgs ? { execArgs: resolved.agentCli.execArgs } : {},
+    ...resolved.agentCli.promptVia ? { promptVia: resolved.agentCli.promptVia } : {},
+    ...resolved.agentCli.model ? { model: resolved.agentCli.model } : {}
   };
 }
 var collab = broker.control.getCollab(collabId);