@vellumai/assistant 0.8.9-staging.1 → 0.8.9-staging.2

package/src/acp/resolve-agent.test.ts

@@ -13,8 +13,7 @@ afterAll(() => {
   setOverridesForTesting({});
 });
 
-const { resolveAcpAgent, listAcpAgents, adapterCommandOf, runsViaBunx } =
-  await import("./resolve-agent.js");
+const { resolveAcpAgent, listAcpAgents } = await import("./resolve-agent.js");
 
 beforeEach(() => {
   config.setConfig({});
@@ -217,7 +216,7 @@ describe("resolveAcpAgent", () => {
     if (result.ok) return;
     expect(result.reason).toBe("binary_not_found");
     if (result.reason !== "binary_not_found") return;
-    expect(result.hint).toBe("npm i -g @agentclientprotocol/claude-agent-acp");
+    expect(result.hint).toBe("bun add -g @agentclientprotocol/claude-agent-acp");
     expect(result.command).toBe("claude-agent-acp");
   });
 
@@ -257,7 +256,7 @@ describe("resolveAcpAgent", () => {
     if (result.ok) return;
     expect(result.reason).toBe("binary_not_found");
     if (result.reason !== "binary_not_found") return;
-    expect(result.hint).toBe("npm i -g @zed-industries/codex-acp");
+    expect(result.hint).toBe("bun add -g @zed-industries/codex-acp");
   });
 
   test("binary preflight honors agent.env.PATH override (matches spawn env)", () => {
@@ -300,7 +299,7 @@ describe("resolveAcpAgent", () => {
     expect(result.agent.args).toEqual(["--verbose"]);
   });
 
-  test("direct resolution sets adapterCommand to the command basename", () => {
+  test("resolves a full-path command directly without rewriting it", () => {
     config.setConfig({
       agents: {
         custom: { command: "/opt/bin/claude-agent-acp", args: [] },
@@ -310,117 +309,38 @@ describe("resolveAcpAgent", () => {
     const direct = resolveAcpAgent("claude");
     expect(direct.ok).toBe(true);
     if (!direct.ok) return;
-    expect(direct.agent.adapterCommand).toBe("claude-agent-acp");
-    expect(runsViaBunx(direct.agent)).toBe(false);
+    expect(direct.agent.command).toBe("claude-agent-acp");
 
     const fullPath = resolveAcpAgent("custom");
     expect(fullPath.ok).toBe(true);
     if (!fullPath.ok) return;
-    expect(fullPath.agent.adapterCommand).toBe("claude-agent-acp");
+    expect(fullPath.agent.command).toBe("/opt/bin/claude-agent-acp");
   });
 });
 
 // ---------------------------------------------------------------------------
-// resolveAcpAgent - bunx fallback for missing binaries
+// resolveAcpAgent - missing binaries are never run from the task cwd
 // ---------------------------------------------------------------------------
 
-describe("resolveAcpAgent - bunx fallback", () => {
-  test("binary missing + bun present: rewrites to `bun x --bun <pkg>` with adapterCommand preserved", () => {
+describe("resolveAcpAgent - missing binary", () => {
+  test("binary missing + bun present: still binary_not_found (no bunx rewrite)", () => {
+    // bun on PATH no longer makes a missing adapter "runnable" at resolve
+    // time: the sandboxed install happens separately, never as a `bun x`
+    // rewrite in the untrusted cwd.
     config.setConfig({ agents: {} });
     which.setWhich({ bun: "/usr/local/bin/bun" });
 
     const result = resolveAcpAgent("claude");
 
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-    expect(result.agent.command).toBe("bun");
-    expect(result.agent.args).toEqual([
-      "x",
-      "--bun",
-      "@agentclientprotocol/claude-agent-acp",
-    ]);
-    expect(result.agent.adapterCommand).toBe("claude-agent-acp");
-    expect(runsViaBunx(result.agent)).toBe(true);
-    expect(adapterCommandOf(result.agent)).toBe("claude-agent-acp");
-  });
-
-  test("bunx rewrite appends the original args after the package (gemini --acp)", () => {
-    config.setConfig({ agents: {} });
-    which.setWhich({ bun: "/usr/local/bin/bun" });
-
-    const result = resolveAcpAgent("gemini");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-    expect(result.agent.command).toBe("bun");
-    expect(result.agent.args).toEqual([
-      "x",
-      "--bun",
-      "@google/gemini-cli",
-      "--acp",
-    ]);
-    expect(result.agent.adapterCommand).toBe("gemini");
-  });
-
-  test("bunx rewrite leaves env unchanged", () => {
-    config.setConfig({
-      agents: {
-        claude: {
-          command: "claude-agent-acp",
-          args: [],
-          env: { KEEP_ME: "yes" },
-        },
-      },
-    });
-    which.setWhich({ bun: "/usr/local/bin/bun" });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-    expect(result.agent.command).toBe("bun");
-    expect(result.agent.env).toEqual({ KEEP_ME: "yes" });
-  });
-
-  test("bun lookup honors agent.env.PATH override (matches spawn env)", () => {
-    config.setConfig({
-      agents: {
-        claude: {
-          command: "claude-agent-acp",
-          args: [],
-          env: { PATH: "/opt/custom/bin" },
-        },
-      },
-    });
-    which.setWhich((cmd, options) =>
-      cmd === "bun" && options?.PATH === "/opt/custom/bin"
-        ? "/opt/custom/bin/bun"
-        : null,
-    );
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-    expect(result.agent.command).toBe("bun");
-  });
-
-  test("user-config command without a package mapping is NOT rewritten even when bun is present", () => {
-    config.setConfig({
-      agents: {
-        custom: { command: "unknown-binary", args: [] },
-      },
-    });
-    which.setWhich({ bun: "/usr/local/bin/bun" });
-
-    const result = resolveAcpAgent("custom");
-
     expect(result.ok).toBe(false);
     if (result.ok) return;
     expect(result.reason).toBe("binary_not_found");
+    if (result.reason !== "binary_not_found") return;
+    expect(result.command).toBe("claude-agent-acp");
+    expect(result.hint).toBe("bun add -g @agentclientprotocol/claude-agent-acp");
   });
 
-  test("binary missing + bun missing: binary_not_found with the npm hint", () => {
+  test("binary missing + bun missing: binary_not_found with the bun hint", () => {
     config.setConfig({ agents: {} });
     which.setWhich({});
 
@@ -430,26 +350,7 @@ describe("resolveAcpAgent - bunx fallback", () => {
     if (result.ok) return;
     expect(result.reason).toBe("binary_not_found");
     if (result.reason !== "binary_not_found") return;
-    expect(result.hint).toBe("npm i -g @agentclientprotocol/claude-agent-acp");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// adapterCommandOf - fallback for plain configs
-// ---------------------------------------------------------------------------
-
-describe("adapterCommandOf", () => {
-  test("falls back to the command basename for configs without adapterCommand", () => {
-    expect(adapterCommandOf({ command: "/opt/bin/claude-agent-acp" })).toBe(
-      "claude-agent-acp",
-    );
-    expect(adapterCommandOf({ command: "codex-acp" })).toBe("codex-acp");
-  });
-
-  test("prefers an explicit adapterCommand over the command", () => {
-    expect(
-      adapterCommandOf({ command: "bun", adapterCommand: "claude-agent-acp" }),
-    ).toBe("claude-agent-acp");
+    expect(result.hint).toBe("bun add -g @agentclientprotocol/claude-agent-acp");
   });
 });
 
@@ -523,18 +424,20 @@ describe("listAcpAgents", () => {
     expect(codex?.source).toBe("default");
   });
 
-  test("missing binaries with bun present are listed available (bunx fallback)", () => {
+  test("missing binaries are listed unavailable even when bun is present", () => {
+    // bun presence no longer makes a missing adapter available: it is
+    // installed on demand at spawn time, not run via `bun x` from the cwd.
     config.setConfig({ agents: {} });
     which.setWhich({ bun: "/usr/local/bin/bun" });
 
     const result = listAcpAgents();
 
     for (const entry of result.agents) {
-      expect(entry.available).toBe(true);
-      expect(entry.unavailableReason).toBeUndefined();
-      expect(entry.setupHint).toBeUndefined();
+      expect(entry.available).toBe(false);
+      expect(entry.unavailableReason).toBeDefined();
+      expect(entry.setupHint).toContain("bun add -g");
     }
-    // The catalog keeps the canonical adapter commands, not the rewrite.
+    // The catalog keeps the canonical adapter commands.
     expect(result.agents.map((a) => a.command)).toEqual([
       "claude-agent-acp",
       "codex-acp",
@@ -551,7 +454,7 @@ describe("listAcpAgents", () => {
     const codex = result.agents.find((a) => a.id === "codex");
     expect(codex?.available).toBe(false);
     expect(codex?.unavailableReason).toBe("'codex-acp' is not on PATH");
-    expect(codex?.setupHint).toBe("npm i -g @zed-industries/codex-acp");
+    expect(codex?.setupHint).toBe("bun add -g @zed-industries/codex-acp");
   });
 
   test("unavailable gemini surfaces the @google/gemini-cli install hint", () => {
@@ -566,7 +469,7 @@ describe("listAcpAgents", () => {
     const gemini = result.agents.find((a) => a.id === "gemini");
     expect(gemini?.available).toBe(false);
     expect(gemini?.unavailableReason).toBe("'gemini' is not on PATH");
-    expect(gemini?.setupHint).toBe("npm i -g @google/gemini-cli");
+    expect(gemini?.setupHint).toBe("bun add -g @google/gemini-cli");
   });
 
   test("aliases are resolution sugar, not catalog entries", () => {

package/src/acp/resolve-agent.ts

@@ -13,22 +13,20 @@
  * acp_list_agents, and the `/v1/acp/spawn` HTTP route) get a single source
  * of truth and matching actionable hints.
  *
- * When the adapter binary is NOT on PATH but `bun` is and the command has a
- * vendored entry in `DEFAULT_AGENT_NPM_PACKAGES`, the resolver rewrites the
- * agent to run via `bun x --bun <package>` instead of failing. bunx fetches
- * the package into its cache on first use, so platform-hosted assistants
- * whose image ships bun (but no node and no npm) work out of the box with
- * no global install. The original command is preserved as `adapterCommand`
- * so downstream consumers (env injection, resume hints, version probe) keep
- * gating on the canonical adapter identity.
+ * The resolver NEVER fetches or runs packages in the (untrusted) task cwd.
+ * When the adapter binary is missing, resolution simply fails with
+ * `binary_not_found`; the `resolveAgentWithAutoInstall` flow in
+ * `auto-install.ts` then performs a one-time sandboxed `bun` global install
+ * (clean temp cwd, secrets stripped from the installer env) and re-resolves.
+ * The resolved command is therefore ALWAYS the real adapter binary on PATH,
+ * so downstream gates (env injection, resume hints) key off the command
+ * basename directly.
  *
  * `listAcpAgents()` exposes the merged catalog with availability info for
  * the `acp_list_agents` tool — same merge semantics, plus per-entry
- * `available` / `setupHint` derived from the same binary-or-bunx resolution.
+ * `available` / `setupHint` derived from the same binary resolution.
  */
 
-import { basename } from "node:path";
-
 import {
   DEFAULT_ACP_AGENT_PROFILES,
   DEFAULT_AGENT_NPM_PACKAGES,
@@ -44,48 +42,8 @@ import { isAcpEnabled } from "./feature-gate.js";
  */
 type AcpAgentSource = "config" | "default";
 
-/**
- * A resolver-produced agent config, ready to spawn. `adapterCommand` carries
- * the canonical adapter identity (e.g. "claude-agent-acp") even when the
- * spawn command was rewritten to run via `bun x`, so consumers that gate
- * behavior on the adapter (env injection in `prepare-agent-env.ts`, resume
- * hints, the version probe in `tools/acp/spawn.ts`) stay correct for
- * bunx-resolved agents.
- */
-export interface ResolvedAcpAgent extends AcpAgentConfig {
-  adapterCommand: string;
-}
-
-/**
- * Canonical adapter identity for a (possibly rewritten) agent config.
- * Resolver-produced configs carry `adapterCommand` explicitly; plain configs
- * that never went through the resolver fall back to the command basename so
- * user-supplied agent configs keep working.
- */
-export function adapterCommandOf(config: {
-  command: string;
-  adapterCommand?: string;
-}): string {
-  return config.adapterCommand ?? basename(config.command);
-}
-
-/**
- * Whether the config was rewritten by the resolver to run through `bun x`
- * (the only path where the canonical adapter identity diverges from the
- * actual spawn command).
- */
-export function runsViaBunx(config: {
-  command: string;
-  adapterCommand?: string;
-}): boolean {
-  return (
-    config.adapterCommand !== undefined &&
-    config.adapterCommand !== basename(config.command)
-  );
-}
-
 export type ResolveAcpAgentResult =
-  | { ok: true; agent: ResolvedAcpAgent }
+  | { ok: true; agent: AcpAgentConfig }
   | ResolveAcpAgentFailure;
 
 export type ResolveAcpAgentFailure =
@@ -146,7 +104,7 @@ export const ACP_DISABLED_HINT =
 function installHintFor(command: string): string {
   const pkg = DEFAULT_AGENT_NPM_PACKAGES[command];
   return pkg
-    ? `npm i -g ${pkg}`
+    ? `bun add -g ${pkg}`
     : `Install '${command}' and ensure it is on PATH.`;
 }
 
@@ -154,8 +112,7 @@ function installHintFor(command: string): string {
  * Resolve a binary using the same PATH the spawn will see. `AcpAgentProcess`
  * spawns with `{ ...process.env, ...config.env }`, so a per-agent `env.PATH`
  * override wins over the assistant's PATH. Mirror that here so a config that
- * relies on a custom PATH to locate the binary (or `bun`, for the bunx
- * rewrite) doesn't fail preflight.
+ * relies on a custom PATH to locate the binary doesn't fail preflight.
  */
 function whichOnAgentPath(
   agent: AcpAgentConfig,
@@ -166,34 +123,17 @@ function whichOnAgentPath(
 }
 
 /**
- * Resolve an agent config to its runnable form, or `null` when it cannot
- * spawn. The ONLY place the bunx rewrite happens:
+ * Resolve an agent config to its runnable form, or `null` when its `command`
+ * is not on PATH. Resolution is pure preflight: the binary is used directly
+ * when present, and otherwise the agent cannot spawn (callers fall back to
+ * the sandboxed `bun` global install in `auto-install.ts`, then re-resolve).
  *
- * 1. Binary on PATH → use it directly (`adapterCommand` = command basename).
- * 2. Binary missing, command has a vendored npm package mapping, and `bun`
- *    is on PATH → rewrite to `bun x --bun <package> <original args>`. bunx
- *    fetches the package on first use, preserving the
- *    install-latest-on-first-use design with no global install.
- * 3. Otherwise → null (callers fall back to npm auto-install or surface the
- *    install hint).
- *
- * Security boundary (mirrors `auto-install.ts`): only commands present in
- * `DEFAULT_AGENT_NPM_PACKAGES` are ever rewritten. The package names are
- * vendored constants, NOT user input: an arbitrary command from user config
- * must never be turned into a `bun x <attacker-controlled-name>` execution.
+ * Crucially, this never fetches or executes anything in the task cwd: a
+ * missing binary returns `null` rather than running a package manager from
+ * the (untrusted) project directory.
  */
-function resolveRunnableAgent(agent: AcpAgentConfig): ResolvedAcpAgent | null {
-  if (whichOnAgentPath(agent, agent.command)) {
-    return { ...agent, adapterCommand: basename(agent.command) };
-  }
-  const packageName = DEFAULT_AGENT_NPM_PACKAGES[agent.command];
-  if (!packageName || !whichOnAgentPath(agent, "bun")) return null;
-  return {
-    ...agent,
-    command: "bun",
-    args: ["x", "--bun", packageName, ...agent.args],
-    adapterCommand: agent.command,
-  };
+function resolveRunnableAgent(agent: AcpAgentConfig): AcpAgentConfig | null {
+  return whichOnAgentPath(agent, agent.command) ? agent : null;
 }
 
 /**
@@ -271,8 +211,8 @@ function mergedAgentIds(userAgents: Record<string, AcpAgentConfig>): string[] {
  * Order of checks:
  * 1. ACP must be enabled (feature flag or config; see `isAcpEnabled`).
  * 2. The id must resolve to an agent (user config wins; falls back to defaults).
- * 3. The agent must be runnable: its `command` on PATH, or the bunx rewrite
- *    applies (see `resolveRunnableAgent`).
+ * 3. The agent must be runnable: its `command` on PATH (see
+ *    `resolveRunnableAgent`).
  *
  * Each failure mode carries an actionable hint so callers can surface a
  * single user-facing message without re-deriving the remediation.
@@ -330,8 +270,9 @@ export function listAcpAgents(): {
   const agents: AcpAgentEntry[] = mergedAgentIds(userAgents).map((id) => {
     // Non-null: ids come from `mergedAgentIds` so the lookup always resolves.
     const { agent, source } = lookupAgent(userAgents, id)!;
-    // Same binary-or-bunx resolution as `resolveAcpAgent`: an agent whose
-    // binary is missing but would spawn via `bun x` IS available.
+    // Same binary preflight as `resolveAcpAgent`: available iff the command
+    // is on PATH. A missing binary is auto-installed at spawn time, but the
+    // catalog reflects what is runnable right now.
     const available = resolveRunnableAgent(agent) !== null;
     const entry: AcpAgentEntry = {
       id,

package/src/acp/resume-hint.ts

@@ -5,9 +5,7 @@
  * adapter binary). Other adapters resume differently or not at all, so the
  * hint is gated by the resolved adapter, not the agent id - this stays
  * correct when a user aliases an id to a different binary. Callers pass the
- * CANONICAL adapter command (`adapterCommandOf` in `resolve-agent.ts`), not
- * the raw spawn command, so the hint still fires when the claude adapter is
- * run via `bun x` (spawn command "bun").
+ * resolved command basename, which is always the real adapter binary.
  *
  * Used by the `acp_spawn` tool's success payload and the session manager's
  * completion notification so both surfaces render identical copy. Returns

package/src/acp/session-manager.ts

@@ -4,6 +4,7 @@
  */
 
 import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
 
 import { eq, inArray } from "drizzle-orm";
 
@@ -15,13 +16,10 @@ import { acpSessionHistory } from "../memory/schema.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { getLogger } from "../util/logger.js";
 import { AcpAgentProcess } from "./agent-process.js";
+import { resolveAgentWithAutoInstall } from "./auto-install.js";
 import { VellumAcpClientHandler } from "./client-handler.js";
 import { prepareAgentEnv } from "./prepare-agent-env.js";
-import {
-  adapterCommandOf,
-  formatResolveFailure,
-  resolveAcpAgent,
-} from "./resolve-agent.js";
+import { formatResolveFailure } from "./resolve-agent.js";
 import { claudeResumeHint } from "./resume-hint.js";
 import type { AcpAgentConfig, AcpSessionState } from "./types.js";
 
@@ -74,8 +72,7 @@ interface SessionEntry {
   currentPrompt: Promise<unknown> | null;
   parentConversationId: string;
   cwd: string;
-  /** Canonical adapter command for the spawned config (e.g.
-   *  "claude-agent-acp" even when the adapter runs via `bun x`). Used to
+  /** Resolved adapter command basename (e.g. "claude-agent-acp"). Used to
    *  gate resume hints to the only adapter (claude-agent-acp) whose CLI
    *  accepts `--resume`. */
   command: string;
@@ -316,7 +313,7 @@ export class AcpSessionManager {
       currentPrompt: null,
       parentConversationId: opts.parentConversationId,
       cwd: opts.cwd,
-      command: adapterCommandOf(opts.agentConfig),
+      command: basename(opts.agentConfig.command),
     };
 
     this.sessions.set(acpSessionId, entry);
@@ -351,8 +348,8 @@ export class AcpSessionManager {
    * merges new events into the original row instead of losing them.
    *
    * Throws with an actionable message when the row is missing, was recorded
-   * before resume support (no cwd), the agent cannot be resolved, or the
-   * agent advertises neither resume capability.
+   * before resume support (no cwd), the agent cannot be resolved or
+   * auto-installed, or the agent advertises neither resume capability.
    */
   async resumeFromHistory(
     acpSessionId: string,
@@ -388,11 +385,6 @@ export class AcpSessionManager {
       );
     }
 
-    const resolved = resolveAcpAgent(row.agentId);
-    if (!resolved.ok) {
-      throw new Error(formatResolveFailure(row.agentId, resolved));
-    }
-
     // Everything up to here is synchronous. Reserve the id + concurrency
     // slot BEFORE the first await so a concurrent resume of the same id
     // (or a spawn racing the cap) fails the guards above instead of
@@ -400,11 +392,12 @@ export class AcpSessionManager {
     // reservation holds the resume's promise until it settles so
     // steerOrResume can await a concurrent caller's in-flight resume, and
     // so the delete guards see the id as live while the row's terminal
-    // status still reflects the previous run.
+    // status still reflects the previous run. Agent resolution (which may
+    // auto-install a missing adapter) is therefore deferred into
+    // performResume, after the slot is reserved.
     const resumePromise = this.performResume(
       acpSessionId,
       row as ResumableHistoryRow,
-      resolved.agent,
       sendToVellum,
     );
     this.pendingResumes.set(acpSessionId, resumePromise);
@@ -418,15 +411,34 @@ export class AcpSessionManager {
   /**
    * The async body of resumeFromHistory, split out so the caller can store
    * its promise in `pendingResumes` synchronously before the first await.
-   * All guards and row validation have already passed.
+   * All guards and row validation have already passed; this resolves the
+   * adapter (auto-installing a missing allowlisted binary), prepares its
+   * env, and reattaches.
    */
   private async performResume(
     acpSessionId: string,
     row: ResumableHistoryRow,
-    agent: AcpAgentConfig,
     sendToVellum: (msg: ServerMessage) => void,
   ): Promise<void> {
-    const agentConfig = await prepareAgentEnv(agent);
+    // Resolve the adapter, silently auto-installing a missing allowlisted
+    // binary via the same sandboxed `bun` path as spawn (see
+    // acp/auto-install.ts). A fresh container, or a session created under
+    // the old bunx fallback, may have no adapter on PATH; resume installs it
+    // transparently instead of failing with binary_not_found. The token is
+    // NEVER in scope here — resolveAgentWithAutoInstall strips it from the
+    // installer env; it is injected only by prepareAgentEnv below, at spawn
+    // time, on the real installed binary.
+    const { resolved, failureMessage } = await resolveAgentWithAutoInstall(
+      row.agentId,
+    );
+    if (failureMessage) {
+      throw new Error(failureMessage);
+    }
+    if (!resolved.ok) {
+      throw new Error(formatResolveFailure(row.agentId, resolved));
+    }
+
+    const agentConfig = await prepareAgentEnv(resolved.agent);
 
     // The daemon may have shut down while prepareAgentEnv was pending.
     // Registering now would spawn a child process on a disposed manager

package/src/acp/types.ts

@@ -12,14 +12,6 @@ export interface AcpAgentConfig {
   args: string[];
   description?: string;
   env?: Record<string, string>;
-  /**
-   * Canonical adapter identity (e.g. "claude-agent-acp"), set by the
-   * resolver. It survives the bunx rewrite, where `command` becomes "bun"
-   * and the adapter package moves into `args`. Optional because plain user
-   * configs that bypass the resolver never set it; consumers fall back to
-   * the command basename via `adapterCommandOf` in `resolve-agent.ts`.
-   */
-  adapterCommand?: string;
 }
 
 /**