@kuralle-syrinx/core 4.1.0 → 4.3.0

package/src/voice-text.ts

@@ -81,6 +81,75 @@ export function appendVoiceText(existing: string, next: string): string {
   return `${existing} ${normalizedNext}`;
 }
 
+/**
+ * Normalize a speakable segment so TTS does not read formatting aloud.
+ *
+ * LLM output is full of markdown — `**bold**`, `## heading`, `` `code` ``, `[text](url)` —
+ * and a TTS engine narrates the punctuation literally ("star star bold star star"). This is
+ * the single highest-frequency voice bug class and has no app-layer fix, because the text is
+ * generated inside the pipeline. Vapi ships a 14-step "voice formatting plan" on by default;
+ * this is the locale-free core of it: markdown removal.
+ *
+ * Deliberately conservative — it strips *formatting* markers, never content, so a sentence
+ * that legitimately contains an asterisk or a hash in prose is left intact where ambiguous.
+ * Number/currency/date verbalization is locale-sensitive and intentionally NOT done here yet;
+ * doing it wrong (wrong locale, wrong magnitude) speaks worse than leaving the digits. That is
+ * a separate stage, not a silent omission.
+ */
+/**
+ * Strip leaked tool-call protocol tokens so TTS never speaks them.
+ *
+ * A model emits tool calls in its own syntax (`<|tool_call|>…`, `<tool_call>…</tool_call>`,
+ * `[TOOL_CALLS]`, harmony `<|channel|>commentary`). The inference server is supposed to parse
+ * that into the structured `tool_calls` field; when the serving stack lacks the right parser
+ * the tokens fall through as ordinary assistant text and the pipeline speaks the markup aloud.
+ * LiveKit's finding: the same weights score 100% behind one endpoint and 0% behind another —
+ * it is the serving stack, not the model. Syrinx (and the Kuralle runtime) both read only the
+ * finalized structured tool-call and never text-scrape, so neither catches a leaked one.
+ *
+ * This is a high-precision guard: it removes only unambiguous sentinel tokens/blocks that never
+ * occur in real speech. It does NOT try to strip bare JSON function calls — that is ambiguous and
+ * stripping legitimate content is worse than the rare leak. A leak of that shape is a serving-stack
+ * bug to fix at the endpoint (LiveKit's "one curl" diagnosis), not something to paper over here.
+ */
+export function stripLeakedToolCalls(text: string): string {
+  let out = text;
+  // Paired XML-style blocks (Qwen/Hermes/Mistral): drop the whole block including inner JSON.
+  out = out.replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, "");
+  out = out.replace(/<tool_response>[\s\S]*?<\/tool_response>/gi, "");
+  // Harmony: a channel token is immediately followed by its label (analysis/commentary/final).
+  // Match the label only right after the token so a legitimate "commentary" in prose is untouched.
+  out = out.replace(/<\|channel\|>\s*(?:analysis|commentary|final)\b/gi, "");
+  // Special sentinel tokens (Gemma/Llama/harmony): <|...|> never appears in spoken text.
+  out = out.replace(/<\|[^|]*\|>/g, "");
+  // Mistral marker.
+  out = out.replace(/\[TOOL_CALLS\]/gi, "");
+  return out.replace(/[ \t]{2,}/g, " ").trim();
+}
+
+export function normalizeForSpeech(text: string): string {
+  let out = stripLeakedToolCalls(text);
+  // Links/images: [label](url) -> label ; ![alt](url) -> alt
+  out = out.replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1");
+  // Bold/italic/strikethrough: **x** __x__ *x* _x_ ~~x~~ -> x
+  out = out.replace(/(\*\*|__)(.+?)\1/g, "$2");
+  out = out.replace(/(\*|_)(?=\S)(.+?)(?<=\S)\1/g, "$2");
+  out = out.replace(/~~(.+?)~~/g, "$1");
+  // Inline + fenced code: `x` and ```x``` -> x
+  out = out.replace(/```[a-zA-Z0-9]*\n?([\s\S]*?)```/g, "$1");
+  out = out.replace(/`([^`]+)`/g, "$1");
+  // Leading block markers per line: headings (#), blockquotes (>), list bullets (-,*,+), numbered lists.
+  out = out.replace(/^\s{0,3}#{1,6}\s+/gm, "");
+  out = out.replace(/^\s{0,3}>\s?/gm, "");
+  out = out.replace(/^\s{0,3}[-*+]\s+/gm, "");
+  out = out.replace(/^\s{0,3}\d+\.\s+/gm, "");
+  // Horizontal rules on their own line.
+  out = out.replace(/^\s{0,3}([-*_])\1{2,}\s*$/gm, "");
+  // Collapse whitespace the stripping may have opened up, preserving single spaces.
+  out = out.replace(/[ \t]{2,}/g, " ");
+  return out;
+}
+
 function isClosingPunctuation(char: string): boolean {
   return char === ")" || char === "]" || char === "}" || char === "\"" || char === "'" || char === "”" || char === "’";
 }

package/src/audio/audio.test.ts

@@ -1,285 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-import { pcm16BytesToSamples, pcm16SamplesToBytes, bigEndianPcm16BytesToSamples, pcm16SamplesToBigEndianBytes } from "./pcm.js";
-import { decodeMuLawToPcm16, encodePcm16ToMuLaw } from "./mulaw.js";
-import { resamplePcm16, StreamingPcm16Resampler } from "./resample.js";
-
-// ── PCM byte ↔ sample conversions ──────────────────────────────────────────
-
-describe("pcm16BytesToSamples (little-endian)", () => {
-  it("decodes a known LE byte sequence", () => {
-    // [0x01, 0x00] = 1 in LE;  [0xFF, 0x7F] = 32767;  [0x00, 0x80] = -32768
-    const bytes = new Uint8Array([0x01, 0x00, 0xff, 0x7f, 0x00, 0x80]);
-    const samples = pcm16BytesToSamples(bytes);
-    expect(samples[0]).toBe(1);
-    expect(samples[1]).toBe(32767);
-    expect(samples[2]).toBe(-32768);
-  });
-
-  it("throws on odd byte length", () => {
-    expect(() => pcm16BytesToSamples(new Uint8Array(3))).toThrow(/even/);
-  });
-
-  it("round-trips through pcm16SamplesToBytes", () => {
-    const original = new Int16Array([0, 1, -1, 32767, -32768, 1000, -1000]);
-    const bytes = pcm16SamplesToBytes(original);
-    const recovered = pcm16BytesToSamples(bytes);
-    expect(Array.from(recovered)).toEqual(Array.from(original));
-  });
-});
-
-describe("pcm16SamplesToBytes (little-endian)", () => {
-  it("encodes a known sample sequence to LE bytes", () => {
-    const samples = new Int16Array([1, 32767, -32768]);
-    const bytes = pcm16SamplesToBytes(samples);
-    expect(bytes[0]).toBe(0x01);
-    expect(bytes[1]).toBe(0x00);
-    expect(bytes[2]).toBe(0xff);
-    expect(bytes[3]).toBe(0x7f);
-    expect(bytes[4]).toBe(0x00);
-    expect(bytes[5]).toBe(0x80);
-  });
-});
-
-describe("bigEndianPcm16BytesToSamples", () => {
-  it("decodes a known BE byte sequence", () => {
-    // BE: [0x00, 0x01] = 1;  [0x7F, 0xFF] = 32767;  [0x80, 0x00] = -32768
-    const bytes = new Uint8Array([0x00, 0x01, 0x7f, 0xff, 0x80, 0x00]);
-    const samples = bigEndianPcm16BytesToSamples(bytes);
-    expect(samples[0]).toBe(1);
-    expect(samples[1]).toBe(32767);
-    expect(samples[2]).toBe(-32768);
-  });
-
-  it("throws on odd byte length", () => {
-    expect(() => bigEndianPcm16BytesToSamples(new Uint8Array(3))).toThrow(/even/);
-  });
-
-  it("round-trips through pcm16SamplesToBigEndianBytes", () => {
-    const original = new Int16Array([0, 1, -1, 32767, -32768, 1000]);
-    const bytes = pcm16SamplesToBigEndianBytes(original);
-    const recovered = bigEndianPcm16BytesToSamples(bytes);
-    expect(Array.from(recovered)).toEqual(Array.from(original));
-  });
-});
-
-describe("LE vs BE byte order", () => {
-  it("produces distinct byte sequences for the same samples", () => {
-    const samples = new Int16Array([256]); // LE: [0x00, 0x01], BE: [0x01, 0x00]
-    const le = pcm16SamplesToBytes(samples);
-    const be = pcm16SamplesToBigEndianBytes(samples);
-    expect(le[0]).not.toBe(be[0]);
-  });
-
-  it("LE bytes decoded as BE yield wrong values and vice versa", () => {
-    const samples = new Int16Array([1000, -500]);
-    const leBytes = pcm16SamplesToBytes(samples);
-    const beBytes = pcm16SamplesToBigEndianBytes(samples);
-    // Cross-decode: LE bytes read as BE should NOT equal original
-    const mismatch = bigEndianPcm16BytesToSamples(leBytes);
-    expect(mismatch[0]).not.toBe(1000);
-    // BE bytes read as LE should NOT equal original
-    const mismatch2 = pcm16BytesToSamples(beBytes);
-    expect(mismatch2[0]).not.toBe(1000);
-  });
-});
-
-// ── μ-law codec ─────────────────────────────────────────────────────────────
-
-describe("μ-law round-trip", () => {
-  it("round-trips silence exactly", () => {
-    const silence = new Int16Array(160);
-    const encoded = encodePcm16ToMuLaw(silence);
-    const decoded = decodeMuLawToPcm16(encoded);
-    for (let i = 0; i < decoded.length; i += 1) {
-      // silence encodes to the mid-code and decodes back to near-zero
-      expect(Math.abs(decoded[i]!)).toBeLessThanOrEqual(8);
-    }
-  });
-
-  it("round-trips a sine wave within μ-law quantization tolerance", () => {
-    const N = 160;
-    const input = new Int16Array(N);
-    for (let i = 0; i < N; i += 1) {
-      input[i] = Math.round(16000 * Math.sin((2 * Math.PI * 1000 * i) / 8000));
-    }
-    const encoded = encodePcm16ToMuLaw(input);
-    expect(encoded.length).toBe(N);
-    const decoded = decodeMuLawToPcm16(encoded);
-    // μ-law is lossy; allow ≤5% full-scale error (~1638 counts)
-    for (let i = 0; i < N; i += 1) {
-      expect(Math.abs(decoded[i]! - input[i]!)).toBeLessThanOrEqual(1638);
-    }
-  });
-
-  it("preserves sign correctly", () => {
-    const positive = new Int16Array([10000]);
-    const negative = new Int16Array([-10000]);
-    const decPos = decodeMuLawToPcm16(encodePcm16ToMuLaw(positive));
-    const decNeg = decodeMuLawToPcm16(encodePcm16ToMuLaw(negative));
-    expect(decPos[0]).toBeGreaterThan(0);
-    expect(decNeg[0]).toBeLessThan(0);
-  });
-});
-
-// ── Resampler ───────────────────────────────────────────────────────────────
-
-describe("resamplePcm16 — identity and length", () => {
-  it("returns the same reference when rates are equal", () => {
-    const input = new Int16Array([100, 200, 300]);
-    const output = resamplePcm16(input, 16000, 16000);
-    expect(output).toBe(input);
-  });
-
-  it("returns empty array for empty input", () => {
-    const output = resamplePcm16(new Int16Array(0), 16000, 8000);
-    expect(output.length).toBe(0);
-  });
-
-  it("produces correct output length for 2× upsample", () => {
-    const input = new Int16Array(80);
-    const output = resamplePcm16(input, 8000, 16000);
-    expect(output.length).toBe(160);
-  });
-
-  it("produces correct output length for 2× downsample", () => {
-    const input = new Int16Array(160);
-    const output = resamplePcm16(input, 16000, 8000);
-    expect(output.length).toBe(80);
-  });
-
-  it("produces correct output length for 3× downsample", () => {
-    const input = new Int16Array(240);
-    const output = resamplePcm16(input, 24000, 8000);
-    expect(output.length).toBe(80);
-  });
-
-  it("produces correct output length for 48k→16k (3× downsample)", () => {
-    const input = new Int16Array(480);
-    const output = resamplePcm16(input, 48000, 16000);
-    expect(output.length).toBe(160);
-  });
-});
-
-describe("resamplePcm16 — upsample fidelity", () => {
-  it("preserves a DC signal on upsample", () => {
-    // A constant signal should remain constant after upsampling.
-    const dc = 10000;
-    const input = new Int16Array(80).fill(dc);
-    const output = resamplePcm16(input, 8000, 16000);
-    for (let i = 0; i < output.length; i += 1) {
-      expect(output[i]).toBe(dc);
-    }
-  });
-});
-
-describe("resamplePcm16 — downsample fidelity", () => {
-  it("preserves a DC signal on downsample in the interior (no boundary effects)", () => {
-    // Use 640 input samples (40 ms @ 16 kHz) → 320 output samples @ 8 kHz.
-    // With a 127-tap centered FIR (halfTaps=63), both sides of the filter are
-    // fully populated for output indices m where:
-    //   n0 - halfTaps >= 0  → n0 >= 63 → m >= 32
-    //   n0 + halfTaps < 640 → n0 < 577 → m <= 288
-    // Check m=40..280 to leave a comfortable margin on both ends.
-    const dc = 10000;
-    const input = new Int16Array(640).fill(dc);
-    const output = resamplePcm16(input, 16000, 8000);
-    expect(output.length).toBe(320);
-    for (let i = 40; i <= 280; i += 1) {
-      expect(Math.abs(output[i]! - dc)).toBeLessThanOrEqual(10);
-    }
-  });
-});
-
-// ── Anti-alias spectral test (F3 regression lock) ───────────────────────────
-//
-// Strategy: synthesize a 7 kHz tone at 16 kHz. When decimated to 8 kHz without
-// a low-pass filter, 7 kHz aliases to 1 kHz (8000 − 7000). Compare the DFT
-// magnitude at 1 kHz between the naive linear-interp baseline and the
-// anti-aliased output. The spec requires ≥40 dB suppression of the alias.
-
-function dftMagnitudeAtBin(samples: Int16Array, binIndex: number): number {
-  // Compute a single DFT bin via direct evaluation (O(N)).
-  let re = 0;
-  let im = 0;
-  const N = samples.length;
-  for (let n = 0; n < N; n += 1) {
-    const angle = (2 * Math.PI * binIndex * n) / N;
-    re += samples[n]! * Math.cos(angle);
-    im -= samples[n]! * Math.sin(angle);
-  }
-  return Math.sqrt(re * re + im * im);
-}
-
-function naiveDecimate16kTo8k(input: Int16Array): Int16Array {
-  // Pure linear interpolation decimation — the pre-existing buggy baseline.
-  const outputLength = Math.max(1, Math.round((input.length * 8000) / 16000));
-  const output = new Int16Array(outputLength);
-  const ratio = 2.0;
-  for (let i = 0; i < outputLength; i += 1) {
-    const pos = i * ratio;
-    const lo = Math.floor(pos);
-    const hi = Math.min(input.length - 1, lo + 1);
-    const frac = pos - lo;
-    output[i] = Math.round(input[lo]! * (1 - frac) + input[hi]! * frac);
-  }
-  return output;
-}
-
-describe("StreamingPcm16Resampler — chunk continuity", () => {
-  it("preserves constant-amplitude PCM across successive 20ms chunks (stateless path rings)", () => {
-    const chunkSamples = 320;
-    const value = 10_000;
-    const chunks = 10;
-    const stateful = new StreamingPcm16Resampler(16_000, 8_000);
-
-    for (let i = 0; i < chunks; i += 1) {
-      const chunk = new Int16Array(chunkSamples).fill(value);
-      const statefulOut = stateful.process(chunk);
-      const statelessOut = resamplePcm16(chunk, 16_000, 8_000);
-      if (i === 0) continue;
-
-      const statefulSwing = Math.max(...statefulOut) - Math.min(...statefulOut);
-      expect(statefulSwing).toBeLessThan(700);
-
-      const statelessSwing = Math.max(...statelessOut) - Math.min(...statelessOut);
-      expect(statelessSwing).toBeGreaterThan(3000);
-      expect(Math.min(...statelessOut)).toBeLessThan(8000);
-      expect(Math.max(...statelessOut)).toBeGreaterThan(10_000);
-    }
-  });
-});
-
-describe("resamplePcm16 — anti-alias spectral test (F3)", () => {
-  it("attenuates 7 kHz alias by ≥40 dB compared to naive linear-interp", () => {
-    // 100 ms of 7 kHz tone at 16 kHz (amplitude 20000).
-    const N_IN = 1600;
-    const AMPLITUDE = 20000;
-    const FREQ_HZ = 7000;
-    const SRC_RATE = 16000;
-    const DST_RATE = 8000;
-
-    const input = new Int16Array(N_IN);
-    for (let n = 0; n < N_IN; n += 1) {
-      input[n] = Math.round(AMPLITUDE * Math.sin((2 * Math.PI * FREQ_HZ * n) / SRC_RATE));
-    }
-
-    const naiveOutput = naiveDecimate16kTo8k(input);
-    const aaOutput = resamplePcm16(input, SRC_RATE, DST_RATE);
-
-    // 7 kHz aliases to 1 kHz (8000 - 7000) in the 8 kHz output.
-    // DFT bin for 1 kHz with 800 output samples at 8 kHz: bin = 800 * 1000/8000 = 100.
-    const aliasBin = Math.round((naiveOutput.length * 1000) / DST_RATE);
-
-    const naiveMag = dftMagnitudeAtBin(naiveOutput, aliasBin);
-    const aaMag = dftMagnitudeAtBin(aaOutput, aliasBin);
-
-    // Guard: naive must actually have a strong alias (sanity-check the test itself).
-    expect(naiveMag).toBeGreaterThan(AMPLITUDE * 100); // should be ~amplitude*N/2
-
-    // Anti-aliased output alias must be ≥40 dB below the naive alias.
-    const ratioDb = 20 * Math.log10(naiveMag / Math.max(1, aaMag));
-    expect(ratioDb).toBeGreaterThanOrEqual(40);
-  });
-});

package/src/audio-envelope.test.ts

@@ -1,167 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-import {
-  SYRINX_AUDIO_ENVELOPE_MAGIC,
-  assertAudioFormat,
-  assertAudioPayload,
-  decodeSyrinxAudioEnvelope,
-  encodeSyrinxAudioEnvelope,
-  hasSyrinxAudioEnvelope,
-} from "./audio-envelope.js";
-import type { SyrinxAudioEnvelopeHeader } from "./audio-envelope.js";
-import type { AudioFormat } from "./packets.js";
-
-describe("Syrinx binary audio envelope", () => {
-  it("round-trips audio metadata and payload", () => {
-    const encoded = encodeSyrinxAudioEnvelope({
-      type: "audio",
-      contextId: "turn-1",
-      sampleRateHz: 16000,
-      sequence: 3,
-      encoding: "pcm_s16le",
-      channels: 1,
-      byteLength: 4,
-      durationMs: 1,
-    }, new Uint8Array([1, 2, 3, 4]));
-
-    expect(hasSyrinxAudioEnvelope(encoded)).toBe(true);
-    expect(decodeSyrinxAudioEnvelope(encoded)).toEqual({
-      header: {
-        type: "audio",
-        contextId: "turn-1",
-        sampleRateHz: 16000,
-        sequence: 3,
-        encoding: "pcm_s16le",
-        channels: 1,
-        byteLength: 4,
-        durationMs: 1,
-      },
-      audio: new Uint8Array([1, 2, 3, 4]),
-    });
-  });
-
-  it("rejects envelopes whose declared byte length does not match the payload", () => {
-    const encoded = encodeMalformedSyrinxAudioEnvelope({
-      type: "audio",
-      sampleRateHz: 16000,
-      byteLength: 5,
-    }, new Uint8Array([1, 2, 3, 4]));
-
-    expect(() => decodeSyrinxAudioEnvelope(encoded)).toThrow(/byteLength/);
-  });
-
-  it("rejects odd-byte PCM16 payloads and inconsistent duration metadata", () => {
-    const oddPayload = encodeMalformedSyrinxAudioEnvelope({
-      type: "audio",
-      sampleRateHz: 16000,
-      byteLength: 3,
-    }, new Uint8Array([1, 2, 3]));
-    const wrongDuration = encodeMalformedSyrinxAudioEnvelope({
-      type: "audio",
-      sampleRateHz: 16000,
-      byteLength: 640,
-      durationMs: 200,
-    }, new Uint8Array(640));
-
-    expect(() => decodeSyrinxAudioEnvelope(oddPayload)).toThrow(/PCM16/);
-    expect(() => decodeSyrinxAudioEnvelope(wrongDuration)).toThrow(/durationMs/);
-  });
-
-  it("rejects envelopes without a valid sample rate", () => {
-    const missingSampleRate = encodeMalformedSyrinxAudioEnvelope({
-      type: "audio",
-      byteLength: 4,
-    }, new Uint8Array([1, 2, 3, 4]));
-    const invalidSampleRate = encodeMalformedSyrinxAudioEnvelope({
-      type: "audio",
-      sampleRateHz: 0,
-      byteLength: 4,
-    }, new Uint8Array([1, 2, 3, 4]));
-
-    expect(() => decodeSyrinxAudioEnvelope(missingSampleRate)).toThrow(/sampleRateHz/);
-    expect(() => decodeSyrinxAudioEnvelope(invalidSampleRate)).toThrow(/sampleRateHz/);
-  });
-
-  it("rejects malformed numeric metadata instead of silently defaulting", () => {
-    const invalidSequence = encodeMalformedSyrinxAudioEnvelope({
-      type: "audio",
-      sampleRateHz: 16000,
-      sequence: -1,
-      byteLength: 4,
-    }, new Uint8Array([1, 2, 3, 4]));
-    const invalidDuration = encodeMalformedSyrinxAudioEnvelope({
-      type: "audio",
-      sampleRateHz: 16000,
-      durationMs: 1.5,
-      byteLength: 4,
-    }, new Uint8Array([1, 2, 3, 4]));
-
-    expect(() => decodeSyrinxAudioEnvelope(invalidSequence)).toThrow(/sequence/);
-    expect(() => decodeSyrinxAudioEnvelope(invalidDuration)).toThrow(/durationMs/);
-  });
-
-  it("round-trips opus-encoded envelopes without PCM16 byte alignment", () => {
-    const encoded = encodeSyrinxAudioEnvelope({
-      type: "audio",
-      contextId: "turn-opus",
-      sampleRateHz: 16000,
-      sequence: 1,
-      encoding: "opus",
-      channels: 1,
-      byteLength: 37,
-      durationMs: 20,
-    }, new Uint8Array(37));
-
-    expect(decodeSyrinxAudioEnvelope(encoded).header.encoding).toBe("opus");
-  });
-
-  it("assertAudioPayload rejects odd-byte PCM16 and empty opus/mulaw", () => {
-    const pcmFormat: AudioFormat = { encoding: "pcm_s16le", sampleRateHz: 16000, channels: 1 };
-    expect(() => assertAudioPayload(pcmFormat, new Uint8Array([1, 2, 3]))).toThrow(/even number of bytes/);
-    expect(() => assertAudioPayload(pcmFormat, new Uint8Array())).not.toThrow();
-
-    const opusFormat: AudioFormat = { encoding: "opus", sampleRateHz: 16000, channels: 1 };
-    expect(() => assertAudioPayload(opusFormat, new Uint8Array())).toThrow(/must not be empty/);
-    expect(() => assertAudioPayload(opusFormat, new Uint8Array([1]))).not.toThrow();
-
-    const mulawFormat: AudioFormat = { encoding: "mulaw", sampleRateHz: 8000, channels: 1 };
-    expect(() => assertAudioPayload(mulawFormat, new Uint8Array())).toThrow(/must not be empty/);
-    expect(() => assertAudioPayload(mulawFormat, new Uint8Array([1, 2, 3]))).not.toThrow();
-  });
-
-  it("assertAudioFormat rejects non-mono and invalid sample rates", () => {
-    expect(() => assertAudioFormat({ encoding: "pcm_s16le", sampleRateHz: 16000, channels: 2 as 1 })).toThrow(/mono/);
-    expect(() => assertAudioFormat({ encoding: "pcm_s16le", sampleRateHz: 0, channels: 1 })).toThrow(/sampleRateHz/);
-    expect(() => assertAudioFormat({ encoding: "pcm_s16le", sampleRateHz: 1.5, channels: 1 })).toThrow(/sampleRateHz/);
-  });
-
-  it("rejects invalid envelopes before encoding them", () => {
-    expect(() => encodeSyrinxAudioEnvelope({
-      type: "audio",
-      byteLength: 4,
-    } as SyrinxAudioEnvelopeHeader, new Uint8Array([1, 2, 3, 4]))).toThrow(/sampleRateHz/);
-    expect(() => encodeSyrinxAudioEnvelope({
-      type: "audio",
-      sampleRateHz: 16000,
-      sequence: -1,
-      byteLength: 4,
-    }, new Uint8Array([1, 2, 3, 4]))).toThrow(/sequence/);
-    expect(() => encodeSyrinxAudioEnvelope({
-      type: "audio",
-      sampleRateHz: 16000,
-      byteLength: 5,
-    }, new Uint8Array([1, 2, 3, 4]))).toThrow(/byteLength/);
-  });
-});
-
-function encodeMalformedSyrinxAudioEnvelope(header: Record<string, unknown>, audio: Uint8Array): Uint8Array {
-  const headerBytes = new TextEncoder().encode(JSON.stringify(header));
-  const output = new Uint8Array(SYRINX_AUDIO_ENVELOPE_MAGIC.byteLength + 4 + headerBytes.byteLength + audio.byteLength);
-  output.set(SYRINX_AUDIO_ENVELOPE_MAGIC, 0);
-  new DataView(output.buffer, output.byteOffset, output.byteLength)
-    .setUint32(SYRINX_AUDIO_ENVELOPE_MAGIC.byteLength, headerBytes.byteLength, true);
-  output.set(headerBytes, SYRINX_AUDIO_ENVELOPE_MAGIC.byteLength + 4);
-  output.set(audio, SYRINX_AUDIO_ENVELOPE_MAGIC.byteLength + 4 + headerBytes.byteLength);
-  return output;
-}

package/src/error-handler.test.ts

@@ -1,56 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-
-import { ErrorCategory } from "./packets.js";
-import { categorizeLlmError, categorizeSttError, categorizeTtsError, isRecoverable } from "./error-handler.js";
-
-describe("LLM error handling", () => {
-  it("treats malformed provider tool calls as retryable generation failures", () => {
-    const category = categorizeLlmError(new Error("AI SDK provider step failed: MALFORMED_FUNCTION_CALL"));
-
-    expect(category).toBe(ErrorCategory.NetworkTimeout);
-    expect(isRecoverable(category)).toBe(true);
-  });
-
-  it("treats provider 500/internal TTS failures as retryable", () => {
-    const category = categorizeTtsError(new Error("code 500: An internal error has occurred. Please retry."));
-
-    expect(category).toBe(ErrorCategory.NetworkTimeout);
-    expect(isRecoverable(category)).toBe(true);
-  });
-
-  it("maps Deepgram NET websocket close frames to recoverable connection failures", () => {
-    const category = categorizeSttError(new Error("Deepgram STT WebSocket closed unexpectedly: code=1011 reason=NET-0000"));
-
-    expect(category).toBe(ErrorCategory.NetworkTimeout);
-    expect(isRecoverable(category)).toBe(true);
-  });
-
-  it("maps provider finalization timed-out wording to recoverable timeout", () => {
-    const category = categorizeSttError(new Error("Deepgram STT Finalize timed out before speech_final/from_finalize confirmation"));
-
-    expect(category).toBe(ErrorCategory.NetworkTimeout);
-    expect(isRecoverable(category)).toBe(true);
-  });
-
-  it("maps Deepgram DATA websocket close frames to fatal input failures", () => {
-    const category = categorizeSttError(new Error("Deepgram STT WebSocket closed unexpectedly: code=1008 reason=DATA-0000"));
-
-    expect(category).toBe(ErrorCategory.InvalidInput);
-    expect(isRecoverable(category)).toBe(false);
-  });
-
-  it("maps provider concurrency-limit errors to recoverable rate-limit (G8)", () => {
-    for (const message of [
-      "Cartesia TTS provider error: concurrency limit exceeded",
-      "Too many concurrent connections",
-      "max concurrency reached",
-      "concurrency_limit_exceeded",
-    ]) {
-      const category = categorizeTtsError(new Error(message));
-      expect(category, `message: ${message}`).toBe(ErrorCategory.RateLimit);
-      expect(isRecoverable(category)).toBe(true);
-    }
-  });
-});

package/src/latency-filler.test.ts

@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-import {
-  LatencyFillerController,
-  selectLatencyFillerConnective,
-  stripRedundantFillerPrefix,
-} from "./latency-filler.js";
-import { LATENCY_FILLER_FIXTURES } from "./latency-filler-fixtures.js";
-
-describe("selectLatencyFillerConnective", () => {
-  it("selects question and gratitude connectives from fixtures", () => {
-    for (const fixture of LATENCY_FILLER_FIXTURES) {
-      const turnIndex = fixture.id === "statement-1" ? 1 : 0;
-      expect(selectLatencyFillerConnective(fixture.userText, turnIndex)).toBe(fixture.expectedConnective);
-    }
-  });
-});
-
-describe("stripRedundantFillerPrefix", () => {
-  it("removes a duplicated leading connective without leaving a gap", () => {
-    expect(stripRedundantFillerPrefix("So,", "So here's the answer.")).toBe("here's the answer.");
-    expect(stripRedundantFillerPrefix("Well,", "  Well, the deadline passed.")).toBe("the deadline passed.");
-  });
-
-  it("preserves unrelated LLM text", () => {
-    expect(stripRedundantFillerPrefix("So,", "The deadline passed.")).toBe("The deadline passed.");
-  });
-
-  it("does not strip filler words embedded in longer words", () => {
-    expect(stripRedundantFillerPrefix("So,", "Some people say...")).toBe("Some people say...");
-    expect(stripRedundantFillerPrefix("So,", "Social distancing matters")).toBe("Social distancing matters");
-    expect(stripRedundantFillerPrefix("Well,", "Wellness is important")).toBe("Wellness is important");
-    expect(stripRedundantFillerPrefix("Well,", "Welcome back")).toBe("Welcome back");
-    expect(stripRedundantFillerPrefix("Well,", "Wellington is windy")).toBe("Wellington is windy");
-  });
-
-  it("still strips a genuine repeated filler connective", () => {
-    expect(stripRedundantFillerPrefix("So,", "So, the plan is simple.")).toBe("the plan is simple.");
-    expect(stripRedundantFillerPrefix("Well,", "Well, let me explain.")).toBe("let me explain.");
-  });
-});
-
-describe("LatencyFillerController", () => {
-  it("tracks active filler-only state until splice or cancel", () => {
-    const controller = new LatencyFillerController({ enabled: true });
-    expect(controller.start("turn-1", "hello")).toBe("So,");
-    expect(controller.isFillerOnly("turn-1")).toBe(true);
-    expect(controller.spliceLlmDelta("turn-1", "The answer is ready.")).toBe("The answer is ready.");
-    expect(controller.isFillerOnly("turn-1")).toBe(false);
-    expect(controller.getState("turn-1")?.spliced).toBe(true);
-  });
-
-  it("marks filler cancelled without splicing", () => {
-    const controller = new LatencyFillerController({ enabled: true });
-    controller.start("turn-1", "hello");
-    const cancelled = controller.cancel("turn-1");
-    expect(cancelled?.text).toBe("So,");
-    expect(controller.isFillerOnly("turn-1")).toBe(false);
-    expect(controller.spliceLlmDelta("turn-1", "ignored")).toBe("ignored");
-  });
-});