@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/__tests__/retry-thinking-tool-choice.test.ts

@@ -5,21 +5,12 @@
  * tool use."
  *
  * This is the root cause of repeated failures in memory graph operations
- * (extraction, narrative, pattern-scan, consolidation) when the user's default
- * LLM config has `thinking.enabled: true` and the call site uses forced
+ * (extraction, narrative, pattern-scan, consolidation) when the resolved LLM
+ * config has `thinking.enabled: true` and the call site uses forced
  * `tool_choice` without explicitly disabling thinking.
  */
 
-import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
-
-import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
-
-// Legacy-shaped fixtures (llm.default-centric resolution): pinned to the
-// flag-off cascade. Override-or-default (flag-on) semantics are pinned by
-// llm-resolver-override-or-default.test.ts and its companion suites.
-beforeAll(() => {
-  setOverridesForTesting({ "override-or-default-resolution": false });
-});
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { RetryProvider } from "../providers/retry.js";
 import type {
@@ -72,13 +63,13 @@ const userMessage: Message = {
 describe("retry normalization: thinking + forced tool_choice", () => {
   test("strips thinking when tool_choice forces a specific tool (type: 'tool')", async () => {
     setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-opus-4-7",
-        thinking: { enabled: true, streamThinking: true },
+      callSites: {
+        memoryExtraction: {
+          provider: "anthropic",
+          model: "claude-opus-4-7",
+          thinking: { enabled: true, streamThinking: true },
+        },
       },
-      // Disable the catalog default so resolution lands on llm.default.
-      profiles: { "cost-optimized": { source: "managed", status: "disabled" } },
     });
     const { provider, lastConfig } = makePipeline("anthropic");
     await provider.sendMessage([userMessage], {
@@ -98,13 +89,13 @@ describe("retry normalization: thinking + forced tool_choice", () => {
 
   test("strips thinking when tool_choice type is 'any'", async () => {
     setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-opus-4-7",
-        thinking: { enabled: true },
+      callSites: {
+        memoryExtraction: {
+          provider: "anthropic",
+          model: "claude-opus-4-7",
+          thinking: { enabled: true },
+        },
       },
-      // Disable the catalog default so resolution lands on llm.default.
-      profiles: { "cost-optimized": { source: "managed", status: "disabled" } },
     });
     const { provider, lastConfig } = makePipeline("anthropic");
     await provider.sendMessage([userMessage], {
@@ -118,13 +109,13 @@ describe("retry normalization: thinking + forced tool_choice", () => {
 
   test("preserves thinking when tool_choice type is 'auto'", async () => {
     setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-opus-4-7",
-        thinking: { enabled: true },
+      callSites: {
+        memoryExtraction: {
+          provider: "anthropic",
+          model: "claude-opus-4-7",
+          thinking: { enabled: true },
+        },
       },
-      // Disable the catalog default so resolution lands on llm.default.
-      profiles: { "cost-optimized": { source: "managed", status: "disabled" } },
     });
     const { provider, lastConfig } = makePipeline("anthropic");
     await provider.sendMessage([userMessage], {
@@ -138,13 +129,13 @@ describe("retry normalization: thinking + forced tool_choice", () => {
 
   test("preserves thinking when no tool_choice is set", async () => {
     setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-opus-4-7",
-        thinking: { enabled: true },
+      callSites: {
+        memoryExtraction: {
+          provider: "anthropic",
+          model: "claude-opus-4-7",
+          thinking: { enabled: true },
+        },
       },
-      // Disable the catalog default so resolution lands on llm.default.
-      profiles: { "cost-optimized": { source: "managed", status: "disabled" } },
     });
     const { provider, lastConfig } = makePipeline("anthropic");
     await provider.sendMessage([userMessage], {
@@ -184,13 +175,13 @@ describe("retry normalization: thinking + forced tool_choice", () => {
 
   test("preserves resolved thinking: disabled with forced tool_choice", async () => {
     setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-opus-4-7",
-        thinking: { enabled: false },
+      callSites: {
+        memoryExtraction: {
+          provider: "anthropic",
+          model: "claude-opus-4-7",
+          thinking: { enabled: false },
+        },
       },
-      // Disable the catalog default so resolution lands on llm.default.
-      profiles: { "cost-optimized": { source: "managed", status: "disabled" } },
     });
     const { provider, lastConfig } = makePipeline("anthropic");
     await provider.sendMessage([userMessage], {
@@ -204,13 +195,13 @@ describe("retry normalization: thinking + forced tool_choice", () => {
 
   test("strips thinking for openrouter with anthropic model and forced tool_choice", async () => {
     setLlmConfig({
-      default: {
-        provider: "openrouter",
-        model: "anthropic/claude-opus-4.7",
-        thinking: { enabled: true },
+      callSites: {
+        memoryExtraction: {
+          provider: "openrouter",
+          model: "anthropic/claude-opus-4.7",
+          thinking: { enabled: true },
+        },
       },
-      // Disable the catalog default so resolution lands on llm.default.
-      profiles: { "cost-optimized": { source: "managed", status: "disabled" } },
     });
     const { provider, lastConfig } = makePipeline("openrouter");
     await provider.sendMessage([userMessage], {
@@ -224,13 +215,13 @@ describe("retry normalization: thinking + forced tool_choice", () => {
 
   test("preserves thinking for openrouter with non-anthropic model and forced tool_choice", async () => {
     setLlmConfig({
-      default: {
-        provider: "openrouter",
-        model: "x-ai/grok-3-mini",
-        thinking: { enabled: true },
+      callSites: {
+        memoryExtraction: {
+          provider: "openrouter",
+          model: "x-ai/grok-3-mini",
+          thinking: { enabled: true },
+        },
       },
-      // Disable the catalog default so resolution lands on llm.default.
-      profiles: { "cost-optimized": { source: "managed", status: "disabled" } },
     });
     const { provider, lastConfig } = makePipeline("openrouter");
     await provider.sendMessage([userMessage], {
@@ -246,13 +237,13 @@ describe("retry normalization: thinking + forced tool_choice", () => {
 
   test("strips thinking for vercel-ai-gateway with anthropic model and forced tool_choice", async () => {
     setLlmConfig({
-      default: {
-        provider: "vercel-ai-gateway",
-        model: "anthropic/claude-opus-4.6",
-        thinking: { enabled: true },
+      callSites: {
+        memoryExtraction: {
+          provider: "vercel-ai-gateway",
+          model: "anthropic/claude-opus-4.6",
+          thinking: { enabled: true },
+        },
       },
-      // Disable the catalog default so resolution lands on llm.default.
-      profiles: { "cost-optimized": { source: "managed", status: "disabled" } },
     });
     const { provider, lastConfig } = makePipeline("vercel-ai-gateway");
     await provider.sendMessage([userMessage], {
@@ -266,13 +257,13 @@ describe("retry normalization: thinking + forced tool_choice", () => {
 
   test("preserves thinking for vercel-ai-gateway with non-anthropic model and forced tool_choice", async () => {
     setLlmConfig({
-      default: {
-        provider: "vercel-ai-gateway",
-        model: "xai/grok-4.3",
-        thinking: { enabled: true },
+      callSites: {
+        memoryExtraction: {
+          provider: "vercel-ai-gateway",
+          model: "xai/grok-4.3",
+          thinking: { enabled: true },
+        },
       },
-      // Disable the catalog default so resolution lands on llm.default.
-      profiles: { "cost-optimized": { source: "managed", status: "disabled" } },
     });
     const { provider, lastConfig } = makePipeline("vercel-ai-gateway");
     await provider.sendMessage([userMessage], {

package/src/__tests__/retry-verbosity-normalization.test.ts

@@ -5,16 +5,7 @@
  * the unknown field on the wire.
  */
 
-import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
-
-import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
-
-// Legacy-shaped fixtures (llm.default-centric resolution): pinned to the
-// flag-off cascade. Override-or-default (flag-on) semantics are pinned by
-// llm-resolver-override-or-default.test.ts and its companion suites.
-beforeAll(() => {
-  setOverridesForTesting({ "override-or-default-resolution": false });
-});
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { RetryProvider } from "../providers/retry.js";
 import type {
@@ -67,10 +58,12 @@ const userMessage: Message = {
 describe("retry normalization for verbosity", () => {
   test("forwards verbosity on the outbound config for openai", async () => {
     setLlmConfig({
-      default: {
-        provider: "openai",
-        model: "gpt-5.5",
-        verbosity: "high",
+      callSites: {
+        mainAgent: {
+          provider: "openai",
+          model: "gpt-5.5",
+          verbosity: "high",
+        },
       },
     });
     const { provider, lastConfig } = makePipeline("openai");
@@ -96,13 +89,17 @@ describe("retry normalization for verbosity", () => {
     expect(lastConfig()?.verbosity).toBe(undefined);
   });
 
-  test("call-site override replaces default verbosity", async () => {
+  test("call-site override replaces the winning profile's verbosity", async () => {
     setLlmConfig({
-      default: {
-        provider: "openai",
-        model: "gpt-5.5",
-        verbosity: "low",
+      profiles: {
+        "openai-profile": {
+          source: "user",
+          provider: "openai",
+          model: "gpt-5.5",
+          verbosity: "low",
+        },
       },
+      activeProfile: "openai-profile",
       callSites: {
         mainAgent: { verbosity: "high" },
       },
@@ -116,11 +113,15 @@ describe("retry normalization for verbosity", () => {
 
   test("per-call explicit verbosity overrides resolved call-site value", async () => {
     setLlmConfig({
-      default: {
-        provider: "openai",
-        model: "gpt-5.5",
-        verbosity: "low",
+      profiles: {
+        "openai-profile": {
+          source: "user",
+          provider: "openai",
+          model: "gpt-5.5",
+          verbosity: "low",
+        },
       },
+      activeProfile: "openai-profile",
       callSites: {
         mainAgent: { verbosity: "medium" },
       },

package/src/__tests__/reveal-success-registry.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Tests for the reveal-success registry's retention behavior (LUM-2768).
+ *
+ * The registry is the ground truth the chat-credential persist seams use
+ * to prove a reveal ran; losing a record before its tool window closes
+ * silently drops the candidate and the printed value persists raw. Recent
+ * records must therefore survive the count cap — only the age bound may
+ * remove them while a window could still be active.
+ */
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  setSystemTime,
+  test,
+} from "bun:test";
+
+import {
+  _recordCountForTest,
+  _resetRevealSuccessRegistryForTest,
+  closeRevealProofWindow,
+  currentRevealSuccessWatermark,
+  openRevealProofWindow,
+  recordRevealSuccess,
+  revealedValueSince,
+} from "../runtime/reveal-success-registry.js";
+
+beforeEach(() => {
+  _resetRevealSuccessRegistryForTest();
+  // Recording is gated on an open proof window (a staged tool reveal);
+  // these tests exercise retention semantics, so arm one for the file.
+  openRevealProofWindow();
+});
+
+afterEach(() => {
+  setSystemTime();
+});
+
+const TEST_NONCE = "nonce-registry-test";
+
+describe("reveal success registry retention", () => {
+  test("recent records survive the count cap while a tool window is active", () => {
+    // A single command with hundreds of reveal invocations records every
+    // success BEFORE the tool result triggers the proof check. A hard
+    // count cap would evict the earliest ones mid-window, so their values
+    // could never become candidates.
+    const watermark = currentRevealSuccessWatermark();
+    for (let i = 0; i < 300; i++) {
+      recordRevealSuccess(`service-${i}`, "api_key", `value-${i}`, TEST_NONCE);
+    }
+    expect(
+      revealedValueSince(watermark, "service-0", "api_key", TEST_NONCE),
+    ).toBe("value-0");
+    expect(
+      revealedValueSince(watermark, "service-299", "api_key", TEST_NONCE),
+    ).toBe("value-299");
+  });
+
+  test("watermark gating still excludes earlier successes", () => {
+    recordRevealSuccess("openai", "api_key", "before-watermark", TEST_NONCE);
+    const watermark = currentRevealSuccessWatermark();
+    expect(
+      revealedValueSince(watermark, "openai", "api_key", TEST_NONCE),
+    ).toBeUndefined();
+    recordRevealSuccess("openai", "api_key", "after-watermark", TEST_NONCE);
+    expect(revealedValueSince(watermark, "openai", "api_key", TEST_NONCE)).toBe(
+      "after-watermark",
+    );
+  });
+
+  test("records nothing while no proof window is open", () => {
+    // A user's own local CLI reveal outside any assistant tool turn has no
+    // pending proof to satisfy — retaining its plaintext for the age bound
+    // would expand every CLI reveal's exposure for nothing.
+    _resetRevealSuccessRegistryForTest();
+    recordRevealSuccess("svc", "f", "hunter2-no-window", TEST_NONCE);
+    expect(_recordCountForTest()).toBe(0);
+    expect(revealedValueSince(0, "svc", "f", TEST_NONCE)).toBeUndefined();
+
+    // With a window open the same reveal records; closing the last window
+    // both stops further recording and drops the retained plaintext.
+    const token = openRevealProofWindow();
+    recordRevealSuccess("svc", "f", "hunter2-windowed", TEST_NONCE);
+    expect(revealedValueSince(0, "svc", "f", TEST_NONCE)).toBe(
+      "hunter2-windowed",
+    );
+    closeRevealProofWindow(token);
+    recordRevealSuccess("svc", "f", "hunter2-after-close", TEST_NONCE);
+    expect(revealedValueSince(0, "svc", "f", TEST_NONCE)).toBeUndefined();
+    expect(_recordCountForTest()).toBe(0);
+  });
+
+  test("closing the last proof window drops retained plaintext immediately", () => {
+    // Proof consumption reads happen BEFORE a window closes, so once the
+    // last window is gone nothing can ever read the records again — they
+    // must not sit in memory until the age bound.
+    _resetRevealSuccessRegistryForTest();
+    const first = openRevealProofWindow();
+    const second = openRevealProofWindow();
+    recordRevealSuccess("svc", "f", "hunter2-windowed", TEST_NONCE);
+    closeRevealProofWindow(first);
+    // A concurrent staging (second window) may still consume the record.
+    expect(_recordCountForTest()).toBe(1);
+    closeRevealProofWindow(second);
+    expect(_recordCountForTest()).toBe(0);
+  });
+
+  test("an expired record is EVICTED on read, not merely filtered", () => {
+    // Records hold credential plaintext. Filtering expired records out of
+    // read results while retaining them in memory would keep a lone
+    // reveal's secret alive indefinitely — eviction must happen on any
+    // registry activity (a write, a read, or the idle timer).
+    setSystemTime(new Date("2026-01-01T00:00:00Z"));
+    recordRevealSuccess("svc", "f", "hunter2-expiring", TEST_NONCE);
+    expect(_recordCountForTest()).toBe(1);
+
+    // Past the 6-hour age bound with NO further writes.
+    setSystemTime(new Date("2026-01-01T07:00:00Z"));
+    expect(revealedValueSince(0, "svc", "f", TEST_NONCE)).toBeUndefined();
+    expect(_recordCountForTest()).toBe(0);
+  });
+});

package/src/__tests__/run-conversation-turn-persistence.test.ts

@@ -0,0 +1,130 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import {
+  createConversation,
+  ensureConversationExists,
+  getConversation,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+
+await initializeDb();
+
+// Capture the list-invalidation calls `runConversationTurn` fires when it
+// creates a brand-new conversation row, without pulling in the real sync
+// publisher (which reaches for live SSE subscribers).
+const listChangedCalls: Array<{ kind: string; conversationId: string }> = [];
+mock.module("../runtime/sync/resource-sync-events.js", () => ({
+  publishConversationListAndMetadataChanged: (
+    kind: string,
+    conversationId: string,
+  ) => {
+    listChangedCalls.push({ kind, conversationId });
+  },
+}));
+
+// Stub the heavy machinery: the in-memory conversation build (provider wiring,
+// system prompt, history hydration) and the SSE event fan-out. The agent turn
+// itself is a no-op — this test only asserts that the `conversations` row is
+// persisted before the turn runs. The real `getOrCreateConversation` now
+// creates the DB row before hydrating, so the mock mirrors that by calling
+// `ensureConversationExists`. The persistence module is intentionally NOT
+// mocked so the real `ensureConversationExists` runs against the real DB.
+let lastProcessMessageConversationId: string | undefined;
+mock.module("../daemon/conversation-store.js", () => ({
+  getOrCreateConversation: async (
+    conversationId: string,
+    options?: { conversationType?: string },
+  ) => {
+    if (!getConversation(conversationId)) {
+      if (options?.conversationType) {
+        createConversation({
+          id: conversationId,
+          conversationType: options.conversationType as "standard" | "background",
+        });
+      } else {
+        ensureConversationExists(conversationId);
+      }
+    }
+    return {
+      abortController: undefined,
+      isProcessing: () => false,
+      async processMessage() {
+        // The row must already exist by the time the turn persists its user
+        // message — record the id so the FK precondition can be asserted.
+        lastProcessMessageConversationId = conversationId;
+        return "user-message-id";
+      },
+      enqueueMessage: () => ({ rejected: false }),
+    };
+  },
+}));
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: () => {},
+}));
+
+mock.module("../providers/media-resolve.js", () => ({
+  resolveMediaSourceData: () => null,
+}));
+
+// Import under test AFTER the mocks are registered so its dynamic imports
+// resolve to the stubs above.
+const { runConversationTurn } =
+  await import("../plugin-api/conversation-turn.js");
+
+describe("runConversationTurn persistence", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM conversations");
+    listChangedCalls.length = 0;
+    lastProcessMessageConversationId = undefined;
+  });
+
+  test("persists a conversations row for a freshly-minted conversation", async () => {
+    const result = await runConversationTurn({
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    // The row exists on disk — not just as an in-memory Conversation object —
+    // so the user-message persist inside the turn has its FK target.
+    const row = getConversation(result.conversationId);
+    expect(row?.id).toBe(result.conversationId);
+    expect(lastProcessMessageConversationId).toBe(result.conversationId);
+
+    // Siblings/sidebars are told about the new conversation, mirroring the
+    // send-message route.
+    expect(listChangedCalls).toEqual([
+      { kind: "created", conversationId: result.conversationId },
+    ]);
+  });
+
+  test("adopts a caller-supplied conversation id verbatim when no row exists", async () => {
+    const conversationId = "0f9c1e2a-3b4d-5e6f-7a8b-9c0d1e2f3a4b";
+
+    const result = await runConversationTurn({
+      conversationId,
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    expect(result.conversationId).toBe(conversationId);
+    expect(getConversation(conversationId)?.id).toBe(conversationId);
+    expect(listChangedCalls).toEqual([{ kind: "created", conversationId }]);
+  });
+
+  test("is a no-op for an already-persisted conversation row", async () => {
+    const existing = createConversation({ title: "already here" });
+    listChangedCalls.length = 0;
+
+    const result = await runConversationTurn({
+      conversationId: existing.id,
+      content: [{ type: "text", text: "follow up" }],
+    });
+
+    expect(result.conversationId).toBe(existing.id);
+    // Row is untouched and no duplicate "created" invalidation fires.
+    expect(getConversation(existing.id)?.title).toBe("already here");
+    expect(listChangedCalls).toEqual([]);
+  });
+});

package/src/__tests__/secret-fixtures.ts

@@ -18,3 +18,12 @@ export const SYNTHETIC_OPENAI_PROJECT_KEY =
 /** The marker `redactSecrets()` substitutes for the key above. */
 export const OPENAI_PROJECT_KEY_REDACTION_MARKER =
   '<redacted type="OpenAI Project Key" />';
+
+/**
+ * An opaque/manual credential value with NO scanner-recognizable shape — no
+ * known prefix, not high-entropy enough for the AWS-secret heuristic, no
+ * private-key header. The scanner leaves it untouched, so only the
+ * reveal-candidate exact-match machinery can redact it. Used to prove the
+ * candidate fallback catches values the pattern scanner cannot classify.
+ */
+export const SYNTHETIC_OPAQUE_CREDENTIAL = "hunter2-manual-token-value";

package/src/__tests__/server-history-render.test.ts

@@ -15,6 +15,34 @@ import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 await initializeDb();
 
+describe("renderHistoryContent sentinel forgery guard", () => {
+  const FORGED = "\u3014redacted:GitHub Token:github-app:pem\u3015";
+
+  test("neutralizes sentinel-shaped text in blocks without the redaction rider (pre-feature rows)", () => {
+    const output = renderHistoryContent([
+      { type: "text", text: `quoted: ${FORGED}` },
+    ]);
+    // The word joiner breaks the chip regex; text is otherwise unchanged.
+    expect(output.textSegments[0]).toBe(
+      `quoted: \u3014\u2060redacted:GitHub Token:github-app:pem\u3015`,
+    );
+  });
+
+  test("passes sentinels through verbatim when the block carries the redaction rider", () => {
+    const output = renderHistoryContent([
+      { type: "text", text: `key: ${FORGED}`, _redactionVersion: 2 },
+    ]);
+    expect(output.textSegments[0]).toBe(`key: ${FORGED}`);
+  });
+
+  test("rider-less text without sentinels is untouched", () => {
+    const output = renderHistoryContent([
+      { type: "text", text: "ordinary history text" },
+    ]);
+    expect(output.textSegments[0]).toBe("ordinary history text");
+  });
+});
+
 describe("renderHistoryContent", () => {
   test("renders text-only content unchanged", () => {
     const output = renderHistoryContent([

package/src/__tests__/skills.test.ts

@@ -340,15 +340,20 @@ describe("plugin-resident skills", () => {
     expect(skill).toBeUndefined();
   });
 
-  test("ignores plugin dirs whose package.json name mismatches the directory", () => {
-    // Mirrors the loader's recognition gate: an un-adapted clone whose
-    // package.json declares `caveman-installer` in a `caveman` dir is skipped.
+  test("surfaces plugin skills when package.json name differs from the directory", () => {
+    // A plugin is installed under its slug (marketplace name or GitHub path
+    // leaf), which routinely differs from its authored `package.json` name —
+    // e.g. cognee installs to `cognee`/`vellum-assistant` while its package is
+    // named `cognee-memory`. The skill must still surface, attributed to the
+    // install directory (the identity every other surface uses).
     writePluginSkill("caveman", "caveman", "Caveman", "Terse mode", "body", {
       packageName: "caveman-installer",
     });
 
     const skill = loadSkillCatalog().find((s) => s.id === "caveman");
-    expect(skill).toBeUndefined();
+    expect(skill).toBeDefined();
+    expect(skill!.source).toBe("plugin");
+    expect(skill!.owner).toEqual({ kind: "plugin", id: "caveman" });
   });
 
   test("warns when a plugin directory is missing package.json", () => {

package/src/__tests__/slack-share-routes.test.ts

@@ -42,7 +42,6 @@ let appStoreResult: unknown = null;
 mock.module("../apps/app-store.js", () => ({
   getApp: (_id: string) => appStoreResult,
   getAppsDir: () => "/tmp/apps",
-  isMultifileApp: () => false,
   listApps: () => [],
 }));
 

package/src/__tests__/stt-stream-session.test.ts

@@ -321,11 +321,12 @@ describe("SttStreamSession", () => {
       const frames = ws.frames;
       expect(frames[0].type).toBe("error");
       expect(frames[0].category).toBe("provider-error");
-      expect(
-        (frames[0].message as string).includes(
-          "Mock provider connection refused",
-        ),
-      ).toBe(true);
+      // Friendly copy names the provider; the raw upstream error stays in
+      // logs and must not leak to the client.
+      expect(frames[0].message as string).toContain("Deepgram");
+      expect(frames[0].message as string).not.toContain(
+        "Mock provider connection refused",
+      );
       expect(frames[1].type).toBe("closed");
       expect(session.isClosed).toBe(true);
       expect(ws.closed).toBe(true);