@bivy/bivy 0.7.0-staging.96 → 0.7.0-staging.97

package/bin/acp-shim.mjs

@@ -57,45 +57,112 @@ function bivy(obj) {
 // --- ACP agent (child JSON-RPC over its stdio) ------------------------------
 const agent = spawn(agentCmd, agentArgs, { stdio: ["pipe", "pipe", "pipe"] });
 agent.stderr.on("data", (d) => process.stderr.write(`[acp-agent] ${d}`));
-agent.on("error", (e) => bivy({ type: "session.error", error: `acp agent spawn failed: ${e.message}` }));
-agent.on("exit", (code) => {
-  if (code && code !== 0) bivy({ type: "session.error", error: `acp agent exited (${code})` });
-});
-
 let nextId = 1;
 const pending = new Map(); // jsonrpc id -> {resolve, reject}
-function agentRequest(method, params) {
+let agentDead = null; // set to an Error once the child is gone
+
+/**
+ * The child is gone (spawn failure or exit). Every in-flight request must be
+ * rejected: without this, a CLI whose ACP mode doesn't exist leaves `initialize`
+ * pending forever and the daemon waits out its whole session.create timeout instead
+ * of surfacing the real reason. Fail fast, with the reason.
+ */
+function killPending(reason) {
+  if (agentDead) return;
+  agentDead = reason instanceof Error ? reason : new Error(String(reason));
+  bivy({ type: "session.error", error: agentDead.message });
+  for (const [id, p] of [...pending]) { pending.delete(id); p.reject(agentDead); }
+}
+agent.on("error", (e) => killPending(`acp agent spawn failed: ${e.message}`));
+agent.on("exit", (code, signal) => {
+  if (code || signal) killPending(`acp agent exited (${code ?? signal})`);
+});
+// Writing to a dead child's stdin raises EPIPE; with no listener that's an uncaught
+// exception that takes the shim down mid-turn instead of reporting the cause.
+agent.stdin.on("error", (e) => killPending(`acp agent stdin closed: ${e.message}`));
+
+function agentWrite(payload) {
+  if (agentDead) throw agentDead;
+  agent.stdin.write(`${JSON.stringify(payload)}\n`);
+}
+function agentRequest(method, params, { timeoutMs } = {}) {
   const id = nextId++;
-  agent.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
-  return new Promise((resolve, reject) => pending.set(id, { resolve, reject }));
+  return new Promise((resolve, reject) => {
+    let timer;
+    pending.set(id, {
+      resolve: (v) => { clearTimeout(timer); resolve(v); },
+      reject: (e) => { clearTimeout(timer); reject(e); },
+    });
+    if (timeoutMs) {
+      timer = setTimeout(() => {
+        if (pending.delete(id)) reject(new Error(`acp ${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+    }
+    try { agentWrite({ jsonrpc: "2.0", id, method, params }); }
+    catch (e) { clearTimeout(timer); pending.delete(id); reject(e); }
+  });
 }
 function agentReply(id, result) {
-  agent.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}\n`);
+  try { agentWrite({ jsonrpc: "2.0", id, result }); } catch { /* child gone; killPending already reported it */ }
 }
 function agentReplyError(id, code, message) {
-  agent.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } })}\n`);
+  try { agentWrite({ jsonrpc: "2.0", id, error: { code, message } }); } catch { /* child gone */ }
 }
 function agentNotify(method, params) {
-  agent.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+  try { agentWrite({ jsonrpc: "2.0", method, params }); } catch { /* child gone */ }
 }
 
 // --- session state ----------------------------------------------------------
 let sessionId = null;
 let cwd = process.cwd();
 let initialized = false;
+// The ACP config-option id that selects the model (usually "model"), learned from
+// session/new; used for the session/set_config_option fallback.
+let modelConfigId = "model";
+// A model chosen before the ACP session existed, applied once it does.
+let pendingModel = null;
 // toolCallId -> { requestId, options } so a later bivy tool.decision answers the
 // right ACP permission request with a concrete optionId.
 const permissionRequests = new Map();
 
 async function ensureInitialized() {
   if (initialized) return;
+  // Bounded: a binary that accepts the launch args but never speaks ACP would
+  // otherwise hang here until the daemon's own session timeout, hiding the cause.
   await agentRequest("initialize", {
     protocolVersion: 1,
     clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
-  });
+  }, { timeoutMs: 20_000 });
   initialized = true;
 }
 
+/**
+ * ACP exposes a session's selectable models as a `select` config option on the
+ * session/new|load result (opencode: `configOptions: [{id:"model", currentValue,
+ * options:[{value,name}]}]`). Models are per-NODE — they depend on which providers
+ * the user has authenticated in the agent — so a hardcoded list would offer models
+ * the agent rejects. Publish what the agent actually reports, as a post-hello
+ * `runtime.models` event ProtocolRuntime folds into its picker.
+ */
+function publishModels(result) {
+  const options = Array.isArray(result?.configOptions) ? result.configOptions : [];
+  const modelOption = options.find((o) => String(o?.id ?? "") === "model" || String(o?.category ?? "") === "model");
+  const choices = Array.isArray(modelOption?.options) ? modelOption.options : [];
+  const models = choices
+    .map((o) => ({ id: String(o?.value ?? ""), name: String(o?.name ?? o?.value ?? "") }))
+    .filter((m) => m.id)
+    // ACP model ids are `provider/model`; split the provider so Bivy can group and
+    // scope provider-specific settings the same way it does for other runtimes.
+    .map((m) => ({ ...m, provider: m.id.includes("/") ? m.id.split("/")[0] : "agent" }));
+  if (!models.length) return;
+  modelConfigId = String(modelOption?.id ?? "model");
+  bivy({
+    type: "runtime.models",
+    models,
+    ...(modelOption?.currentValue ? { currentModel: String(modelOption.currentValue) } : {}),
+  });
+}
+
 // --- ACP → bivy: streamed session/update notifications ----------------------
 function onSessionUpdate(params) {
   const u = params?.update;
@@ -211,6 +278,33 @@ createInterface({ input: agent.stdout }).on("line", (line) => {
   if (msg.method === "session/update") onSessionUpdate(msg.params);
 });
 
+/**
+ * Select a model on the live ACP session. `session/set_model` is the direct form;
+ * agents that only expose the generic config-option surface take the same choice as
+ * `session/set_config_option`. A rejection propagates: ProtocolRuntime only commits
+ * the selection once we ack, so a model the agent won't accept must not look applied.
+ */
+async function setAgentModel(model) {
+  try {
+    await agentRequest("session/set_model", { sessionId, modelId: model }, { timeoutMs: 15_000 });
+  } catch (primary) {
+    try {
+      await agentRequest("session/set_config_option", { sessionId, configId: modelConfigId, value: model }, { timeoutMs: 15_000 });
+    } catch {
+      throw primary;
+    }
+  }
+}
+
+async function applyPendingModel() {
+  if (!pendingModel || !sessionId) return;
+  const model = pendingModel;
+  pendingModel = null;
+  // Best-effort: a stale pick shouldn't block the session from opening.
+  try { await setAgentModel(model); }
+  catch (e) { bivy({ type: "runtime.debug", message: `acp set_model failed: ${e instanceof Error ? e.message : String(e)}` }); }
+}
+
 // --- bivy commands in (daemon → us) -----------------------------------------
 async function onBivyCommand(msg) {
   const type = String(msg.type || "");
@@ -224,6 +318,8 @@ async function onBivyCommand(msg) {
         cwd = String(msg.cwd || msg.workspace || cwd);
         const res = await agentRequest("session/new", { cwd, mcpServers: [] });
         sessionId = res?.sessionId ?? res?.session?.id ?? null;
+        publishModels(res);
+        await applyPendingModel();
         bivy({ replyTo: id, ok: true, runtimeSessionRef: sessionId });
         return;
       }
@@ -235,11 +331,14 @@ async function onBivyCommand(msg) {
         try {
           const res = await agentRequest("session/load", { sessionId: ref, cwd, mcpServers: [] });
           sessionId = res?.sessionId ?? ref;
+          publishModels(res);
         } catch {
           // Agent doesn't support session/load — start fresh so the chat still opens.
           const res = await agentRequest("session/new", { cwd, mcpServers: [] });
           sessionId = res?.sessionId ?? null;
+          publishModels(res);
         }
+        await applyPendingModel();
         bivy({ replyTo: id, ok: true, runtimeSessionRef: sessionId });
         return;
       }
@@ -270,6 +369,19 @@ async function onBivyCommand(msg) {
         }
         return;
       }
+      case "model.set": {
+        const model = String(msg.model ?? "").trim();
+        if (!model) { bivy({ replyTo: id, ok: true }); return; }
+        if (!sessionId) {
+          // Chosen before the session exists — remember and apply at session/new.
+          pendingModel = model;
+          bivy({ replyTo: id, ok: true });
+          return;
+        }
+        await setAgentModel(model);
+        bivy({ replyTo: id, ok: true });
+        return;
+      }
       case "session.abort": {
         if (sessionId) agentNotify("session/cancel", { sessionId });
         if (id !== undefined) bivy({ replyTo: id, ok: true });
@@ -286,8 +398,10 @@ async function onBivyCommand(msg) {
 }
 
 // Announce capabilities: ACP agents are governed (per-tool permission) and
-// resumable (session/load). Models aren't part of the core ACP surface, so we
-// don't advertise a picker we can't drive.
+// resumable (session/load). modelSelection starts FALSE and is upgraded later by a
+// `runtime.models` event if the session reports selectable models — the list is
+// per-node (it depends on the providers the user has authenticated in the agent)
+// and only arrives with session/new, so claiming a picker here would be a guess.
 bivy({ type: "hello", runtime: { capabilities: { toolInterception: true, modelSelection: false, resume: true } } });
 
 createInterface({ input: process.stdin }).on("line", (line) => {

package/bin/agent-manifest.json

@@ -20,8 +20,9 @@
       "label": "OpenCode",
       "command": "opencode",
       "hidden": false,
-      "supportTier": "beta",
-      "certification": "adapter-tested",
+      "supportTier": "supported",
+      "certification": "release-tested",
+      "testedVersion": "1.18.13",
       "headlessFlags": [
         "run",
         "-s"

package/dist/runtime/index.js

@@ -179,7 +179,11 @@ const CLI_AGENT_SPECS = {
         // reply to stdout (the TUI needs a real TTY and would hang over a pipe).
         args: ["run"],
         promptMode: "argv",
-        supportTier: "beta",
+        // Supported tier: OpenCode runs on the governed ACP path by default (per-tool
+        // Approve/Deny + session/load resume + a real model picker), the same bar Pi,
+        // Claude Code, and Codex clear. See `acp` below for the version fallback.
+        supportTier: "supported",
+        testedVersion: "1.18.13",
         blurb: "The most widely used open-source coding harness (OpenCode CLI).",
         // `opencode run -s <id> "<prompt>"` continues a prior session by its own id
         // (`-s, --session  session id to continue`, per `opencode run --help`).
@@ -195,11 +199,14 @@ const CLI_AGENT_SPECS = {
                 { id: "google/gemini-2.5-pro", name: "Gemini 2.5 Pro", provider: "google" },
             ],
         },
-        // OpenCode ships a native ACP server (`opencode acp`, per opencode.ai/docs/acp),
-        // so it can be driven through the governed ProtocolRuntime instead of the pipe —
-        // per-tool approvals + streaming + resume. Opt in with BIVY_OPENCODE_ACP=1 (or
-        // global BIVY_PREFER_ACP=1); off by default until validated for your version.
-        acp: { args: ["acp"] },
+        // `opencode acp` ("start ACP (Agent Client Protocol) server") drives OpenCode
+        // through the governed ProtocolRuntime instead of the one-shot pipe: per-tool
+        // Approve/Deny, streaming, `session/load` resume, and `session/set_model`.
+        // Validated against opencode 1.18.13, so it is ON by default (`preferred`) —
+        // gated on the binary actually listing the `acp` subcommand, so an older
+        // OpenCode falls back to the pipe path rather than opening a dead session.
+        // Force the pipe path back with BIVY_OPENCODE_ACP=0.
+        acp: { args: ["acp"], helpToken: "acp", preferred: true },
         install: { kind: "npm", pkg: "opencode-ai" },
     },
     aider: {
@@ -857,10 +864,28 @@ function cliThinkingConfig(id) {
 // installed binary doesn't actually mention. It never UPGRADES — adding a
 // capability needs the exact arg template, which help text can't safely supply — so
 // probing can only make the catalog MORE honest, never invent a no-op control.
+/**
+ * Absolute path of a command on the current PATH, or null when it isn't there.
+ * Used to key the help-probe cache: caching by the bare NAME would keep serving a
+ * stale answer after the binary behind that name changed (a CLI upgraded or
+ * installed while the daemon is running, or a different PATH entry winning).
+ */
+function resolveCommandPath(command) {
+    if (!command.trim())
+        return null;
+    const res = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
+        shell: process.platform !== "win32",
+        encoding: "utf8",
+    });
+    if (res.status !== 0)
+        return null;
+    return (res.stdout ?? "").split(/\r?\n/)[0]?.trim() || null;
+}
 const HELP_PROBE_CACHE = new Map();
 function probeHelpText(command) {
-    if (HELP_PROBE_CACHE.has(command))
-        return HELP_PROBE_CACHE.get(command) ?? null;
+    const key = resolveCommandPath(command) ?? command;
+    if (HELP_PROBE_CACHE.has(key))
+        return HELP_PROBE_CACHE.get(key) ?? null;
     let text = null;
     try {
         const res = spawnSync(command, ["--help"], { encoding: "utf8", timeout: 4000 });
@@ -870,7 +895,7 @@ function probeHelpText(command) {
     catch {
         text = null;
     }
-    HELP_PROBE_CACHE.set(command, text);
+    HELP_PROBE_CACHE.set(key, text);
     return text;
 }
 // A resume template mixes launch flags (`-p`, `--force`) with the resume-specific
@@ -963,9 +988,14 @@ function cliAgentInfo(id) {
         // src/harness/mcp-inject.ts + governMcpCall in src/server.ts.
         capabilities: { toolInterception: acpActive, mcpToolApprovals: acpActive || Boolean(process.env.BIVY_MCP_PROXY), modelSelection, resume, packages: false, fork: false, usageReporting, sessionDiscovery: id === "codex" },
         supportTier: spec.supportTier ?? (id === "codex" ? "supported" : "experimental"),
+        testedVersion: spec.testedVersion,
         authOwner: spec.authOwner ?? "agent",
         notes: installed
-            ? `Available on PATH. This process adapter ${spec.parserId && !spec.parserUnverified ? "parses its native JSON stream into a structured transcript" : spec.parserId ? "streams stdout/stderr (a structured JSON parser is available; opt in with BIVY_AGENT_STRUCTURED=1 once validated for your version)" : "streams stdout/stderr"}; Bivy governs its filesystem/exec/MCP effects at the sandbox tier rather than intercepting each tool call. Override its launch flags with BIVY_${id.toUpperCase()}_ARGS if your CLI version differs.`
+            ? acpActive
+                // Promoted to ACP: the description must match the governed path actually in
+                // use, not the pipe path this agent would otherwise take.
+                ? `Available on PATH, driven through its Agent Client Protocol server (\`${spec.command} ${spec.acp?.args.join(" ")}\`): each tool call is gated by Bivy's Approve/Deny before it runs, and sessions resume natively. Force the plain stdout pipe with BIVY_${id.toUpperCase()}_ACP=0.`
+                : `Available on PATH. This process adapter ${spec.parserId && !spec.parserUnverified ? "parses its native JSON stream into a structured transcript" : spec.parserId ? "streams stdout/stderr (a structured JSON parser is available; opt in with BIVY_AGENT_STRUCTURED=1 once validated for your version)" : "streams stdout/stderr"}; Bivy governs its filesystem/exec/MCP effects at the sandbox tier rather than intercepting each tool call. Override its launch flags with BIVY_${id.toUpperCase()}_ARGS if your CLI version differs.`
             : `${spec.command} was not found on PATH. Install it on this node, then select this agent again.`,
         install: installed || !installCommand ? undefined : {
             label: `Install ${spec.displayName}`,
@@ -980,6 +1010,13 @@ function cliAgentInfo(id) {
 // Approve/Deny card via guardianInterceptor, AND it resumes a prior thread by its
 // rollout id (thread/resume). Governed + resumable in one runtime supersedes the
 // exec path, which stays runnable via `BIVY_RUNTIME=codex` for a no-approval flow.
+/**
+ * The Codex CLI release this adapter was last certified against. Unlike Pi and the
+ * Claude Agent SDK, Codex is an external binary rather than a pinned npm dependency,
+ * so there is no lockfile entry to derive this from — it is bumped deliberately when
+ * the app-server shim is re-validated against a new Codex release.
+ */
+const CODEX_TESTED_VERSION = "0.145.0";
 function codexApprovalsInfo() {
     const installed = commandAvailable("codex");
     return {
@@ -1009,7 +1046,12 @@ function codexApprovalsInfo() {
             nativeSessionDiscovery: true,
             nativeSessionAdoption: true,
         },
-        supportTier: "beta",
+        // Supported tier: the app-server shim already clears the same bar as Pi and
+        // Claude Code — per-tool Approve/Deny, model selection, thread resume, usage
+        // reporting, and native session discovery/adoption — all over a bidirectional
+        // protocol rather than a one-shot pipe.
+        supportTier: "supported",
+        testedVersion: CODEX_TESTED_VERSION,
         authOwner: "agent",
         notes: installed
             ? "Drives Codex's experimental app-server so tool calls surface as in-chat approval cards, and resumes a prior thread by its rollout id (thread/resume). Governance AND resume in one runtime."
@@ -1202,15 +1244,50 @@ function acpRuntimeFromEnv(credsDir) {
     return acpRuntimeOptions({ id: "acp", displayName: process.env.BIVY_ACP_NAME?.trim() || "ACP Agent", command, agentArgs, credsDir });
 }
 /**
- * Whether a CLI agent should be driven through ACP rather than the one-shot pipe:
- * it declares an `acp` mode AND ACP is preferred for it (per-agent `BIVY_<ID>_ACP=1`
- * or global `BIVY_PREFER_ACP=1`). This is the data-driven "promote an agent to the
- * high-capability path" switch — no per-agent code, just a spec field + a flag.
+ * Does the INSTALLED binary actually evidence the agent's ACP mode? A default-on
+ * promotion must never be taken on faith: ACP is a hard switch (the pipe path is
+ * unreachable once a session opens), so a CLI too old to have the subcommand would
+ * otherwise hang and die instead of degrading. We reuse the same cached `--help`
+ * probe the opt-in capability refinement uses, and fail CLOSED — a missing binary
+ * or unreadable help keeps the agent on the honest pipe path.
+ */
+function acpSupportedByBinary(id) {
+    const spec = CLI_AGENT_SPECS[id];
+    if (!spec.acp)
+        return false;
+    if (!commandAvailable(spec.command))
+        return false;
+    const help = probeHelpText(spec.command);
+    if (!help)
+        return false;
+    const token = (spec.acp.helpToken ?? spec.acp.args[0] ?? "acp").toLowerCase();
+    return help.includes(token);
+}
+/**
+ * Whether a CLI agent should be driven through ACP rather than the one-shot pipe.
+ * Three ways in, in precedence order:
+ *   - `BIVY_<ID>_ACP=0` — operator forces the pipe path back (escape hatch).
+ *   - `BIVY_<ID>_ACP=1` / `BIVY_PREFER_ACP=1` — operator forces ACP, no probe (they
+ *     know their binary; an explicit request shouldn't be second-guessed).
+ *   - `spec.acp.preferred` — validated agents are promoted by DEFAULT, but only
+ *     when the installed binary evidences the ACP mode (see acpSupportedByBinary).
+ * Still no per-agent code: a spec field plus a flag.
+ *
+ * Both the catalog (cliAgentInfo) and the launch path (makeCliRuntime) call this,
+ * so what the picker advertises and what actually starts cannot disagree.
  */
 function prefersAcp(id) {
-    if (!CLI_AGENT_SPECS[id].acp)
+    const spec = CLI_AGENT_SPECS[id];
+    if (!spec.acp)
+        return false;
+    const override = process.env[`BIVY_${id.toUpperCase()}_ACP`];
+    if (override === "0")
+        return false;
+    if (override === "1" || process.env.BIVY_PREFER_ACP === "1")
+        return true;
+    if (!spec.acp.preferred)
         return false;
-    return process.env.BIVY_PREFER_ACP === "1" || process.env[`BIVY_${id.toUpperCase()}_ACP`] === "1";
+    return acpSupportedByBinary(id);
 }
 /**
  * Resolve the communication mode for a CLI agent. This is deliberately pure so

package/dist/runtime/protocol.js

@@ -410,6 +410,21 @@ class ProtocolSession {
                 this.runtimeSessionRef = msg.runtimeSessionRef;
             return;
         }
+        // Late-arriving model registry. A shim that knows its models up front puts them
+        // in `hello`; one whose list is only knowable per session — an ACP agent's
+        // models depend on which providers the user has authenticated, and arrive with
+        // session/new — publishes them here instead. Same contract as the hello path: a
+        // picker backed by a real `model.set` the shim answers, never a claimed one.
+        if (type === "runtime.models") {
+            const models = parseModels(msg.models);
+            if (models.length) {
+                this.models = models;
+                this.capabilitiesRef.modelSelection = true;
+                if (typeof msg.currentModel === "string")
+                    this.currentModelId = msg.currentModel;
+            }
+            return;
+        }
         if (type === "message.delta") {
             const text = String(msg.text ?? "");
             if (!this.assistantText)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.7.0-staging.96",
+  "version": "0.7.0-staging.97",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",