@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/acp/__tests__/agent-process.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Unit tests for AcpAgentProcess capability getters.
+ *
+ * The getters reflect the InitializeResponse captured during initialize();
+ * before that resolves (or after kill()) they must report false. The
+ * connection is stubbed directly so no child process is spawned.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import type { InitializeResponse } from "@agentclientprotocol/sdk";
+
+import { AcpAgentProcess } from "../agent-process.js";
+
+function makeProcess(): AcpAgentProcess {
+  return new AcpAgentProcess(
+    "test-agent",
+    { command: "echo", args: [] },
+    () => {
+      throw new Error("client factory should not be called in this test");
+    },
+  );
+}
+
+/** Injects a stub connection whose initialize() resolves with `response`. */
+function stubConnection(
+  proc: AcpAgentProcess,
+  response: InitializeResponse,
+): void {
+  (
+    proc as unknown as {
+      connection: { initialize: () => Promise<InitializeResponse> };
+    }
+  ).connection = {
+    initialize: () => Promise.resolve(response),
+  };
+}
+
+describe("AcpAgentProcess capability getters", () => {
+  test("both getters return false before initialize() resolves", () => {
+    const proc = makeProcess();
+    expect(proc.supportsLoadSession).toBe(false);
+    expect(proc.supportsSessionResume).toBe(false);
+  });
+
+  test("supportsLoadSession reflects agentCapabilities.loadSession", async () => {
+    const proc = makeProcess();
+    stubConnection(proc, {
+      protocolVersion: 1,
+      agentCapabilities: { loadSession: true },
+    });
+
+    await proc.initialize();
+
+    expect(proc.supportsLoadSession).toBe(true);
+    expect(proc.supportsSessionResume).toBe(false);
+  });
+
+  test("supportsSessionResume reflects agentCapabilities.sessionCapabilities.resume", async () => {
+    const proc = makeProcess();
+    stubConnection(proc, {
+      protocolVersion: 1,
+      agentCapabilities: { sessionCapabilities: { resume: {} } },
+    });
+
+    await proc.initialize();
+
+    expect(proc.supportsSessionResume).toBe(true);
+    expect(proc.supportsLoadSession).toBe(false);
+  });
+
+  test("both getters return false when the agent advertises no capabilities", async () => {
+    const proc = makeProcess();
+    stubConnection(proc, { protocolVersion: 1 });
+
+    await proc.initialize();
+
+    expect(proc.supportsLoadSession).toBe(false);
+    expect(proc.supportsSessionResume).toBe(false);
+  });
+
+  test("kill() clears the captured initialize response", async () => {
+    const proc = makeProcess();
+    stubConnection(proc, {
+      protocolVersion: 1,
+      agentCapabilities: {
+        loadSession: true,
+        sessionCapabilities: { resume: {} },
+      },
+    });
+
+    await proc.initialize();
+    expect(proc.supportsLoadSession).toBe(true);
+    expect(proc.supportsSessionResume).toBe(true);
+
+    proc.kill();
+
+    expect(proc.supportsLoadSession).toBe(false);
+    expect(proc.supportsSessionResume).toBe(false);
+  });
+});
+
+describe("AcpAgentProcess loadSession/resumeSession", () => {
+  /** Injects a stub connection that records loadSession/resumeSession params. */
+  function stubSessionConnection(proc: AcpAgentProcess): {
+    loadCalls: unknown[];
+    resumeCalls: unknown[];
+  } {
+    const loadCalls: unknown[] = [];
+    const resumeCalls: unknown[] = [];
+    (proc as unknown as { connection: unknown }).connection = {
+      loadSession: (params: unknown) => {
+        loadCalls.push(params);
+        return Promise.resolve({});
+      },
+      resumeSession: (params: unknown) => {
+        resumeCalls.push(params);
+        return Promise.resolve({});
+      },
+    };
+    return { loadCalls, resumeCalls };
+  }
+
+  test("loadSession forwards { sessionId, cwd, mcpServers: [] } to the connection", async () => {
+    const proc = makeProcess();
+    const { loadCalls } = stubSessionConnection(proc);
+
+    await proc.loadSession("session-1", "/tmp/project");
+
+    expect(loadCalls).toEqual([
+      { sessionId: "session-1", cwd: "/tmp/project", mcpServers: [] },
+    ]);
+  });
+
+  test("resumeSession forwards { sessionId, cwd, mcpServers: [] } to the connection", async () => {
+    const proc = makeProcess();
+    const { resumeCalls } = stubSessionConnection(proc);
+
+    await proc.resumeSession("session-2", "/tmp/project");
+
+    expect(resumeCalls).toEqual([
+      { sessionId: "session-2", cwd: "/tmp/project", mcpServers: [] },
+    ]);
+  });
+
+  test("loadSession throws when the process is not spawned", async () => {
+    const proc = makeProcess();
+
+    await expect(proc.loadSession("session-1", "/tmp/project")).rejects.toThrow(
+      'ACP agent "test-agent" is not spawned',
+    );
+  });
+
+  test("resumeSession throws when the process is not spawned", async () => {
+    const proc = makeProcess();
+
+    await expect(
+      proc.resumeSession("session-1", "/tmp/project"),
+    ).rejects.toThrow('ACP agent "test-agent" is not spawned');
+  });
+});

