@vellumai/assistant 0.8.0 → 0.8.2

package/src/runtime/routes/__tests__/surface-action-routes.test.ts

@@ -0,0 +1,384 @@
+/**
+ * Tests for surface-action route handlers.
+ *
+ * Focus is the rehydrate-on-miss path: after daemon restart or LRU eviction,
+ * the in-memory conversation map is empty even though the surface still
+ * persists as a `ui_surface` content block in the messages table. The handler
+ * must fall back to a DB scan, then call `getOrCreateConversation` so the
+ * action dispatches against a live conversation with restored `surfaceState`.
+ *
+ * Strategy: mock `conversation-store` and `raw-query` at module boundaries,
+ * import ROUTES afterwards, find each handler by operationId, and exercise.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+interface StubConversation {
+  id: string;
+  handleSurfaceActionResult?:
+    | { accepted: true; conversationId?: string }
+    | { accepted: false; error: string };
+  handleSurfaceActionThrows?: Error;
+  handleSurfaceUndoCalled?: boolean;
+  handleSurfaceUndoThrows?: Error;
+  surfaceActionCalls: Array<{
+    surfaceId: string;
+    actionId: string;
+    data: unknown;
+  }>;
+}
+
+let memoryById: StubConversation | null = null;
+let memoryBySurface: StubConversation | null = null;
+let rehydrated: StubConversation | null = null;
+let rawGetReturn: { conversation_id: string } | null = null;
+
+const findConvCalls: string[] = [];
+const findBySurfaceCalls: string[] = [];
+const getOrCreateCalls: string[] = [];
+const rawGetCalls: Array<{ sql: string; params: unknown[] }> = [];
+
+mock.module("../../../daemon/conversation-store.js", () => ({
+  findConversation: (id: string) => {
+    findConvCalls.push(id);
+    return memoryById ?? undefined;
+  },
+  findConversationBySurfaceId: (surfaceId: string) => {
+    findBySurfaceCalls.push(surfaceId);
+    return memoryBySurface ?? undefined;
+  },
+  getOrCreateConversation: async (id: string) => {
+    getOrCreateCalls.push(id);
+    if (!rehydrated) {
+      throw new Error(
+        `getOrCreateConversation(${id}) called but no rehydrated stub configured`,
+      );
+    }
+    return rehydrated;
+  },
+}));
+
+mock.module("../../../memory/raw-query.js", () => ({
+  rawGet: (sql: string, ...params: unknown[]) => {
+    rawGetCalls.push({ sql, params });
+    return rawGetReturn;
+  },
+}));
+
+// Defer route import until after mocks are installed.
+const { ROUTES } = await import("../surface-action-routes.js");
+const { NotFoundError } = await import("../errors.js");
+import type { RouteDefinition } from "../types.js";
+
+function findHandler(operationId: string): RouteDefinition["handler"] {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+function makeStub(id: string): StubConversation {
+  const stub: StubConversation = {
+    id,
+    handleSurfaceActionResult: { accepted: true },
+    surfaceActionCalls: [],
+  };
+  // Methods reference `stub` so handler invocations land on the same object.
+  Object.assign(stub, {
+    handleSurfaceAction: async (
+      surfaceId: string,
+      actionId: string,
+      data: unknown,
+    ) => {
+      stub.surfaceActionCalls.push({ surfaceId, actionId, data });
+      if (stub.handleSurfaceActionThrows) throw stub.handleSurfaceActionThrows;
+      return stub.handleSurfaceActionResult;
+    },
+    handleSurfaceUndo: (_surfaceId: string) => {
+      stub.handleSurfaceUndoCalled = true;
+      if (stub.handleSurfaceUndoThrows) throw stub.handleSurfaceUndoThrows;
+    },
+  });
+  return stub;
+}
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  memoryById = null;
+  memoryBySurface = null;
+  rehydrated = null;
+  rawGetReturn = null;
+  findConvCalls.length = 0;
+  findBySurfaceCalls.length = 0;
+  getOrCreateCalls.length = 0;
+  rawGetCalls.length = 0;
+});
+
+// ---------------------------------------------------------------------------
+// triggerSurfaceAction
+// ---------------------------------------------------------------------------
+
+describe("triggerSurfaceAction handler", () => {
+  test("dispatches against live in-memory conversation when found by surfaceId", async () => {
+    const live = makeStub("conv-live");
+    memoryBySurface = live;
+
+    const handler = findHandler("triggerSurfaceAction");
+    const result = await handler({
+      body: { surfaceId: "surf-1", actionId: "act-1" },
+    });
+
+    expect(result).toEqual({ ok: true });
+    expect(findBySurfaceCalls).toEqual(["surf-1"]);
+    expect(findConvCalls).toEqual([]);
+    expect(rawGetCalls).toEqual([]);
+    expect(getOrCreateCalls).toEqual([]);
+    expect(live.surfaceActionCalls).toEqual([
+      { surfaceId: "surf-1", actionId: "act-1", data: undefined },
+    ]);
+  });
+
+  test("uses caller-supplied conversationId for in-memory hit", async () => {
+    const live = makeStub("conv-explicit");
+    memoryById = live;
+
+    const handler = findHandler("triggerSurfaceAction");
+    await handler({
+      body: {
+        conversationId: "conv-explicit",
+        surfaceId: "surf-2",
+        actionId: "act-2",
+        data: { foo: "bar" },
+      },
+    });
+
+    expect(findConvCalls).toEqual(["conv-explicit"]);
+    expect(findBySurfaceCalls).toEqual([]);
+    expect(rawGetCalls).toEqual([]);
+    expect(getOrCreateCalls).toEqual([]);
+    expect(live.surfaceActionCalls).toEqual([
+      { surfaceId: "surf-2", actionId: "act-2", data: { foo: "bar" } },
+    ]);
+  });
+
+  test("rehydrates via DB fallback when in-memory lookup misses", async () => {
+    rawGetReturn = { conversation_id: "conv-from-db" };
+    rehydrated = makeStub("conv-from-db");
+
+    const handler = findHandler("triggerSurfaceAction");
+    const result = await handler({
+      body: { surfaceId: "surf-evicted", actionId: "act-3" },
+    });
+
+    expect(result).toEqual({ ok: true });
+    expect(findBySurfaceCalls).toEqual(["surf-evicted"]);
+    expect(findConvCalls).toEqual([]);
+    expect(rawGetCalls).toHaveLength(1);
+    // SQL must filter the messages table by ui_surface payload pattern.
+    expect(rawGetCalls[0]!.sql).toContain("FROM messages");
+    expect(rawGetCalls[0]!.sql).toContain("LIKE");
+    expect(rawGetCalls[0]!.params).toEqual([
+      `%"surfaceId":"surf-evicted"%`,
+    ]);
+    expect(getOrCreateCalls).toEqual(["conv-from-db"]);
+    expect(rehydrated.surfaceActionCalls).toEqual([
+      { surfaceId: "surf-evicted", actionId: "act-3", data: undefined },
+    ]);
+  });
+
+  test("rehydrates with caller-supplied conversationId after validating DB row", async () => {
+    rawGetReturn = { conversation_id: "conv-caller" };
+    rehydrated = makeStub("conv-caller");
+
+    const handler = findHandler("triggerSurfaceAction");
+    await handler({
+      body: {
+        conversationId: "conv-caller",
+        surfaceId: "surf-caller",
+        actionId: "act-4",
+      },
+    });
+
+    expect(findConvCalls).toEqual(["conv-caller"]);
+    expect(findBySurfaceCalls).toEqual([]);
+    // DB scan validates the surface actually exists before rehydrating.
+    expect(rawGetCalls).toHaveLength(1);
+    expect(getOrCreateCalls).toEqual(["conv-caller"]);
+    expect(rehydrated.surfaceActionCalls).toEqual([
+      { surfaceId: "surf-caller", actionId: "act-4", data: undefined },
+    ]);
+  });
+
+  test("returns 404 when surface is not in memory and not in DB", async () => {
+    const handler = findHandler("triggerSurfaceAction");
+
+    let caught: unknown;
+    try {
+      await handler({
+        body: { surfaceId: "surf-ghost", actionId: "act-5" },
+      });
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(NotFoundError);
+    expect(rawGetCalls).toHaveLength(1);
+    // No phantom conversation created.
+    expect(getOrCreateCalls).toEqual([]);
+  });
+
+  test("returns 404 when caller-supplied conversationId has no matching surface in DB", async () => {
+    // rawGetReturn stays null → DB has no row for this surface, so we
+    // refuse to rehydrate even though the caller named a conversation.
+    const handler = findHandler("triggerSurfaceAction");
+
+    let caught: unknown;
+    try {
+      await handler({
+        body: {
+          conversationId: "conv-deleted",
+          surfaceId: "surf-x",
+          actionId: "act-x",
+        },
+      });
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(NotFoundError);
+    // Crucially, we did NOT call getOrCreateConversation — the previous
+    // version would have created a phantom empty conversation here.
+    expect(getOrCreateCalls).toEqual([]);
+  });
+
+  test("returns 404 when caller-supplied conversationId mismatches the DB row", async () => {
+    // Surface exists in conv-real, but caller asserts conv-other.
+    rawGetReturn = { conversation_id: "conv-real" };
+    const handler = findHandler("triggerSurfaceAction");
+
+    let caught: unknown;
+    try {
+      await handler({
+        body: {
+          conversationId: "conv-other",
+          surfaceId: "surf-shared",
+          actionId: "act-x",
+        },
+      });
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(NotFoundError);
+    expect(getOrCreateCalls).toEqual([]);
+  });
+
+  test("escapes LIKE wildcards in surfaceId", async () => {
+    // A request with `surfaceId: "%"` must not match unrelated rows. We
+    // assert the SQL uses ESCAPE and the bound parameter has the wildcard
+    // backslash-escaped.
+    const handler = findHandler("triggerSurfaceAction");
+
+    try {
+      await handler({
+        body: { surfaceId: "%", actionId: "act-evil" },
+      });
+    } catch {
+      /* expected NotFoundError, we only care about the SQL */
+    }
+
+    expect(rawGetCalls).toHaveLength(1);
+    expect(rawGetCalls[0]!.sql).toContain("ESCAPE");
+    expect(rawGetCalls[0]!.params).toEqual([`%"surfaceId":"\\%"%`]);
+  });
+
+  test("propagates accepted=false rejection as BadRequestError", async () => {
+    const live = makeStub("conv-reject");
+    live.handleSurfaceActionResult = {
+      accepted: false,
+      error: "surface already completed",
+    };
+    memoryBySurface = live;
+
+    const handler = findHandler("triggerSurfaceAction");
+
+    let caught: unknown;
+    try {
+      await handler({
+        body: { surfaceId: "surf-done", actionId: "act-y" },
+      });
+    } catch (err) {
+      caught = err;
+    }
+
+    // BadRequestError is a RouteError — verify the error message bubbled.
+    expect(caught).toBeDefined();
+    expect((caught as Error).message).toContain("surface already completed");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// undoSurfaceAction
+// ---------------------------------------------------------------------------
+
+describe("undoSurfaceAction handler", () => {
+  test("dispatches against live in-memory conversation", async () => {
+    const live = makeStub("conv-undo-live");
+    memoryById = live;
+
+    const handler = findHandler("undoSurfaceAction");
+    const result = await handler({
+      body: { conversationId: "conv-undo-live" },
+      pathParams: { id: "surf-undo-1" },
+    });
+
+    expect(result).toEqual({ ok: true });
+    expect(findConvCalls).toEqual(["conv-undo-live"]);
+    expect(rawGetCalls).toEqual([]);
+    expect(getOrCreateCalls).toEqual([]);
+    expect(live.handleSurfaceUndoCalled).toBe(true);
+  });
+
+  test("rehydrates via DB fallback when conversation evicted", async () => {
+    rawGetReturn = { conversation_id: "conv-undo-from-db" };
+    rehydrated = makeStub("conv-undo-from-db");
+
+    const handler = findHandler("undoSurfaceAction");
+    const result = await handler({
+      body: {},
+      pathParams: { id: "surf-undo-evicted" },
+    });
+
+    expect(result).toEqual({ ok: true });
+    expect(findBySurfaceCalls).toEqual(["surf-undo-evicted"]);
+    expect(rawGetCalls).toHaveLength(1);
+    expect(rawGetCalls[0]!.params).toEqual([
+      `%"surfaceId":"surf-undo-evicted"%`,
+    ]);
+    expect(getOrCreateCalls).toEqual(["conv-undo-from-db"]);
+    expect(rehydrated.handleSurfaceUndoCalled).toBe(true);
+  });
+
+  test("returns 404 when surface cannot be located", async () => {
+    const handler = findHandler("undoSurfaceAction");
+
+    let caught: unknown;
+    try {
+      await handler({
+        body: {},
+        pathParams: { id: "surf-undo-ghost" },
+      });
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(NotFoundError);
+    expect(getOrCreateCalls).toEqual([]);
+  });
+});

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

@@ -94,7 +94,7 @@ mock.module("../../../tts/synthesize-text.js", () => ({
 // ---------------------------------------------------------------------------
 
 import { RouteError } from "../errors.js";
-import { ROUTES } from "../tts-routes.js";
+import { formatTtsFailureMessage, ROUTES } from "../tts-routes.js";
 import type { RouteHandlerArgs } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -164,8 +164,8 @@ afterEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("tts-routes", () => {
-  test("exports route definitions for messages/:messageId/tts and tts/synthesize", () => {
-    expect(ROUTES).toHaveLength(2);
+  test("exports route definitions for messages/:messageId/tts, tts/synthesize, and tts/synthesize-cli", () => {
+    expect(ROUTES).toHaveLength(3);
 
     const msgTts = getRoute("messages/:messageId/tts");
     expect(msgTts.method).toBe("POST");
@@ -174,6 +174,10 @@ describe("tts-routes", () => {
     const synthesize = getRoute("tts/synthesize");
     expect(synthesize.method).toBe("POST");
     expect(synthesize.policyKey).toBe("tts/synthesize");
+
+    const synthesizeCli = getRoute("tts/synthesize-cli");
+    expect(synthesizeCli.method).toBe("POST");
+    expect(synthesizeCli.policyKey).toBe("tts/synthesize-cli");
   });
 
   // -- Feature flag gating --------------------------------------------------
@@ -282,6 +286,69 @@ describe("tts-routes", () => {
       "BAD_GATEWAY",
     );
   });
+
+  test("propagates the underlying error message into the 502 response", async () => {
+    // Mimics what `synthesize-text.ts` re-throws when an ElevenLabs adapter
+    // raises ELEVENLABS_TTS_HTTP_ERROR with a parsed upstream message.
+    mockSynthesizeError = new MockTtsSynthesisError(
+      "TTS_SYNTHESIS_FAILED",
+      "TTS synthesis failed (provider: elevenlabs): Free users cannot use library voices via the API. Please upgrade your subscription to use this voice.",
+    );
+
+    const { handler } = getRoute("messages/:messageId/tts");
+    const err = await expectRouteError(
+      () => handler(makeMessageTtsArgs()),
+      502,
+      "BAD_GATEWAY",
+    );
+    expect(err.message).toContain("Free users cannot use library voices");
+    expect(err.message).toContain("Please upgrade your subscription");
+    // No double-prefix — message stays as the inner self-describing form.
+    expect(err.message.startsWith("TTS synthesis failed")).toBe(true);
+    expect(
+      err.message.startsWith("TTS synthesis failed: TTS synthesis failed"),
+    ).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests — formatTtsFailureMessage
+// ---------------------------------------------------------------------------
+
+describe("formatTtsFailureMessage", () => {
+  test("returns the base message when given a non-Error value", () => {
+    expect(formatTtsFailureMessage(undefined)).toBe("TTS synthesis failed");
+    expect(formatTtsFailureMessage(null)).toBe("TTS synthesis failed");
+    expect(formatTtsFailureMessage("oops")).toBe("TTS synthesis failed");
+  });
+
+  test("returns the base message when the error has no message text", () => {
+    const err = new Error("");
+    expect(formatTtsFailureMessage(err)).toBe("TTS synthesis failed");
+  });
+
+  test("prefixes raw provider error messages with the base", () => {
+    const err = new Error("Voice not found");
+    expect(formatTtsFailureMessage(err)).toBe(
+      "TTS synthesis failed: Voice not found",
+    );
+  });
+
+  test("passes pre-prefixed messages through verbatim (no double-prefix)", () => {
+    const err = new Error(
+      "TTS synthesis failed (provider: elevenlabs): Free users cannot use library voices via the API.",
+    );
+    expect(formatTtsFailureMessage(err)).toBe(
+      "TTS synthesis failed (provider: elevenlabs): Free users cannot use library voices via the API.",
+    );
+  });
+
+  test("trims surrounding whitespace from messages", () => {
+    const err = new Error("   Quota exceeded   ");
+    expect(formatTtsFailureMessage(err)).toBe(
+      "TTS synthesis failed: Quota exceeded",
+    );
+  });
 });
 
 // ---------------------------------------------------------------------------

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

@@ -0,0 +1,143 @@
+/**
+ * Tests for the GET /v1/acp/sessions list handler — specifically the SQL
+ * pad amount applied to acp_session_history when in-memory sessions are
+ * also present. We mock the DB layer so the limit value passed to the
+ * query builder can be asserted directly.
+ *
+ * Regression for codex P2 feedback on PR #29993: padding by the global
+ * inMemory.length over-fetched when many unrelated sessions were live
+ * but only one conversation was being queried.
+ */
+
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+import type { AcpSessionState } from "../../acp/index.js";
+
+const inMemoryStates = new Map<string, AcpSessionState>();
+
+mock.module("../../acp/index.js", () => ({
+  getAcpSessionManager: () => ({
+    getStatus: (id?: string) => {
+      if (id === undefined) return Array.from(inMemoryStates.values());
+      const state = inMemoryStates.get(id);
+      if (!state) throw new Error(`ACP session "${id}" not found`);
+      return state;
+    },
+  }),
+}));
+
+// Spy on the drizzle limit() call to assert the exact value the handler
+// passes to SQL. The stub mirrors only the chained methods used by
+// listMergedSessions; calls fall through to a final `.all()` returning [].
+const capturedLimits: number[] = [];
+
+mock.module("../../memory/db-connection.js", () => {
+  const builder: any = {};
+  builder.select = () => builder;
+  builder.from = () => builder;
+  builder.where = () => builder;
+  builder.orderBy = () => builder;
+  builder.limit = (n: number) => {
+    capturedLimits.push(n);
+    return builder;
+  };
+  builder.all = () => [];
+  return {
+    getDb: () => builder,
+  };
+});
+
+const { ROUTES } = await import("./acp-routes.js");
+
+function getListHandler() {
+  const route = ROUTES.find(
+    (r: { endpoint: string; method: string }) =>
+      r.endpoint === "acp/sessions" && r.method === "GET",
+  );
+  if (!route) throw new Error("GET acp/sessions route not registered");
+  return route.handler;
+}
+
+function makeInMemoryState(
+  id: string,
+  parentConversationId: string,
+): AcpSessionState {
+  return {
+    id,
+    agentId: "claude",
+    acpSessionId: `proto-${id}`,
+    parentConversationId,
+    status: "running",
+    startedAt: 1_700_000_000_000,
+  };
+}
+
+afterAll(() => {
+  inMemoryStates.clear();
+  capturedLimits.length = 0;
+});
+
+describe("GET /v1/acp/sessions — SQL pad amount", () => {
+  test("pads SQL limit by the conversation-filtered in-memory count, not the global one", async () => {
+    inMemoryStates.clear();
+    capturedLimits.length = 0;
+
+    // Many in-memory sessions for an unrelated conversation, plus one
+    // that matches the target conversation.
+    for (let i = 0; i < 25; i++) {
+      inMemoryStates.set(
+        `other-${i}`,
+        makeInMemoryState(`other-${i}`, "conv-other"),
+      );
+    }
+    inMemoryStates.set(
+      "target-mem",
+      makeInMemoryState("target-mem", "conv-target"),
+    );
+
+    const handler = getListHandler();
+    await handler({
+      queryParams: { conversationId: "conv-target", limit: "10" },
+    });
+
+    expect(capturedLimits).toHaveLength(1);
+    // pad = filtered in-memory count (1), not global (26).
+    expect(capturedLimits[0]).toBe(11);
+  });
+
+  test("pads by zero when no in-memory sessions match the target conversation", async () => {
+    inMemoryStates.clear();
+    capturedLimits.length = 0;
+
+    for (let i = 0; i < 10; i++) {
+      inMemoryStates.set(
+        `other-${i}`,
+        makeInMemoryState(`other-${i}`, "conv-other"),
+      );
+    }
+
+    const handler = getListHandler();
+    await handler({
+      queryParams: { conversationId: "conv-target", limit: "5" },
+    });
+
+    expect(capturedLimits).toEqual([5]);
+  });
+
+  test("pads by the full in-memory count when no conversation filter is supplied", async () => {
+    inMemoryStates.clear();
+    capturedLimits.length = 0;
+
+    for (let i = 0; i < 4; i++) {
+      inMemoryStates.set(
+        `sess-${i}`,
+        makeInMemoryState(`sess-${i}`, `conv-${i}`),
+      );
+    }
+
+    const handler = getListHandler();
+    await handler({ queryParams: { limit: "20" } });
+
+    expect(capturedLimits).toEqual([24]);
+  });
+});

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

@@ -56,9 +56,7 @@ async function spawnSession({ body }: RouteHandlerArgs) {
   const cwd = (body?.cwd as string | undefined) ?? process.cwd();
 
   if (!agent || !task || !conversationId) {
-    throw new BadRequestError(
-      "agent, task, and conversationId are required",
-    );
+    throw new BadRequestError("agent, task, and conversationId are required");
   }
 
   const resolved = resolveAcpAgent(agent);
@@ -182,10 +180,7 @@ function deleteSession({ pathParams }: RouteHandlerArgs) {
     // Not in memory — fall through to the (idempotent) DB delete.
   }
 
-  getDb()
-    .delete(acpSessionHistory)
-    .where(eq(acpSessionHistory.id, id))
-    .run();
+  getDb().delete(acpSessionHistory).where(eq(acpSessionHistory.id, id)).run();
   const deleted = rawChanges() > 0;
   log.info({ acpSessionId: id, deleted }, "ACP session history delete");
   return { deleted };
@@ -376,7 +371,16 @@ function listMergedSessions(opts: {
         eq(acpSessionHistory.parentConversationId, opts.conversationId),
       )
     : baseQuery;
-  const historyRows = filtered.orderBy(desc(acpSessionHistory.startedAt)).all();
+  // Fetch only enough rows to fill the requested page after merging with
+  // in-memory sessions. In-memory entries take precedence on id collision,
+  // so we pad by the count that survived the conversation filter to
+  // guarantee we still surface `limit` distinct rows even when every
+  // in-memory session shadows a DB row — without over-fetching when many
+  // unrelated sessions are in memory.
+  const historyRows = filtered
+    .orderBy(desc(acpSessionHistory.startedAt))
+    .limit(opts.limit + merged.size)
+    .all();
 
   for (const row of historyRows) {
     if (merged.has(row.id)) continue;