@vellumai/assistant 0.6.3 → 0.6.5

package/src/__tests__/call-controller.test.ts

@@ -35,10 +35,43 @@ mock.module("../config/loader.js", () => {
       silenceTimeoutSeconds: 30,
       disclosure: { enabled: false, text: "" },
       safety: { denyCategories: [] },
-      model: undefined,
     },
     memory: { enabled: false },
-    notifications: { decisionModelIntent: "latency-optimized" },
+    notifications: {},
+    services: {
+      tts: {
+        mode: "your-own" as const,
+        provider: "elevenlabs",
+        providers: {
+          elevenlabs: {
+            voiceId: "ZF6FPAbjXT4488VcRRnw",
+            voiceModelId: "",
+            speed: 1.0,
+            stability: 0.5,
+            similarityBoost: 0.75,
+            conversationTimeoutSeconds: 30,
+          },
+          "fish-audio": {
+            referenceId: "",
+            chunkLength: 200,
+            format: "mp3",
+            latency: "normal",
+            speed: 1.0,
+          },
+          deepgram: {
+            model: "aura-2-theia-en",
+            format: "mp3",
+          },
+        },
+      },
+    },
+    elevenlabs: {
+      voiceId: "ZF6FPAbjXT4488VcRRnw",
+    },
+    fishAudio: {
+      referenceId: "",
+      format: "mp3",
+    },
   };
   return {
     getConfig: () => config,
@@ -54,6 +87,17 @@ mock.module("../config/loader.js", () => {
   };
 });
 
+// ── Credential mock (prevents real key lookups) ──────────────────────
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async () => null,
+  getSecureKey: () => null,
+}));
+
+mock.module("../security/credential-key.js", () => ({
+  credentialKey: (...args: string[]) => args.join("/"),
+}));
+
 // ── Call constants mock ──────────────────────────────────────────────
 
 let mockConsultationTimeoutMs = 90_000;
@@ -128,6 +172,63 @@ mock.module("../calls/voice-session-bridge.js", () => {
   };
 });
 
+// ── TTS provider registry setup ──────────────────────────────────────
+// Register test providers so call-controller can resolve the TTS provider
+// abstraction. ElevenLabs is the default native provider (no streaming),
+// while Fish Audio is a synthesized provider (streaming).
+
+import {
+  _resetTtsProviderRegistry,
+  registerTtsProvider,
+} from "../tts/provider-registry.js";
+import type { TtsProvider } from "../tts/types.js";
+
+function registerTestTtsProviders(): void {
+  _resetTtsProviderRegistry();
+
+  const elevenlabs: TtsProvider = {
+    id: "elevenlabs",
+    capabilities: { supportsStreaming: false, supportedFormats: ["mp3"] },
+    async synthesize() {
+      return { audio: Buffer.from(""), contentType: "audio/mpeg" };
+    },
+  };
+  registerTtsProvider(elevenlabs);
+
+  const fishAudio: TtsProvider = {
+    id: "fish-audio",
+    capabilities: {
+      supportsStreaming: true,
+      supportedFormats: ["mp3", "wav", "opus"],
+    },
+    async synthesize() {
+      return { audio: Buffer.from(""), contentType: "audio/mpeg" };
+    },
+    async synthesizeStream(_req, _onChunk) {
+      return { audio: Buffer.from(""), contentType: "audio/mpeg" };
+    },
+  };
+  registerTtsProvider(fishAudio);
+
+  const deepgram: TtsProvider = {
+    id: "deepgram",
+    capabilities: {
+      supportsStreaming: false,
+      supportedFormats: ["mp3", "wav", "opus"],
+    },
+    async synthesize() {
+      return {
+        audio: Buffer.from("fake-deepgram-audio"),
+        contentType: "audio/mpeg",
+      };
+    },
+  };
+  registerTtsProvider(deepgram);
+}
+
+// Register providers immediately so they're available for all tests
+registerTestTtsProviders();
+
 // ── Import source modules after all mocks are registered ────────────
 
 import { CallController } from "../calls/call-controller.js";