package/src/acp/__tests__/client-handler.test.ts

@@ -62,3 +62,43 @@ describe("VellumAcpClientHandler.sessionUpdate", () => {
     expect(handler.responseText).toBe("");
   });
 });
+
+describe("VellumAcpClientHandler replay suppression", () => {
+  function messageChunk(text: string): SessionNotification {
+    return {
+      sessionId: ACP_SESSION_ID,
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text },
+      },
+    };
+  }
+
+  test("updates received while suppressed are dropped", async () => {
+    const { handler, sent } = makeHandler();
+
+    handler.beginReplaySuppression();
+    await handler.sessionUpdate(messageChunk("replayed history"));
+
+    expect(sent).toHaveLength(0);
+    expect(handler.responseText).toBe("");
+  });
+
+  test("updates after endReplaySuppression() flow normally", async () => {
+    const { handler, sent } = makeHandler();
+
+    handler.beginReplaySuppression();
+    await handler.sessionUpdate(messageChunk("replayed history"));
+    handler.endReplaySuppression();
+    await handler.sessionUpdate(messageChunk("live response"));
+
+    expect(sent).toHaveLength(1);
+    expect(sent[0]).toEqual({
+      type: "acp_session_update",
+      acpSessionId: ACP_SESSION_ID,
+      updateType: "agent_message_chunk",
+      content: "live response",
+    });
+    expect(handler.responseText).toBe("live response");
+  });
+});

