@vellumai/assistant 0.8.1 → 0.8.3

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

@@ -0,0 +1,395 @@
+/**
+ * Tests for the `/v1/question-response` route in `question-routes.ts`.
+ *
+ * Covers:
+ *   - kind: "submit" — single-entry happy path (option + free_text).
+ *   - kind: "submit" — multi-entry batch resolves with the full result.
+ *   - kind: "close" — every entry reported as skipped, overall="closed".
+ *   - Validation: missing questionId from the batch → 400.
+ *   - Validation: unknown questionId → 400.
+ *   - Validation: option submission with unknown optionId → 400.
+ *   - Cross-talk safety: a registered "confirmation" requestId returns 404.
+ *   - Legacy single-question shim: works against a one-element batch,
+ *     400s against a multi-element batch.
+ *   - The pending interaction is removed after a successful resolve.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import type { QuestionPromptResult } from "../../../permissions/question-prompter.js";
+import * as pendingInteractions from "../../pending-interactions.js";
+import { BadRequestError, NotFoundError } from "../errors.js";
+import { ROUTES as QUESTION_ROUTES } from "../question-routes.js";
+import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findHandler(operationId: string): RouteDefinition["handler"] {
+  const route = QUESTION_ROUTES.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+const handler = findHandler("question_response");
+
+async function call(args: RouteHandlerArgs): Promise<unknown> {
+  return await handler(args);
+}
+
+/**
+ * Register a pending "question" interaction with the metadata the route
+ * needs to validate batched submissions. Mirrors what
+ * QuestionPrompter.prompt() does internally.
+ */
+function registerQuestion(
+  requestId: string,
+  questions: Array<{ id: string; options: string[] }>,
+  rpcResolve: (value: unknown) => void = () => {},
+): void {
+  const optionsById: Record<string, string[]> = {};
+  for (const q of questions) optionsById[q.id] = q.options;
+  pendingInteractions.register(requestId, {
+    conversationId: "conv-1",
+    kind: "question",
+    rpcResolve,
+    metadata: {
+      orderedIds: questions.map((q) => q.id),
+      optionsById,
+    },
+  });
+}
+
+beforeEach(() => {
+  pendingInteractions.clear();
+});
+
+afterEach(() => {
+  pendingInteractions.clear();
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("POST /v1/question-response", () => {
+  test("submit: resolves a one-question batch with an option entry", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion(
+      "req-1",
+      [{ id: "q1", options: ["yes", "no"] }],
+      (v) => resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await call({
+      body: {
+        requestId: "req-1",
+        kind: "submit",
+        responses: [{ questionId: "q1", kind: "option", optionId: "yes" }],
+      },
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(resolved).toEqual([
+      {
+        entries: [{ questionId: "q1", decision: "option", optionId: "yes" }],
+        overall: "completed",
+      },
+    ]);
+    expect(pendingInteractions.get("req-1")).toBeUndefined();
+  });
+
+  test("submit: three-question batch with two options + one free-text", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion(
+      "req-3",
+      [
+        { id: "q1", options: ["alice_work", "alice_personal"] },
+        { id: "q2", options: ["yes", "no"] },
+        { id: "q3", options: ["noon", "1pm"] },
+      ],
+      (v) => resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await call({
+      body: {
+        requestId: "req-3",
+        kind: "submit",
+        responses: [
+          { questionId: "q1", kind: "option", optionId: "alice_work" },
+          { questionId: "q3", kind: "free_text", text: "noon-ish" },
+          { questionId: "q2", kind: "option", optionId: "yes" },
+        ],
+      },
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(resolved[0]?.overall).toBe("completed");
+    // Entries are ordered to match the original questions array.
+    expect(resolved[0]?.entries).toEqual([
+      { questionId: "q1", decision: "option", optionId: "alice_work" },
+      { questionId: "q2", decision: "option", optionId: "yes" },
+      { questionId: "q3", decision: "free_text", text: "noon-ish" },
+    ]);
+  });
+
+  test("submit: all-skip resolves with completed + skipped entries", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion(
+      "req-skip-all",
+      [
+        { id: "q1", options: ["a", "b"] },
+        { id: "q2", options: ["x", "y"] },
+      ],
+      (v) => resolved.push(v as QuestionPromptResult),
+    );
+
+    await call({
+      body: {
+        requestId: "req-skip-all",
+        kind: "submit",
+        responses: [
+          { questionId: "q1", kind: "skip" },
+          { questionId: "q2", kind: "skip" },
+        ],
+      },
+    });
+
+    expect(resolved[0]).toEqual({
+      entries: [
+        { questionId: "q1", decision: "skipped" },
+        { questionId: "q2", decision: "skipped" },
+      ],
+      overall: "completed",
+    });
+  });
+
+  test("close: every entry reported as skipped with overall=closed", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion(
+      "req-close",
+      [
+        { id: "q1", options: ["a", "b"] },
+        { id: "q2", options: ["x", "y"] },
+      ],
+      (v) => resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await call({
+      body: { requestId: "req-close", kind: "close" },
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(resolved[0]).toEqual({
+      entries: [
+        { questionId: "q1", decision: "skipped" },
+        { questionId: "q2", decision: "skipped" },
+      ],
+      overall: "closed",
+    });
+    expect(pendingInteractions.get("req-close")).toBeUndefined();
+  });
+
+  test("returns 404 when no pending interaction exists for the requestId", async () => {
+    let thrown: unknown;
+    try {
+      await call({
+        body: {
+          requestId: "missing",
+          kind: "submit",
+          responses: [{ questionId: "q1", kind: "option", optionId: "a" }],
+        },
+      });
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(NotFoundError);
+    expect((thrown as NotFoundError).statusCode).toBe(404);
+  });
+
+  test("returns 400 when the request body fails schema validation", async () => {
+    registerQuestion("req-bad", [{ id: "q1", options: ["a", "b"] }]);
+    let thrown: unknown;
+    try {
+      // Missing `responses` for kind: "submit".
+      await call({ body: { requestId: "req-bad", kind: "submit" } });
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(BadRequestError);
+    expect((thrown as BadRequestError).statusCode).toBe(400);
+  });
+
+  test("returns 400 when kind is unknown", async () => {
+    let thrown: unknown;
+    try {
+      await call({ body: { requestId: "req-1", kind: "bogus" } });
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(BadRequestError);
+  });
+
+  test("returns 400 when body is missing entirely", async () => {
+    let thrown: unknown;
+    try {
+      await call({});
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(BadRequestError);
+  });
+
+  test("validation: batch missing a questionId from the original set → 400", async () => {
+    const resolved: unknown[] = [];
+    registerQuestion(
+      "req-miss",
+      [
+        { id: "q1", options: ["a", "b"] },
+        { id: "q2", options: ["x", "y"] },
+      ],
+      (v) => resolved.push(v),
+    );
+
+    let thrown: unknown;
+    try {
+      await call({
+        body: {
+          requestId: "req-miss",
+          kind: "submit",
+          responses: [{ questionId: "q1", kind: "option", optionId: "a" }],
+        },
+      });
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(BadRequestError);
+    // Pending interaction left in place so the user can retry.
+    expect(pendingInteractions.get("req-miss")).toBeDefined();
+    expect(resolved).toEqual([]);
+  });
+
+  test("validation: unknown questionId → 400", async () => {
+    registerQuestion("req-uq", [{ id: "q1", options: ["a", "b"] }]);
+
+    let thrown: unknown;
+    try {
+      await call({
+        body: {
+          requestId: "req-uq",
+          kind: "submit",
+          responses: [
+            { questionId: "q1", kind: "option", optionId: "a" },
+            { questionId: "qX", kind: "skip" },
+          ],
+        },
+      });
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(BadRequestError);
+  });
+
+  test("validation: unknown optionId → 400", async () => {
+    registerQuestion("req-uo", [{ id: "q1", options: ["a", "b"] }]);
+
+    let thrown: unknown;
+    try {
+      await call({
+        body: {
+          requestId: "req-uo",
+          kind: "submit",
+          responses: [{ questionId: "q1", kind: "option", optionId: "nope" }],
+        },
+      });
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(BadRequestError);
+  });
+
+  test("cross-talk safe: confirmation requestId returns 404", async () => {
+    const resolved: unknown[] = [];
+    pendingInteractions.register("req-confirm", {
+      conversationId: "conv-1",
+      kind: "confirmation",
+      rpcResolve: (value) => resolved.push(value),
+    });
+
+    let thrown: unknown;
+    try {
+      await call({
+        body: {
+          requestId: "req-confirm",
+          kind: "submit",
+          responses: [{ questionId: "q1", kind: "option", optionId: "yes" }],
+        },
+      });
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(NotFoundError);
+    expect(resolved).toEqual([]);
+    expect(pendingInteractions.get("req-confirm")?.kind).toBe("confirmation");
+  });
+
+  test("legacy single-question shim: resolves against a one-element batch", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion(
+      "req-legacy",
+      [{ id: "q1", options: ["yes", "no"] }],
+      (v) => resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await call({
+      body: { requestId: "req-legacy", kind: "option", optionId: "yes" },
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(resolved[0]).toEqual({
+      entries: [{ questionId: "q1", decision: "option", optionId: "yes" }],
+      overall: "completed",
+    });
+  });
+
+  test("legacy single-question shim: free-text resolves against a one-element batch", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion(
+      "req-legacy-ft",
+      [{ id: "q1", options: ["yes", "no"] }],
+      (v) => resolved.push(v as QuestionPromptResult),
+    );
+
+    await call({
+      body: { requestId: "req-legacy-ft", kind: "free_text", text: "maybe" },
+    });
+
+    expect(resolved[0]).toEqual({
+      entries: [{ questionId: "q1", decision: "free_text", text: "maybe" }],
+      overall: "completed",
+    });
+  });
+
+  test("legacy single-question shim: rejects against a multi-element batch", async () => {
+    registerQuestion("req-legacy-multi", [
+      { id: "q1", options: ["a", "b"] },
+      { id: "q2", options: ["x", "y"] },
+    ]);
+
+    let thrown: unknown;
+    try {
+      await call({
+        body: { requestId: "req-legacy-multi", kind: "option", optionId: "a" },
+      });
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(BadRequestError);
+    expect((thrown as BadRequestError).message.toLowerCase()).toContain(
+      "multi-question",
+    );
+    // Pending interaction left in place.
+    expect(pendingInteractions.get("req-legacy-multi")).toBeDefined();
+  });
+});

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";
 
 // ---------------------------------------------------------------------------
@@ -286,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

@@ -373,11 +373,13 @@ function listMergedSessions(opts: {
     : baseQuery;
   // 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 inMemory.length to guarantee we still surface `limit`
-  // distinct rows even when every in-memory session shadows a DB row.
+  // 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 + inMemory.length)
+    .limit(opts.limit + merged.size)
     .all();
 
   for (const row of historyRows) {

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

@@ -12,7 +12,7 @@ import {
   getPlatformOrganizationId,
   getPlatformUserId,
 } from "../../config/env.js";
-import { resolveManagedProxyContext } from "../../providers/managed-proxy/context.js";
+import { resolveManagedProxyContext } from "../../providers/platform-proxy/context.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 interface AuthInfoResult {

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

@@ -79,9 +79,11 @@ function handleCreateBookmark({
     );
   }
 
-  const summary = createBookmark(getDb(), { messageId, conversationId });
-  publishBookmarkCreated(summary);
-  return summary;
+  const result = createBookmark(getDb(), { messageId });
+  if (result.inserted) {
+    publishBookmarkCreated(result.bookmark);
+  }
+  return result.bookmark;
 }
 
 function handleDeleteBookmarkByMessage({ pathParams = {} }: RouteHandlerArgs): {

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

@@ -16,6 +16,7 @@ import { existsSync, readFileSync } from "node:fs";
 
 import { z } from "zod";
 
+import { getConfig } from "../../config/loader.js";
 import { readNowScratchpad } from "../../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import { buildToolDefinitions } from "../../daemon/conversation-tool-setup.js";
@@ -92,7 +93,10 @@ async function handleBtw({
 
   // ----- Greeting context enrichment -----
   let effectiveContent = trimmedContent;
-  if (conversationKey === GREETING_KEY) {
+  if (
+    conversationKey === GREETING_KEY &&
+    getConfig().memory.retrieval.scratchpadInjection.enabled
+  ) {
     const now = readNowScratchpad();
     if (now) {
       effectiveContent = `${trimmedContent}\n\n<context>\n${now}\n</context>`;