@vellumai/assistant 0.5.6 → 0.5.8

package/src/calls/__tests__/tts-text-sanitizer.test.ts

@@ -0,0 +1,254 @@
+import { describe, expect, test } from "bun:test";
+
+import { sanitizeForTts } from "../tts-text-sanitizer.js";
+
+describe("sanitizeForTts", () => {
+  describe("markdown links", () => {
+    test("strips markdown links, keeping link text", () => {
+      expect(sanitizeForTts("Check [this link](https://example.com)")).toBe(
+        "Check this link",
+      );
+    });
+
+    test("handles multiple links", () => {
+      expect(
+        sanitizeForTts("See [foo](http://a.com) and [bar](http://b.com)"),
+      ).toBe("See foo and bar");
+    });
+
+    test("preserves Fish Audio S2 bracket annotations", () => {
+      expect(sanitizeForTts("Hello [laughter] world")).toBe(
+        "Hello [laughter] world",
+      );
+      expect(sanitizeForTts("[breath] ok")).toBe("[breath] ok");
+    });
+
+    test("handles URLs with balanced parentheses (e.g. Wikipedia)", () => {
+      expect(
+        sanitizeForTts(
+          "See [Function](https://en.wikipedia.org/wiki/Function_(mathematics))",
+        ),
+      ).toBe("See Function");
+    });
+
+    test("handles URLs with multiple balanced parentheses groups", () => {
+      expect(
+        sanitizeForTts("[link](http://example.com/a_(b)_c_(d))"),
+      ).toBe("link");
+    });
+  });
+
+  describe("bold and italic", () => {
+    test("strips bold (asterisks)", () => {
+      expect(sanitizeForTts("Hello **world**")).toBe("Hello world");
+    });
+
+    test("strips bold (underscores)", () => {
+      expect(sanitizeForTts("Hello __world__")).toBe("Hello world");
+    });
+
+    test("strips italic (asterisks)", () => {
+      expect(sanitizeForTts("Hello *world*")).toBe("Hello world");
+    });
+
+    test("strips italic (underscores)", () => {
+      expect(sanitizeForTts("Hello _world_")).toBe("Hello world");
+    });
+
+    test("strips bold+italic (asterisks)", () => {
+      expect(sanitizeForTts("Hello ***world***")).toBe("Hello world");
+    });
+
+    test("strips bold+italic (underscores)", () => {
+      expect(sanitizeForTts("Hello ___world___")).toBe("Hello world");
+    });
+
+    test("preserves arithmetic asterisks", () => {
+      expect(sanitizeForTts("5 * 3 = 15")).toBe("5 * 3 = 15");
+    });
+
+    test("preserves identifiers with underscores", () => {
+      expect(sanitizeForTts("The my_var variable")).toBe(
+        "The my_var variable",
+      );
+    });
+
+    test("preserves snake_case identifiers", () => {
+      expect(sanitizeForTts("use some_function_name here")).toBe(
+        "use some_function_name here",
+      );
+    });
+  });
+
+  describe("headers", () => {
+    test("strips h1", () => {
+      expect(sanitizeForTts("# Header\n\nSome text")).toBe(
+        "Header\n\nSome text",
+      );
+    });
+
+    test("strips h2", () => {
+      expect(sanitizeForTts("## Sub Header")).toBe("Sub Header");
+    });
+
+    test("strips h3 through h6", () => {
+      expect(sanitizeForTts("### H3")).toBe("H3");
+      expect(sanitizeForTts("#### H4")).toBe("H4");
+      expect(sanitizeForTts("##### H5")).toBe("H5");
+      expect(sanitizeForTts("###### H6")).toBe("H6");
+    });
+
+    test("does not strip # in middle of line", () => {
+      expect(sanitizeForTts("Issue #42")).toBe("Issue #42");
+    });
+  });
+
+  describe("code", () => {
+    test("strips code fences, keeping content", () => {
+      const input = "Here:\n```js\nconst x = 1;\n```\nDone.";
+      expect(sanitizeForTts(input)).toBe("Here:\nconst x = 1;\nDone.");
+    });
+
+    test("strips inline code backticks", () => {
+      expect(sanitizeForTts("Use `console.log` here")).toBe(
+        "Use console.log here",
+      );
+    });
+
+    test("preserves # comments inside code fences", () => {
+      const input = "Example:\n```python\n# This is a comment\nprint('hi')\n```\nDone.";
+      expect(sanitizeForTts(input)).toBe(
+        "Example:\n# This is a comment\nprint('hi')\nDone.",
+      );
+    });
+
+    test("preserves shell comments inside code fences", () => {
+      const input = "Run:\n```bash\n## Install deps\napt-get install curl\n```";
+      expect(sanitizeForTts(input)).toBe(
+        "Run:\n## Install deps\napt-get install curl\n",
+      );
+    });
+  });
+
+  describe("bullet markers", () => {
+    test("strips dash bullets", () => {
+      expect(sanitizeForTts("- First\n- Second")).toBe("First\nSecond");
+    });
+
+    test("strips asterisk bullets", () => {
+      expect(sanitizeForTts("* First\n* Second")).toBe("First\nSecond");
+    });
+
+    test("does not strip dashes mid-line", () => {
+      expect(sanitizeForTts("well-known fact")).toBe("well-known fact");
+    });
+  });
+
+  describe("emojis", () => {
+    test("strips simple emojis", () => {
+      expect(sanitizeForTts("Hello world 👋")).toBe("Hello world ");
+    });
+
+    test("strips compound emojis (ZWJ sequences)", () => {
+      // Family emoji: man + ZWJ + woman + ZWJ + girl
+      expect(sanitizeForTts("Family: 👨‍👩‍👧")).toBe("Family: ");
+    });
+
+    test("strips emojis with skin tone modifiers", () => {
+      expect(sanitizeForTts("Wave 👋🏽 hello")).toBe("Wave hello");
+    });
+
+    test("strips flag emojis", () => {
+      // Flags are regional indicator sequences (Extended_Pictographic)
+      expect(sanitizeForTts("Hello 🇺🇸 world")).toBe("Hello world");
+    });
+
+    test("strips emojis with variation selectors", () => {
+      // Heart with variation selector
+      expect(sanitizeForTts("Love ❤️ you")).toBe("Love you");
+    });
+
+    test("preserves numbers and currency", () => {
+      expect(sanitizeForTts("$100.50 and €200")).toBe("$100.50 and €200");
+    });
+
+    test("preserves punctuation", () => {
+      expect(sanitizeForTts("Hello, world! How are you?")).toBe(
+        "Hello, world! How are you?",
+      );
+    });
+  });
+
+  describe("whitespace collapsing", () => {
+    test("collapses multiple spaces to single space", () => {
+      expect(sanitizeForTts("Hello    world")).toBe("Hello world");
+    });
+
+    test("collapses multiple blank lines to single newline", () => {
+      expect(sanitizeForTts("Hello\n\n\n\nworld")).toBe("Hello\n\nworld");
+    });
+  });
+
+  describe("combined transformations", () => {
+    test("acceptance: Hello **world** with emoji", () => {
+      expect(sanitizeForTts("Hello **world** 👋")).toBe("Hello world ");
+    });
+
+    test("acceptance: markdown link", () => {
+      expect(
+        sanitizeForTts("Check [this link](https://example.com)"),
+      ).toBe("Check this link");
+    });
+
+    test("acceptance: arithmetic preserved", () => {
+      expect(sanitizeForTts("5 * 3 = 15")).toBe("5 * 3 = 15");
+    });
+
+    test("acceptance: header with text", () => {
+      expect(sanitizeForTts("# Header\n\nSome text")).toBe(
+        "Header\n\nSome text",
+      );
+    });
+
+    test("complex mixed markdown and emojis", () => {
+      const input =
+        "# Welcome 🎉\n\nHello **world**! Check [docs](http://x.com).\n\n- Item *one*\n- Item `two`";
+      const expected =
+        "Welcome \n\nHello world! Check docs.\n\nItem one\nItem two";
+      expect(sanitizeForTts(input)).toBe(expected);
+    });
+  });
+
+  describe("edge cases", () => {
+    test("empty string", () => {
+      expect(sanitizeForTts("")).toBe("");
+    });
+
+    test("already-clean text", () => {
+      const clean = "Hello, this is plain text.";
+      expect(sanitizeForTts(clean)).toBe(clean);
+    });
+
+    test("nested markdown (bold inside italic)", () => {
+      expect(sanitizeForTts("*Hello **world***")).toBe("Hello world");
+    });
+
+    test("partial markdown (unmatched asterisks)", () => {
+      expect(sanitizeForTts("Hello **world")).toBe("Hello **world");
+    });
+
+    test("idempotency: applying twice gives same result", () => {
+      const input = "# Hello **world** 👋\n\n- Item *one*\n- [link](http://x.com)";
+      const once = sanitizeForTts(input);
+      const twice = sanitizeForTts(once);
+      expect(twice).toBe(once);
+    });
+
+    test("preserves trailing whitespace for streaming chunks", () => {
+      // Streaming chunks must keep trailing spaces so word boundaries survive
+      // concatenation: "Hello " + "world" = "Hello world", not "Helloworld"
+      expect(sanitizeForTts("Hello ")).toBe("Hello ");
+      expect(sanitizeForTts("the quick ")).toBe("the quick ");
+    });
+  });
+});

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);
+    }
+  }
+}