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

package/src/tts/__tests__/provider-adapters.test.ts

@@ -4,13 +4,6 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 // Module mocks — must appear before any imports of the modules under test
 // ---------------------------------------------------------------------------
 
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // -- Config mock -----------------------------------------------------------
 
 let mockElevenLabsConfig = {
@@ -43,21 +36,6 @@ let mockXaiConfig = {
   bitRate: 128000,
 };
 
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => ({
-    services: {
-      tts: {
-        providers: {
-          elevenlabs: mockElevenLabsConfig,
-          "fish-audio": mockFishAudioConfig,
-          deepgram: mockDeepgramConfig,
-          xai: mockXaiConfig,
-        },
-      },
-    },
-  }),
-}));
-
 // -- Secure keys mock ------------------------------------------------------
 
 let mockApiKey: string | null = "test-elevenlabs-api-key";
@@ -121,6 +99,7 @@ mock.module("../providers/xai-tts-socket.js", () => ({
 // Imports (after mocks)
 // ---------------------------------------------------------------------------
 
+import { setConfig } from "../../__tests__/helpers/set-config.js";
 import {
   getProviderDefinition,
   getTtsProvider,
@@ -141,6 +120,20 @@ import { createXaiProvider, XaiTtsError } from "../providers/xai-provider.js";
 import type { XaiTtsSocketOptions } from "../providers/xai-tts-socket.js";
 import type { TtsSynthesisRequest } from "../types.js";
 
+/** Seed the current per-provider TTS config into the workspace config file. */
+function seedTtsConfig(): void {
+  setConfig("services", {
+    tts: {
+      providers: {
+        elevenlabs: mockElevenLabsConfig,
+        "fish-audio": mockFishAudioConfig,
+        deepgram: mockDeepgramConfig,
+        xai: mockXaiConfig,
+      },
+    },
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Fetch mock helpers
 // ---------------------------------------------------------------------------
@@ -181,6 +174,7 @@ beforeEach(() => {
   mockSynthesizeWithFishAudio.mockClear();
   mockSynthesizeOverXaiTtsSocket.mockClear();
   mockSynthesizeOverXaiTtsSocket.mockImplementation(defaultXaiSocketImpl);
+  seedTtsConfig();
 });
 
 afterEach(() => {
@@ -318,6 +312,7 @@ describe("ElevenLabs TTS provider adapter", () => {
 
   test("uses configured voiceModelId when set", async () => {
     mockElevenLabsConfig.voiceModelId = "eleven_turbo_v2_5";
+    seedTtsConfig();
 
     const audioPayload = new Uint8Array([0x49, 0x44, 0x33]);
     let capturedBody = "";
@@ -552,6 +547,7 @@ describe("ElevenLabs TTS provider adapter", () => {
 
   test("synthesizeStream respects configured voiceModelId over flash default", async () => {
     mockElevenLabsConfig.voiceModelId = "eleven_turbo_v2_5";
+    seedTtsConfig();
     let capturedBody = "";
 
     globalThis.fetch = mock(
@@ -979,6 +975,7 @@ describe("Fish Audio TTS provider adapter", () => {
 
   test("explicit format request does not set a sample rate", async () => {
     mockFishAudioConfig.format = "wav";
+    seedTtsConfig();
     const provider = createFishAudioProvider();
     await provider.synthesize(makeRequest());
 
@@ -1011,6 +1008,7 @@ describe("Fish Audio TTS provider adapter", () => {
 
   test("returns audio/mpeg content type for mp3 format", async () => {
     mockFishAudioConfig.format = "mp3";
+    seedTtsConfig();
     const provider = createFishAudioProvider();
     const result = await provider.synthesize(makeRequest());
     expect(result.contentType).toBe("audio/mpeg");
@@ -1018,6 +1016,7 @@ describe("Fish Audio TTS provider adapter", () => {
 
   test("returns audio/wav content type for wav format", async () => {
     mockFishAudioConfig.format = "wav";
+    seedTtsConfig();
     const provider = createFishAudioProvider();
     const result = await provider.synthesize(makeRequest());
     expect(result.contentType).toBe("audio/wav");
@@ -1025,6 +1024,7 @@ describe("Fish Audio TTS provider adapter", () => {
 
   test("returns audio/opus content type for opus format", async () => {
     mockFishAudioConfig.format = "opus";
+    seedTtsConfig();
     const provider = createFishAudioProvider();
     const result = await provider.synthesize(makeRequest());
     expect(result.contentType).toBe("audio/opus");
@@ -1034,6 +1034,7 @@ describe("Fish Audio TTS provider adapter", () => {
 
   test("throws FISH_AUDIO_TTS_NO_REFERENCE_ID when no reference ID is available", async () => {
     mockFishAudioConfig.referenceId = "";
+    seedTtsConfig();
 
     const provider = createFishAudioProvider();
 
@@ -1051,6 +1052,7 @@ describe("Fish Audio TTS provider adapter", () => {
 
   test("throws FISH_AUDIO_TTS_NO_REFERENCE_ID in synthesizeStream when no reference ID", async () => {
     mockFishAudioConfig.referenceId = "";
+    seedTtsConfig();
 
     const provider = createFishAudioProvider();
 
@@ -1263,6 +1265,7 @@ describe("Deepgram TTS provider adapter", () => {
 
   test("translates wav config format to linear16 encoding with container=wav", async () => {
     mockDeepgramConfig.format = "wav";
+    seedTtsConfig();
     const audioPayload = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
     let capturedUrl = "";
 
@@ -1282,6 +1285,7 @@ describe("Deepgram TTS provider adapter", () => {
 
   test("uses configured model", async () => {
     mockDeepgramConfig.model = "aura-luna-en";
+    seedTtsConfig();
     const audioPayload = new Uint8Array([0x49, 0x44, 0x33]);
     let capturedUrl = "";
 
@@ -1639,6 +1643,7 @@ describe("xAI TTS provider adapter", () => {
 
   test("uses configured voiceId when request has none", async () => {
     mockXaiConfig.voiceId = "ara";
+    seedTtsConfig();
     const audioPayload = new Uint8Array([0x49, 0x44, 0x33]);
     let capturedBody = "";
 
@@ -1658,6 +1663,7 @@ describe("xAI TTS provider adapter", () => {
 
   test("wav config format produces codec=wav without bit_rate", async () => {
     mockXaiConfig.format = "wav";
+    seedTtsConfig();
     const audioPayload = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
     let capturedBody = "";
 

package/src/tts/__tests__/provider-resolution.test.ts

@@ -6,6 +6,7 @@ import {
   getTtsProvider,
   listCatalogProviderIds,
 } from "../provider-catalog.js";
+import { resolveTtsConfig } from "../tts-config-resolver.js";
 import type { TtsProvider } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -81,3 +82,28 @@ describe("TTS provider resolution", () => {
     expect(resolved.id).toBe("elevenlabs");
   });
 });
+
+describe("managed TTS mode resolution", () => {
+  const configWith = (tts: Record<string, unknown>) =>
+    ({ services: { tts } }) as unknown as Parameters<
+      typeof resolveTtsConfig
+    >[0];
+
+  test("managed mode resolves provider vellum regardless of the BYOK choice", () => {
+    const config = configWith({
+      mode: "managed",
+      provider: "elevenlabs",
+      providers: {},
+    });
+    expect(resolveTtsConfig(config).provider).toBe("vellum");
+  });
+
+  test("your-own mode still resolves the configured provider", () => {
+    const config = configWith({
+      mode: "your-own",
+      provider: "deepgram",
+      providers: {},
+    });
+    expect(resolveTtsConfig(config).provider).toBe("deepgram");
+  });
+});

package/src/tts/__tests__/synthesis-stream.test.ts

@@ -1,10 +1,10 @@
-import { describe, expect, mock, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 
-mock.module("../../config/loader.js", () => ({
-  loadConfig: () => ({
-    ingress: { publicBaseUrl: "https://assistant.example.com" },
-  }),
-}));
+import { setConfig } from "../../__tests__/helpers/set-config.js";
+
+// The audio-store sink builds play URLs from `ingress.publicBaseUrl` (defaults
+// to ""), so seed the base URL the tests assert on.
+setConfig("ingress", { publicBaseUrl: "https://assistant.example.com" });
 
 import type { StreamingAudioHandle } from "../../calls/audio-store.js";
 import {

package/src/tts/__tests__/vellum-provider.test.ts

@@ -0,0 +1,251 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+let mockSynthesizeResult: unknown;
+let synthesizeCalls: Array<{
+  text: string;
+  format: string;
+  signal?: AbortSignal;
+}> = [];
+
+mock.module("../../platform/managed-speech.js", () => ({
+  managedSpeechSynthesize: async (input: {
+    text: string;
+    format: string;
+    signal?: AbortSignal;
+  }) => {
+    synthesizeCalls.push(input);
+    return mockSynthesizeResult;
+  },
+}));
+
+let mockRelayConnection: {
+  wsBaseUrl: string;
+  httpBaseUrl: string;
+  mintServiceToken: () => string;
+} | null = null;
+
+mock.module(
+  "../../providers/speech-to-text/vellum-speech-relay-connection.js",
+  () => ({
+    resolveSpeechRelayConnection: async () => mockRelayConnection,
+    mapVelayError: (e: { code: string }) => ({
+      category: "provider-error",
+      message: `mapped:${e.code}`,
+    }),
+    probeVelayRejection: async () => mockProbeRejection,
+  }),
+);
+let mockProbeRejection: { code: string; detail?: string } | null = null;
+
+let socketCalls: Array<{ url: string; text: string }> = [];
+let mockSocketResult: () => Promise<Buffer> = async () => Buffer.from("pcm");
+
+mock.module("../providers/vellum-tts-socket.js", () => ({
+  synthesizeOverVellumTtsSocket: async (opts: {
+    url: string;
+    text: string;
+    onChunk?: (c: Uint8Array) => void;
+  }) => {
+    socketCalls.push({ url: opts.url, text: opts.text });
+    const audio = await mockSocketResult();
+    opts.onChunk?.(audio);
+    return audio;
+  },
+}));
+
+import {
+  createVellumProvider,
+  vellumTtsProviderDefinition,
+} from "../providers/vellum-provider.js";
+import type { TtsSynthesisRequest } from "../types.js";
+
+const MP3_BYTES = Buffer.from([0x49, 0x44, 0x33]);
+
+function request(
+  overrides: Partial<TtsSynthesisRequest> = {},
+): TtsSynthesisRequest {
+  return {
+    text: "hello",
+    useCase: "message-playback",
+    ...overrides,
+  } as TtsSynthesisRequest;
+}
+
+describe("vellum TTS adapter", () => {
+  beforeEach(() => {
+    synthesizeCalls = [];
+    socketCalls = [];
+    mockProbeRejection = null;
+    mockSocketResult = async () => Buffer.from("pcm");
+    mockRelayConnection = {
+      wsBaseUrl: "ws://gateway.test",
+      httpBaseUrl: "http://gateway.test",
+      mintServiceToken: () => "tok-1",
+    };
+    mockSynthesizeResult = {
+      ok: true,
+      value: { audio: MP3_BYTES, contentType: "audio/mpeg" },
+    };
+  });
+
+  test("message playback synthesizes mp3 and round-trips audio", async () => {
+    const provider = createVellumProvider();
+    const result = await provider.synthesize(request());
+
+    expect(synthesizeCalls).toEqual([{ text: "hello", format: "mp3" }]);
+    expect(Buffer.compare(result.audio, MP3_BYTES)).toBe(0);
+    expect(result.contentType).toBe("audio/mpeg");
+  });
+
+  test("PCM hint maps to the platform's fixed 16 kHz PCM format", async () => {
+    const provider = createVellumProvider();
+    await provider.synthesize(request({ outputFormat: "pcm" }));
+
+    expect(synthesizeCalls[0].format).toBe("pcm_16000");
+    expect(
+      provider.resolveOutputSampleRateHz?.(request({ outputFormat: "pcm" })),
+    ).toBe(16000);
+    // Contract: undefined for non-PCM output.
+    expect(provider.resolveOutputSampleRateHz?.(request())).toBeUndefined();
+  });
+
+  test("forwards the abort signal to the platform call", async () => {
+    const controller = new AbortController();
+    const provider = createVellumProvider();
+    await provider.synthesize(request({ signal: controller.signal }));
+
+    expect(synthesizeCalls[0].signal).toBe(controller.signal);
+  });
+
+  test("insufficient balance throws a top-up message", async () => {
+    mockSynthesizeResult = {
+      ok: false,
+      kind: "platform-error",
+      status: 402,
+      code: "insufficient_balance",
+      message: "balance",
+    };
+    const provider = createVellumProvider();
+    await expect(provider.synthesize(request())).rejects.toThrow(
+      /Vellum credits/,
+    );
+  });
+
+  test("unavailable platform throws a connect-your-account message", async () => {
+    mockSynthesizeResult = {
+      ok: false,
+      kind: "unavailable",
+      message: "No Vellum platform connection.",
+    };
+    const provider = createVellumProvider();
+    await expect(provider.synthesize(request())).rejects.toThrow(
+      /platform connect/,
+    );
+  });
+});
+
+describe("vellum TTS streaming", () => {
+  beforeEach(() => {
+    synthesizeCalls = [];
+    socketCalls = [];
+    mockProbeRejection = null;
+    mockSocketResult = async () => Buffer.from("pcm");
+    mockRelayConnection = {
+      wsBaseUrl: "ws://gateway.test",
+      httpBaseUrl: "http://gateway.test",
+      mintServiceToken: () => "tok-1",
+    };
+    mockSynthesizeResult = {
+      ok: true,
+      value: { audio: MP3_BYTES, contentType: "audio/mpeg" },
+    };
+  });
+
+  test("PCM streaming dials the gateway relay with token and audio params", async () => {
+    const provider = createVellumProvider();
+    const chunks: Uint8Array[] = [];
+
+    const result = await provider.synthesizeStream!(
+      request({ outputFormat: "pcm" }),
+      (c) => chunks.push(c),
+    );
+
+    expect(socketCalls).toHaveLength(1);
+    const url = new URL(socketCalls[0]!.url);
+    expect(url.origin).toBe("ws://gateway.test");
+    expect(url.pathname).toBe("/v1/speech/tts/stream");
+    expect(url.searchParams.get("key")).toBe("tok-1");
+    expect(url.searchParams.get("encoding")).toBe("linear16");
+    expect(url.searchParams.get("sample_rate")).toBe("16000");
+    // Raw PCM, not Deepgram's default WAV container — RIFF headers would
+    // play as static on the headerless media-stream path.
+    expect(url.searchParams.get("container")).toBe("none");
+    expect(result.contentType).toBe("audio/pcm");
+    expect(chunks).toHaveLength(1);
+    // Batch path untouched.
+    expect(synthesizeCalls).toHaveLength(0);
+  });
+
+  test("non-PCM streaming delegates to the batch path with one chunk", async () => {
+    const provider = createVellumProvider();
+    const chunks: Uint8Array[] = [];
+
+    const result = await provider.synthesizeStream!(request(), (c) =>
+      chunks.push(c),
+    );
+
+    expect(socketCalls).toHaveLength(0);
+    expect(synthesizeCalls).toEqual([{ text: "hello", format: "mp3" }]);
+    expect(result.contentType).toBe("audio/mpeg");
+    expect(chunks).toHaveLength(1);
+  });
+
+  test("a rejected dial surfaces the relay's mapped rejection via the probe", async () => {
+    mockSocketResult = async () => {
+      throw new Error("socket closed before Flushed");
+    };
+    mockProbeRejection = { code: "insufficient_balance" };
+    const provider = createVellumProvider();
+
+    await expect(
+      provider.synthesizeStream!(request({ outputFormat: "pcm" }), () => {}),
+    ).rejects.toThrow("mapped:insufficient_balance");
+  });
+
+  test("no relay connection throws a connect-your-account message", async () => {
+    mockRelayConnection = null;
+    const provider = createVellumProvider();
+
+    await expect(
+      provider.synthesizeStream!(request({ outputFormat: "pcm" }), () => {}),
+    ).rejects.toThrow(/platform connect/);
+  });
+
+  test("streaming capability is advertised", () => {
+    expect(createVellumProvider().capabilities.supportsStreaming).toBe(true);
+  });
+});
+
+describe("vellum TTS definition", () => {
+  test("declares streaming synthesized-play with PCM media-stream playback", () => {
+    expect(vellumTtsProviderDefinition.capabilities.supportsStreaming).toBe(
+      true,
+    );
+    expect(vellumTtsProviderDefinition.callMode).toBe("synthesized-play");
+    expect(vellumTtsProviderDefinition.allowNativeFallback).toBe(false);
+    expect(vellumTtsProviderDefinition.mediaStreamPlayback.outputFormat).toBe(
+      "pcm",
+    );
+    expect(vellumTtsProviderDefinition.supportsVoiceSelection).toBe(false);
+  });
+
+  test("requires only the platform connection credential", () => {
+    expect(vellumTtsProviderDefinition.secretRequirements).toEqual([
+      {
+        credentialStoreKey: "credential/vellum/assistant_api_key",
+        displayName: "Vellum account connection",
+        setCommand: "assistant platform connect",
+      },
+    ]);
+  });
+});

package/src/tts/provider-catalog.ts

@@ -24,6 +24,7 @@ import type {
 import { deepgramTtsProviderDefinition } from "./providers/deepgram-provider.js";
 import { elevenLabsTtsProviderDefinition } from "./providers/elevenlabs-provider.js";
 import { fishAudioTtsProviderDefinition } from "./providers/fish-audio-provider.js";
+import { vellumTtsProviderDefinition } from "./providers/vellum-provider.js";
 import { xaiTtsProviderDefinition } from "./providers/xai-provider.js";
 import type { TtsProvider, TtsProviderId } from "./types.js";
 
@@ -47,11 +48,16 @@ const DEFINITIONS = {
   "fish-audio": fishAudioTtsProviderDefinition,
   deepgram: deepgramTtsProviderDefinition,
   xai: xaiTtsProviderDefinition,
+  vellum: vellumTtsProviderDefinition,
 } as const satisfies Record<TtsProviderId, TtsProviderDefinition>;
 
 /**
  * Definitions in display order (e.g. settings dropdowns).
  */
+// vellum is deliberately absent: managed mode is selected via
+// `services.tts.mode`, not the provider picker — today's settings UI writes
+// only `provider` + an API key, which the schema rejects for vellum. The
+// definition stays in DEFINITIONS so managed-mode resolution works.
 const CATALOG: readonly TtsProviderDefinition[] = [
   DEFINITIONS.elevenlabs,
   DEFINITIONS["fish-audio"],