@vellumai/assistant 0.8.1 → 0.8.2

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -14,6 +14,12 @@ import {
 
 let rawConfigFixture: Record<string, unknown> = {};
 let savedRawConfig: Record<string, unknown> | null = null;
+// Counters / spies so tests can assert that `commitConfigWrite` ran its
+// post-write side effects. Each `replaceProfileRoute.handler` call that
+// hits `commitConfigWrite` should bump these once.
+let invalidateConfigCacheCalls = 0;
+let initializeProvidersCalls = 0;
+let clearEmbeddingBackendCacheCalls = 0;
 
 mock.module("../../../config/loader.js", () => ({
   loadRawConfig: () => structuredClone(rawConfigFixture),
@@ -26,6 +32,28 @@ mock.module("../../../config/loader.js", () => ({
   ) => {
     Object.assign(target, overrides);
   },
+  // `commitConfigWrite` (used by `handleReplaceInferenceProfile`) pulls
+  // in `getConfig` for the provider reinit's config arg and
+  // `invalidateConfigCache` so the next caller sees the fresh write.
+  // Stub both: getConfig returns whatever was last saved (or the fixture
+  // if nothing has been saved yet) and the cache-invalidation function
+  // is a counter so we can assert it fired.
+  getConfig: () => structuredClone(savedRawConfig ?? rawConfigFixture),
+  invalidateConfigCache: () => {
+    invalidateConfigCacheCalls += 1;
+  },
+}));
+
+mock.module("../../../providers/registry.js", () => ({
+  initializeProviders: async () => {
+    initializeProvidersCalls += 1;
+  },
+}));
+
+mock.module("../../../memory/embedding-backend.js", () => ({
+  clearEmbeddingBackendCache: () => {
+    clearEmbeddingBackendCacheCalls += 1;
+  },
 }));
 
 import type { ConversationCreateType } from "../../../memory/conversation-crud.js";
@@ -288,6 +316,9 @@ describe("GET /v1/messages/:id/llm-context — conversationTotalEstimatedCostUsd
 describe("PUT /v1/config/llm/profiles/:name", () => {
   beforeEach(() => {
     savedRawConfig = null;
+    invalidateConfigCacheCalls = 0;
+    initializeProvidersCalls = 0;
+    clearEmbeddingBackendCacheCalls = 0;
     rawConfigFixture = {
       llm: {
         profiles: {
@@ -313,8 +344,8 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     };
   });
 
-  test("owns contextWindow maxInputTokens while preserving non-UI profile leaves", () => {
-    const result = replaceProfileRoute.handler({
+  test("owns contextWindow maxInputTokens while preserving non-UI profile leaves", async () => {
+    const result = await replaceProfileRoute.handler({
       pathParams: { name: "custom" },
       body: {
         provider: "openai",
@@ -343,8 +374,8 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     expect(savedProfile.openrouter).toEqual({ only: ["anthropic"] });
   });
 
-  test("writes only the replacement contextWindow maxInputTokens override", () => {
-    const result = replaceProfileRoute.handler({
+  test("writes only the replacement contextWindow maxInputTokens override", async () => {
+    const result = await replaceProfileRoute.handler({
       pathParams: { name: "custom" },
       body: {
         provider: "openai",
@@ -375,8 +406,8 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     expect(savedProfile.openrouter).toEqual({ only: ["anthropic"] });
   });
 
-  test("writes provider_connection when present in body", () => {
-    const result = replaceProfileRoute.handler({
+  test("writes provider_connection when present in body", async () => {
+    const result = await replaceProfileRoute.handler({
       pathParams: { name: "custom" },
       body: {
         provider: "openai",
@@ -396,7 +427,7 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     expect(savedProfile.provider_connection).toBe("personal-openai");
   });
 
-  test("clears provider_connection when omitted from body (UI-owned key)", () => {
+  test("clears provider_connection when omitted from body (UI-owned key)", async () => {
     // Seed an existing binding so the test starts from a non-empty state.
     (
       rawConfigFixture.llm as {
@@ -404,7 +435,7 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
       }
     ).profiles.custom.provider_connection = "stale-openai";
 
-    const result = replaceProfileRoute.handler({
+    const result = await replaceProfileRoute.handler({
       pathParams: { name: "custom" },
       body: {
         provider: "openai",
@@ -439,8 +470,8 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
       };
     });
 
-    test("allows label edit on managed profile, preserving seed fields", () => {
-      const result = replaceProfileRoute.handler({
+    test("allows label edit on managed profile, preserving seed fields", async () => {
+      const result = await replaceProfileRoute.handler({
         pathParams: { name: "balanced" },
         body: { label: "My Balanced" },
       });
@@ -459,8 +490,8 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
       expect(savedProfile.source).toBe("managed");
     });
 
-    test("allows status edit on managed profile", () => {
-      const result = replaceProfileRoute.handler({
+    test("allows status edit on managed profile", async () => {
+      const result = await replaceProfileRoute.handler({
         pathParams: { name: "balanced" },
         body: { status: "disabled" },
       });
@@ -476,8 +507,8 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
       expect(savedProfile.provider).toBe("anthropic");
     });
 
-    test("allows label+status edit together", () => {
-      const result = replaceProfileRoute.handler({
+    test("allows label+status edit together", async () => {
+      const result = await replaceProfileRoute.handler({
         pathParams: { name: "balanced" },
         body: { label: "Renamed", status: "disabled" },
       });
@@ -493,25 +524,81 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
       expect(savedProfile.status).toBe("disabled");
     });
 
-    test("rejects provider edit on managed profile with disallowed-keys error", () => {
-      expect(() =>
+    test("rejects provider edit on managed profile with disallowed-keys error", async () => {
+      // The handler is `async`, so synchronous BadRequest throws still
+      // surface as a rejected promise; assert via `.rejects.toThrow`.
+      await expect(
         replaceProfileRoute.handler({
           pathParams: { name: "balanced" },
           body: { provider: "openai", model: "gpt-5" },
         }),
-      ).toThrow(/Cannot edit managed profile "balanced" fields \[provider, model\]/);
+      ).rejects.toThrow(
+        /Cannot edit managed profile "balanced" fields \[provider, model\]/,
+      );
     });
 
-    test("rejects mixed allowed+disallowed fields", () => {
+    test("rejects mixed allowed+disallowed fields", async () => {
       // label is allowed but maxTokens is not — must reject without partially
       // applying label, so saver should never be invoked.
-      expect(() =>
+      await expect(
         replaceProfileRoute.handler({
           pathParams: { name: "balanced" },
           body: { label: "Try", maxTokens: 999 },
         }),
-      ).toThrow(/Cannot edit managed profile "balanced" fields \[maxTokens\]/);
+      ).rejects.toThrow(
+        /Cannot edit managed profile "balanced" fields \[maxTokens\]/,
+      );
       expect(savedRawConfig).toBeNull();
+      // Reject path skips commitConfigWrite entirely — no provider reinit
+      // or cache invalidation should fire on a guard rejection.
+      expect(initializeProvidersCalls).toBe(0);
+      expect(invalidateConfigCacheCalls).toBe(0);
+      expect(clearEmbeddingBackendCacheCalls).toBe(0);
+    });
+  });
+
+  describe("commitConfigWrite side effects", () => {
+    test("status flip on managed profile triggers provider reinit + cache invalidation", async () => {
+      // Seed a managed profile that the user will disable. commitConfigWrite
+      // must reinit the provider registry so the status change is reflected
+      // in the running daemon immediately, not at the next watcher tick.
+      (rawConfigFixture.llm as { profiles: Record<string, unknown> }).profiles[
+        "balanced"
+      ] = {
+        source: "managed",
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        label: "Balanced",
+        status: "active",
+      };
+
+      const result = await replaceProfileRoute.handler({
+        pathParams: { name: "balanced" },
+        body: { status: "disabled" },
+      });
+
+      expect(result).toEqual({ ok: true });
+      expect(initializeProvidersCalls).toBe(1);
+      expect(invalidateConfigCacheCalls).toBe(1);
+      expect(clearEmbeddingBackendCacheCalls).toBe(1);
+    });
+
+    test("custom profile provider swap triggers provider reinit + cache invalidation", async () => {
+      // Custom profile path: provider/model swap on a user-owned profile.
+      // Same side-effect contract — registry must reinit so the new
+      // provider is wired into the running daemon without restart.
+      const result = await replaceProfileRoute.handler({
+        pathParams: { name: "custom" },
+        body: {
+          provider: "openai",
+          model: "gpt-5.5",
+        },
+      });
+
+      expect(result).toEqual({ ok: true });
+      expect(initializeProvidersCalls).toBe(1);
+      expect(invalidateConfigCacheCalls).toBe(1);
+      expect(clearEmbeddingBackendCacheCalls).toBe(1);
     });
   });
 });

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",
+    );
+  });
 });
 
 // ---------------------------------------------------------------------------