@vellumai/assistant 0.8.7-dev.202606052232.2ddc989 → 0.8.8

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

@@ -23,13 +23,35 @@ 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.
@@ -39,7 +61,6 @@ function buildSessionWithFakeProcess(opts: {
   agentId: string;
   protocolSessionId: string;
   parentConversationId: string;
-  cwd?: string;
 }): {
   manager: AcpSessionManager;
   resolvePrompt: (v: { stopReason: string }) => void;
@@ -105,7 +126,7 @@ function buildSessionWithFakeProcess(opts: {
     sendToVellum: wrappedSend,
     currentPrompt: null as Promise<unknown> | null,
     parentConversationId: opts.parentConversationId,
-    cwd: opts.cwd ?? "/tmp",
+    cwd: "/tmp",
     command: "claude-agent-acp",
   };
   sessions.set(opts.id, entry);
@@ -324,94 +345,6 @@ 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({

package/src/acp/agent-process.ts

@@ -34,7 +34,6 @@ export type AcpClientFactory = (agent: Agent) => Client;
 export class AcpAgentProcess {
   private proc: ChildProcess | null = null;
   private connection: acp.ClientSideConnection | null = null;
-  private initializeResponse: InitializeResponse | null = null;
 
   constructor(
     public readonly agentId: string,
@@ -100,7 +99,7 @@ export class AcpAgentProcess {
 
     log.info({ agentId: this.agentId }, "Initializing ACP connection");
 
-    const response = await this.connection.initialize({
+    return this.connection.initialize({
       protocolVersion: acp.PROTOCOL_VERSION,
       clientInfo: { name: "vellum", version: "1.0.0" },
       clientCapabilities: {
@@ -108,28 +107,6 @@ export class AcpAgentProcess {
         terminal: true,
       },
     });
-
-    this.initializeResponse = response;
-    return response;
-  }
-
-  /**
-   * Whether the agent advertised support for `session/load` at initialize.
-   * Returns false before initialize() resolves.
-   */
-  get supportsLoadSession(): boolean {
-    return this.initializeResponse?.agentCapabilities?.loadSession === true;
-  }
-
-  /**
-   * Whether the agent advertised support for `session/resume` at initialize.
-   * Returns false before initialize() resolves.
-   */
-  get supportsSessionResume(): boolean {
-    return (
-      this.initializeResponse?.agentCapabilities?.sessionCapabilities?.resume !=
-      null
-    );
   }
 
   /**
@@ -151,41 +128,6 @@ export class AcpAgentProcess {
     return result.sessionId;
   }
 
-  /**
-   * Loads a previously persisted ACP session via `session/load`.
-   *
-   * Per the ACP spec, the agent replays the session's conversation history
-   * as `session/update` notifications before the load response resolves;
-   * callers should suppress forwarding of those replayed updates (see
-   * VellumAcpClientHandler.beginReplaySuppression).
-   */
-  async loadSession(sessionId: string, cwd: string): Promise<void> {
-    if (!this.connection) {
-      throw new Error(`ACP agent "${this.agentId}" is not spawned`);
-    }
-
-    log.info({ agentId: this.agentId, sessionId, cwd }, "Loading ACP session");
-
-    await this.connection.loadSession({ sessionId, cwd, mcpServers: [] });
-  }
-
-  /**
-   * Resumes a previously persisted ACP session via `session/resume`.
-   *
-   * Unlike `session/load`, resume performs no history replay, so it is
-   * preferred when the agent advertises the capability
-   * (see supportsSessionResume).
-   */
-  async resumeSession(sessionId: string, cwd: string): Promise<void> {
-    if (!this.connection) {
-      throw new Error(`ACP agent "${this.agentId}" is not spawned`);
-    }
-
-    log.info({ agentId: this.agentId, sessionId, cwd }, "Resuming ACP session");
-
-    await this.connection.resumeSession({ sessionId, cwd, mcpServers: [] });
-  }
-
   /**
    * Sends a prompt to an existing ACP session.
    * Returns the prompt response (includes stopReason).
@@ -233,7 +175,6 @@ export class AcpAgentProcess {
       this.proc = null;
     }
     this.connection = null;
-    this.initializeResponse = null;
   }
 
   /**
@@ -264,6 +205,5 @@ export class AcpAgentProcess {
 
     this.proc = null;
     this.connection = null;
-    this.initializeResponse = null;
   }
 }

package/src/acp/client-handler.ts

@@ -51,7 +51,6 @@ interface TerminalState {
 export class VellumAcpClientHandler implements Client {
   private terminals = new Map<string, TerminalState>();
   private accumulatedText = "";
-  private suppressForwarding = false;
   /** Tracks pending ACP permission requestIds for cleanup on session close. */
   readonly pendingRequestIds = new Set<string>();
 
@@ -66,38 +65,8 @@ export class VellumAcpClientHandler implements Client {
     private readonly parentConversationId: string,
   ) {}
 
-  /**
-   * Begins suppressing session updates from being forwarded to Vellum.
-   *
-   * Per the ACP spec, `session/load` replays the entire conversation history
-   * as `session/update` notifications before the load response resolves. The
-   * parent conversation already received those events during the original
-   * run, so re-forwarding them would duplicate them into the conversation and
-   * the ring buffer. Callers wrap `loadSession` in
-   * beginReplaySuppression()/endReplaySuppression() to drop the replay.
-   * `session/resume` performs no replay, which is why it is preferred when
-   * the agent supports it.
-   */
-  beginReplaySuppression(): void {
-    this.suppressForwarding = true;
-  }
-
-  /** Ends replay suppression; subsequent updates flow normally. */
-  endReplaySuppression(): void {
-    this.suppressForwarding = false;
-  }
-
   async sessionUpdate(params: SessionNotification): Promise<void> {
     const update = params.update;
-
-    if (this.suppressForwarding) {
-      log.debug(
-        { acpSessionId: this.acpSessionId, updateType: update.sessionUpdate },
-        "Dropping replayed session update during suppression",
-      );
-      return;
-    }
-
     log.debug(
       { acpSessionId: this.acpSessionId, updateType: update.sessionUpdate },
       "ACP session update received",

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

@@ -20,91 +20,56 @@
  * owns the plaintext read boundary.
  */
 
+import { basename } from "node:path";
+
 import { FailedDependencyError } from "../runtime/routes/errors.js";
 import { credentialBroker } from "../tools/credentials/broker.js";
 import {
   getCredentialMetadata,
   upsertCredentialMetadata,
 } from "../tools/credentials/metadata-store.js";
-import { getLogger } from "../util/logger.js";
-import { adapterCommandOf } from "./resolve-agent.js";
 import type { AcpAgentConfig } from "./types.js";
 
-const log = getLogger("acp:prepare-agent-env");
-
 const ACP_SPAWN_TOOL = "acp_spawn";
-const ACP_SERVICE = "acp";
 
 /**
- * Ensure an `acp/<field>` credential has metadata that allows the
- * `acp_spawn` tool to read it, but only for legacy/unmanaged cases:
+ * Ensure the `acp/claude_oauth_token` credential has metadata that allows
+ * the `acp_spawn` tool to read it, but only for legacy/unmanaged cases:
  *
- * - No metadata at all: create with `allowedTools: ["acp_spawn"]`.
- * - Metadata exists with an empty `allowedTools`: default provisioning
+ * - No metadata at all → create with `allowedTools: ["acp_spawn"]`.
+ * - Metadata exists with an empty `allowedTools` → default provisioning
  *   path (user ran `credentials set` without `--allowed-tools`), add it.
- * - Metadata exists with a non-empty `allowedTools`: explicit policy set
- *   by the user/admin. Respect it even if `acp_spawn` is absent; the
- *   broker will deny the read and the caller decides whether that's fatal.
+ * - Metadata exists with a non-empty `allowedTools` → explicit policy set
+ *   by the user/admin. Respect it even if `acp_spawn` is absent — the
+ *   broker will deny the read and the preflight will throw.
  */
-function ensureAcpCredentialPolicy(
-  field: string,
-  usageDescription: string,
-): void {
-  const meta = getCredentialMetadata(ACP_SERVICE, field);
+function ensureAcpTokenPolicy(): void {
+  const meta = getCredentialMetadata("acp", "claude_oauth_token");
   if (!meta) {
-    upsertCredentialMetadata(ACP_SERVICE, field, {
+    upsertCredentialMetadata("acp", "claude_oauth_token", {
       allowedTools: [ACP_SPAWN_TOOL],
-      usageDescription,
+      usageDescription:
+        "Claude OAuth token for ACP agent authentication",
     });
     return;
   }
   const tools = meta.allowedTools ?? [];
   if (tools.length === 0) {
-    upsertCredentialMetadata(ACP_SERVICE, field, {
+    upsertCredentialMetadata("acp", "claude_oauth_token", {
       allowedTools: [ACP_SPAWN_TOOL],
     });
   }
 }
 
-/**
- * Read an `acp/<field>` credential through the broker and inject it into
- * `env` under `envVar`. Returns the broker's failure reason when the value
- * was not injected (missing credential, denied policy, no stored value),
- * or undefined on success. Never throws: `serverUse` signals every failure
- * mode, including a simply-absent credential, as `{ success: false,
- * reason }`, so callers choose whether a miss is fatal.
- */
-async function injectCredential(
-  env: Record<string, string>,
-  field: string,
-  envVar: string,
-  usageDescription: string,
-): Promise<string | undefined> {
-  ensureAcpCredentialPolicy(field, usageDescription);
-  const result = await credentialBroker.serverUse<void>({
-    service: ACP_SERVICE,
-    field,
-    toolName: ACP_SPAWN_TOOL,
-    execute: async (value) => {
-      env[envVar] = value;
-    },
-  });
-  return result.success ? undefined : result.reason;
-}
-
 /**
  * Returns a NEW config with any required credentials merged into `env`.
  * Does NOT mutate the input. Throws `FailedDependencyError` if a required
  * credential is missing from both the user-supplied env override and the
  * secure store.
  *
- * Gating is keyed off the canonical adapter identity (`adapterCommand` set
- * by the resolver, falling back to the command basename for plain configs),
- * not the user-facing agent id. A custom `acp.agents.my-claude = { command:
- * "claude-agent-acp", ... }` alias still gets the env it needs, and so does
- * the bunx-rewritten claude adapter (whose `command` is "bun"). Without
- * the adapterCommand gate, bunx-resolved spawns would start with no auth
- * and die as zombies on the first prompt.
+ * Gating is keyed off the resolved agent COMMAND (basename), not the
+ * user-facing agent id, so a custom `acp.agents.my-claude = { command:
+ * "claude-agent-acp", ... }` alias still gets the env it needs.
  *
  * For `claude-agent-acp` the only required env var is
  * `CLAUDE_CODE_OAUTH_TOKEN`. Two provisioning routes converge on it, with
@@ -119,11 +84,6 @@ async function injectCredential(
  * before spawning. The "fail-fast" throw is symmetric with the existing
  * `binary_not_found` preflight in `resolveAcpAgent` and strictly better
  * than a `warn` + zombie subprocess 10 seconds later.
- *
- * For `gemini` the env var is `GEMINI_API_KEY`, provisioned the same two
- * ways (config.json override wins, vault field `gemini_api_key` second),
- * but it is OPTIONAL: the Gemini CLI supports its own OAuth login, so a
- * vault miss proceeds without the key instead of failing the spawn.
  */
 export async function prepareAgentEnv(
   agentConfig: AcpAgentConfig,
@@ -132,16 +92,19 @@ export async function prepareAgentEnv(
   // agent reference. The local `env` binding sidesteps TS narrowing
   // limitations on the optional `AcpAgentConfig.env` field.
   const env: Record<string, string> = { ...(agentConfig.env ?? {}) };
-  const adapterCommand = adapterCommandOf(agentConfig);
+  const commandBasename = basename(agentConfig.command);
 
-  if (adapterCommand === "claude-agent-acp") {
+  if (commandBasename === "claude-agent-acp") {
     if (!env.CLAUDE_CODE_OAUTH_TOKEN) {
-      await injectCredential(
-        env,
-        "claude_oauth_token",
-        "CLAUDE_CODE_OAUTH_TOKEN",
-        "Claude OAuth token for ACP agent authentication",
-      );
+      ensureAcpTokenPolicy();
+      await credentialBroker.serverUse<void>({
+        service: "acp",
+        field: "claude_oauth_token",
+        toolName: ACP_SPAWN_TOOL,
+        execute: async (token) => {
+          env.CLAUDE_CODE_OAUTH_TOKEN = token;
+        },
+      });
     }
     if (!env.CLAUDE_CODE_OAUTH_TOKEN) {
       throw new FailedDependencyError(
@@ -150,23 +113,6 @@ export async function prepareAgentEnv(
           "(or set it under acp.agents.<id>.env in config.json).",
       );
     }
-  } else if (adapterCommand === "gemini") {
-    if (!env.GEMINI_API_KEY) {
-      const missReason = await injectCredential(
-        env,
-        "gemini_api_key",
-        "GEMINI_API_KEY",
-        "Gemini API key for ACP agent authentication",
-      );
-      if (missReason !== undefined) {
-        // Optional credential: Gemini CLI can authenticate via its own
-        // OAuth login, so a vault miss must not fail the spawn.
-        log.debug(
-          { reason: missReason },
-          "Gemini API key unavailable from the vault; spawning without GEMINI_API_KEY",
-        );
-      }
-    }
   }
 
   return { ...agentConfig, env };