@vellumai/assistant 0.5.6 → 0.5.7

package/src/__tests__/workspace-migrations-runner.test.ts

@@ -54,6 +54,7 @@ mock.module("node:fs", () => ({
 // Import after mocking
 import {
   loadCheckpoints,
+  rollbackWorkspaceMigrations,
   runWorkspaceMigrations,
 } from "../workspace/migrations/runner.js";
 
@@ -68,6 +69,7 @@ function makeMigration(id: string): WorkspaceMigration {
     id,
     description: `Migration ${id}`,
     run: mock(() => {}),
+    down: mock(() => {}),
   };
 }
 
@@ -244,6 +246,7 @@ describe("runWorkspaceMigrations", () => {
         // Simulate async work
         await Promise.resolve();
       }),
+      down: mock(() => {}),
     };
 
     await runWorkspaceMigrations(WORKSPACE_DIR, [asyncMigration]);
@@ -291,3 +294,114 @@ describe("runWorkspaceMigrations", () => {
     );
   });
 });
+
+describe("rollbackWorkspaceMigrations", () => {
+  beforeEach(() => {
+    mockCheckpointContents = null;
+    readTextFileSyncFn.mockClear();
+    ensureDirFn.mockClear();
+    writeFileSyncFn.mockClear();
+    renameSyncFn.mockClear();
+    logWarnFn.mockClear();
+    logInfoFn.mockClear();
+    logErrorFn.mockClear();
+  });
+
+  test("rolls back migrations in reverse order", async () => {
+    const m1 = makeMigration("001");
+    const m2 = makeMigration("002");
+    const m3 = makeMigration("003");
+
+    // All three migrations are marked as completed in checkpoints
+    mockCheckpointContents = JSON.stringify({
+      applied: {
+        "001": { appliedAt: "2025-01-01T00:00:00.000Z", status: "completed" },
+        "002": { appliedAt: "2025-01-02T00:00:00.000Z", status: "completed" },
+        "003": { appliedAt: "2025-01-03T00:00:00.000Z", status: "completed" },
+      },
+    });
+
+    const callOrder: string[] = [];
+    (m2.down as ReturnType<typeof mock>).mockImplementation(() => {
+      callOrder.push("002");
+    });
+    (m3.down as ReturnType<typeof mock>).mockImplementation(() => {
+      callOrder.push("003");
+    });
+
+    // Roll back to m1 — should reverse m3 then m2, but not m1
+    await rollbackWorkspaceMigrations(WORKSPACE_DIR, [m1, m2, m3], "001");
+
+    expect(m3.down).toHaveBeenCalledTimes(1);
+    expect(m2.down).toHaveBeenCalledTimes(1);
+    expect(m1.down).not.toHaveBeenCalled();
+    expect(callOrder).toEqual(["003", "002"]);
+  });
+
+  test("handles crash during rollback (rolling_back status)", async () => {
+    const m1 = makeMigration("001");
+
+    // Simulate a crash during a previous rollback — m1 is left in rolling_back state
+    mockCheckpointContents = JSON.stringify({
+      applied: {
+        "001": {
+          appliedAt: "2025-01-01T00:00:00.000Z",
+          status: "rolling_back",
+        },
+      },
+    });
+
+    // runWorkspaceMigrations should clear the rolling_back status and re-run forward
+    await runWorkspaceMigrations(WORKSPACE_DIR, [m1]);
+
+    // The runner treats "rolling_back" like "started" — it clears the entry and re-runs
+    expect(m1.run).toHaveBeenCalledTimes(1);
+  });
+
+  test("removes checkpoints for rolled-back migrations", async () => {
+    const m1 = makeMigration("001");
+    const m2 = makeMigration("002");
+    const m3 = makeMigration("003");
+
+    mockCheckpointContents = JSON.stringify({
+      applied: {
+        "001": { appliedAt: "2025-01-01T00:00:00.000Z", status: "completed" },
+        "002": { appliedAt: "2025-01-02T00:00:00.000Z", status: "completed" },
+        "003": { appliedAt: "2025-01-03T00:00:00.000Z", status: "completed" },
+      },
+    });
+
+    await rollbackWorkspaceMigrations(WORKSPACE_DIR, [m1, m2, m3], "001");
+
+    // The last checkpoint write should only contain m1 (002 and 003 were rolled back)
+    const lastWriteCall = writeFileSyncFn.mock.calls.at(-1) as unknown[];
+    const finalCheckpoint = JSON.parse(lastWriteCall[1] as string);
+    expect(finalCheckpoint.applied["001"]).toBeDefined();
+    expect(finalCheckpoint.applied["002"]).toBeUndefined();
+    expect(finalCheckpoint.applied["003"]).toBeUndefined();
+  });
+
+  test("no-op when already at target", async () => {
+    const m1 = makeMigration("001");
+    const m2 = makeMigration("002");
+    const m3 = makeMigration("003");
+
+    mockCheckpointContents = JSON.stringify({
+      applied: {
+        "001": { appliedAt: "2025-01-01T00:00:00.000Z", status: "completed" },
+        "002": { appliedAt: "2025-01-02T00:00:00.000Z", status: "completed" },
+        "003": { appliedAt: "2025-01-03T00:00:00.000Z", status: "completed" },
+      },
+    });
+
+    // Target is the last migration — nothing to roll back
+    await rollbackWorkspaceMigrations(WORKSPACE_DIR, [m1, m2, m3], "003");
+
+    expect(m1.down).not.toHaveBeenCalled();
+    expect(m2.down).not.toHaveBeenCalled();
+    expect(m3.down).not.toHaveBeenCalled();
+
+    // No checkpoint writes should have occurred (no rollback happened)
+    expect(writeFileSyncFn).not.toHaveBeenCalled();
+  });
+});

