@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/providers/speech-to-text/__tests__/resolve.test.ts

@@ -1,5 +1,8 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { setConfig } from "../../../__tests__/helpers/set-config.js";
+import { getConfig } from "../../../config/loader.js";
+
 // ---------------------------------------------------------------------------
 // Mocks — must be declared before any subject imports
 // ---------------------------------------------------------------------------
@@ -36,15 +39,6 @@ mock.module("../../../util/logger.js", () => ({
   }),
 }));
 
-// -- Config mock ----------------------------------------------------------
-
-let mockConfig: Record<string, unknown> = {};
-
-mock.module("../../../config/loader.js", () => ({
-  getConfig: () => mockConfig,
-  loadConfig: () => mockConfig,
-}));
-
 // -- Credential mock ------------------------------------------------------
 
 let mockProviderKeys: Record<string, string | undefined> = {};
@@ -60,6 +54,38 @@ mock.module("../../../security/credential-key.js", () => ({
   credentialKey: (...args: string[]) => args.join("/"),
 }));
 
+// -- Vellum managed availability mock --------------------------------------
+
+let mockVellumAvailable = false;
+
+mock.module("../vellum-managed.js", () => ({
+  vellumManagedSpeechAvailable: async () => mockVellumAvailable,
+  vellumManagedTranscribe: async () => ({ text: "" }),
+  sttErrorFromManagedSpeech: (failure: unknown) => new Error(String(failure)),
+}));
+
+const vellumStreamCtorCalls: Array<{ connection: unknown; options: unknown }> =
+  [];
+let mockVelayConnection: {
+  wsBaseUrl: string;
+  httpBaseUrl: string;
+  mintServiceToken: () => string;
+} | null = null;
+
+mock.module("../vellum-speech-relay-connection.js", () => ({
+  resolveSpeechRelayConnection: async () => mockVelayConnection,
+}));
+
+mock.module("../vellum-managed-realtime.js", () => ({
+  VellumManagedRealtimeTranscriber: class {
+    readonly providerId = "vellum";
+    readonly boundaryId = "daemon-streaming";
+    constructor(connection: unknown, options: unknown) {
+      vellumStreamCtorCalls.push({ connection, options });
+    }
+  },
+}));
+
 // -- Streaming adapter mocks ----------------------------------------------
 
 /**
@@ -123,6 +149,7 @@ mock.module("../xai-realtime.js", () => ({
 
 const {
   resolveBatchTranscriber,
+  sttCredentialGapReason,
   resolveConversationStreamingSttCapability,
   resolveStreamingTranscriber,
   resolveTelephonySttCapability,
@@ -132,21 +159,26 @@ const {
 // Helpers
 // ---------------------------------------------------------------------------
 
-function buildConfig(overrides: {
-  provider?: string;
-}): Record<string, unknown> {
-  return {
-    services: {
-      stt: {
-        mode: "your-own",
-        provider: overrides.provider ?? "openai-whisper",
-        providers: {
-          "openai-whisper": {},
-          deepgram: {},
-        },
+function applyConfig(overrides: { provider?: string; mode?: string }): void {
+  const provider = overrides.provider ?? "openai-whisper";
+  const mode = overrides.mode ?? "your-own";
+  // Seed a schema-valid base so the loader caches a fresh config object, then
+  // set the provider under test on that live cached object. `services.stt.
+  // provider` is a strict enum, so the "unconfigured" cases (empty string /
+  // non-catalog ids) can't round-trip through the validated file — resolve.ts
+  // reads the live cached config, so a direct mutation drives the same code
+  // path the raw mock did.
+  setConfig("services", {
+    stt: {
+      mode,
+      provider: "openai-whisper",
+      providers: {
+        "openai-whisper": {},
+        deepgram: {},
       },
     },
-  };
+  });
+  (getConfig().services.stt as { provider: string }).provider = provider;
 }
 
 // ---------------------------------------------------------------------------
@@ -155,13 +187,13 @@ function buildConfig(overrides: {
 
 describe("resolveBatchTranscriber", () => {
   beforeEach(() => {
-    mockConfig = buildConfig({});
+    applyConfig({});
     mockProviderKeys = {};
   });
 
   test("returns a BatchTranscriber when openai-whisper is configured and credentials are available", async () => {
     mockProviderKeys["openai"] = "sk-test-key";
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -172,7 +204,7 @@ describe("resolveBatchTranscriber", () => {
 
   test("returns null when credentials are missing for the configured provider", async () => {
     mockProviderKeys = {}; // no keys at all
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -183,7 +215,7 @@ describe("resolveBatchTranscriber", () => {
     // Force an unknown provider past the type system to simulate a future
     // provider that hasn't been wired into the daemon-batch boundary yet.
     mockProviderKeys["some-provider"] = "key";
-    mockConfig = buildConfig({ provider: "unknown-provider" as string });
+    applyConfig({ provider: "unknown-provider" as string });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -194,7 +226,7 @@ describe("resolveBatchTranscriber", () => {
     // Verify the resolver reads from config rather than always using "openai".
     // If the config says openai-whisper, we expect credential lookup for "openai".
     mockProviderKeys["openai"] = "sk-config-driven";
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -204,7 +236,7 @@ describe("resolveBatchTranscriber", () => {
 
   test("resolved transcriber has stable provider identity", async () => {
     mockProviderKeys["openai"] = "sk-identity-test";
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -219,7 +251,7 @@ describe("resolveBatchTranscriber", () => {
 
   test("returns a BatchTranscriber when deepgram is configured and credentials are available", async () => {
     mockProviderKeys["deepgram"] = "dg-test-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -230,7 +262,7 @@ describe("resolveBatchTranscriber", () => {
 
   test("returns null when deepgram is configured but no credentials exist", async () => {
     mockProviderKeys = {}; // no keys
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -240,7 +272,7 @@ describe("resolveBatchTranscriber", () => {
   test("deepgram uses 'deepgram' credential key, not 'openai'", async () => {
     // Only openai key is set — deepgram should NOT resolve
     mockProviderKeys["openai"] = "sk-test-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -249,7 +281,7 @@ describe("resolveBatchTranscriber", () => {
 
   test("resolved deepgram transcriber has stable provider identity", async () => {
     mockProviderKeys["deepgram"] = "dg-identity-test";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -263,7 +295,7 @@ describe("resolveBatchTranscriber", () => {
 
   test("returns a BatchTranscriber when google-gemini is configured and credentials are available", async () => {
     mockProviderKeys["gemini"] = "gemini-test-key";
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -274,7 +306,7 @@ describe("resolveBatchTranscriber", () => {
 
   test("returns null when google-gemini is configured but no credentials exist", async () => {
     mockProviderKeys = {}; // no keys
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -284,7 +316,7 @@ describe("resolveBatchTranscriber", () => {
   test("google-gemini uses 'gemini' credential key, not 'openai' or 'deepgram'", async () => {
     // Only openai key is set — google-gemini should NOT resolve
     mockProviderKeys["openai"] = "sk-test-key";
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -293,7 +325,7 @@ describe("resolveBatchTranscriber", () => {
 
   test("resolved google-gemini transcriber has stable provider identity", async () => {
     mockProviderKeys["gemini"] = "gemini-identity-test";
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const transcriber = await resolveBatchTranscriber();
 
@@ -308,13 +340,13 @@ describe("resolveBatchTranscriber", () => {
 
 describe("resolveTelephonySttCapability", () => {
   beforeEach(() => {
-    mockConfig = buildConfig({});
+    applyConfig({});
     mockProviderKeys = {};
   });
 
   test("returns 'supported' when provider is telephony-eligible and credentials exist", async () => {
     mockProviderKeys["openai"] = "sk-telephony-test";
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const result = await resolveTelephonySttCapability();
 
@@ -328,7 +360,7 @@ describe("resolveTelephonySttCapability", () => {
 
   test("returns 'unconfigured' when provider is not in the catalog", async () => {
     mockProviderKeys["unknown-provider"] = "key-doesnt-matter";
-    mockConfig = buildConfig({ provider: "unknown-provider" as string });
+    applyConfig({ provider: "unknown-provider" as string });
 
     const result = await resolveTelephonySttCapability();
 
@@ -341,7 +373,7 @@ describe("resolveTelephonySttCapability", () => {
 
   test("returns 'missing-credentials' when provider is eligible but has no API key", async () => {
     mockProviderKeys = {}; // no keys
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const result = await resolveTelephonySttCapability();
 
@@ -356,7 +388,7 @@ describe("resolveTelephonySttCapability", () => {
   test("uses config-driven provider, not a hardcoded default", async () => {
     // Use a provider that IS in the catalog to verify config is read
     mockProviderKeys["openai"] = "sk-config-test";
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const result = await resolveTelephonySttCapability();
 
@@ -367,7 +399,7 @@ describe("resolveTelephonySttCapability", () => {
   });
 
   test("returns 'unconfigured' for empty-string provider", async () => {
-    mockConfig = buildConfig({ provider: "" as string });
+    applyConfig({ provider: "" as string });
 
     const result = await resolveTelephonySttCapability();
 
@@ -380,7 +412,7 @@ describe("resolveTelephonySttCapability", () => {
 
   test("returns 'supported' for google-gemini with batch-only telephonyMode", async () => {
     mockProviderKeys["gemini"] = "gemini-telephony-test";
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const result = await resolveTelephonySttCapability();
 
@@ -393,7 +425,7 @@ describe("resolveTelephonySttCapability", () => {
 
   test("returns 'missing-credentials' for google-gemini without a gemini key", async () => {
     mockProviderKeys = {};
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const result = await resolveTelephonySttCapability();
 
@@ -487,14 +519,17 @@ describe("telephony capability catalog alignment", () => {
       deepgram: "deepgram",
       "google-gemini": "gemini",
       xai: "xai",
+      // vellum's credential is the platform connection, mocked below.
+      vellum: "vellum",
     };
 
     for (const id of listProviderIds()) {
       const credKey = credentialMap[id];
       expect(credKey).toBeDefined();
 
-      mockProviderKeys = { [credKey]: `test-key-${id}` };
-      mockConfig = buildConfig({ provider: id });
+      mockVellumAvailable = id === "vellum";
+      mockProviderKeys = id === "vellum" ? {} : { [credKey]: `test-key-${id}` };
+      applyConfig({ provider: id });
 
       const result = await resolveTelephonySttCapability();
       expect(result.status).toBe("supported");
@@ -511,7 +546,7 @@ describe("telephony capability catalog alignment", () => {
 
 describe("resolveConversationStreamingSttCapability", () => {
   beforeEach(() => {
-    mockConfig = buildConfig({});
+    applyConfig({});
     mockProviderKeys = {};
   });
 
@@ -521,7 +556,7 @@ describe("resolveConversationStreamingSttCapability", () => {
 
   test("returns 'supported' with realtime-ws mode for deepgram", async () => {
     mockProviderKeys["deepgram"] = "dg-stream-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const result = await resolveConversationStreamingSttCapability();
 
@@ -534,7 +569,7 @@ describe("resolveConversationStreamingSttCapability", () => {
 
   test("returns 'missing-credentials' for deepgram without an API key", async () => {
     mockProviderKeys = {};
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const result = await resolveConversationStreamingSttCapability();
 
@@ -552,7 +587,7 @@ describe("resolveConversationStreamingSttCapability", () => {
 
   test("returns 'supported' with realtime-ws mode for google-gemini", async () => {
     mockProviderKeys["gemini"] = "gemini-stream-key";
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const result = await resolveConversationStreamingSttCapability();
 
@@ -565,7 +600,7 @@ describe("resolveConversationStreamingSttCapability", () => {
 
   test("returns 'missing-credentials' for google-gemini without a gemini key", async () => {
     mockProviderKeys = {};
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const result = await resolveConversationStreamingSttCapability();
 
@@ -582,7 +617,7 @@ describe("resolveConversationStreamingSttCapability", () => {
 
   test("returns 'supported' with incremental-batch mode for openai-whisper", async () => {
     mockProviderKeys["openai"] = "sk-stream-test";
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const result = await resolveConversationStreamingSttCapability();
 
@@ -595,7 +630,7 @@ describe("resolveConversationStreamingSttCapability", () => {
 
   test("returns 'missing-credentials' for openai-whisper without an API key", async () => {
     mockProviderKeys = {};
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const result = await resolveConversationStreamingSttCapability();
 
@@ -613,7 +648,7 @@ describe("resolveConversationStreamingSttCapability", () => {
 
   test("returns 'unconfigured' when provider is not in the catalog", async () => {
     mockProviderKeys["unknown-provider"] = "key-doesnt-matter";
-    mockConfig = buildConfig({ provider: "unknown-provider" as string });
+    applyConfig({ provider: "unknown-provider" as string });
 
     const result = await resolveConversationStreamingSttCapability();
 
@@ -625,7 +660,7 @@ describe("resolveConversationStreamingSttCapability", () => {
   });
 
   test("returns 'unconfigured' for empty-string provider", async () => {
-    mockConfig = buildConfig({ provider: "" as string });
+    applyConfig({ provider: "" as string });
 
     const result = await resolveConversationStreamingSttCapability();
 
@@ -638,7 +673,7 @@ describe("resolveConversationStreamingSttCapability", () => {
 
   test("uses config-driven provider, not a hardcoded default", async () => {
     mockProviderKeys["deepgram"] = "dg-config-test";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const result = await resolveConversationStreamingSttCapability();
 
@@ -655,7 +690,7 @@ describe("resolveConversationStreamingSttCapability", () => {
 
 describe("resolveStreamingTranscriber diarize preference", () => {
   beforeEach(() => {
-    mockConfig = buildConfig({});
+    applyConfig({});
     mockProviderKeys = {};
     deepgramCtorCalls.length = 0;
     geminiCtorCalls.length = 0;
@@ -666,7 +701,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("default (no diarize option) constructs Deepgram without the diarize flag", async () => {
     mockProviderKeys["deepgram"] = "dg-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveStreamingTranscriber();
 
@@ -678,7 +713,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("diarize: 'off' constructs Deepgram without the diarize flag", async () => {
     mockProviderKeys["deepgram"] = "dg-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveStreamingTranscriber({ diarize: "off" });
 
@@ -690,7 +725,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("diarize: 'preferred' with Deepgram constructs the transcriber with diarize: true", async () => {
     mockProviderKeys["deepgram"] = "dg-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveStreamingTranscriber({
       diarize: "preferred",
@@ -704,7 +739,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("diarize: 'preferred' with Gemini silently skips diarization (no error, no diarize arg)", async () => {
     mockProviderKeys["gemini"] = "gemini-key";
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const transcriber = await resolveStreamingTranscriber({
       diarize: "preferred",
@@ -721,7 +756,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("diarize: 'required' with Gemini returns null and logs a warning identifying the provider", async () => {
     mockProviderKeys["gemini"] = "gemini-key";
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const transcriber = await resolveStreamingTranscriber({
       diarize: "required",
@@ -744,7 +779,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("diarize: 'required' with Deepgram constructs the transcriber with diarize: true", async () => {
     mockProviderKeys["deepgram"] = "dg-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveStreamingTranscriber({
       diarize: "required",
@@ -760,7 +795,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("sampleRate is still forwarded when diarize is enabled", async () => {
     mockProviderKeys["deepgram"] = "dg-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     await resolveStreamingTranscriber({
       diarize: "preferred",
@@ -779,7 +814,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("resolves a non-null xai transcriber when xai is configured and credentials are available", async () => {
     mockProviderKeys["xai"] = "xai-key";
-    mockConfig = buildConfig({ provider: "xai" });
+    applyConfig({ provider: "xai" });
 
     const transcriber = await resolveStreamingTranscriber();
 
@@ -791,7 +826,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("diarize: 'required' with xai constructs the transcriber (does not reject)", async () => {
     mockProviderKeys["xai"] = "xai-key";
-    mockConfig = buildConfig({ provider: "xai" });
+    applyConfig({ provider: "xai" });
 
     const transcriber = await resolveStreamingTranscriber({
       diarize: "required",
@@ -807,7 +842,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("returns null for xai when no credential is set", async () => {
     mockProviderKeys = {};
-    mockConfig = buildConfig({ provider: "xai" });
+    applyConfig({ provider: "xai" });
 
     const transcriber = await resolveStreamingTranscriber();
 
@@ -821,7 +856,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("utteranceBoundaryFinals with xai returns null with a warning (per-segment finals cannot be boundary-gated)", async () => {
     mockProviderKeys["xai"] = "xai-key";
-    mockConfig = buildConfig({ provider: "xai" });
+    applyConfig({ provider: "xai" });
 
     const transcriber = await resolveStreamingTranscriber({
       utteranceBoundaryFinals: true,
@@ -838,7 +873,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("utteranceBoundaryFinals with Deepgram forwards the gating options", async () => {
     mockProviderKeys["deepgram"] = "dg-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveStreamingTranscriber({
       utteranceBoundaryFinals: true,
@@ -853,7 +888,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("utteranceBoundaryFinals with Deepgram forwards a caller-supplied utteranceEndMs", async () => {
     mockProviderKeys["deepgram"] = "dg-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveStreamingTranscriber({
       utteranceBoundaryFinals: true,
@@ -869,7 +904,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("utteranceEndMs without utteranceBoundaryFinals does not reach the Deepgram constructor", async () => {
     mockProviderKeys["deepgram"] = "dg-key";
-    mockConfig = buildConfig({ provider: "deepgram" });
+    applyConfig({ provider: "deepgram" });
 
     const transcriber = await resolveStreamingTranscriber({
       utteranceEndMs: 2500,
@@ -884,7 +919,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("utteranceBoundaryFinals with google-gemini returns null (catalog telephonyMode is batch-only)", async () => {
     mockProviderKeys["gemini"] = "gemini-key";
-    mockConfig = buildConfig({ provider: "google-gemini" });
+    applyConfig({ provider: "google-gemini" });
 
     const transcriber = await resolveStreamingTranscriber({
       utteranceBoundaryFinals: true,
@@ -900,7 +935,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("utteranceBoundaryFinals with openai-whisper returns null with a warning (finals fire only on stop — end-of-stream, not utterance boundary)", async () => {
     mockProviderKeys["openai"] = "openai-key";
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const transcriber = await resolveStreamingTranscriber({
       utteranceBoundaryFinals: true,
@@ -917,7 +952,7 @@ describe("resolveStreamingTranscriber diarize preference", () => {
 
   test("openai-whisper still resolves a streaming transcriber without utteranceBoundaryFinals", async () => {
     mockProviderKeys["openai"] = "openai-key";
-    mockConfig = buildConfig({ provider: "openai-whisper" });
+    applyConfig({ provider: "openai-whisper" });
 
     const transcriber = await resolveStreamingTranscriber();
 
@@ -925,3 +960,105 @@ describe("resolveStreamingTranscriber diarize preference", () => {
     expect(whisperCtorCalls).toHaveLength(1);
   });
 });
+
+describe("vellum managed resolution", () => {
+  beforeEach(() => {
+    mockVellumAvailable = false;
+    mockProviderKeys = {};
+    mockVelayConnection = null;
+    vellumStreamCtorCalls.length = 0;
+  });
+
+  test("managed mode resolves the vellum batch transcriber when the platform connection exists", async () => {
+    mockVellumAvailable = true;
+    applyConfig({ provider: "deepgram", mode: "managed" });
+
+    const transcriber = await resolveBatchTranscriber();
+    expect(transcriber?.providerId).toBe("vellum");
+  });
+
+  test("managed mode resolves null without a platform connection", async () => {
+    mockVellumAvailable = false;
+    applyConfig({ provider: "deepgram", mode: "managed" });
+
+    expect(await resolveBatchTranscriber()).toBeNull();
+  });
+
+  test("managed mode preserves the BYOK provider choice (effective provider is vellum)", async () => {
+    mockVellumAvailable = true;
+    mockProviderKeys = { deepgram: "dg-key" };
+    applyConfig({ provider: "deepgram", mode: "managed" });
+
+    const capability = await resolveConversationStreamingSttCapability();
+    expect(capability.status).toBe("supported");
+    if (capability.status === "supported") {
+      expect(capability.providerId).toBe("vellum");
+      expect(capability.streamingMode).toBe("realtime-ws");
+    }
+  });
+
+  test("streaming resolver constructs the vellum adapter with the velay connection and sample rate", async () => {
+    mockVellumAvailable = true;
+    mockVelayConnection = {
+      wsBaseUrl: "ws://gateway.test",
+      httpBaseUrl: "http://gateway.test",
+      mintServiceToken: () => "vk-test",
+    };
+    applyConfig({ provider: "openai-whisper", mode: "managed" });
+
+    const transcriber = await resolveStreamingTranscriber({
+      sampleRate: 24000,
+    });
+    expect(transcriber?.providerId).toBe("vellum");
+    expect(vellumStreamCtorCalls).toEqual([
+      {
+        connection: mockVelayConnection,
+        options: { sampleRate: 24000 },
+      },
+    ]);
+  });
+
+  test("streaming resolver returns null when the platform connection is unavailable", async () => {
+    mockVellumAvailable = false;
+    mockVelayConnection = {
+      wsBaseUrl: "ws://gateway.test",
+      httpBaseUrl: "http://gateway.test",
+      mintServiceToken: () => "vk-test",
+    };
+    applyConfig({ provider: "deepgram", mode: "managed" });
+
+    expect(await resolveStreamingTranscriber({ sampleRate: 16000 })).toBeNull();
+    expect(vellumStreamCtorCalls).toHaveLength(0);
+  });
+
+  test("streaming resolver returns null when the velay connection is missing", async () => {
+    mockVellumAvailable = true;
+    mockVelayConnection = null;
+    applyConfig({ provider: "deepgram", mode: "managed" });
+
+    expect(await resolveStreamingTranscriber({ sampleRate: 16000 })).toBeNull();
+    expect(vellumStreamCtorCalls).toHaveLength(0);
+  });
+
+  test("conversation streaming capability reports missing credentials without a connection", async () => {
+    mockVellumAvailable = false;
+    applyConfig({ provider: "deepgram", mode: "managed" });
+
+    const capability = await resolveConversationStreamingSttCapability();
+    expect(capability.status).toBe("missing-credentials");
+    if (capability.status === "missing-credentials") {
+      // Connection-based gap copy: the fix is connecting the account,
+      // not entering an API key.
+      expect(capability.reason).toContain("platform connect");
+      expect(capability.reason).not.toContain("API key");
+    }
+  });
+});
+
+describe("sttCredentialGapReason", () => {
+  test("vellum gets connection copy; API-key providers keep key copy", () => {
+    expect(sttCredentialGapReason("vellum")).toContain("platform connect");
+    expect(sttCredentialGapReason("vellum")).not.toContain("API key");
+    expect(sttCredentialGapReason("deepgram")).toContain("API key");
+  });
+});