@@ -139,7 +240,9 @@ import {
   getPendingQuestion,
   updateCallSession,
 } from "../calls/call-store.js";
-import type { RelayConnection } from "../calls/relay-server.js";
+import type { CallTransport } from "../calls/call-transport.js";
+import { resolveCallTtsProvider } from "../calls/resolve-call-tts-provider.js";
+import { loadConfig } from "../config/loader.js";
 import {
   getCanonicalGuardianRequest,
   getPendingCanonicalRequestByCallSessionId,
@@ -154,18 +257,20 @@ afterAll(() => {
   resetDb();
 });
 
-// ── RelayConnection mock factory ────────────────────────────────────
+// ── CallTransport mock factory ───────────────────────────────────────
 
-interface MockRelay extends RelayConnection {
+interface MockTransport extends CallTransport {
   sentTokens: Array<{ token: string; last: boolean }>;
+  sentPlayUrls: string[];
   endCalled: boolean;
   endReason: string | undefined;
   mockConnectionState: string;
 }
 
-function createMockRelay(): MockRelay {
+function createMockTransport(): MockTransport {
   const state = {
     sentTokens: [] as Array<{ token: string; last: boolean }>,
+    sentPlayUrls: [] as string[],
     _endCalled: false,
     _endReason: undefined as string | undefined,
     _connectionState: "connected",
@@ -175,6 +280,9 @@ function createMockRelay(): MockRelay {
     get sentTokens() {
       return state.sentTokens;
     },
+    get sentPlayUrls() {
+      return state.sentPlayUrls;
+    },
     get endCalled() {
       return state._endCalled;
     },
@@ -190,6 +298,9 @@ function createMockRelay(): MockRelay {
     sendTextToken(token: string, last: boolean) {
       state.sentTokens.push({ token, last });
     },
+    sendPlayUrl(url: string) {
+      state.sentPlayUrls.push(url);
+    },
     endSession(reason?: string) {
       state._endCalled = true;
       state._endReason = reason;
@@ -197,7 +308,7 @@ function createMockRelay(): MockRelay {
     getConnectionState() {
       return state._connectionState;
     },
-  } as unknown as MockRelay;
+  } as MockTransport;
 }
 
 // ── Helpers ─────────────────────────────────────────────────────────
@@ -254,7 +365,7 @@ async function pollUntil(
 }
 
 /**
- * Create a call session and a controller wired to a mock relay.
+ * Create a call session and a controller wired to a mock transport.
  */
 function setupController(
   task?: string,
@@ -272,17 +383,12 @@ function setupController(
     task,
   });
   updateCallSession(session.id, { status: "in_progress" });
-  const relay = createMockRelay();
-  const controller = new CallController(
-    session.id,
-    relay as unknown as RelayConnection,
-    task ?? null,
-    {
-      assistantId: opts?.assistantId,
-      trustContext: opts?.trustContext,
-    },
-  );
-  return { session, relay, controller };
+  const transport = createMockTransport();
+  const controller = new CallController(session.id, transport, task ?? null, {
+    assistantId: opts?.assistantId,
+    trustContext: opts?.trustContext,
+  });
+  return { session, relay: transport, controller };
 }
 
 function getLatestAssistantText(conversationId: string): string | null {
@@ -325,14 +431,14 @@ function setupControllerWithOrigin(task?: string) {
     status: "in_progress",
     startedAt: Date.now() - 30_000,
   });
-  const relay = createMockRelay();
+  const transport = createMockTransport();
   const controller = new CallController(
     session.id,
-    relay as unknown as RelayConnection,
+    transport,
     task ?? null,
     {},
   );
-  return { session, relay, controller };
+  return { session, relay: transport, controller };
 }
 
 describe("call-controller", () => {
@@ -345,6 +451,12 @@ describe("call-controller", () => {
     // Reset consultation timeout to the default (long) value
     mockConsultationTimeoutMs = 90_000;
     mockSilenceTimeoutMs = 30_000;
+    // Reset TTS config to defaults so per-test mutations don't leak.
+    const cfg = loadConfig();
+    cfg.services.tts.provider = "elevenlabs";
+    cfg.services.tts.providers["fish-audio"].referenceId = "";
+    // Reset TTS provider registry to ensure clean state
+    registerTestTtsProviders();
   });
 
   // ── handleCallerUtterance ─────────────────────────────────────────
@@ -2291,4 +2403,452 @@ describe("call-controller", () => {
 
     controller.destroy();
   });
+
+  // ── TTS provider abstraction: native-token path ─────────────────────
+
+  test("native provider (ElevenLabs): streams text tokens directly to relay", async () => {
+    // Default config uses ElevenLabs (native, no streaming) — the text
+    // tokens should flow directly through sendTextToken to the relay.
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Hello", ", how", " are you?"]),
+    );
+    const { relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("Hi");
+
+    // Verify text tokens were sent directly (not empty — real text content)
+    const nonEmptyTokens = relay.sentTokens.filter((t) => t.token.length > 0);
+    expect(nonEmptyTokens.length).toBeGreaterThan(0);
+    // At least one token should contain actual text content
+    const allText = nonEmptyTokens.map((t) => t.token).join("");
+    expect(allText).toContain("Hello");
+    expect(allText).toContain("how");
+    expect(allText).toContain("are you");
+
+    // The final token should signal end of turn
+    const lastToken = relay.sentTokens[relay.sentTokens.length - 1];
+    expect(lastToken.last).toBe(true);
+
+    controller.destroy();
+  });
+
+  test("native provider (ElevenLabs): strips control markers from streamed text tokens", async () => {
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn([
+        "I will check on that. ",
+        "[ASK_GUARDIAN: Is 3pm ok?]",
+      ]),
+    );
+    const { relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("Book an appointment");
+
+    const allText = relay.sentTokens.map((t) => t.token).join("");
+    expect(allText).toContain("I will check on that.");
+    expect(allText).not.toContain("[ASK_GUARDIAN:");
+
+    controller.destroy();
+  });
+
+  test("native provider (ElevenLabs): END_CALL marker handled correctly with text tokens", async () => {
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Thanks for calling! ", "[END_CALL]"]),
+    );
+    const { session, relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("Goodbye");
+
+    expect(relay.endCalled).toBe(true);
+    const updatedSession = getCallSession(session.id);
+    expect(updatedSession!.status).toBe("completed");
+
+    const allText = relay.sentTokens.map((t) => t.token).join("");
+    expect(allText).not.toContain("[END_CALL]");
+    expect(allText).toContain("Thanks for calling!");
+
+    controller.destroy();
+  });
+
+  test("synthesized provider: if synthesis fails before first chunk, falls back to text-token speech without sending play URL", async () => {
+    const cfg = loadConfig();
+    cfg.services.tts.provider = "fish-audio";
+    cfg.services.tts.providers["fish-audio"].referenceId = "fish-ref-123";
+
+    _resetTtsProviderRegistry();
+    const elevenlabs: TtsProvider = {
+      id: "elevenlabs",
+      capabilities: { supportsStreaming: false, supportedFormats: ["mp3"] },
+      async synthesize() {
+        return { audio: Buffer.from(""), contentType: "audio/mpeg" };
+      },
+    };
+    registerTtsProvider(elevenlabs);
+
+    const fishAudioFailing: TtsProvider = {
+      id: "fish-audio",
+      capabilities: {
+        supportsStreaming: true,
+        supportedFormats: ["mp3", "wav", "opus"],
+      },
+      async synthesize() {
+        throw new Error("fish-audio synth failure");
+      },
+      async synthesizeStream() {
+        throw new Error("fish-audio stream failure");
+      },
+    };
+    registerTtsProvider(fishAudioFailing);
+
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Hello from synthesized path"]),
+    );
+    const { relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("Hi");
+
+    // No play URL should be emitted when synthesis fails before first chunk.
+    expect(relay.sentPlayUrls.length).toBe(0);
+
+    // Fallback token speech should still reach the caller.
+    const fallbackText = relay.sentTokens.map((t) => t.token).join("");
+    expect(fallbackText).toContain("Hello from synthesized path");
+
+    const lastToken = relay.sentTokens[relay.sentTokens.length - 1];
+    expect(lastToken.last).toBe(true);
+
+    controller.destroy();
+  });
+
+  test("Deepgram selected path resolves useSynthesizedPath to true", () => {
+    const cfg = loadConfig();
+    cfg.services.tts.provider = "deepgram";
+
+    const result = resolveCallTtsProvider();
+    expect(result.provider).not.toBeNull();
+    expect(result.provider!.id).toBe("deepgram");
+    expect(result.useSynthesizedPath).toBe(true);
+  });
+
+  test("Deepgram synthesis failure does NOT fall back to native token TTS", async () => {
+    const cfg = loadConfig();
+    cfg.services.tts.provider = "deepgram";
+
+    _resetTtsProviderRegistry();
+    const elevenlabs: TtsProvider = {
+      id: "elevenlabs",
+      capabilities: { supportsStreaming: false, supportedFormats: ["mp3"] },
+      async synthesize() {
+        return { audio: Buffer.from(""), contentType: "audio/mpeg" };
+      },
+    };
+    registerTtsProvider(elevenlabs);
+
+    const deepgramFailing: TtsProvider = {
+      id: "deepgram",
+      capabilities: {
+        supportsStreaming: false,
+        supportedFormats: ["mp3", "wav", "opus"],
+      },
+      async synthesize() {
+        const err = new Error("Deepgram TTS returned 503: service unavailable");
+        (err as Error & { code?: string }).code = "DEEPGRAM_TTS_HTTP_ERROR";
+        throw err;
+      },
+    };
+    registerTtsProvider(deepgramFailing);
+
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Hello from deepgram path"]),
+    );
+    const { relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("Hi");
+
+    // No play URL should be emitted when synthesis fails.
+    expect(relay.sentPlayUrls.length).toBe(0);
+
+    // Deepgram should NOT have fallen back to sending the LLM text as
+    // native token TTS. Instead, the outer error handler should have
+    // produced a recovery message ("Could you repeat that?").
+    const allTokenText = relay.sentTokens.map((t) => t.token).join("");
+    expect(allTokenText).not.toContain("Hello from deepgram path");
+    expect(allTokenText).toContain("technical issue");
+
+    controller.destroy();
+  });
+
+  test("Fish Audio synthesis failure still falls back to native token TTS (unchanged behavior)", async () => {
+    const cfg = loadConfig();
+    cfg.services.tts.provider = "fish-audio";
+    cfg.services.tts.providers["fish-audio"].referenceId = "fish-ref-abc";
+
+    _resetTtsProviderRegistry();
+    const elevenlabs: TtsProvider = {
+      id: "elevenlabs",
+      capabilities: { supportsStreaming: false, supportedFormats: ["mp3"] },
+      async synthesize() {
+        return { audio: Buffer.from(""), contentType: "audio/mpeg" };
+      },
+    };
+    registerTtsProvider(elevenlabs);
+
+    const fishAudioFailing: TtsProvider = {
+      id: "fish-audio",
+      capabilities: {
+        supportsStreaming: true,
+        supportedFormats: ["mp3", "wav", "opus"],
+      },
+      async synthesize() {
+        throw new Error("fish-audio synth failure");
+      },
+      async synthesizeStream() {
+        throw new Error("fish-audio stream failure");
+      },
+    };
+    registerTtsProvider(fishAudioFailing);
+
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Hello from fish path"]),
+    );
+    const { relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("Hi");
+
+    // Fish Audio fallback: the LLM text should reach the caller
+    // via native token TTS despite synthesis failure.
+    const allTokenText = relay.sentTokens.map((t) => t.token).join("");
+    expect(allTokenText).toContain("Hello from fish path");
+
+    controller.destroy();
+  });
+
+  // ── TTS provider abstraction: interruption behavior ─────────────────
+
+  test("handleInterrupt: cancels synthesis abort controller for native provider path", async () => {
+    // Using the default native provider (ElevenLabs) — no synthesis abort
+    // controller should be active, but interrupt should still work cleanly.
+    mockStartVoiceTurn.mockImplementation(
+      async (opts: {
+        signal?: AbortSignal;
+        onTextDelta: (t: string) => void;
+        onComplete: () => void;
+      }) => {
+        return new Promise((resolve) => {
+          const timeout = setTimeout(() => {
+            opts.onTextDelta("This should be interrupted");
+            opts.onComplete();
+            resolve({ turnId: "run-1", abort: () => {} });
+          }, 1000);
+
+          opts.signal?.addEventListener(
+            "abort",
+            () => {
+              clearTimeout(timeout);
+              opts.onComplete();
+              resolve({ turnId: "run-1", abort: () => {} });
+            },
+            { once: true },
+          );
+        });
+      },
+    );
+
+    const { relay, controller } = setupController();
+    const turnPromise = controller.handleCallerUtterance("Start speaking");
+    await new Promise((r) => setTimeout(r, 5));
+    controller.handleInterrupt();
+    await turnPromise;
+
+    // Should have sent an end-of-turn marker
+    const endTurnMarkers = relay.sentTokens.filter(
+      (t) => t.token === "" && t.last === true,
+    );
+    expect(endTurnMarkers.length).toBeGreaterThan(0);
+    expect(controller.getState()).toBe("idle");
+
+    controller.destroy();
+  });
+
+  // ── Shared TTS provider resolution ──────────────────────────────────
+
+  describe("resolveCallTtsProvider (shared helper)", () => {
+    test("returns native path with elevenlabs (non-streaming provider)", () => {
+      // Default config has provider: "elevenlabs" which is registered as
+      // non-streaming in registerTestTtsProviders()
+      const result = resolveCallTtsProvider();
+      expect(result.provider).not.toBeNull();
+      expect(result.provider!.id).toBe("elevenlabs");
+      expect(result.useSynthesizedPath).toBe(false);
+      expect(result.audioFormat).toBe("mp3");
+    });
+
+    test("returns fallback when provider registry is empty", () => {
+      _resetTtsProviderRegistry();
+      const result = resolveCallTtsProvider();
+      expect(result.provider).toBeNull();
+      expect(result.useSynthesizedPath).toBe(false);
+      expect(result.audioFormat).toBe("mp3");
+    });
+
+    test("degrades fish-audio synthesized path when referenceId is missing", () => {
+      const cfg = loadConfig();
+      cfg.services.tts.provider = "fish-audio";
+      cfg.services.tts.providers["fish-audio"].referenceId = "";
+
+      const result = resolveCallTtsProvider();
+      expect(result.provider).toBeNull();
+      expect(result.useSynthesizedPath).toBe(false);
+      expect(result.audioFormat).toBe("mp3");
+    });
+
+    test("call controller LLM path uses shared resolution (native provider sends text tokens)", async () => {
+      // With the default elevenlabs provider (non-streaming), the call
+      // controller should send text tokens directly to the relay (native path).
+      mockStartVoiceTurn.mockImplementation(
+        createMockVoiceTurn(["Hello", " caller"]),
+      );
+      const { relay, controller } = setupController();
+
+      await controller.handleCallerUtterance("Hi");
+
+      // Native path: text tokens should be sent, no play URLs
+      const nonEmptyTokens = relay.sentTokens.filter((t) => t.token.length > 0);
+      expect(nonEmptyTokens.length).toBeGreaterThan(0);
+      expect(relay.sentPlayUrls.length).toBe(0);
+
+      controller.destroy();
+    });
+
+    test("returns synthesized path with deepgram provider", () => {
+      const cfg = loadConfig();
+      cfg.services.tts.provider = "deepgram";
+
+      const result = resolveCallTtsProvider();
+      expect(result.provider).not.toBeNull();
+      expect(result.provider!.id).toBe("deepgram");
+      expect(result.useSynthesizedPath).toBe(true);
+      expect(result.audioFormat).toBe("mp3");
+    });
+
+    test("Deepgram does not apply fish-audio referenceId gate", () => {
+      // Deepgram has no referenceId requirement. Verify the fish-audio
+      // config gate does not apply to deepgram resolution.
+      const cfg = loadConfig();
+      cfg.services.tts.provider = "deepgram";
+      // fish-audio referenceId left empty — should not affect deepgram.
+      cfg.services.tts.providers["fish-audio"].referenceId = "";
+
+      const result = resolveCallTtsProvider();
+      expect(result.provider).not.toBeNull();
+      expect(result.provider!.id).toBe("deepgram");
+      expect(result.useSynthesizedPath).toBe(true);
+    });
+  });
+
+  // ── handleBargeIn ───────────────────────────────────────────────────
+
+  describe("handleBargeIn", () => {
+    test("handleBargeIn returns false and does not abort when controller is idle", () => {
+      const { relay, controller } = setupController();
+
+      // Controller starts idle after construction
+      expect(controller.getState()).toBe("idle");
+      const result = controller.handleBargeIn();
+
+      expect(result).toBe(false);
+      // No end-of-turn token should have been sent (no interruption)
+      const endTokens = relay.sentTokens.filter(
+        (t) => t.last === true && t.token === "",
+      );
+      expect(endTokens.length).toBe(0);
+
+      controller.destroy();
+    });
+
+    test("handleBargeIn returns false when controller is processing", async () => {
+      // Use a slow turn that never completes so we can observe
+      // the processing state.
+      mockStartVoiceTurn.mockImplementation(
+        async (opts: {
+          onTextDelta: (t: string) => void;
+          onComplete: () => void;
+          signal?: AbortSignal;
+        }) => {
+          // Don't call onComplete — keep in processing/speaking
+          return { turnId: "run-slow", abort: () => opts.onComplete() };
+        },
+      );
+
+      const { relay, controller } = setupController();
+      // Kick off a turn (moves to speaking state)
+      const turnPromise = controller.handleCallerUtterance("Hello");
+
+      // Wait for microtasks to settle
+      for (let i = 0; i < 5; i++) await Promise.resolve();
+
+      // The controller transitions to "speaking" once runTurnInner starts.
+      // Before any onTextDelta, a barge-in should be accepted if speaking.
+      // But if no text has been emitted yet, the state is "speaking" per
+      // the implementation (state is set to speaking at the start of
+      // runTurnInner). So handleBargeIn should accept. Let's verify the
+      // state and behavior.
+      const bargeResult = controller.handleBargeIn();
+
+      // Regardless of the specific state, if accepted the transport
+      // should see an interrupt token.
+      if (bargeResult) {
+        const endTokens = relay.sentTokens.filter(
+          (t) => t.last === true && t.token === "",
+        );
+        expect(endTokens.length).toBeGreaterThan(0);
+      }
+
+      // Cleanup: abort the pending turn
+      controller.destroy();
+      await turnPromise.catch(() => {});
+    });
+
+    test("handleBargeIn returns true and interrupts when controller is speaking", async () => {
+      // Create a turn that holds the speaking state long enough to test barge-in
+      let resolveComplete: () => void;
+      const completePromise = new Promise<void>((r) => {
+        resolveComplete = r;
+      });
+
+      mockStartVoiceTurn.mockImplementation(
+        async (opts: {
+          onTextDelta: (t: string) => void;
+          onComplete: () => void;
+          signal?: AbortSignal;
+        }) => {
+          opts.onTextDelta("Hello");
+          opts.onTextDelta(" there");
+          // Don't complete yet — wait for external signal
+          opts.signal?.addEventListener("abort", () => {
+            resolveComplete!();
+          });
+          await completePromise;
+          opts.onComplete();
+          return { turnId: "run-barge", abort: () => resolveComplete!() };
+        },
+      );
+
+      const { controller } = setupController();
+      const turnPromise = controller.handleCallerUtterance("Hi");
+
+      // Let microtasks settle so onTextDelta runs
+      for (let i = 0; i < 10; i++) await Promise.resolve();
+
+      expect(controller.getState()).toBe("speaking");
+
+      const result = controller.handleBargeIn();
+      expect(result).toBe(true);
+
+      // After barge-in, controller should be idle
+      expect(controller.getState()).toBe("idle");
+
+      controller.destroy();
+      await turnPromise.catch(() => {});
+    });
+  });
 });