package/src/calls/audio-store.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from "bun:test";
+
+import { getAudio, storeAudio } from "./audio-store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Reset module-level state between tests by re-importing.
+ * Since the store uses module-level variables, we isolate via fresh imports
+ * where needed, but for most tests the shared module state is fine as long
+ * as we account for it.
+ */
+
+function makeBuffer(sizeBytes: number): Buffer {
+  return Buffer.alloc(sizeBytes, 0x42);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("audio-store", () => {
+  describe("storeAudio / getAudio", () => {
+    test("stores and retrieves audio by id", () => {
+      const buf = makeBuffer(1024);
+      const id = storeAudio(buf, "mp3");
+      const result = getAudio(id);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe("buffer");
+      if (result!.type === "buffer") {
+        expect(result!.buffer).toEqual(buf);
+      }
+      expect(result!.contentType).toBe("audio/mpeg");
+    });
+
+    test("returns correct content type for each format", () => {
+      const buf = makeBuffer(64);
+
+      const mp3Id = storeAudio(buf, "mp3");
+      expect(getAudio(mp3Id)!.contentType).toBe("audio/mpeg");
+
+      const wavId = storeAudio(buf, "wav");
+      expect(getAudio(wavId)!.contentType).toBe("audio/wav");
+
+      const opusId = storeAudio(buf, "opus");
+      expect(getAudio(opusId)!.contentType).toBe("audio/opus");
+    });
+
+    test("returns null for unknown id", () => {
+      expect(getAudio("nonexistent-id")).toBeNull();
+    });
+  });
+
+  describe("TTL expiration", () => {
+    test("expired entries return null", () => {
+      const buf = makeBuffer(128);
+      const id = storeAudio(buf, "wav");
+
+      // Fast-forward time past TTL (60s)
+      const originalNow = Date.now;
+      Date.now = () => originalNow() + 61_000;
+      try {
+        const result = getAudio(id);
+        expect(result).toBeNull();
+      } finally {
+        Date.now = originalNow;
+      }
+    });
+  });
+
+  describe("capacity eviction", () => {
+    test("evicts oldest entries when capacity is exceeded", () => {
+      // The store has a 50MB cap. Fill it with entries, then add one more
+      // that would exceed the cap. The oldest should be evicted.
+      const chunkSize = 10 * 1024 * 1024; // 10MB per chunk
+      const ids: string[] = [];
+
+      // Store 5 x 10MB = 50MB (at capacity)
+      for (let i = 0; i < 5; i++) {
+        ids.push(storeAudio(makeBuffer(chunkSize), "opus"));
+      }
+
+      // All 5 should be retrievable
+      for (const id of ids) {
+        expect(getAudio(id)).not.toBeNull();
+      }
+
+      // Add one more 10MB entry — should evict the oldest
+      const newId = storeAudio(makeBuffer(chunkSize), "mp3");
+      expect(getAudio(newId)).not.toBeNull();
+      // The first entry should have been evicted
+      expect(getAudio(ids[0]!)).toBeNull();
+    });
+  });
+});

package/src/calls/audio-store.ts

@@ -0,0 +1,205 @@
+import { randomUUID } from "node:crypto";
+
+interface AudioEntry {
+  buffer: Buffer;
+  contentType: string;
+  expiresAt: number;
+}
+
+interface StreamingAudioEntry {
+  contentType: string;
+  expiresAt: number;
+  chunks: Uint8Array[];
+  totalBytes: number;
+  complete: boolean;
+  subscribers: Set<ReadableStreamDefaultController<Uint8Array>>;
+}
+
+const store = new Map<string, AudioEntry>();
+const streamingStore = new Map<string, StreamingAudioEntry>();
+const MAX_STORE_BYTES = 50 * 1024 * 1024; // 50MB cap
+const TTL_MS = 60_000; // 60 seconds
+
+let currentBytes = 0;
+
+export function storeAudio(
+  buffer: Buffer,
+  format: "mp3" | "wav" | "opus",
+): string {
+  evictExpired();
+  // Evict oldest if over capacity
+  while (currentBytes + buffer.length > MAX_STORE_BYTES && store.size > 0) {
+    const oldest = store.keys().next().value;
+    if (oldest) removeEntry(oldest);
+  }
+  const id = randomUUID();
+  const contentType = contentTypeForFormat(format);
+  store.set(id, { buffer, contentType, expiresAt: Date.now() + TTL_MS });
+  currentBytes += buffer.length;
+  return id;
+}
+
+// ---------------------------------------------------------------------------
+// Streaming entries — audio is pushed chunk-by-chunk while being served
+// ---------------------------------------------------------------------------
+
+export interface StreamingAudioHandle {
+  audioId: string;
+  push: (chunk: Uint8Array) => void;
+  finalize: () => void;
+}
+
+export function createStreamingEntry(
+  format: "mp3" | "wav" | "opus",
+): StreamingAudioHandle {
+  evictExpired();
+  const id = randomUUID();
+  const contentType = contentTypeForFormat(format);
+  const entry: StreamingAudioEntry = {
+    contentType,
+    expiresAt: Date.now() + TTL_MS,
+    chunks: [],
+    totalBytes: 0,
+    complete: false,
+    subscribers: new Set(),
+  };
+  streamingStore.set(id, entry);
+
+  return {
+    audioId: id,
+    push(chunk: Uint8Array) {
+      entry.chunks.push(chunk);
+      entry.totalBytes += chunk.byteLength;
+      for (const controller of entry.subscribers) {
+        try {
+          controller.enqueue(chunk);
+        } catch {
+          entry.subscribers.delete(controller);
+        }
+      }
+    },
+    finalize() {
+      entry.complete = true;
+      for (const controller of entry.subscribers) {
+        try {
+          controller.close();
+        } catch {
+          // Already closed
+        }
+      }
+      entry.subscribers.clear();
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Retrieval — handles both regular and streaming entries
+// ---------------------------------------------------------------------------
+
+export type AudioResult =
+  | { type: "buffer"; buffer: Buffer; contentType: string }
+  | { type: "stream"; stream: ReadableStream<Uint8Array>; contentType: string };
+
+export function getAudio(id: string): AudioResult | null {
+  evictExpired();
+
+  // Check streaming store first
+  const streamingEntry = streamingStore.get(id);
+  if (streamingEntry) {
+    if (Date.now() > streamingEntry.expiresAt) {
+      streamingStore.delete(id);
+      return null;
+    }
+
+    if (streamingEntry.complete) {
+      // Synthesis finished — serve the complete buffer
+      const merged = mergeChunks(streamingEntry.chunks);
+      return {
+        type: "buffer",
+        buffer: Buffer.from(merged),
+        contentType: streamingEntry.contentType,
+      };
+    }
+
+    // Still streaming — return a ReadableStream that replays existing
+    // chunks and subscribes for future ones.
+    let ctrl: ReadableStreamDefaultController<Uint8Array>;
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        ctrl = controller;
+        for (const chunk of streamingEntry.chunks) {
+          controller.enqueue(chunk);
+        }
+        if (streamingEntry.complete) {
+          controller.close();
+        } else {
+          streamingEntry.subscribers.add(controller);
+        }
+      },
+      cancel() {
+        streamingEntry.subscribers.delete(ctrl);
+      },
+    });
+
+    return { type: "stream", stream, contentType: streamingEntry.contentType };
+  }
+
+  // Check regular store
+  const entry = store.get(id);
+  if (!entry) return null;
+  if (Date.now() > entry.expiresAt) {
+    removeEntry(id);
+    return null;
+  }
+  return { type: "buffer", buffer: entry.buffer, contentType: entry.contentType };
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function contentTypeForFormat(format: "mp3" | "wav" | "opus"): string {
+  return format === "mp3"
+    ? "audio/mpeg"
+    : format === "wav"
+      ? "audio/wav"
+      : "audio/opus";
+}
+
+function mergeChunks(chunks: Uint8Array[]): Uint8Array {
+  const totalLength = chunks.reduce((sum, c) => sum + c.byteLength, 0);
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return merged;
+}
+
+function removeEntry(id: string): void {
+  const entry = store.get(id);
+  if (entry) {
+    currentBytes -= entry.buffer.length;
+    store.delete(id);
+  }
+}
+
+function evictExpired(): void {
+  const now = Date.now();
+  for (const [id, entry] of store) {
+    if (now > entry.expiresAt) removeEntry(id);
+  }
+  for (const [id, entry] of streamingStore) {
+    if (now > entry.expiresAt) {
+      for (const controller of entry.subscribers) {
+        try {
+          controller.close();
+        } catch {
+          // noop
+        }
+      }
+      streamingStore.delete(id);
+    }
+  }
+}

package/src/calls/call-controller.ts

@@ -9,8 +9,10 @@
  */
 
 import { getGatewayInternalBaseUrl } from "../config/env.js";
+import { loadConfig } from "../config/loader.js";
 import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import { getPublicBaseUrl } from "../inbound/public-ingress-urls.js";
 import {
   expireCanonicalGuardianRequest,
   getCanonicalRequestByPendingQuestionId,
@@ -22,6 +24,7 @@ import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { mintDaemonDeliveryToken } from "../runtime/auth/token-service.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { getLogger } from "../util/logger.js";
+import { createStreamingEntry } from "./audio-store.js";
 import {
   getMaxCallDurationMs,
   getSilenceTimeoutMs,
@@ -42,6 +45,7 @@ import {
   updateCallSession,
 } from "./call-store.js";
 import { finalizeCall } from "./finalize-call.js";
+import { synthesizeWithFishAudio } from "./fish-audio-client.js";
 import { sendGuardianExpiryNotices } from "./guardian-action-sweep.js";
 import { dispatchGuardianQuestion } from "./guardian-dispatch.js";
 import type { RelayConnection } from "./relay-server.js";
@@ -56,6 +60,7 @@ import {
   extractBalancedJson,
   stripInternalSpeechMarkers,
 } from "./voice-control-protocol.js";
+import { isFishAudioTts } from "./voice-quality.js";
 import {
   startVoiceTurn,
   type VoiceTurnHandle,
@@ -101,6 +106,8 @@ export class CallController {
   private task: string | null;
   /** True when the call session was created via the inbound path (no outbound task). */
   private isInbound: boolean;
+  /** When true, the disclosure announcement is skipped for this call. */
+  private skipDisclosure: boolean;
   /** Instructions queued while an LLM turn is in-flight or during pending guardian input */
   private pendingInstructions: string[] = [];
   /** Ensures the call opener is triggered at most once per call. */
@@ -131,6 +138,8 @@ export class CallController {
    * without blocking the caller.
    */
   private guardianUnavailableForCall = false;
+  /** Active Fish Audio session — tracked so interrupt handling can close it. */
+  private activeFishAbort: AbortController | null = null;
 
   constructor(
     callSessionId: string,
@@ -150,9 +159,10 @@ export class CallController {
     this.assistantId = opts?.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID;
     this.trustContext = opts?.trustContext ?? null;
 
-    // Resolve the conversation ID from the call session
+    // Resolve the conversation ID and skipDisclosure from the call session
     const session = getCallSession(callSessionId);
     this.conversationId = session?.conversationId ?? callSessionId;
+    this.skipDisclosure = session?.skipDisclosure ?? false;
 
     this.startDurationTimer();
     this.resetSilenceTimer();
@@ -340,6 +350,11 @@ export class CallController {
     const wasSpeaking = this.state === "speaking";
     this.abortCurrentTurn();
     this.llmRunVersion++;
+    // Cancel in-flight Fish Audio synthesis on barge-in
+    if (this.activeFishAbort) {
+      this.activeFishAbort.abort();
+      this.activeFishAbort = null;
+    }
     // Explicitly terminate the in-progress TTS turn so the relay can
     // immediately hand control back to the caller after barge-in.
     if (wasSpeaking) {
@@ -370,6 +385,10 @@ export class CallController {
     this.pendingInstructions = [];
     this.llmRunVersion++;
     this.abortCurrentTurn();
+    if (this.activeFishAbort) {
+      this.activeFishAbort.abort();
+      this.activeFishAbort = null;
+    }
     this.currentTurnPromise = null;
     unregisterCallController(this.callSessionId);
 
@@ -516,24 +535,43 @@ export class CallController {
     runVersion: number,
     runSignal: AbortSignal,
   ): Promise<string> {
+    // Fish Audio TTS routing: when configured, buffer text by sentence
+    // boundaries and synthesize via Fish Audio instead of streaming text
+    // tokens for ElevenLabs TTS.
+    const config = loadConfig();
+    const useFishAudio = isFishAudioTts(config);
+
     // Buffer incoming tokens so we can strip control markers ([ASK_GUARDIAN:...], [END_CALL])
     // before they reach TTS. We hold text whenever an unmatched '[' appears, since it
     // could be the start of a control marker.
     let ttsBuffer = "";
     let fullResponseText = "";
 
+    // When using Fish Audio, we accumulate all text and synthesize
+    // the complete response at the end of the turn (better prosody).
+    let fishAudioTextBuffer = "";
+
+    /** Emit a chunk of safe text to the appropriate TTS backend. */
+    const emitSafeChunk = (safeText: string): void => {
+      if (useFishAudio) {
+        fishAudioTextBuffer += safeText;
+      } else {
+        this.relay.sendTextToken(safeText, false);
+      }
+    };
+
     const flushSafeText = (): void => {
       if (!this.isCurrentRun(runVersion)) return;
       if (ttsBuffer.length === 0) return;
       const bracketIdx = ttsBuffer.indexOf("[");
       if (bracketIdx === -1) {
         // No bracket at all — safe to flush everything
-        this.relay.sendTextToken(ttsBuffer, false);
+        emitSafeChunk(ttsBuffer);
         ttsBuffer = "";
       } else {
         // Flush everything before the bracket
         if (bracketIdx > 0) {
-          this.relay.sendTextToken(ttsBuffer.slice(0, bracketIdx), false);
+          emitSafeChunk(ttsBuffer.slice(0, bracketIdx));
           ttsBuffer = ttsBuffer.slice(bracketIdx);
         }
 
@@ -547,10 +585,10 @@ export class CallController {
           // Not a control marker prefix — flush up to the next '[' (if any)
           const nextBracket = ttsBuffer.indexOf("[", 1);
           if (nextBracket === -1) {
-            this.relay.sendTextToken(ttsBuffer, false);
+            emitSafeChunk(ttsBuffer);
             ttsBuffer = "";
           } else {
-            this.relay.sendTextToken(ttsBuffer.slice(0, nextBracket), false);
+            emitSafeChunk(ttsBuffer.slice(0, nextBracket));
             ttsBuffer = ttsBuffer.slice(nextBracket);
           }
         }
@@ -585,6 +623,7 @@ export class CallController {
         trustContext: this.trustContext ?? undefined,
         isInbound: this.isInbound,
         task: this.task,
+        skipDisclosure: this.skipDisclosure,
         onTextDelta,
         onComplete,
         onError,
@@ -625,10 +664,49 @@ export class CallController {
     // Final sweep: strip any remaining control markers from the buffer
     ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
     if (ttsBuffer.length > 0) {
-      this.relay.sendTextToken(ttsBuffer, false);
+      emitSafeChunk(ttsBuffer);
+    }
+
+    // When using Fish Audio, synthesize the complete response text in a
+    // single REST API call. The full text gives Fish Audio better context
+    // for prosody and intonation. Audio streams back via chunked transfer
+    // encoding and is forwarded to Twilio as it arrives.
+    if (useFishAudio && fishAudioTextBuffer.trim().length > 0) {
+      if (!this.isCurrentRun(runVersion)) return fullResponseText;
+      let handle: ReturnType<typeof createStreamingEntry> | null = null;
+      try {
+        const format = config.fishAudio.format ?? "mp3";
+        handle = createStreamingEntry(format as "mp3" | "wav" | "opus");
+        const baseUrl = getPublicBaseUrl(config);
+        const url = `${baseUrl}/v1/audio/${handle.audioId}`;
+        this.relay.sendPlayUrl(url);
+        const abortController = new AbortController();
+        this.activeFishAbort = abortController;
+        await synthesizeWithFishAudio(
+          fishAudioTextBuffer.trim(),
+          config.fishAudio,
+          {
+            onChunk: (chunk) => handle!.push(chunk),
+            signal: abortController.signal,
+          },
+        );
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+          log.debug("Fish Audio synthesis aborted (barge-in)");
+        } else {
+          log.error({ err }, "Fish Audio synthesis failed — skipping");
+        }
+      } finally {
+        this.activeFishAbort = null;
+        handle?.finalize();
+      }
     }
 
-    // Signal end of this turn's speech
+    // Signal end of this turn's speech.  An empty token with `last: true`
+    // tells ConversationRelay to start listening — it does NOT trigger TTS
+    // synthesis.  This is required even when Fish Audio handled all audio
+    // playback, because ConversationRelay still needs the end-of-turn signal
+    // to transition from "assistant speaking" to "caller speaking" state.
     this.relay.sendTextToken("", true);
 
     // Mark the greeting's first response as awaiting ack

package/src/calls/call-domain.ts

@@ -85,6 +85,7 @@ export type StartCallInput = {
   conversationId: string;
   assistantId?: string;
   callerIdentityMode?: "assistant_number" | "user_number";
+  skipDisclosure?: boolean;
 };
 
 export type CancelCallInput = {
@@ -364,6 +365,7 @@ export async function startCall(
     context: callContext,
     conversationId,
     callerIdentityMode,
+    skipDisclosure,
     assistantId = DAEMON_INTERNAL_ASSISTANT_ID,
   } = input;
 
@@ -440,6 +442,7 @@ export async function startCall(
       task: callContext ? `${task}\n\nContext: ${callContext}` : task,
       callerIdentityMode: identityResult.mode,
       callerIdentitySource: identityResult.source,
+      skipDisclosure,
       initiatedFromConversationId: conversationId,
     });
     sessionId = session.id;