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

package/src/runtime/routes/__tests__/acp-routes.test.ts

@@ -1,13 +1,23 @@
 /**
- * Tests for `GET /v1/acp/sessions`.
+ * Tests for ACP route handlers.
  *
- * The handler merges in-memory `AcpSessionManager.getStatus()` output with
- * persisted `acp_session_history` rows, deduping by id (in-memory wins),
- * filtering by `?conversationId`, sorting newest-first, and truncating to
- * `?limit` (default 50, max 500).
+ * `GET /v1/acp/sessions`: the handler merges in-memory
+ * `AcpSessionManager.getStatus()` output with persisted
+ * `acp_session_history` rows, deduping by id (in-memory wins), filtering by
+ * `?conversationId`, sorting newest-first, and truncating to `?limit`
+ * (default 50, max 500).
+ *
+ * `POST /v1/acp/spawn`: when the adapter binary is missing, the handler
+ * silently auto-installs allowlisted adapter packages before failing with
+ * the install hint. `execFile` is stubbed via the shared
+ * `installExecFileStub` helper so tests can script `npm i -g` outcomes.
  */
 
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { installAcpConfigStub } from "../../../acp/__tests__/helpers/acp-config-stub.js";
+import { installExecFileStub } from "../../../acp/__tests__/helpers/exec-file-stub.js";
+import { installWhichStub } from "../../../acp/__tests__/helpers/which-stub.js";
 
 mock.module("../../../util/logger.js", () => ({
   getLogger: () =>
@@ -16,6 +26,12 @@ mock.module("../../../util/logger.js", () => ({
     }),
 }));
 
+const {
+  execScripts,
+  execFileMock,
+  reset: resetExecFileStub,
+} = installExecFileStub();
+
 // ---------------------------------------------------------------------------
 // Stub the ACP session manager so tests control the in-memory side without
 // spawning real child processes. The route handler imports
@@ -37,64 +53,61 @@ interface FakeSessionState {
 
 let fakeInMemorySessions: FakeSessionState[] = [];
 
+const spawnMock = mock(async () => ({
+  acpSessionId: "acp-route-session",
+  protocolSessionId: "proto-route-session",
+}));
+
+const defaultSteerOrResumeImpl = async (
+  _id: string,
+  _instruction: string,
+): Promise<{ resumed: boolean }> => ({ resumed: false });
+let steerOrResumeImpl: (
+  id: string,
+  instruction: string,
+) => Promise<{ resumed: boolean }> = defaultSteerOrResumeImpl;
+const steerOrResumeMock = mock(
+  (id: string, instruction: string, _send: unknown) =>
+    steerOrResumeImpl(id, instruction),
+);
+
 mock.module("../../../acp/index.js", () => ({
   getAcpSessionManager: () => ({
     getStatus: () => fakeInMemorySessions,
+    spawn: spawnMock,
+    steerOrResume: steerOrResumeMock,
   }),
 }));
 
-import { getSqlite } from "../../../memory/db-connection.js";
+// Identity env-prep: the credential-broker plumbing it wraps is exercised in
+// its own suite; spawn tests here only care about the resolve/install flow.
+mock.module("../../../acp/prepare-agent-env.js", () => ({
+  prepareAgentEnv: async (agentConfig: unknown) => agentConfig,
+}));
+
+const config = await installAcpConfigStub();
+const which = installWhichStub();
+
+import {
+  clearHistory,
+  insertHistoryRow,
+} from "../../../acp/__tests__/helpers/acp-history-db.js";
+import {
+  AcpResumeError,
+  AcpSessionNotFoundError,
+} from "../../../acp/session-manager.js";
 import { initializeDb } from "../../../memory/db-init.js";
-import { ROUTES } from "../acp-routes.js";
+import { FailedDependencyError, NotFoundError } from "../errors.js";
 
-initializeDb();
+const { ROUTES } = await import("../acp-routes.js");
+const { _resetAdapterInstallCacheForTests } =
+  await import("../../../acp/auto-install.js");
 
-function clearHistory(): void {
-  getSqlite().run("DELETE FROM acp_session_history");
-}
+initializeDb();
 
-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;
-}): void {
-  getSqlite()
-    .query(
-      /*sql*/ `
-      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
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `,
-    )
-    .run(
-      row.id,
-      row.agentId,
-      row.acpSessionId,
-      row.parentConversationId,
-      row.startedAt,
-      row.completedAt ?? null,
-      row.status,
-      row.stopReason ?? null,
-      row.error ?? null,
-      row.eventLogJson ?? "[]",
-    );
-}
+afterAll(() => {
+  which.restore();
+});
 
 function getSessionsHandler() {
   const route = ROUTES.find(
@@ -122,6 +135,13 @@ interface ResponseShape {
 beforeEach(() => {
   fakeInMemorySessions = [];
   clearHistory();
+  resetExecFileStub();
+  spawnMock.mockClear();
+  steerOrResumeMock.mockClear();
+  steerOrResumeImpl = defaultSteerOrResumeImpl;
+  _resetAdapterInstallCacheForTests();
+  config.setConfig({});
+  which.setWhich((cmd) => `/usr/local/bin/${cmd}`);
 });
 
 describe("GET /v1/acp/sessions — merged in-memory + history", () => {
@@ -306,7 +326,9 @@ describe("GET /v1/acp/sessions — merged in-memory + history", () => {
     });
 
     const handler = getSessionsHandler();
-    const body = (await handler({ queryParams: { limit: "2" } })) as ResponseShape;
+    const body = (await handler({
+      queryParams: { limit: "2" },
+    })) as ResponseShape;
     expect(body.sessions).toHaveLength(2);
     expect(body.sessions.map((s) => s.id)).toEqual(["live-newest", "hist-mid"]);
   });
@@ -392,3 +414,209 @@ describe("GET /v1/acp/sessions — merged in-memory + history", () => {
     expect(body.sessions).toHaveLength(3);
   });
 });
+
+// ---------------------------------------------------------------------------
+// POST /v1/acp/spawn: auto-install on missing adapter binary
+// ---------------------------------------------------------------------------
+
+function getSpawnHandler() {
+  const route = ROUTES.find(
+    (r) => r.endpoint === "acp/spawn" && r.method === "POST",
+  );
+  if (!route) throw new Error("acp/spawn POST route not found");
+  return route.handler;
+}
+
+const SPAWN_BODY = {
+  agent: "claude",
+  task: "do something",
+  conversationId: "conv-1",
+};
+
+describe("POST /v1/acp/spawn: auto-install on missing binary", () => {
+  test("binary missing + bun present: spawn proceeds via bunx without npm", async () => {
+    which.setWhich({ bun: "/usr/local/bin/bun" });
+
+    const handler = getSpawnHandler();
+    const body = (await handler({ body: SPAWN_BODY })) as Record<
+      string,
+      unknown
+    >;
+
+    expect(body).toEqual({
+      acpSessionId: "acp-route-session",
+      protocolSessionId: "proto-route-session",
+      agent: "claude",
+    });
+    expect(execFileMock).not.toHaveBeenCalled();
+    expect(spawnMock).toHaveBeenCalledTimes(1);
+    const agentConfigArg = (spawnMock.mock.calls[0] as unknown[])[1] as {
+      command: string;
+      args: string[];
+      adapterCommand?: string;
+    };
+    expect(agentConfigArg.command).toBe("bun");
+    expect(agentConfigArg.args).toEqual([
+      "x",
+      "--bun",
+      "@agentclientprotocol/claude-agent-acp",
+    ]);
+    expect(agentConfigArg.adapterCommand).toBe("claude-agent-acp");
+  });
+
+  test("known command: installs the mapped package and spawn proceeds", async () => {
+    // Binary appears on PATH only after `npm i -g` runs, simulating a
+    // successful global install.
+    let binaryOnPath = false;
+    which.setWhich((cmd) => (binaryOnPath ? `/usr/local/bin/${cmd}` : null));
+    execScripts.set("npm i", {
+      stdout: "",
+      onCall: () => {
+        binaryOnPath = true;
+      },
+    });
+
+    const handler = getSpawnHandler();
+    const body = (await handler({ body: SPAWN_BODY })) as Record<
+      string,
+      unknown
+    >;
+
+    expect(body).toEqual({
+      acpSessionId: "acp-route-session",
+      protocolSessionId: "proto-route-session",
+      agent: "claude",
+    });
+    expect(spawnMock).toHaveBeenCalledTimes(1);
+    expect(execFileMock).toHaveBeenCalledTimes(1);
+    expect(execFileMock.mock.calls[0][1]).toEqual([
+      "i",
+      "-g",
+      "@agentclientprotocol/claude-agent-acp",
+    ]);
+  });
+
+  test("npm failure: FailedDependencyError carries hint and failure reason", async () => {
+    which.setWhich({});
+    execScripts.set("npm i", {
+      error: new Error("EACCES: permission denied"),
+    });
+
+    const handler = getSpawnHandler();
+    const promise = handler({ body: SPAWN_BODY });
+    await expect(promise).rejects.toBeInstanceOf(FailedDependencyError);
+    await expect(promise).rejects.toThrow(
+      /claude-agent-acp is not on PATH.*npm i -g @agentclientprotocol\/claude-agent-acp.*auto-install failed.*EACCES/,
+    );
+    expect(spawnMock).not.toHaveBeenCalled();
+  });
+
+  test("unknown command: plain hint maps to FailedDependencyError", async () => {
+    // The allowlist itself (no npm invocation for unmapped commands) is
+    // pinned in auto-install.test.ts and spawn.test.ts; this asserts only
+    // the route's transport mapping of the plain-hint failure.
+    config.setConfig({
+      agents: { custom: { command: "custom-bin", args: [] } },
+    });
+    which.setWhich({});
+
+    const handler = getSpawnHandler();
+    const promise = handler({ body: { ...SPAWN_BODY, agent: "custom" } });
+    await expect(promise).rejects.toBeInstanceOf(FailedDependencyError);
+    await expect(promise).rejects.toThrow(
+      "custom-bin is not on PATH. Install 'custom-bin' and ensure it is on PATH.",
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// POST /v1/acp/:id/steer: transparent resume of sessions not in memory
+// ---------------------------------------------------------------------------
+
+function getSteerHandler() {
+  const route = ROUTES.find(
+    (r) => r.endpoint === "acp/:id/steer" && r.method === "POST",
+  );
+  if (!route) throw new Error("acp/:id/steer POST route not found");
+  return route.handler;
+}
+
+describe("POST /v1/acp/:id/steer: resume fallback", () => {
+  test("in-memory session steers without a resume", async () => {
+    const handler = getSteerHandler();
+    const body = await handler({
+      pathParams: { id: "live-1" },
+      body: { instruction: "redirect" },
+    });
+
+    expect(body).toEqual({ acpSessionId: "live-1", steered: true });
+    expect(steerOrResumeMock).toHaveBeenCalledTimes(1);
+    expect(steerOrResumeMock.mock.calls[0][0]).toBe("live-1");
+    expect(steerOrResumeMock.mock.calls[0][1]).toBe("redirect");
+    expect(typeof steerOrResumeMock.mock.calls[0][2]).toBe("function");
+  });
+
+  test("resumed session reports the resumed flag", async () => {
+    steerOrResumeImpl = async () => ({ resumed: true });
+
+    const handler = getSteerHandler();
+    const body = await handler({
+      pathParams: { id: "gone-1" },
+      body: { instruction: "keep going" },
+    });
+
+    expect(body).toEqual({
+      acpSessionId: "gone-1",
+      steered: true,
+      resumed: true,
+    });
+  });
+
+  test("typed not-found (no session, no history row) maps to NotFoundError", async () => {
+    steerOrResumeImpl = async (id) => {
+      throw new AcpSessionNotFoundError(id);
+    };
+
+    const handler = getSteerHandler();
+    const promise = handler({
+      pathParams: { id: "missing-1" },
+      body: { instruction: "go" },
+    });
+    await expect(promise).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("resume failure surfaces as FailedDependencyError with the actionable hint", async () => {
+    steerOrResumeImpl = async (id) => {
+      throw new AcpResumeError(
+        new Error(
+          `ACP session "${id}" was recorded before resume support ` +
+            `(no working directory persisted) and cannot be resumed. ` +
+            `Spawn a new session instead.`,
+        ),
+      );
+    };
+
+    const handler = getSteerHandler();
+    const promise = handler({
+      pathParams: { id: "legacy-1" },
+      body: { instruction: "go" },
+    });
+    await expect(promise).rejects.toBeInstanceOf(FailedDependencyError);
+    await expect(promise).rejects.toThrow(/recorded before resume support/);
+  });
+
+  test("plain steer errors map to NotFoundError", async () => {
+    steerOrResumeImpl = async (id) => {
+      throw new Error(
+        `ACP session "${id}" is not running (status: initializing)`,
+      );
+    };
+
+    const handler = getSteerHandler();
+    const promise = handler({
+      pathParams: { id: "init-1" },
+      body: { instruction: "go" },
+    });
+    await expect(promise).rejects.toBeInstanceOf(NotFoundError);
+  });
+});

package/src/runtime/routes/__tests__/consolidation-routes.test.ts

@@ -24,7 +24,10 @@
  *     once assistant output exists.
  */
 
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../../../util/logger.js", () => ({
   getLogger: () =>
@@ -33,19 +36,28 @@ mock.module("../../../util/logger.js", () => ({
     }),
 }));
 
+import { invalidateConfigCache } from "../../../config/loader.js";
 import { createConversation } from "../../../memory/conversation-crud.js";
 import { getDb } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
-import { rawRun } from "../../../memory/raw-query.js";
+import { enqueueMemoryJob } from "../../../memory/jobs-store.js";
+import { recordUsageEvent } from "../../../memory/llm-usage-store.js";
+import { rawAll, rawRun } from "../../../memory/raw-query.js";
 import { ROUTES } from "../consolidation-routes.js";
 import type { RouteDefinition } from "../types.js";
 
 initializeDb();
 
+let workspaceDir: string;
+let origWorkspaceDir: string | undefined;
+let configPath: string;
+
 function resetTables(): void {
   const db = getDb();
+  db.run(`DELETE FROM llm_usage_events`);
   db.run(`DELETE FROM messages`);
   db.run(`DELETE FROM conversations`);
+  db.run(`DELETE FROM memory_jobs`);
 }
 
 function findHandler(operationId: string): RouteDefinition["handler"] {
@@ -69,6 +81,59 @@ function insertMessage(
   );
 }
 
+function recordUsageCostAt(
+  conversationId: string,
+  requestId: string,
+  createdAt: number,
+  estimatedCostUsd: number,
+): void {
+  const event = recordUsageEvent(
+    {
+      conversationId,
+      runId: null,
+      requestId,
+      actor: "main_agent",
+      callSite: "mainAgent",
+      inferenceProfile: "balanced",
+      provider: "anthropic",
+      model: "claude-sonnet-4-20250514",
+      inputTokens: 100,
+      outputTokens: 50,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+      rawUsage: null,
+    },
+    { estimatedCostUsd, pricingStatus: "priced" },
+  );
+  rawRun(
+    "UPDATE llm_usage_events SET created_at = ? WHERE id = ?",
+    createdAt,
+    event.id,
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath, "utf-8"));
+}
+
+function readMemoryJobRows(): Array<{
+  id: string;
+  status: string;
+  lastError: string | null;
+  payload: string;
+}> {
+  return rawAll<{
+    id: string;
+    status: string;
+    lastError: string | null;
+    payload: string;
+  }>(`
+    SELECT id, status, last_error AS lastError, payload
+    FROM memory_jobs
+    ORDER BY id
+  `);
+}
+
 interface RunRecord {
   id: string;
   scheduledFor: number;
@@ -79,6 +144,7 @@ interface RunRecord {
   skipReason: string | null;
   error: string | null;
   conversationId: string | null;
+  estimatedCostUsd: number;
   createdAt: number;
 }
 
@@ -88,9 +154,24 @@ interface ListRunsResponse {
 
 describe("listConsolidationRuns handler", () => {
   beforeEach(() => {
+    workspaceDir = mkdtempSync(join(tmpdir(), "vellum-consolidation-routes-"));
+    origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+    process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+    configPath = join(workspaceDir, "config.json");
+    invalidateConfigCache();
     resetTables();
   });
 
+  afterEach(() => {
+    if (origWorkspaceDir === undefined) {
+      delete process.env.VELLUM_WORKSPACE_DIR;
+    } else {
+      process.env.VELLUM_WORKSPACE_DIR = origWorkspaceDir;
+    }
+    invalidateConfigCache();
+    rmSync(workspaceDir, { recursive: true, force: true });
+  });
+
   test("returns only conversations sourced from memory_v2_consolidation", async () => {
     createConversation({ title: "c1", source: "memory_v2_consolidation" });
     createConversation({ title: "h1", source: "heartbeat" });
@@ -138,6 +219,47 @@ describe("listConsolidationRuns handler", () => {
     expect(run.createdAt).toBe(1000);
   });
 
+  test("exposes estimatedCostUsd from the conversation total when available", async () => {
+    const conv = createConversation({
+      title: "c1",
+      source: "memory_v2_consolidation",
+    });
+    rawRun(
+      "UPDATE conversations SET created_at = ?, total_estimated_cost = ? WHERE id = ?",
+      1000,
+      0.42,
+      conv.id,
+    );
+    insertMessage(conv.id, "assistant", 2000);
+    recordUsageCostAt(conv.id, "consolidation-fallback-cost", 1500, 0.99);
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs[0]!.estimatedCostUsd).toBeCloseTo(0.42);
+  });
+
+  test("falls back to conversation-window usage cost when the total is empty", async () => {
+    const conv = createConversation({
+      title: "c1",
+      source: "memory_v2_consolidation",
+    });
+    rawRun(
+      "UPDATE conversations SET created_at = ? WHERE id = ?",
+      1000,
+      conv.id,
+    );
+    insertMessage(conv.id, "assistant", 2000);
+    recordUsageCostAt(conv.id, "consolidation-before", 999, 0.4);
+    recordUsageCostAt(conv.id, "consolidation-inside", 1500, 0.07);
+    recordUsageCostAt(conv.id, "consolidation-after", 2001, 0.5);
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs[0]!.estimatedCostUsd).toBeCloseTo(0.07);
+  });
+
   test("synthesizes status='running' when conversation has no assistant message", async () => {
     createConversation({ title: "c1", source: "memory_v2_consolidation" });
 
@@ -256,3 +378,144 @@ describe("listConsolidationRuns handler", () => {
     expect(bad.runs).toHaveLength(5);
   });
 });
+
+describe("updateConsolidationConfig handler", () => {
+  beforeEach(() => {
+    workspaceDir = mkdtempSync(join(tmpdir(), "vellum-consolidation-routes-"));
+    origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+    process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+    configPath = join(workspaceDir, "config.json");
+    invalidateConfigCache();
+    resetTables();
+  });
+
+  afterEach(() => {
+    if (origWorkspaceDir === undefined) {
+      delete process.env.VELLUM_WORKSPACE_DIR;
+    } else {
+      process.env.VELLUM_WORKSPACE_DIR = origWorkspaceDir;
+    }
+    invalidateConfigCache();
+    rmSync(workspaceDir, { recursive: true, force: true });
+  });
+
+  test("persists only the consolidation enabled override without disabling memory v2", async () => {
+    writeFileSync(
+      configPath,
+      JSON.stringify(
+        {
+          memory: {
+            v2: {
+              enabled: true,
+              consolidation_interval_hours: 4,
+            },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const handler = findHandler("updateConsolidationConfig");
+    const result = (await handler({ body: { enabled: false } })) as {
+      available: boolean;
+      enabled: boolean;
+      intervalMs: number;
+      nextRunAt: number | null;
+      success: boolean;
+    };
+
+    expect(readConfig()).toEqual({
+      memory: {
+        v2: {
+          enabled: true,
+          consolidation_interval_hours: 4,
+          consolidation_enabled: false,
+        },
+      },
+    });
+    expect(result).toMatchObject({
+      available: true,
+      enabled: false,
+      intervalMs: 4 * 60 * 60 * 1000,
+      nextRunAt: null,
+      success: true,
+    });
+  });
+
+  test("disabling automatic consolidation cancels pending automatic jobs but preserves manual run-now jobs", async () => {
+    writeFileSync(
+      configPath,
+      JSON.stringify(
+        {
+          memory: {
+            v2: {
+              enabled: true,
+              consolidation_enabled: true,
+            },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    const automaticJobId = enqueueMemoryJob("memory_v2_consolidate", {
+      trigger: "automatic",
+    });
+    const legacyJobId = enqueueMemoryJob("memory_v2_consolidate", {});
+    const manualJobId = enqueueMemoryJob("memory_v2_consolidate", {
+      trigger: "manual",
+    });
+
+    const handler = findHandler("updateConsolidationConfig");
+    await handler({ body: { enabled: false } });
+
+    const rowsById = new Map(
+      readMemoryJobRows().map((row) => [row.id, row] as const),
+    );
+    expect(rowsById.get(automaticJobId)).toMatchObject({
+      status: "failed",
+      lastError: "automatic_consolidation_disabled",
+    });
+    expect(rowsById.get(legacyJobId)).toMatchObject({
+      status: "failed",
+      lastError: "automatic_consolidation_disabled",
+    });
+    expect(rowsById.get(manualJobId)).toMatchObject({
+      status: "pending",
+      lastError: null,
+      payload: JSON.stringify({ trigger: "manual" }),
+    });
+  });
+
+  test("run-now remains available when automatic consolidation is disabled", async () => {
+    writeFileSync(
+      configPath,
+      JSON.stringify(
+        {
+          memory: {
+            v2: {
+              enabled: true,
+              consolidation_enabled: false,
+            },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const handler = findHandler("runConsolidationNow");
+    const result = (await handler({})) as {
+      success: boolean;
+      ran: boolean;
+      jobId: string | null;
+    };
+
+    expect(result.success).toBe(true);
+    expect(result.ran).toBe(true);
+    expect(result.jobId).toBeString();
+    const row = readMemoryJobRows().find((job) => job.id === result.jobId);
+    expect(row?.payload).toBe(JSON.stringify({ trigger: "manual" }));
+  });
+});