package/src/acp/__tests__/helpers/acp-history-db.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared test helpers for the `acp_session_history` table.
+ *
+ * Several suites (session-manager resume/persistence, the ACP route
+ * handlers) seed and read history rows directly via SQL; this module
+ * consolidates the copy-pasted row shape + insert/read/clear helpers.
+ * Tests must run `initializeDb()` themselves before calling these.
+ */
+
+import { getSqlite } from "../../../memory/db-connection.js";
+
+/** Raw column snapshot of an `acp_session_history` row. */
+export interface HistoryRow {
+  id: string;
+  agent_id: string;
+  acp_session_id: string;
+  parent_conversation_id: string;
+  started_at: number;
+  completed_at: number | null;
+  status: string;
+  stop_reason: string | null;
+  error: string | null;
+  event_log_json: string;
+  cwd: string | null;
+}
+
+export function clearHistory(): void {
+  getSqlite().run("DELETE FROM acp_session_history");
+}
+
+/**
+ * Inserts a history row. Every field except `id` defaults to the values
+ * the resume suites were built around (a completed claude run in
+ * /tmp/proj); pass explicit values to override, including `null` where the
+ * column is nullable (e.g. `cwd: null` for legacy rows).
+ */
+export function insertHistoryRow(row: {
+  id: string;
+  agentId?: string;
+  acpSessionId?: string;
+  parentConversationId?: string;
+  startedAt?: number;
+  completedAt?: number | null;
+  status?: string;
+  stopReason?: string | null;
+  error?: string | null;
+  eventLogJson?: string;
+  cwd?: string | null;
+}): void {
+  getSqlite()
+    .query(
+      `INSERT INTO acp_session_history (
+         id, agent_id, acp_session_id, parent_conversation_id,
+         started_at, completed_at, status, stop_reason, error,
+         event_log_json, cwd
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      row.id,
+      row.agentId ?? "claude",
+      row.acpSessionId ?? "proto-old",
+      row.parentConversationId ?? "conv-1",
+      row.startedAt ?? 1234,
+      row.completedAt === undefined ? 5678 : row.completedAt,
+      row.status ?? "completed",
+      row.stopReason === undefined ? "end_turn" : row.stopReason,
+      row.error ?? null,
+      row.eventLogJson ?? "[]",
+      row.cwd === undefined ? "/tmp/proj" : row.cwd,
+    );
+}
+
+export function readHistoryRow(id: string): HistoryRow | null {
+  return getSqlite()
+    .query(
+      `SELECT id, agent_id, acp_session_id, parent_conversation_id,
+              started_at, completed_at, status, stop_reason, error,
+              event_log_json, cwd
+       FROM acp_session_history WHERE id = ?`,
+    )
+    .get(id) as HistoryRow | null;
+}

package/src/acp/__tests__/helpers/exec-file-stub.ts

@@ -0,0 +1,101 @@
+/**
+ * Shared test helper: stub `execFile` from `node:child_process` for ACP tests.
+ *
+ * Several ACP suites (the `acp_spawn` tool's version probes, the adapter
+ * auto-installer, and the `/v1/acp/spawn` route) shell out via
+ * `execFileWithTimeout`. Each test file used to duplicate the same
+ * `mock.module("node:child_process", ...)` + scripted-responses boilerplate;
+ * this helper consolidates it, mirroring `which-stub.ts`.
+ *
+ * Like the other helpers here, the hook is process-global by design (Bun's
+ * `mock.module` is process-global). Each test file should call
+ * `installExecFileStub()` once at the top level, script calls per test via
+ * `execScripts`, and clear state in `beforeEach` via `reset()`.
+ */
+
+import * as realChildProcess from "node:child_process";
+import { mock } from "bun:test";
+
+type ExecCallback = (
+  err: Error | null,
+  stdout: string | Buffer,
+  stderr: string | Buffer,
+) => void;
+
+export interface ExecScript {
+  /** When set, the call rejects with this error. */
+  error?: Error;
+  /** When set, the call resolves with this stdout. */
+  stdout?: string;
+  /** When set, runs as the call executes (e.g. flip a which-stub flag). */
+  onCall?: () => void;
+}
+
+type ExecFileMock = ReturnType<
+  typeof mock<
+    (
+      command: string,
+      args: string[],
+      options: unknown,
+      callback?: ExecCallback,
+    ) => ReturnType<typeof realChildProcess.execFile>
+  >
+>;
+
+export interface ExecFileStubHandle {
+  /**
+   * Per-call scripted responses, keyed by `${command} ${args[0]}` so tests
+   * can target `npm ls`, `npm view`, and `npm i` independently. Calls with
+   * no script reject with a recognizable "No script for <key>" error.
+   */
+  execScripts: Map<string, ExecScript>;
+  execFileMock: ExecFileMock;
+  /** Clears scripts and recorded calls. Call from `beforeEach`. */
+  reset(): void;
+}
+
+/** Installs a process-global `execFile` mock. Returns handles to drive it. */
+export function installExecFileStub(): ExecFileStubHandle {
+  const execScripts: Map<string, ExecScript> = new Map();
+
+  const execFileMock: ExecFileMock = mock(
+    (
+      command: string,
+      args: string[],
+      _options: unknown,
+      callback?: ExecCallback,
+    ) => {
+      const key = `${command} ${args[0]}`;
+      const script = execScripts.get(key);
+      queueMicrotask(() => {
+        if (!callback) return;
+        if (!script) {
+          callback(new Error(`No script for ${key}`), "", "");
+          return;
+        }
+        script.onCall?.();
+        if (script.error) {
+          callback(script.error, "", "");
+          return;
+        }
+        callback(null, script.stdout ?? "", "");
+      });
+      // Return value is not used by execFileWithTimeout.
+      return {} as ReturnType<typeof realChildProcess.execFile>;
+    },
+  );
+
+  mock.module("node:child_process", () => ({
+    ...realChildProcess,
+    execFile: execFileMock,
+  }));
+
+  return {
+    execScripts,
+    execFileMock,
+    reset(): void {
+      execScripts.clear();
+      execFileMock.mockClear();
+    },
+  };
+}

package/src/acp/__tests__/prepare-agent-env.test.ts

@@ -216,6 +216,22 @@ describe("prepareAgentEnv — claude-agent-acp gating", () => {
     expect(prepared.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe("vault-FFF");
   });
 
+  test("injects the token for the bunx-rewritten claude adapter (adapterCommand gate)", async () => {
+    // The resolver rewrites a missing claude-agent-acp binary to run via
+    // `bun x --bun <pkg>` and preserves the canonical identity on
+    // `adapterCommand`. Without this gate, bunx-resolved spawns would start
+    // with no auth and die as zombies on the first prompt.
+    seedVaultToken("vault-bunx");
+
+    const prepared = await prepareAgentEnv({
+      command: "bun",
+      args: ["x", "--bun", "@agentclientprotocol/claude-agent-acp"],
+      adapterCommand: "claude-agent-acp",
+    });
+
+    expect(prepared.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe("vault-bunx");
+  });
+
   test("does NOT mutate the caller's agentConfig", async () => {
     seedVaultToken("vault-GGG");
     const original = {
@@ -234,6 +250,115 @@ describe("prepareAgentEnv — claude-agent-acp gating", () => {
   });
 });
 
+describe("prepareAgentEnv - gemini gating", () => {
+  function seedVaultGeminiKey(key: string): void {
+    vaultStore.set("acp/gemini_api_key", key);
+  }
+
+  test("injects GEMINI_API_KEY from the vault via the broker when agent.env has no override", async () => {
+    seedVaultGeminiKey("vault-gem-AAA");
+
+    const prepared = await prepareAgentEnv({
+      command: "gemini",
+      args: ["--acp"],
+    });
+
+    expect(prepared.env?.GEMINI_API_KEY).toBe("vault-gem-AAA");
+  });
+
+  test("auto-registers metadata with acp_spawn in allowedTools when none exists", async () => {
+    seedVaultGeminiKey("vault-gem-auto-meta");
+
+    await prepareAgentEnv({ command: "gemini", args: ["--acp"] });
+
+    const meta = metadataStore.get("acp/gemini_api_key");
+    expect(meta).toBeDefined();
+    expect(meta!.allowedTools).toContain("acp_spawn");
+  });
+
+  test("injects the key for the bunx-rewritten gemini CLI (adapterCommand gate)", async () => {
+    seedVaultGeminiKey("vault-gem-bunx");
+
+    const prepared = await prepareAgentEnv({
+      command: "bun",
+      args: ["x", "--bun", "@google/gemini-cli", "--acp"],
+      adapterCommand: "gemini",
+    });
+
+    expect(prepared.env?.GEMINI_API_KEY).toBe("vault-gem-bunx");
+  });
+
+  test("a vault miss does NOT throw and spawns without GEMINI_API_KEY (key is optional)", async () => {
+    const prepared = await prepareAgentEnv({
+      command: "gemini",
+      args: ["--acp"],
+    });
+
+    expect(prepared.env).not.toHaveProperty("GEMINI_API_KEY");
+  });
+
+  test("respects explicit tool policy that excludes acp_spawn without failing the spawn", async () => {
+    metadataStore.set("acp/gemini_api_key", {
+      allowedTools: ["other_tool"],
+    });
+    seedVaultGeminiKey("vault-gem-restricted");
+
+    const prepared = await prepareAgentEnv({
+      command: "gemini",
+      args: ["--acp"],
+    });
+
+    expect(prepared.env).not.toHaveProperty("GEMINI_API_KEY");
+    const meta = metadataStore.get("acp/gemini_api_key");
+    expect(meta!.allowedTools).toEqual(["other_tool"]);
+  });
+
+  test("agent.env override wins over the vault entry and skips the broker (precedence pin)", async () => {
+    // Seed a vault value but no metadata: if the override path consulted the
+    // broker anyway, ensureAcpCredentialPolicy would create metadata here.
+    seedVaultGeminiKey("vault-gem-CCC");
+
+    const prepared = await prepareAgentEnv({
+      command: "gemini",
+      args: ["--acp"],
+      env: { GEMINI_API_KEY: "config-gem-DDD" },
+    });
+
+    expect(prepared.env?.GEMINI_API_KEY).toBe("config-gem-DDD");
+    expect(metadataStore.has("acp/gemini_api_key")).toBe(false);
+  });
+
+  test("preserves unrelated env vars on agent.env when injecting from the vault", async () => {
+    seedVaultGeminiKey("vault-gem-EEE");
+
+    const prepared = await prepareAgentEnv({
+      command: "gemini",
+      args: ["--acp"],
+      env: { NO_COLOR: "1" },
+    });
+
+    expect(prepared.env?.GEMINI_API_KEY).toBe("vault-gem-EEE");
+    expect(prepared.env?.NO_COLOR).toBe("1");
+  });
+
+  test("does NOT mutate the caller's agentConfig", async () => {
+    seedVaultGeminiKey("vault-gem-GGG");
+    const original = {
+      command: "gemini",
+      args: ["--acp"],
+      env: { OTHER: "keep" },
+    };
+    const beforeEnv = { ...original.env };
+
+    const prepared = await prepareAgentEnv(original);
+
+    expect(prepared).not.toBe(original);
+    expect(prepared.env).not.toBe(original.env);
+    expect(original.env).toEqual(beforeEnv);
+    expect(original.env).not.toHaveProperty("GEMINI_API_KEY");
+  });
+});
+
 describe("prepareAgentEnv — non-claude commands", () => {
   test("returns the config unchanged for codex-acp (no required env vars today)", async () => {
     const prepared = await prepareAgentEnv({
@@ -244,6 +369,18 @@ describe("prepareAgentEnv — non-claude commands", () => {
     expect(prepared.env).toEqual({});
   });
 
+  test("no injection for a bunx-rewritten non-claude adapter", async () => {
+    seedVaultToken("vault-should-not-leak");
+
+    const prepared = await prepareAgentEnv({
+      command: "bun",
+      args: ["x", "--bun", "@zed-industries/codex-acp"],
+      adapterCommand: "codex-acp",
+    });
+
+    expect(prepared.env).toEqual({});
+  });
+
   test("returns the config unchanged for an unrecognized command basename", async () => {
     seedVaultToken("vault-HHH");
 

package/src/acp/__tests__/session-manager-persistence.test.ts

@@ -23,35 +23,13 @@ import type { ServerMessage } from "../../daemon/message-protocol.js";
 import type { AcpSessionUpdate } from "../../daemon/message-types/acp.js";
 import { getSqlite } from "../../memory/db-connection.js";
 import { initializeDb } from "../../memory/db-init.js";
+import {
+  clearHistory,
+  insertHistoryRow,
+  readHistoryRow,
+} from "./helpers/acp-history-db.js";
 initializeDb();
 
-function clearHistory() {
-  getSqlite().run("DELETE FROM acp_session_history");
-}
-
-interface HistoryRow {
-  id: string;
-  agent_id: string;
-  acp_session_id: string;
-  parent_conversation_id: string;
-  started_at: number;
-  completed_at: number | null;
-  status: string;
-  stop_reason: string | null;
-  error: string | null;
-  event_log_json: string;
-}
-
-function readHistoryRow(id: string): HistoryRow | null {
-  return getSqlite()
-    .query(
-      `SELECT id, agent_id, acp_session_id, parent_conversation_id,
-              started_at, completed_at, status, stop_reason, error, event_log_json
-       FROM acp_session_history WHERE id = ?`,
-    )
-    .get(id) as HistoryRow | null;
-}
-
 /**
  * Builds a manager with a fake session pre-injected and returns the handles
  * needed to drive terminal transitions in tests.
@@ -61,6 +39,7 @@ function buildSessionWithFakeProcess(opts: {
   agentId: string;
   protocolSessionId: string;
   parentConversationId: string;
+  cwd?: string;
 }): {
   manager: AcpSessionManager;
   resolvePrompt: (v: { stopReason: string }) => void;
@@ -126,7 +105,7 @@ function buildSessionWithFakeProcess(opts: {
     sendToVellum: wrappedSend,
     currentPrompt: null as Promise<unknown> | null,
     parentConversationId: opts.parentConversationId,
-    cwd: "/tmp",
+    cwd: opts.cwd ?? "/tmp",
     command: "claude-agent-acp",
   };
   sessions.set(opts.id, entry);
@@ -345,6 +324,94 @@ describe("AcpSessionManager — terminal persistence", () => {
     expect(row!.event_log_json.length).toBeLessThan(256 * 1024 + 1024);
   });
 
+  test("persists the spawn cwd on terminal transition", async () => {
+    const id = "session-cwd-1";
+    const handles = buildSessionWithFakeProcess({
+      id,
+      agentId: "agent-cwd",
+      protocolSessionId: "proto-cwd",
+      parentConversationId: "conv-cwd",
+      cwd: "/Users/me/projects/widget",
+    });
+
+    handles.resolvePrompt({ stopReason: "end_turn" });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const row = readHistoryRow(id);
+    expect(row).not.toBeNull();
+    expect(row!.cwd).toBe("/Users/me/projects/widget");
+  });
+
+  test("legacy rows without a cwd read back as null", () => {
+    insertHistoryRow({
+      id: "legacy-row-1",
+      agentId: "agent-legacy",
+      acpSessionId: "proto-legacy",
+      parentConversationId: "conv-legacy",
+      startedAt: 1000,
+      completedAt: null,
+      status: "completed",
+      stopReason: null,
+      cwd: null,
+    });
+
+    const row = readHistoryRow("legacy-row-1");
+    expect(row).not.toBeNull();
+    expect(row!.cwd).toBeNull();
+  });
+
+  test("upserts over a pre-existing row with the same id (resumed runs)", async () => {
+    const id = "session-upsert-1";
+    // Simulate the row left behind by the original run that a resumed run
+    // reuses the id of.
+    insertHistoryRow({
+      id,
+      agentId: "agent-up",
+      acpSessionId: "proto-up",
+      parentConversationId: "conv-up",
+      startedAt: 1000,
+      completedAt: 2000,
+      status: "cancelled",
+      stopReason: "daemon_restarted",
+      eventLogJson: '[{"old":true}]',
+      cwd: "/old/cwd",
+    });
+
+    const handles = buildSessionWithFakeProcess({
+      id,
+      agentId: "agent-up",
+      protocolSessionId: "proto-up",
+      parentConversationId: "conv-up",
+      cwd: "/new/cwd",
+    });
+
+    handles.emitUpdate({
+      type: "acp_session_update",
+      acpSessionId: id,
+      updateType: "agent_message_chunk",
+      content: "from the resumed run",
+    });
+
+    handles.resolvePrompt({ stopReason: "end_turn" });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const count = getSqlite()
+      .query(`SELECT COUNT(*) AS n FROM acp_session_history WHERE id = ?`)
+      .get(id) as { n: number };
+    expect(count.n).toBe(1);
+
+    const row = readHistoryRow(id);
+    expect(row).not.toBeNull();
+    expect(row!.status).toBe("completed");
+    expect(row!.stop_reason).toBe("end_turn");
+    expect(row!.cwd).toBe("/new/cwd");
+    const log = JSON.parse(row!.event_log_json) as AcpSessionUpdate[];
+    expect(log).toHaveLength(1);
+    expect(log[0]).toMatchObject({ content: "from the resumed run" });
+  });
+
   test("persists empty event log when no updates were emitted", async () => {
     const id = "session-empty-1";
     const handles = buildSessionWithFakeProcess({