@craftedxp/voice-js 0.5.4 → 0.6.0

package/dist/browser.js

@@ -1,26 +1,24 @@
-'use strict'
-var __defProp = Object.defineProperty
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor
-var __getOwnPropNames = Object.getOwnPropertyNames
-var __hasOwnProp = Object.prototype.hasOwnProperty
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, { get: all[name], enumerable: true })
-}
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
-  if ((from && typeof from === 'object') || typeof from === 'function') {
+  if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, {
-          get: () => from[key],
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
-        })
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return to
-}
-var __toCommonJS = (mod) => __copyProps(__defProp({}, '__esModule', { value: true }), mod)
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/browser.ts
-var browser_exports = {}
+var browser_exports = {};
 __export(browser_exports, {
   buildWsUrl: () => buildWsUrl,
   configureVoiceClient: () => configureVoiceClient,
@@ -31,63 +29,57 @@ __export(browser_exports, {
   handleServerMessage: () => handleServerMessage,
   joinRoom: () => joinRoom,
   parseIncomingCall: () => parseIncomingCall,
-})
-module.exports = __toCommonJS(browser_exports)
+  startTextSession: () => startTextSession
+});
+module.exports = __toCommonJS(browser_exports);
 
 // src/config.ts
 function normalizeConfig(config) {
-  if (!config) throw new Error('configureVoiceClient: config is required')
-  if ('apiKey' in config) {
+  if (!config) throw new Error("configureVoiceClient: config is required");
+  if ("apiKey" in config) {
     throw new Error(
-      'configureVoiceClient: `apiKey` is no longer supported. Embedding sk_ in JS code ships server-grade credentials to every client. Pass `fetchToken: async ({ agentId }) => { /* call YOUR backend mint */ }` instead \u2014 see the @craftedxp/voice-js README for the migration recipe.',
-    )
+      "configureVoiceClient: `apiKey` is no longer supported. Embedding sk_ in JS code ships server-grade credentials to every client. Pass `fetchToken: async ({ agentId }) => { /* call YOUR backend mint */ }` instead \u2014 see the @craftedxp/voice-js README for the migration recipe."
+    );
   }
   if (!config.apiBase) {
-    throw new Error('configureVoiceClient: apiBase is required')
+    throw new Error("configureVoiceClient: apiBase is required");
   }
-  if (typeof config.fetchToken !== 'function') {
-    throw new Error('configureVoiceClient: fetchToken must be a function')
+  if (typeof config.fetchToken !== "function") {
+    throw new Error("configureVoiceClient: fetchToken must be a function");
   }
   return {
     ...config,
-    apiBase: config.apiBase.replace(/\/+$/, ''),
-  }
+    apiBase: config.apiBase.replace(/\/+$/, "")
+  };
 }
 function mergeStartCallContext(factory, call) {
-  const context =
-    factory.defaultContext || call.context
-      ? { ...(factory.defaultContext ?? {}), ...(call.context ?? {}) }
-      : void 0
-  const metadata =
-    factory.defaultMetadata || call.metadata
-      ? { ...(factory.defaultMetadata ?? {}), ...(call.metadata ?? {}) }
-      : void 0
-  return { context, metadata }
+  const context = factory.defaultContext || call.context ? { ...factory.defaultContext ?? {}, ...call.context ?? {} } : void 0;
+  const metadata = factory.defaultMetadata || call.metadata ? { ...factory.defaultMetadata ?? {}, ...call.metadata ?? {} } : void 0;
+  return { context, metadata };
 }
 
 // src/worklets/mic-downsampler.worklet.js
-var mic_downsampler_worklet_default =
-  "// AudioWorklet \u2014 runs off the main thread in the audio rendering graph.\n//\n// Input: Float32 samples at the AudioContext's native sampleRate (typically\n// 48000 Hz on desktop, 44100 Hz on some iOS devices).\n// Output: 16 kHz mono Int16 PCM, shipped to the main thread via\n// `port.postMessage(ArrayBuffer, [ArrayBuffer])` (transferred, not copied).\n//\n// Why AudioWorklet instead of ScriptProcessorNode: ScriptProcessorNode is\n// deprecated + main-thread-bound, so any JS jank produces audible audio\n// glitches. AudioWorklet's `process()` runs on the audio rendering thread\n// at the graph's block cadence (128 frames by default) and backpressures\n// via returning `true` / `false`.\n//\n// This file is loaded as text (see tsup.config.ts loader) and registered\n// at runtime via `audioWorklet.addModule(blobUrl)`.\n\nclass MicDownsampler extends AudioWorkletProcessor {\n  constructor() {\n    super()\n    // Target sample rate for STT. Matches Deepgram Nova-3 + the platform's\n    // server-side SAMPLE_RATE constant in AgentCallHandler.\n    this.targetRate = 16000\n    // Accumulator for the downsample. We collect incoming samples and emit\n    // an Int16 chunk when we've accumulated ~1024 target-rate samples\n    // (~64 ms at 16 kHz) \u2014 matches the mobile SDK's chunk size so both\n    // platforms have the same server-side framing.\n    this.outputFrames = 1024\n    this.acc = []\n    // Running index used for fractional resampling.\n    this.readCursor = 0\n  }\n\n  // `inputs[0][0]` = first channel of first input. 128 Float32 samples per\n  // call at the context's sampleRate. Return true = keep processing.\n  process(inputs) {\n    const input = inputs[0]\n    if (!input || input.length === 0) return true\n    const channel = input[0]\n    if (!channel || channel.length === 0) return true\n\n    const ctxRate = sampleRate // global inside AudioWorkletProcessor\n    const ratio = ctxRate / this.targetRate\n\n    // Simple linear-interp downsample. For 48000 \u2192 16000 that's 3:1, which\n    // linear handles fine for voice. Anti-alias filtering would be\n    // theoretically better but inaudible for speech.\n    for (let i = 0; i < channel.length; i++) {\n      this.acc.push(channel[i])\n    }\n\n    while (this.acc.length - this.readCursor >= ratio * this.outputFrames) {\n      const out = new Int16Array(this.outputFrames)\n      let readIdx = this.readCursor\n      for (let i = 0; i < this.outputFrames; i++) {\n        // Linear interp between floor(readIdx) and ceil(readIdx)\n        const low = Math.floor(readIdx)\n        const high = Math.min(low + 1, this.acc.length - 1)\n        const frac = readIdx - low\n        const sample = this.acc[low] * (1 - frac) + this.acc[high] * frac\n        // Clip + convert to int16\n        const clipped = Math.max(-1, Math.min(1, sample))\n        out[i] = clipped < 0 ? clipped * 0x8000 : clipped * 0x7fff\n        readIdx += ratio\n      }\n      // Transfer the ArrayBuffer (zero-copy) to the main thread.\n      this.port.postMessage(out.buffer, [out.buffer])\n      this.readCursor = readIdx\n    }\n\n    // Garbage-collect the consumed portion of `acc` every so often so it\n    // doesn't grow without bound. Leave ~one chunk of headroom.\n    if (this.readCursor > ratio * this.outputFrames) {\n      this.acc = this.acc.slice(Math.floor(this.readCursor))\n      this.readCursor -= Math.floor(this.readCursor)\n    }\n\n    return true\n  }\n}\n\nregisterProcessor('mic-downsampler', MicDownsampler)\n"
+var mic_downsampler_worklet_default = "// AudioWorklet \u2014 runs off the main thread in the audio rendering graph.\n//\n// Input: Float32 samples at the AudioContext's native sampleRate (typically\n// 48000 Hz on desktop, 44100 Hz on some iOS devices).\n// Output: 16 kHz mono Int16 PCM, shipped to the main thread via\n// `port.postMessage(ArrayBuffer, [ArrayBuffer])` (transferred, not copied).\n//\n// Why AudioWorklet instead of ScriptProcessorNode: ScriptProcessorNode is\n// deprecated + main-thread-bound, so any JS jank produces audible audio\n// glitches. AudioWorklet's `process()` runs on the audio rendering thread\n// at the graph's block cadence (128 frames by default) and backpressures\n// via returning `true` / `false`.\n//\n// This file is loaded as text (see tsup.config.ts loader) and registered\n// at runtime via `audioWorklet.addModule(blobUrl)`.\n\nclass MicDownsampler extends AudioWorkletProcessor {\n  constructor() {\n    super()\n    // Target sample rate for STT. Matches Deepgram Nova-3 + the platform's\n    // server-side SAMPLE_RATE constant in AgentCallHandler.\n    this.targetRate = 16000\n    // Accumulator for the downsample. We collect incoming samples and emit\n    // an Int16 chunk when we've accumulated ~1024 target-rate samples\n    // (~64 ms at 16 kHz) \u2014 matches the mobile SDK's chunk size so both\n    // platforms have the same server-side framing.\n    this.outputFrames = 1024\n    this.acc = []\n    // Running index used for fractional resampling.\n    this.readCursor = 0\n  }\n\n  // `inputs[0][0]` = first channel of first input. 128 Float32 samples per\n  // call at the context's sampleRate. Return true = keep processing.\n  process(inputs) {\n    const input = inputs[0]\n    if (!input || input.length === 0) return true\n    const channel = input[0]\n    if (!channel || channel.length === 0) return true\n\n    const ctxRate = sampleRate // global inside AudioWorkletProcessor\n    const ratio = ctxRate / this.targetRate\n\n    // Simple linear-interp downsample. For 48000 \u2192 16000 that's 3:1, which\n    // linear handles fine for voice. Anti-alias filtering would be\n    // theoretically better but inaudible for speech.\n    for (let i = 0; i < channel.length; i++) {\n      this.acc.push(channel[i])\n    }\n\n    while (this.acc.length - this.readCursor >= ratio * this.outputFrames) {\n      const out = new Int16Array(this.outputFrames)\n      let readIdx = this.readCursor\n      for (let i = 0; i < this.outputFrames; i++) {\n        // Linear interp between floor(readIdx) and ceil(readIdx)\n        const low = Math.floor(readIdx)\n        const high = Math.min(low + 1, this.acc.length - 1)\n        const frac = readIdx - low\n        const sample = this.acc[low] * (1 - frac) + this.acc[high] * frac\n        // Clip + convert to int16\n        const clipped = Math.max(-1, Math.min(1, sample))\n        out[i] = clipped < 0 ? clipped * 0x8000 : clipped * 0x7fff\n        readIdx += ratio\n      }\n      // Transfer the ArrayBuffer (zero-copy) to the main thread.\n      this.port.postMessage(out.buffer, [out.buffer])\n      this.readCursor = readIdx\n    }\n\n    // Garbage-collect the consumed portion of `acc` every so often so it\n    // doesn't grow without bound. Leave ~one chunk of headroom.\n    if (this.readCursor > ratio * this.outputFrames) {\n      this.acc = this.acc.slice(Math.floor(this.readCursor))\n      this.readCursor -= Math.floor(this.readCursor)\n    }\n\n    return true\n  }\n}\n\nregisterProcessor('mic-downsampler', MicDownsampler)\n";
 
 // src/AudioCapture.ts
-var VOLUME_INTERVAL_MS = 100
+var VOLUME_INTERVAL_MS = 100;
 var createAudioCapture = (options) => {
-  let audioContext = null
-  let mediaStream = null
-  let sourceNode = null
-  let workletNode = null
-  let analyser = null
-  let volumeTimer = null
-  let muted = false
-  let capturing = false
+  let audioContext = null;
+  let mediaStream = null;
+  let sourceNode = null;
+  let workletNode = null;
+  let analyser = null;
+  let volumeTimer = null;
+  let muted = false;
+  let capturing = false;
   const computeRms = (buf) => {
-    let sum = 0
-    for (let i = 0; i < buf.length; i++) sum += buf[i] * buf[i]
-    const rms = Math.sqrt(sum / buf.length)
-    return Math.min(1, rms * 1.8)
-  }
+    let sum = 0;
+    for (let i = 0; i < buf.length; i++) sum += buf[i] * buf[i];
+    const rms = Math.sqrt(sum / buf.length);
+    return Math.min(1, rms * 1.8);
+  };
   const start = async () => {
-    if (capturing) return
+    if (capturing) return;
     try {
       mediaStream = await navigator.mediaDevices.getUserMedia({
         audio: {
@@ -98,748 +90,751 @@ var createAudioCapture = (options) => {
           echoCancellation: true,
           noiseSuppression: true,
           autoGainControl: true,
-          channelCount: 1,
-        },
-      })
-      audioContext = new AudioContext()
-      if (audioContext.state === 'suspended') await audioContext.resume()
-      const blob = new Blob([mic_downsampler_worklet_default], { type: 'application/javascript' })
-      const url = URL.createObjectURL(blob)
+          channelCount: 1
+        }
+      });
+      audioContext = new AudioContext();
+      if (audioContext.state === "suspended") await audioContext.resume();
+      const blob = new Blob([mic_downsampler_worklet_default], { type: "application/javascript" });
+      const url = URL.createObjectURL(blob);
       try {
-        await audioContext.audioWorklet.addModule(url)
+        await audioContext.audioWorklet.addModule(url);
       } finally {
-        URL.revokeObjectURL(url)
+        URL.revokeObjectURL(url);
       }
-      sourceNode = audioContext.createMediaStreamSource(mediaStream)
-      workletNode = new AudioWorkletNode(audioContext, 'mic-downsampler')
+      sourceNode = audioContext.createMediaStreamSource(mediaStream);
+      workletNode = new AudioWorkletNode(audioContext, "mic-downsampler");
       workletNode.port.onmessage = (event) => {
-        if (muted) return
-        options.onChunk(event.data)
-      }
+        if (muted) return;
+        options.onChunk(event.data);
+      };
       if (options.onVolume) {
-        analyser = audioContext.createAnalyser()
-        analyser.fftSize = 256
-        sourceNode.connect(analyser)
-        const buf = new Float32Array(analyser.fftSize)
+        analyser = audioContext.createAnalyser();
+        analyser.fftSize = 256;
+        sourceNode.connect(analyser);
+        const buf = new Float32Array(analyser.fftSize);
         volumeTimer = setInterval(() => {
-          if (!analyser) return
-          analyser.getFloatTimeDomainData(buf)
-          options.onVolume?.(computeRms(buf))
-        }, VOLUME_INTERVAL_MS)
+          if (!analyser) return;
+          analyser.getFloatTimeDomainData(buf);
+          options.onVolume?.(computeRms(buf));
+        }, VOLUME_INTERVAL_MS);
       }
-      sourceNode.connect(workletNode)
-      const sink = audioContext.createGain()
-      sink.gain.value = 0
-      workletNode.connect(sink).connect(audioContext.destination)
-      capturing = true
+      sourceNode.connect(workletNode);
+      const sink = audioContext.createGain();
+      sink.gain.value = 0;
+      workletNode.connect(sink).connect(audioContext.destination);
+      capturing = true;
     } catch (err) {
-      const wrapped =
-        err instanceof Error ? err : new Error(typeof err === 'string' ? err : 'capture failed')
-      options.onError?.(wrapped)
-      throw wrapped
+      const wrapped = err instanceof Error ? err : new Error(typeof err === "string" ? err : "capture failed");
+      options.onError?.(wrapped);
+      throw wrapped;
     }
-  }
+  };
   const stop = () => {
-    if (!capturing) return
-    capturing = false
+    if (!capturing) return;
+    capturing = false;
     if (volumeTimer) {
-      clearInterval(volumeTimer)
-      volumeTimer = null
+      clearInterval(volumeTimer);
+      volumeTimer = null;
     }
     try {
-      workletNode?.disconnect()
-      analyser?.disconnect()
-      sourceNode?.disconnect()
-    } catch {}
-    workletNode = null
-    analyser = null
-    sourceNode = null
+      workletNode?.disconnect();
+      analyser?.disconnect();
+      sourceNode?.disconnect();
+    } catch {
+    }
+    workletNode = null;
+    analyser = null;
+    sourceNode = null;
     if (mediaStream) {
-      for (const track of mediaStream.getTracks()) track.stop()
-      mediaStream = null
+      for (const track of mediaStream.getTracks()) track.stop();
+      mediaStream = null;
     }
-    if (audioContext && audioContext.state !== 'closed') {
-      void audioContext.close().catch(() => void 0)
+    if (audioContext && audioContext.state !== "closed") {
+      void audioContext.close().catch(() => void 0);
     }
-    audioContext = null
-  }
+    audioContext = null;
+  };
   return {
     start,
     stop,
     mute: (v) => {
-      muted = v
+      muted = v;
     },
-    isCapturing: () => capturing,
-  }
-}
+    isCapturing: () => capturing
+  };
+};
 
 // src/AudioPlayback.ts
-var DEFAULT_SAMPLE_RATE = 16e3
-var VOLUME_INTERVAL_MS2 = 100
+var DEFAULT_SAMPLE_RATE = 16e3;
+var VOLUME_INTERVAL_MS2 = 100;
 var createAudioPlayback = (options = {}) => {
-  const sampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE
-  let audioContext = null
-  let gainNode = null
-  let analyser = null
-  let volumeTimer = null
-  let nextStartTime = 0
-  let scheduledNodes = []
-  let speaking = false
+  const sampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE;
+  let audioContext = null;
+  let gainNode = null;
+  let analyser = null;
+  let volumeTimer = null;
+  let nextStartTime = 0;
+  let scheduledNodes = [];
+  let speaking = false;
   const ensureContext = async () => {
     if (audioContext) {
-      if (audioContext.state === 'suspended') await audioContext.resume()
-      return
+      if (audioContext.state === "suspended") await audioContext.resume();
+      return;
     }
-    audioContext = new AudioContext({ sampleRate })
-    gainNode = audioContext.createGain()
+    audioContext = new AudioContext({ sampleRate });
+    gainNode = audioContext.createGain();
     if (options.onVolume) {
-      analyser = audioContext.createAnalyser()
-      analyser.fftSize = 256
-      gainNode.connect(analyser)
-      const buf = new Float32Array(analyser.fftSize)
+      analyser = audioContext.createAnalyser();
+      analyser.fftSize = 256;
+      gainNode.connect(analyser);
+      const buf = new Float32Array(analyser.fftSize);
       volumeTimer = setInterval(() => {
-        if (!analyser) return
-        analyser.getFloatTimeDomainData(buf)
-        let sum = 0
-        for (let i = 0; i < buf.length; i++) sum += buf[i] * buf[i]
-        const rms = Math.sqrt(sum / buf.length)
-        options.onVolume?.(Math.min(1, rms * 1.8))
-      }, VOLUME_INTERVAL_MS2)
+        if (!analyser) return;
+        analyser.getFloatTimeDomainData(buf);
+        let sum = 0;
+        for (let i = 0; i < buf.length; i++) sum += buf[i] * buf[i];
+        const rms = Math.sqrt(sum / buf.length);
+        options.onVolume?.(Math.min(1, rms * 1.8));
+      }, VOLUME_INTERVAL_MS2);
     }
-    gainNode.connect(audioContext.destination)
-    nextStartTime = audioContext.currentTime
-  }
+    gainNode.connect(audioContext.destination);
+    nextStartTime = audioContext.currentTime;
+  };
   const setSpeaking = (v) => {
-    if (v === speaking) return
-    speaking = v
-    options.onSpeakingChange?.(v)
-  }
+    if (v === speaking) return;
+    speaking = v;
+    options.onSpeakingChange?.(v);
+  };
   const pruneFinished = () => {
-    const now = audioContext?.currentTime ?? 0
+    const now = audioContext?.currentTime ?? 0;
     scheduledNodes = scheduledNodes.filter((n) => {
-      const node = n
-      return (node._endsAt ?? 0) > now
-    })
-    if (scheduledNodes.length === 0) setSpeaking(false)
-  }
+      const node = n;
+      return (node._endsAt ?? 0) > now;
+    });
+    if (scheduledNodes.length === 0) setSpeaking(false);
+  };
   const enqueue = (pcm) => {
     if (!audioContext) {
-      void ensureContext().then(() => enqueue(pcm))
-      return
+      void ensureContext().then(() => enqueue(pcm));
+      return;
     }
-    if (!audioContext || !gainNode) return
-    const int16 = new Int16Array(pcm)
-    if (int16.length === 0) return
-    const audioBuffer = audioContext.createBuffer(1, int16.length, sampleRate)
-    const float32 = audioBuffer.getChannelData(0)
+    if (!audioContext || !gainNode) return;
+    const int16 = new Int16Array(pcm);
+    if (int16.length === 0) return;
+    const audioBuffer = audioContext.createBuffer(1, int16.length, sampleRate);
+    const float32 = audioBuffer.getChannelData(0);
     for (let i = 0; i < int16.length; i++) {
-      float32[i] = int16[i] / 32768
+      float32[i] = int16[i] / 32768;
     }
-    const node = audioContext.createBufferSource()
-    node.buffer = audioBuffer
-    node.connect(gainNode)
-    const now = audioContext.currentTime
-    const startAt = Math.max(now, nextStartTime)
-    node.start(startAt)
-    const duration = int16.length / sampleRate
-    node._endsAt = startAt + duration
-    nextStartTime = startAt + duration
-    scheduledNodes.push(node)
-    setSpeaking(true)
-    node.onended = () => pruneFinished()
-  }
+    const node = audioContext.createBufferSource();
+    node.buffer = audioBuffer;
+    node.connect(gainNode);
+    const now = audioContext.currentTime;
+    const startAt = Math.max(now, nextStartTime);
+    node.start(startAt);
+    const duration = int16.length / sampleRate;
+    node._endsAt = startAt + duration;
+    nextStartTime = startAt + duration;
+    scheduledNodes.push(node);
+    setSpeaking(true);
+    node.onended = () => pruneFinished();
+  };
   const flush = () => {
-    if (!audioContext || !gainNode) return
+    if (!audioContext || !gainNode) return;
     for (const node of scheduledNodes) {
       try {
-        node.stop()
-      } catch {}
+        node.stop();
+      } catch {
+      }
     }
-    scheduledNodes = []
-    gainNode.disconnect()
-    gainNode = audioContext.createGain()
+    scheduledNodes = [];
+    gainNode.disconnect();
+    gainNode = audioContext.createGain();
     if (analyser) {
-      analyser.disconnect()
-      gainNode.connect(analyser)
+      analyser.disconnect();
+      gainNode.connect(analyser);
     }
-    gainNode.connect(audioContext.destination)
-    nextStartTime = audioContext.currentTime
-    setSpeaking(false)
-  }
+    gainNode.connect(audioContext.destination);
+    nextStartTime = audioContext.currentTime;
+    setSpeaking(false);
+  };
   const close = () => {
-    flush()
+    flush();
     if (volumeTimer) {
-      clearInterval(volumeTimer)
-      volumeTimer = null
+      clearInterval(volumeTimer);
+      volumeTimer = null;
     }
-    if (audioContext && audioContext.state !== 'closed') {
-      void audioContext.close().catch(() => void 0)
+    if (audioContext && audioContext.state !== "closed") {
+      void audioContext.close().catch(() => void 0);
     }
-    audioContext = null
-    gainNode = null
-    analyser = null
-  }
+    audioContext = null;
+    gainNode = null;
+    analyser = null;
+  };
   const resume = async () => {
-    await ensureContext()
-  }
-  return { enqueue, flush, close, resume }
-}
+    await ensureContext();
+  };
+  return { enqueue, flush, close, resume };
+};
 
 // src/ReconnectingWebSocket.ts
-var READYSTATE_OPEN = 1
-var READYSTATE_CLOSED = 3
+var READYSTATE_OPEN = 1;
+var READYSTATE_CLOSED = 3;
 var createReconnectingWebSocket = (options, onEvent) => {
-  const maxRetries = options.maxRetries ?? 3
-  const initialBackoff = options.initialBackoffMs ?? 500
-  const maxBackoff = options.maxBackoffMs ?? 8e3
-  let ws = null
-  let intentionalClose = false
-  let retries = 0
-  let backoff = initialBackoff
-  let reconnectTimer = null
+  const maxRetries = options.maxRetries ?? 3;
+  const initialBackoff = options.initialBackoffMs ?? 500;
+  const maxBackoff = options.maxBackoffMs ?? 8e3;
+  let ws = null;
+  let intentionalClose = false;
+  let retries = 0;
+  let backoff = initialBackoff;
+  let reconnectTimer = null;
   const openOnce = () => {
-    ws = options.wsFactory(options.url)
-    ws.binaryType = 'arraybuffer'
+    ws = options.wsFactory(options.url);
+    ws.binaryType = "arraybuffer";
     ws.onopen = () => {
-      if (retries === 0) onEvent({ type: 'open' })
-      else onEvent({ type: 'reconnected' })
-      retries = 0
-      backoff = initialBackoff
-    }
+      if (retries === 0) onEvent({ type: "open" });
+      else onEvent({ type: "reconnected" });
+      retries = 0;
+      backoff = initialBackoff;
+    };
     ws.onmessage = (ev) => {
-      onEvent({ type: 'message', data: ev.data })
-    }
+      onEvent({ type: "message", data: ev.data });
+    };
     ws.onerror = () => {
-      onEvent({ type: 'error', error: new Error('WebSocket error') })
-    }
+      onEvent({ type: "error", error: new Error("WebSocket error") });
+    };
     ws.onclose = (ev) => {
-      ws = null
-      const shouldRetry = !intentionalClose && retries < maxRetries
+      ws = null;
+      const shouldRetry = !intentionalClose && retries < maxRetries;
       if (!shouldRetry) {
         onEvent({
-          type: 'close',
+          type: "close",
           code: ev.code,
           reason: ev.reason,
-          permanent: true,
-        })
-        return
+          permanent: true
+        });
+        return;
       }
       onEvent({
-        type: 'close',
+        type: "close",
         code: ev.code,
         reason: ev.reason,
-        permanent: false,
-      })
-      retries++
-      const delay = Math.min(backoff, maxBackoff)
-      backoff = Math.min(backoff * 2, maxBackoff)
-      reconnectTimer = setTimeout(openOnce, delay)
-    }
-  }
-  openOnce()
+        permanent: false
+      });
+      retries++;
+      const delay = Math.min(backoff, maxBackoff);
+      backoff = Math.min(backoff * 2, maxBackoff);
+      reconnectTimer = setTimeout(openOnce, delay);
+    };
+  };
+  openOnce();
   return {
     send: (data) => {
-      if (ws && ws.readyState === READYSTATE_OPEN) ws.send(data)
+      if (ws && ws.readyState === READYSTATE_OPEN) ws.send(data);
     },
-    close: (code = 1e3, reason = 'client-requested') => {
-      intentionalClose = true
+    close: (code = 1e3, reason = "client-requested") => {
+      intentionalClose = true;
       if (reconnectTimer) {
-        clearTimeout(reconnectTimer)
-        reconnectTimer = null
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
       }
       try {
-        ws?.close(code, reason)
-      } catch {}
+        ws?.close(code, reason);
+      } catch {
+      }
     },
-    readyState: () => ws?.readyState ?? READYSTATE_CLOSED,
-  }
-}
+    readyState: () => ws?.readyState ?? READYSTATE_CLOSED
+  };
+};
 
 // src/protocol.ts
 var createProtocolState = () => ({
-  state: 'idle',
+  state: "idle",
   transcript: [],
   agentBubbleId: null,
   idCounter: 0,
-  endReason: null,
-})
+  endReason: null
+});
 var mapEndReason = (raw) => {
-  if (raw === 'agent_ended') return 'agent_ended'
-  if (raw === 'caller_hung_up') return 'user_hangup'
-  if (raw === 'silence_timeout' || raw === 'max_duration') return 'timeout'
-  return 'error'
-}
+  if (raw === "agent_ended") return "agent_ended";
+  if (raw === "caller_hung_up") return "user_hangup";
+  if (raw === "silence_timeout" || raw === "max_duration") return "timeout";
+  return "error";
+};
 function handleServerMessage(raw, state, cb) {
-  let msg
+  let msg;
   try {
-    msg = JSON.parse(raw)
+    msg = JSON.parse(raw);
   } catch {
-    return
+    return;
   }
   switch (msg.type) {
-    case 'connected':
-      cb.onConnected()
-      setState(state, 'listening', cb)
-      return
-    case 'transcript': {
-      const text = msg.text ?? ''
-      if (!text) return
-      const isFinal = !!msg.isFinal
-      if (!isFinal) setState(state, 'user_speaking', cb)
-      upsertUserPartial(state, text, isFinal)
-      cb.onTranscript(state.transcript)
-      return
+    case "connected":
+      cb.onConnected();
+      setState(state, "listening", cb);
+      return;
+    case "transcript": {
+      const text = msg.text ?? "";
+      if (!text) return;
+      const isFinal = !!msg.isFinal;
+      if (!isFinal) setState(state, "user_speaking", cb);
+      upsertUserPartial(state, text, isFinal);
+      cb.onTranscript(state.transcript);
+      return;
     }
-    case 'agent_turn_start': {
-      const id = `m${state.idCounter++}`
-      state.agentBubbleId = id
-      state.transcript = [...state.transcript, { id, role: 'agent', text: '' }]
-      cb.onTranscript(state.transcript)
-      const seq = typeof msg.seq === 'number' ? msg.seq : void 0
-      cb.onAgentTurnStart(seq)
-      setState(state, 'agent_speaking', cb)
-      return
+    case "agent_turn_start": {
+      const id = `m${state.idCounter++}`;
+      state.agentBubbleId = id;
+      state.transcript = [...state.transcript, { id, role: "agent", text: "" }];
+      cb.onTranscript(state.transcript);
+      const seq = typeof msg.seq === "number" ? msg.seq : void 0;
+      cb.onAgentTurnStart(seq);
+      setState(state, "agent_speaking", cb);
+      return;
     }
-    case 'agent_text': {
-      const delta = msg.text ?? ''
-      if (!delta || !state.agentBubbleId) return
-      const id = state.agentBubbleId
-      state.transcript = state.transcript.map((e) =>
-        e.id === id && e.role === 'agent' ? { ...e, text: e.text + delta } : e,
-      )
-      cb.onTranscript(state.transcript)
-      return
+    case "agent_text": {
+      const delta = msg.text ?? "";
+      if (!delta || !state.agentBubbleId) return;
+      const id = state.agentBubbleId;
+      state.transcript = state.transcript.map(
+        (e) => e.id === id && e.role === "agent" ? { ...e, text: e.text + delta } : e
+      );
+      cb.onTranscript(state.transcript);
+      return;
     }
-    case 'agent_turn_end': {
-      state.agentBubbleId = null
-      const seq = typeof msg.seq === 'number' ? msg.seq : void 0
-      cb.onAgentTurnEnd(seq)
-      setState(state, 'listening', cb)
-      return
+    case "agent_turn_end": {
+      state.agentBubbleId = null;
+      const seq = typeof msg.seq === "number" ? msg.seq : void 0;
+      cb.onAgentTurnEnd(seq);
+      setState(state, "listening", cb);
+      return;
     }
-    case 'interrupt':
-      cb.onInterrupt()
-      return
-    case 'agent_turn_abort': {
-      const committed = (msg.committedText ?? '').trim()
+    case "interrupt":
+      cb.onInterrupt();
+      return;
+    case "agent_turn_abort": {
+      const committed = (msg.committedText ?? "").trim();
       if (state.agentBubbleId) {
-        const id = state.agentBubbleId
+        const id = state.agentBubbleId;
         if (committed) {
-          state.transcript = state.transcript.map((e) =>
-            e.id === id && e.role === 'agent' ? { ...e, text: committed, interrupted: true } : e,
-          )
+          state.transcript = state.transcript.map(
+            (e) => e.id === id && e.role === "agent" ? { ...e, text: committed, interrupted: true } : e
+          );
         } else {
-          state.transcript = state.transcript.filter((e) => e.id !== id)
+          state.transcript = state.transcript.filter((e) => e.id !== id);
         }
-        cb.onTranscript(state.transcript)
+        cb.onTranscript(state.transcript);
       }
-      state.agentBubbleId = null
-      return
+      state.agentBubbleId = null;
+      return;
     }
-    case 'tool_call':
+    case "tool_call":
       state.transcript = [
         ...state.transcript,
         {
           id: `m${state.idCounter++}`,
-          role: 'tool',
-          text: `\u2192 ${String(msg.tool ?? '?')}(${msg.args ? JSON.stringify(msg.args) : ''})`,
-        },
-      ]
-      cb.onTranscript(state.transcript)
-      return
-    case 'tool_result':
+          role: "tool",
+          text: `\u2192 ${String(msg.tool ?? "?")}(${msg.args ? JSON.stringify(msg.args) : ""})`
+        }
+      ];
+      cb.onTranscript(state.transcript);
+      return;
+    case "tool_result":
       state.transcript = [
         ...state.transcript,
         {
           id: `m${state.idCounter++}`,
-          role: 'tool',
-          text: `${msg.ok ? '\u2713' : '\u2717'} ${String(msg.tool ?? '?')}`,
-        },
-      ]
-      cb.onTranscript(state.transcript)
-      return
-    case 'client_tool_call': {
-      const toolCallId = String(msg.toolCallId ?? '')
-      const name = String(msg.name ?? '')
-      const args = msg.args ?? {}
-      if (!toolCallId || !name) return
-      cb.onClientToolCall({ toolCallId, name, args })
-      return
+          role: "tool",
+          text: `${msg.ok ? "\u2713" : "\u2717"} ${String(msg.tool ?? "?")}`
+        }
+      ];
+      cb.onTranscript(state.transcript);
+      return;
+    case "client_tool_call": {
+      const toolCallId = String(msg.toolCallId ?? "");
+      const name = String(msg.name ?? "");
+      const args = msg.args ?? {};
+      if (!toolCallId || !name) return;
+      cb.onClientToolCall({ toolCallId, name, args });
+      return;
     }
-    case 'call_end': {
-      const reasonRaw = String(msg.reason ?? '')
-      const reason = mapEndReason(reasonRaw)
-      state.endReason = reason
+    case "call_end": {
+      const reasonRaw = String(msg.reason ?? "");
+      const reason = mapEndReason(reasonRaw);
+      state.endReason = reason;
       state.transcript = [
         ...state.transcript,
         {
           id: `m${state.idCounter++}`,
-          role: 'system',
-          text: `call ended${reasonRaw ? ` (${reasonRaw})` : ''}`,
-        },
-      ]
-      cb.onTranscript(state.transcript)
-      cb.onCallEnd(reason)
-      return
+          role: "system",
+          text: `call ended${reasonRaw ? ` (${reasonRaw})` : ""}`
+        }
+      ];
+      cb.onTranscript(state.transcript);
+      cb.onCallEnd(reason);
+      return;
     }
-    case 'error': {
-      const code = msg.code ?? 'server_error'
-      const message = msg.message ?? 'server error'
-      cb.onError({ code, message })
-      return
+    case "error": {
+      const code = msg.code ?? "server_error";
+      const message = msg.message ?? "server error";
+      cb.onError({ code, message });
+      return;
     }
   }
 }
 var setState = (state, next, cb) => {
-  if (state.state === next) return
-  cb.onState(next)
-}
+  if (state.state === next) return;
+  cb.onState(next);
+};
 var upsertUserPartial = (state, text, isFinal) => {
-  let idx = -1
+  let idx = -1;
   for (let i = state.transcript.length - 1; i >= 0; i--) {
-    const e = state.transcript[i]
-    if (e.role === 'user' && e.committed === false) {
-      idx = i
-      break
+    const e = state.transcript[i];
+    if (e.role === "user" && e.committed === false) {
+      idx = i;
+      break;
     }
   }
   if (idx === -1) {
     state.transcript = [
       ...state.transcript,
-      { id: `m${state.idCounter++}`, role: 'user', text, committed: isFinal },
-    ]
-    return
-  }
-  const target = state.transcript[idx]
-  const next = [...state.transcript]
-  next[idx] = { ...target, text, committed: isFinal }
-  state.transcript = next
-}
+      { id: `m${state.idCounter++}`, role: "user", text, committed: isFinal }
+    ];
+    return;
+  }
+  const target = state.transcript[idx];
+  const next = [...state.transcript];
+  next[idx] = { ...target, text, committed: isFinal };
+  state.transcript = next;
+};
 function buildWsUrl(args) {
-  const base = new URL(args.apiBase)
-  const proto = base.protocol === 'https:' ? 'wss:' : 'ws:'
-  const bargeQS = args.bargeIn === false ? '&barge=off' : ''
-  return `${proto}//${base.host}/v1/agents/${encodeURIComponent(args.agentId)}/call?token=${encodeURIComponent(args.token)}${bargeQS}`
+  const base = new URL(args.apiBase);
+  const proto = base.protocol === "https:" ? "wss:" : "ws:";
+  const bargeQS = args.bargeIn === false ? "&barge=off" : "";
+  return `${proto}//${base.host}/v1/agents/${encodeURIComponent(args.agentId)}/call?token=${encodeURIComponent(args.token)}${bargeQS}`;
 }
 
 // src/clientTools.ts
-var NAME_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/
-var MAX_TOOLS = 64
-var MAX_USAGE = 500
-var MAX_TIMEOUT_MS = 3e4
+var NAME_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var MAX_TOOLS = 64;
+var MAX_USAGE = 500;
+var MAX_TIMEOUT_MS = 3e4;
 var validateClientToolMap = (tools) => {
-  if (tools === void 0) return
-  if (typeof tools !== 'object' || tools === null || Array.isArray(tools)) {
-    throw new Error('clientTools must be an object keyed by tool name')
+  if (tools === void 0) return;
+  if (typeof tools !== "object" || tools === null || Array.isArray(tools)) {
+    throw new Error("clientTools must be an object keyed by tool name");
   }
-  const entries = Object.entries(tools)
+  const entries = Object.entries(tools);
   if (entries.length > MAX_TOOLS) {
-    throw new Error(`clientTools may declare at most 64 tools (got ${entries.length})`)
+    throw new Error(`clientTools may declare at most 64 tools (got ${entries.length})`);
   }
   for (const [name, def] of entries) {
     if (!NAME_RE.test(name)) {
       throw new Error(
-        `clientTools["${name}"]: name must be a valid identifier (^[a-zA-Z_][a-zA-Z0-9_]*$)`,
-      )
+        `clientTools["${name}"]: name must be a valid identifier (^[a-zA-Z_][a-zA-Z0-9_]*$)`
+      );
     }
-    if (!def || typeof def !== 'object') {
-      throw new Error(`clientTools["${name}"]: must be an object`)
+    if (!def || typeof def !== "object") {
+      throw new Error(`clientTools["${name}"]: must be an object`);
     }
-    if (typeof def.description !== 'string' || def.description.length === 0) {
-      throw new Error(`clientTools["${name}"]: must have a description`)
+    if (typeof def.description !== "string" || def.description.length === 0) {
+      throw new Error(`clientTools["${name}"]: must have a description`);
     }
-    if (typeof def.handler !== 'function') {
-      throw new Error(`clientTools["${name}"]: must have a handler function`)
+    if (typeof def.handler !== "function") {
+      throw new Error(`clientTools["${name}"]: must have a handler function`);
     }
     if (def.usage !== void 0 && def.usage.length > MAX_USAGE) {
-      throw new Error(`clientTools["${name}"]: usage must be \u2264500 chars`)
+      throw new Error(`clientTools["${name}"]: usage must be \u2264500 chars`);
     }
-    if (
-      def.timeoutMs !== void 0 &&
-      (!Number.isFinite(def.timeoutMs) || def.timeoutMs <= 0 || def.timeoutMs > MAX_TIMEOUT_MS)
-    ) {
-      throw new Error(`clientTools["${name}"]: timeoutMs must be in (0, 30000]`)
+    if (def.timeoutMs !== void 0 && (!Number.isFinite(def.timeoutMs) || def.timeoutMs <= 0 || def.timeoutMs > MAX_TIMEOUT_MS)) {
+      throw new Error(`clientTools["${name}"]: timeoutMs must be in (0, 30000]`);
     }
   }
-}
+};
 var buildRegisterFrame = (tools) => ({
-  type: 'client_tools_register',
+  type: "client_tools_register",
   tools: Object.entries(tools).map(([name, def]) => ({
     name,
     description: def.description,
     parameters: def.parameters,
-    ...(def.usage !== void 0 ? { usage: def.usage } : {}),
-    ...(def.timeoutMs !== void 0 ? { timeoutMs: def.timeoutMs } : {}),
-  })),
-})
+    ...def.usage !== void 0 ? { usage: def.usage } : {},
+    ...def.timeoutMs !== void 0 ? { timeoutMs: def.timeoutMs } : {}
+  }))
+});
 var dispatchClientToolCall = (send, tools, frame) => {
   const safeSend = (payload) => {
     try {
-      send(payload)
-    } catch {}
-  }
-  const tool = tools[frame.name]
+      send(payload);
+    } catch {
+    }
+  };
+  const tool = tools[frame.name];
   if (!tool) {
     safeSend({
-      type: 'client_tool_result',
+      type: "client_tool_result",
       toolCallId: frame.toolCallId,
-      error: `No handler for ${frame.name}`,
-    })
-    return
+      error: `No handler for ${frame.name}`
+    });
+    return;
   }
   void (async () => {
     try {
-      const out = await tool.handler(frame.args)
+      const out = await tool.handler(frame.args);
       safeSend({
-        type: 'client_tool_result',
+        type: "client_tool_result",
         toolCallId: frame.toolCallId,
-        result: typeof out === 'string' ? out : JSON.stringify(out),
-      })
+        result: typeof out === "string" ? out : JSON.stringify(out)
+      });
     } catch (err) {
       safeSend({
-        type: 'client_tool_result',
+        type: "client_tool_result",
         toolCallId: frame.toolCallId,
-        error: err instanceof Error ? err.message : String(err),
-      })
+        error: err instanceof Error ? err.message : String(err)
+      });
     }
-  })()
-}
+  })();
+};
 
 // src/ClientMarksBuffer.ts
 var createClientMarksBuffer = (args) => {
-  const now = args.now ?? (() => performance.now())
-  let pendingFirstOutboundAt = null
-  const inFlight = /* @__PURE__ */ new Map()
+  const now = args.now ?? (() => performance.now());
+  let pendingFirstOutboundAt = null;
+  const inFlight = /* @__PURE__ */ new Map();
   const tryEmit = (seq) => {
-    const slot = inFlight.get(seq)
-    if (!slot) return
-    if (!slot.ended) return
-    const marks = {}
+    const slot = inFlight.get(seq);
+    if (!slot) return;
+    if (!slot.ended) return;
+    const marks = {};
     if (slot.firstOutboundAt !== null && slot.firstAudibleAt !== null) {
-      marks.client_mic_to_first_audible_ms = slot.firstAudibleAt - slot.firstOutboundAt
+      marks.client_mic_to_first_audible_ms = slot.firstAudibleAt - slot.firstOutboundAt;
     }
     args.send({
-      type: 'client_marks',
+      type: "client_marks",
       seq,
       marks,
-      clientNow: Date.now(),
-    })
-    inFlight.delete(seq)
-  }
+      clientNow: Date.now()
+    });
+    inFlight.delete(seq);
+  };
   const markFirstOutboundAudio = () => {
-    if (pendingFirstOutboundAt !== null) return
-    pendingFirstOutboundAt = now()
-  }
+    if (pendingFirstOutboundAt !== null) return;
+    pendingFirstOutboundAt = now();
+  };
   const markFirstAudibleOutput = () => {
-    let target
+    let target;
     for (const slot of inFlight.values()) {
       if (!slot.ended) {
-        target = slot
+        target = slot;
       }
     }
-    if (!target) return
-    if (target.firstAudibleAt !== null) return
-    target.firstAudibleAt = now()
-  }
+    if (!target) return;
+    if (target.firstAudibleAt !== null) return;
+    target.firstAudibleAt = now();
+  };
   const onAgentTurnStart = (seq) => {
     inFlight.set(seq, {
       firstOutboundAt: pendingFirstOutboundAt,
       firstAudibleAt: null,
-      ended: false,
-    })
-    pendingFirstOutboundAt = null
-  }
+      ended: false
+    });
+    pendingFirstOutboundAt = null;
+  };
   const onAgentTurnEnd = (seq) => {
-    const slot = inFlight.get(seq)
+    const slot = inFlight.get(seq);
     if (!slot) {
-      args.send({ type: 'client_marks', seq, marks: {}, clientNow: Date.now() })
-      return
+      args.send({ type: "client_marks", seq, marks: {}, clientNow: Date.now() });
+      return;
     }
-    slot.ended = true
-    tryEmit(seq)
-  }
+    slot.ended = true;
+    tryEmit(seq);
+  };
   const flush = () => {
     for (const seq of [...inFlight.keys()]) {
-      const slot = inFlight.get(seq)
-      slot.ended = true
-      tryEmit(seq)
+      const slot = inFlight.get(seq);
+      slot.ended = true;
+      tryEmit(seq);
     }
-    pendingFirstOutboundAt = null
-  }
+    pendingFirstOutboundAt = null;
+  };
   return {
     markFirstOutboundAudio,
     markFirstAudibleOutput,
     onAgentTurnStart,
     onAgentTurnEnd,
-    flush,
-  }
-}
+    flush
+  };
+};
 
 // src/VoiceClient.ts
 var BrowserVoiceClient = class {
   constructor(args) {
-    this.rws = null
-    this.capture = null
-    this.playback = null
-    this.muted = false
-    this.inputVolume = 0
-    this.outputVolume = 0
-    this.startedAt = null
-    this.endedFired = false
-    this.lastError = null
+    this.rws = null;
+    this.capture = null;
+    this.playback = null;
+    this.muted = false;
+    this.inputVolume = 0;
+    this.outputVolume = 0;
+    this.startedAt = null;
+    this.endedFired = false;
+    this.lastError = null;
     this.end = () => {
-      this.teardown('user_hangup')
-    }
+      this.teardown("user_hangup");
+    };
     this.mute = () => {
-      if (this.muted) return
-      this.muted = true
-      this.capture?.mute(true)
-    }
+      if (this.muted) return;
+      this.muted = true;
+      this.capture?.mute(true);
+    };
     this.unmute = () => {
-      if (!this.muted) return
-      this.muted = false
-      this.capture?.mute(false)
-    }
+      if (!this.muted) return;
+      this.muted = false;
+      this.capture?.mute(false);
+    };
     // ---------------------------------------------------------------
     // Internal
     // ---------------------------------------------------------------
     this.sendClientToolsRegister = () => {
-      const frame = buildRegisterFrame(this.args.options.clientTools ?? {})
-      this.rws?.send(JSON.stringify(frame))
-    }
+      const frame = buildRegisterFrame(this.args.options.clientTools ?? {});
+      this.rws?.send(JSON.stringify(frame));
+    };
     this.setState = (next) => {
-      if (this.proto.state === next) return
-      this.proto.state = next
-      this.args.options.onStateChange?.(next)
-    }
+      if (this.proto.state === next) return;
+      this.proto.state = next;
+      this.args.options.onStateChange?.(next);
+    };
     this.emitError = (err) => {
-      this.lastError = err
-      this.args.options.onError?.(err)
-    }
+      this.lastError = err;
+      this.args.options.onError?.(err);
+    };
     this.handleSocketEvent = (ev) => {
       switch (ev.type) {
-        case 'open':
-          void this.startCapture()
-          break
-        case 'reconnected':
-          this.proto.transcript = []
-          this.proto.agentBubbleId = null
-          this.args.options.onTranscript?.(this.proto.transcript)
-          void this.startCapture()
-          this.setState('listening')
-          break
-        case 'message':
-          if (typeof ev.data === 'string') {
+        case "open":
+          void this.startCapture();
+          break;
+        case "reconnected":
+          this.proto.transcript = [];
+          this.proto.agentBubbleId = null;
+          this.args.options.onTranscript?.(this.proto.transcript);
+          void this.startCapture();
+          this.setState("listening");
+          break;
+        case "message":
+          if (typeof ev.data === "string") {
             handleServerMessage(ev.data, this.proto, {
               onState: this.setState,
               onTranscript: (entries) => this.args.options.onTranscript?.(entries),
               onError: this.emitError,
               onInterrupt: () => {
-                this.playback?.flush()
-                this.args.options.onInterrupt?.()
+                this.playback?.flush();
+                this.args.options.onInterrupt?.();
               },
               onAgentTurnStart: (seq) => {
-                if (typeof seq === 'number') this.marks.onAgentTurnStart(seq)
-                this.args.options.onAgentTurnStart?.()
+                if (typeof seq === "number") this.marks.onAgentTurnStart(seq);
+                this.args.options.onAgentTurnStart?.();
               },
               onAgentTurnEnd: (seq) => {
-                if (typeof seq === 'number') this.marks.onAgentTurnEnd(seq)
+                if (typeof seq === "number") this.marks.onAgentTurnEnd(seq);
               },
               onCallEnd: (reason) => this.teardown(reason),
               onConnected: () => this.sendClientToolsRegister(),
-              onClientToolCall: (frame) =>
-                dispatchClientToolCall(
-                  (f) => this.rws?.send(JSON.stringify(f)),
-                  this.args.options.clientTools ?? {},
-                  frame,
-                ),
-            })
+              onClientToolCall: (frame) => dispatchClientToolCall(
+                (f) => this.rws?.send(JSON.stringify(f)),
+                this.args.options.clientTools ?? {},
+                frame
+              )
+            });
           } else {
-            this.marks.markFirstAudibleOutput()
-            this.playback?.enqueue(ev.data)
+            this.marks.markFirstAudibleOutput();
+            this.playback?.enqueue(ev.data);
           }
-          break
-        case 'close':
+          break;
+        case "close":
           if (ev.permanent) {
-            const reason = this.proto.endReason ?? (this.lastError ? 'error' : 'user_hangup')
-            this.teardown(reason)
+            const reason = this.proto.endReason ?? (this.lastError ? "error" : "user_hangup");
+            this.teardown(reason);
           }
-          break
-        case 'error':
-          this.emitError({ code: 'socket_error', message: ev.error.message })
-          break
+          break;
+        case "error":
+          this.emitError({ code: "socket_error", message: ev.error.message });
+          break;
       }
-    }
+    };
     this.startCapture = async () => {
-      if (this.capture?.isCapturing()) return
+      if (this.capture?.isCapturing()) return;
       this.capture = createAudioCapture({
         onChunk: (pcm) => {
-          this.marks.markFirstOutboundAudio()
-          this.rws?.send(pcm)
+          this.marks.markFirstOutboundAudio();
+          this.rws?.send(pcm);
         },
         onVolume: (v) => {
-          this.inputVolume = v
-          this.args.options.onVolume?.({ input: v, output: this.outputVolume })
+          this.inputVolume = v;
+          this.args.options.onVolume?.({ input: v, output: this.outputVolume });
         },
         onError: (err) => {
           this.emitError({
-            code: err.name === 'NotAllowedError' ? 'mic_denied' : 'mic_start_failed',
-            message: err.message,
-          })
-        },
-      })
-      if (this.muted) this.capture.mute(true)
+            code: err.name === "NotAllowedError" ? "mic_denied" : "mic_start_failed",
+            message: err.message
+          });
+        }
+      });
+      if (this.muted) this.capture.mute(true);
       try {
-        await this.capture.start()
-      } catch {}
-    }
+        await this.capture.start();
+      } catch {
+      }
+    };
     this.teardown = (reason) => {
       try {
-        this.marks.flush()
-      } catch {}
-      this.capture?.stop()
-      this.capture = null
-      this.playback?.close()
-      this.playback = null
+        this.marks.flush();
+      } catch {
+      }
+      this.capture?.stop();
+      this.capture = null;
+      this.playback?.close();
+      this.playback = null;
       try {
-        this.rws?.close(1e3, reason)
-      } catch {}
-      this.rws = null
-      this.setState('ended')
-      this.fireEndOnce(reason)
-    }
+        this.rws?.close(1e3, reason);
+      } catch {
+      }
+      this.rws = null;
+      this.setState("ended");
+      this.fireEndOnce(reason);
+    };
     this.fireEndOnce = (reason) => {
-      if (this.endedFired) return
-      this.endedFired = true
-      const startedAt = this.startedAt ?? Date.now()
+      if (this.endedFired) return;
+      this.endedFired = true;
+      const startedAt = this.startedAt ?? Date.now();
       this.args.options.onEnd?.({
         reason,
-        errorCode: reason === 'error' ? this.lastError?.code : void 0,
-        durationMs: Date.now() - startedAt,
-      })
-    }
-    this.args = args
-    this.proto = createProtocolState()
-    validateClientToolMap(args.options.clientTools)
+        errorCode: reason === "error" ? this.lastError?.code : void 0,
+        durationMs: Date.now() - startedAt
+      });
+    };
+    this.args = args;
+    this.proto = createProtocolState();
+    validateClientToolMap(args.options.clientTools);
     this.marks = createClientMarksBuffer({
       send: (frame) => {
         try {
-          this.rws?.send(JSON.stringify(frame))
-        } catch {}
-      },
-    })
+          this.rws?.send(JSON.stringify(frame));
+        } catch {
+        }
+      }
+    });
   }
   // ---------------------------------------------------------------
   // Call interface
   // ---------------------------------------------------------------
   get state() {
-    return this.proto.state
+    return this.proto.state;
   }
   get transcript() {
-    return this.proto.transcript.slice()
+    return this.proto.transcript.slice();
   }
   get isMuted() {
-    return this.muted
+    return this.muted;
   }
   // ---------------------------------------------------------------
   // Lifecycle — called by the factory immediately after construction.
@@ -847,52 +842,54 @@ var BrowserVoiceClient = class {
   // failures arrive via `onError`.
   // ---------------------------------------------------------------
   async start() {
-    this.setState('connecting')
-    this.startedAt = Date.now()
+    this.setState("connecting");
+    this.startedAt = Date.now();
     const url = buildWsUrl({
       apiBase: this.args.config.apiBase,
       agentId: this.args.options.agentId,
       token: this.args.token,
-      bargeIn: this.args.options.bargeIn,
-    })
+      bargeIn: this.args.options.bargeIn
+    });
     this.playback = createAudioPlayback({
       onVolume: (v) => {
-        this.outputVolume = v
-        this.args.options.onVolume?.({ input: this.inputVolume, output: v })
-      },
-    })
+        this.outputVolume = v;
+        this.args.options.onVolume?.({ input: this.inputVolume, output: v });
+      }
+    });
     try {
-      await this.playback.resume()
-    } catch {}
+      await this.playback.resume();
+    } catch {
+    }
     this.rws = createReconnectingWebSocket(
       {
         url,
         wsFactory: this.args.wsFactory,
-        maxRetries: 3,
+        maxRetries: 3
       },
-      (ev) => this.handleSocketEvent(ev),
-    )
+      (ev) => this.handleSocketEvent(ev)
+    );
   }
-}
+};
 
 // src/webrtc/createWebRtcCall.ts
 async function createWebRtcCall(opts) {
-  validateClientToolMap(opts.clientTools)
-  const proto = createProtocolState()
-  let muted = false
-  let ended = false
-  const tools = opts.clientTools ?? {}
+  validateClientToolMap(opts.clientTools);
+  const proto = createProtocolState();
+  let muted = false;
+  let ended = false;
+  const tools = opts.clientTools ?? {};
   const sendControl = (frame) => {
-    if (dc?.readyState !== 'open') return
+    if (dc?.readyState !== "open") return;
     try {
-      dc.send(JSON.stringify(frame))
-    } catch {}
-  }
+      dc.send(JSON.stringify(frame));
+    } catch {
+    }
+  };
   const fireState = (next) => {
-    if (proto.state === next) return
-    proto.state = next
-    opts.onStateChange?.(next)
-  }
+    if (proto.state === next) return;
+    proto.state = next;
+    opts.onStateChange?.(next);
+  };
   const dispatch = (raw) => {
     handleServerMessage(raw, proto, {
       onState: fireState,
@@ -900,383 +897,466 @@ async function createWebRtcCall(opts) {
       onError: (err) => opts.onError?.(err),
       onInterrupt: () => opts.onInterrupt?.(),
       onAgentTurnStart: () => opts.onAgentTurnStart?.(),
-      onAgentTurnEnd: () => {},
+      onAgentTurnEnd: () => {
+      },
       onCallEnd: () => teardown(),
       onConnected: () => {
         if (Object.keys(tools).length > 0) {
-          sendControl(buildRegisterFrame(tools))
+          sendControl(buildRegisterFrame(tools));
         }
       },
       onClientToolCall: (frame) => {
-        dispatchClientToolCall(sendControl, tools, frame)
-      },
-    })
-  }
-  fireState('connecting')
+        dispatchClientToolCall(sendControl, tools, frame);
+      }
+    });
+  };
+  fireState("connecting");
   const pc = new RTCPeerConnection({
-    iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
-  })
-  const audioEl = document.createElement('audio')
-  audioEl.autoplay = true
-  audioEl.style.display = 'none'
-  document.body.appendChild(audioEl)
+    iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
+  });
+  const audioEl = document.createElement("audio");
+  audioEl.autoplay = true;
+  audioEl.style.display = "none";
+  document.body.appendChild(audioEl);
   pc.ontrack = (event) => {
-    audioEl.srcObject = event.streams[0] ?? new MediaStream([event.track])
-  }
-  let mic
+    audioEl.srcObject = event.streams[0] ?? new MediaStream([event.track]);
+  };
+  let mic;
   try {
-    mic = await navigator.mediaDevices.getUserMedia({ audio: true })
+    mic = await navigator.mediaDevices.getUserMedia({ audio: true });
   } catch (err) {
-    const code =
-      err instanceof DOMException && err.name === 'NotAllowedError'
-        ? 'mic_denied'
-        : 'mic_start_failed'
+    const code = err instanceof DOMException && err.name === "NotAllowedError" ? "mic_denied" : "mic_start_failed";
     opts.onError?.({
       code,
-      message: err instanceof Error ? err.message : 'getUserMedia failed',
-    })
-    fireState('error')
-    pc.close()
-    audioEl.remove()
-    throw err
-  }
-  for (const track of mic.getAudioTracks()) pc.addTrack(track, mic)
-  const dc = pc.createDataChannel('control', { ordered: true })
+      message: err instanceof Error ? err.message : "getUserMedia failed"
+    });
+    fireState("error");
+    pc.close();
+    audioEl.remove();
+    throw err;
+  }
+  for (const track of mic.getAudioTracks()) pc.addTrack(track, mic);
+  const dc = pc.createDataChannel("control", { ordered: true });
   dc.onmessage = (e) => {
-    if (typeof e.data === 'string') dispatch(e.data)
-  }
+    if (typeof e.data === "string") dispatch(e.data);
+  };
   dc.onerror = () => {
-    opts.onError?.({ code: 'socket_error', message: 'control channel error' })
-  }
+    opts.onError?.({ code: "socket_error", message: "control channel error" });
+  };
   dc.onopen = () => {
     if (Object.keys(tools).length > 0) {
-      sendControl(buildRegisterFrame(tools))
+      sendControl(buildRegisterFrame(tools));
     }
-  }
-  const gateway = opts.webrtcGatewayBase || ''
-  const offerUrl = gateway
-    ? `${gateway}/webrtc/offer?token=${encodeURIComponent(opts.token)}`
-    : `${opts.apiBase}/v1/agents/${encodeURIComponent(opts.agentId)}/webrtc/offer?token=${encodeURIComponent(opts.token)}`
-  const iceUrl = gateway
-    ? `${gateway}/webrtc/ice?token=${encodeURIComponent(opts.token)}`
-    : `${opts.apiBase}/v1/agents/${encodeURIComponent(opts.agentId)}/webrtc/ice?token=${encodeURIComponent(opts.token)}`
+  };
+  const gateway = opts.webrtcGatewayBase || "";
+  const offerUrl = gateway ? `${gateway}/webrtc/offer?token=${encodeURIComponent(opts.token)}` : `${opts.apiBase}/v1/agents/${encodeURIComponent(opts.agentId)}/webrtc/offer?token=${encodeURIComponent(opts.token)}`;
+  const iceUrl = gateway ? `${gateway}/webrtc/ice?token=${encodeURIComponent(opts.token)}` : `${opts.apiBase}/v1/agents/${encodeURIComponent(opts.agentId)}/webrtc/ice?token=${encodeURIComponent(opts.token)}`;
   const teardown = () => {
-    if (ended) return
-    ended = true
+    if (ended) return;
+    ended = true;
     try {
-      mic.getTracks().forEach((t) => t.stop())
-    } catch {}
+      mic.getTracks().forEach((t) => t.stop());
+    } catch {
+    }
     try {
-      pc.close()
-    } catch {}
+      pc.close();
+    } catch {
+    }
     try {
-      audioEl.remove()
-    } catch {}
-    fireState('ended')
-    opts.onEnd?.()
-  }
-  let callId = null
-  const pendingCandidates = []
+      audioEl.remove();
+    } catch {
+    }
+    fireState("ended");
+    opts.onEnd?.();
+  };
+  let callId = null;
+  const pendingCandidates = [];
   const postCandidate = (candidate) => {
     void fetch(iceUrl, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ callId, candidate }),
-    }).catch(() => {})
-  }
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ callId, candidate })
+    }).catch(() => {
+    });
+  };
   pc.onicecandidate = (e) => {
-    if (!e.candidate) return
-    if (callId) postCandidate(e.candidate)
-    else pendingCandidates.push(e.candidate)
-  }
+    if (!e.candidate) return;
+    if (callId) postCandidate(e.candidate);
+    else pendingCandidates.push(e.candidate);
+  };
   pc.onconnectionstatechange = () => {
-    const s = pc.connectionState
-    if (s === 'connected') fireState('listening')
-    if (s === 'failed' || s === 'disconnected') {
-      opts.onError?.({ code: 'socket_error', message: `webrtc connection ${s}` })
-      teardown()
+    const s = pc.connectionState;
+    if (s === "connected") fireState("listening");
+    if (s === "failed" || s === "disconnected") {
+      opts.onError?.({ code: "socket_error", message: `webrtc connection ${s}` });
+      teardown();
     }
-    if (s === 'closed' && !ended) teardown()
-  }
-  await pc.setLocalDescription(await pc.createOffer())
+    if (s === "closed" && !ended) teardown();
+  };
+  await pc.setLocalDescription(await pc.createOffer());
   try {
     const offerRes = await fetch(offerUrl, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ sdp: pc.localDescription.sdp, type: 'offer', agentId: opts.agentId }),
-    })
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ sdp: pc.localDescription.sdp, type: "offer", agentId: opts.agentId })
+    });
     if (!offerRes.ok) {
-      const code = offerRes.status === 401 ? 'unauthorized' : 'server_error'
-      opts.onError?.({ code, message: `signaling failed: HTTP ${offerRes.status}` })
-      fireState('error')
-      mic.getTracks().forEach((t) => t.stop())
-      pc.close()
-      audioEl.remove()
-      throw new Error(`webrtc offer failed: ${offerRes.status}`)
+      const code = offerRes.status === 401 ? "unauthorized" : "server_error";
+      opts.onError?.({ code, message: `signaling failed: HTTP ${offerRes.status}` });
+      fireState("error");
+      mic.getTracks().forEach((t) => t.stop());
+      pc.close();
+      audioEl.remove();
+      throw new Error(`webrtc offer failed: ${offerRes.status}`);
     }
-    const body = await offerRes.json()
-    callId = body.callId
-    await pc.setRemoteDescription({ type: 'answer', sdp: body.sdp })
-    while (pendingCandidates.length > 0) postCandidate(pendingCandidates.shift())
+    const body = await offerRes.json();
+    callId = body.callId;
+    await pc.setRemoteDescription({ type: "answer", sdp: body.sdp });
+    while (pendingCandidates.length > 0) postCandidate(pendingCandidates.shift());
   } catch (err) {
     if (!ended) {
       opts.onError?.({
-        code: 'network_unreachable',
-        message: err instanceof Error ? err.message : 'signaling failed',
-      })
-      fireState('error')
-      mic.getTracks().forEach((t) => t.stop())
-      pc.close()
-      audioEl.remove()
+        code: "network_unreachable",
+        message: err instanceof Error ? err.message : "signaling failed"
+      });
+      fireState("error");
+      mic.getTracks().forEach((t) => t.stop());
+      pc.close();
+      audioEl.remove();
     }
-    throw err
+    throw err;
   }
   return {
     get state() {
-      return proto.state
+      return proto.state;
     },
     get transcript() {
-      return proto.transcript.slice()
+      return proto.transcript.slice();
     },
     get isMuted() {
-      return muted
+      return muted;
     },
     end: () => teardown(),
     mute: () => {
-      if (muted) return
-      muted = true
-      mic.getAudioTracks().forEach((t) => (t.enabled = false))
+      if (muted) return;
+      muted = true;
+      mic.getAudioTracks().forEach((t) => t.enabled = false);
     },
     unmute: () => {
-      if (!muted) return
-      muted = false
-      mic.getAudioTracks().forEach((t) => (t.enabled = true))
-    },
-  }
+      if (!muted) return;
+      muted = false;
+      mic.getAudioTracks().forEach((t) => t.enabled = true);
+    }
+  };
 }
 
 // src/room.ts
-var import_livekit_client = require('livekit-client')
+var import_livekit_client = require("livekit-client");
 
 // src/roomProtocol.ts
-var SYSTEM_TOPIC = 'system'
-var TRANSCRIPT_TOPIC = 'transcript'
+var SYSTEM_TOPIC = "system";
+var TRANSCRIPT_TOPIC = "transcript";
 var decodeSystem = (bytes) => {
   try {
-    const v = JSON.parse(new TextDecoder().decode(bytes))
-    if (v && typeof v.kind === 'string') return v
-    return null
+    const v = JSON.parse(new TextDecoder().decode(bytes));
+    if (v && typeof v.kind === "string") return v;
+    return null;
   } catch {
-    return null
+    return null;
   }
-}
+};
 var decodeTranscript = (bytes) => {
   try {
-    const v = JSON.parse(new TextDecoder().decode(bytes))
-    if (v && v.kind === 'partial') return v
-    return null
+    const v = JSON.parse(new TextDecoder().decode(bytes));
+    if (v && v.kind === "partial") return v;
+    return null;
   } catch {
-    return null
+    return null;
   }
-}
+};
 
 // src/room.ts
-var identityToPid = (identity) =>
-  identity.startsWith('guest:') ? identity.slice('guest:'.length) : identity
+var identityToPid = (identity) => identity.startsWith("guest:") ? identity.slice("guest:".length) : identity;
 var joinRoom = async (opts) => {
-  const exchangeUrl = `${opts.apiBase.replace(/\/+$/, '')}/v1/rooms/${encodeURIComponent(
-    opts.roomId,
-  )}/join`
+  const exchangeUrl = `${opts.apiBase.replace(/\/+$/, "")}/v1/rooms/${encodeURIComponent(
+    opts.roomId
+  )}/join`;
   const exchangeRes = await fetch(exchangeUrl, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ code: opts.joinCode, name: opts.name }),
-  })
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ code: opts.joinCode, name: opts.name })
+  });
   if (!exchangeRes.ok) {
-    const err = await exchangeRes.json().catch(() => ({}))
-    throw new Error(err.error?.code ?? `join_failed_${exchangeRes.status}`)
+    const err = await exchangeRes.json().catch(() => ({}));
+    throw new Error(err.error?.code ?? `join_failed_${exchangeRes.status}`);
   }
-  const exchange = await exchangeRes.json()
-  const handlers = /* @__PURE__ */ new Map()
+  const exchange = await exchangeRes.json();
+  const handlers = /* @__PURE__ */ new Map();
   const emit = (e, payload) => {
     handlers.get(e)?.forEach((h) => {
       try {
-        h(payload)
-      } catch {}
-    })
-  }
-  const room = new import_livekit_client.Room({ adaptiveStream: true, dynacast: true })
-  room.on(import_livekit_client.RoomEvent.ParticipantConnected, (p) =>
-    emit('participant.joined', {
+        h(payload);
+      } catch {
+      }
+    });
+  };
+  const room = new import_livekit_client.Room({ adaptiveStream: true, dynacast: true });
+  room.on(
+    import_livekit_client.RoomEvent.ParticipantConnected,
+    (p) => emit("participant.joined", {
       participantId: identityToPid(p.identity),
-      name: p.name ?? '',
-    }),
-  )
-  room.on(import_livekit_client.RoomEvent.ParticipantDisconnected, (p) =>
-    emit('participant.left', {
+      name: p.name ?? ""
+    })
+  );
+  room.on(
+    import_livekit_client.RoomEvent.ParticipantDisconnected,
+    (p) => emit("participant.left", {
       participantId: identityToPid(p.identity),
-      name: p.name ?? '',
-    }),
-  )
-  room.on(import_livekit_client.RoomEvent.Disconnected, () => emit('room.ended', void 0))
+      name: p.name ?? ""
+    })
+  );
+  room.on(import_livekit_client.RoomEvent.Disconnected, () => emit("room.ended", void 0));
   room.on(import_livekit_client.RoomEvent.DataReceived, (data, _participant, _kind, topic) => {
     if (topic === SYSTEM_TOPIC) {
-      const m = decodeSystem(data)
-      if (m) emit('system.message', m)
+      const m = decodeSystem(data);
+      if (m) emit("system.message", m);
     } else if (topic === TRANSCRIPT_TOPIC) {
-      const m = decodeTranscript(data)
-      if (m) emit('transcript.partial', m)
+      const m = decodeTranscript(data);
+      if (m) emit("transcript.partial", m);
     }
-  })
-  const trackKind = (t) => (t.kind === import_livekit_client.Track.Kind.Video ? 'video' : 'audio')
+  });
+  const trackKind = (t) => t.kind === import_livekit_client.Track.Kind.Video ? "video" : "audio";
   const trackSource = (s) => {
     switch (s) {
       case import_livekit_client.Track.Source.Camera:
-        return 'camera'
+        return "camera";
       case import_livekit_client.Track.Source.Microphone:
-        return 'microphone'
+        return "microphone";
       case import_livekit_client.Track.Source.ScreenShare:
-        return 'screen_share'
+        return "screen_share";
       case import_livekit_client.Track.Source.ScreenShareAudio:
-        return 'screen_share_audio'
+        return "screen_share_audio";
       default:
-        return 'unknown'
+        return "unknown";
     }
-  }
-  room.on(import_livekit_client.RoomEvent.TrackSubscribed, (track, pub, participant) =>
-    emit('track.subscribed', {
+  };
+  room.on(
+    import_livekit_client.RoomEvent.TrackSubscribed,
+    (track, pub, participant) => emit("track.subscribed", {
       participantId: identityToPid(participant.identity),
       kind: trackKind(track),
       source: trackSource(pub.source),
-      track,
-    }),
-  )
-  room.on(import_livekit_client.RoomEvent.TrackUnsubscribed, (track, pub, participant) =>
-    emit('track.unsubscribed', {
+      track
+    })
+  );
+  room.on(
+    import_livekit_client.RoomEvent.TrackUnsubscribed,
+    (track, pub, participant) => emit("track.unsubscribed", {
       participantId: identityToPid(participant.identity),
       kind: trackKind(track),
       source: trackSource(pub.source),
-      track,
-    }),
-  )
-  room.on(import_livekit_client.RoomEvent.ActiveSpeakersChanged, (speakers) =>
-    emit(
-      'active.speakers',
-      speakers.map((p) => identityToPid(p.identity)),
-    ),
-  )
-  await room.connect(exchange.livekit.url, exchange.livekit.token)
+      track
+    })
+  );
+  room.on(
+    import_livekit_client.RoomEvent.ActiveSpeakersChanged,
+    (speakers) => emit(
+      "active.speakers",
+      speakers.map((p) => identityToPid(p.identity))
+    )
+  );
+  await room.connect(exchange.livekit.url, exchange.livekit.token);
   return {
     participantId: exchange.participantId,
     get participants() {
       return [...room.remoteParticipants.values()].map((p) => ({
         participantId: identityToPid(p.identity),
-        name: p.name ?? '',
-      }))
+        name: p.name ?? ""
+      }));
     },
     on(event, handler) {
-      const set = handlers.get(event) ?? /* @__PURE__ */ new Set()
-      set.add(handler)
-      handlers.set(event, set)
+      const set = handlers.get(event) ?? /* @__PURE__ */ new Set();
+      set.add(handler);
+      handlers.set(event, set);
     },
     publishMic: async () => {
-      await room.localParticipant.setMicrophoneEnabled(true)
+      await room.localParticipant.setMicrophoneEnabled(true);
     },
     publishCamera: async () => {
-      await room.localParticipant.setCameraEnabled(true)
+      await room.localParticipant.setCameraEnabled(true);
     },
     setMicEnabled: async (on) => {
-      await room.localParticipant.setMicrophoneEnabled(on)
+      await room.localParticipant.setMicrophoneEnabled(on);
     },
     setCameraEnabled: async (on) => {
-      await room.localParticipant.setCameraEnabled(on)
+      await room.localParticipant.setCameraEnabled(on);
     },
     isMicEnabled: () => room.localParticipant.isMicrophoneEnabled,
     isCameraEnabled: () => room.localParticipant.isCameraEnabled,
-    getLocalCameraTrack: () =>
-      room.localParticipant.getTrackPublication(import_livekit_client.Track.Source.Camera)
-        ?.videoTrack ?? null,
+    getLocalCameraTrack: () => room.localParticipant.getTrackPublication(import_livekit_client.Track.Source.Camera)?.videoTrack ?? null,
     getRemoteTracks: () => {
-      const out = []
+      const out = [];
       for (const p of room.remoteParticipants.values()) {
         for (const pub of p.trackPublications.values()) {
-          const track = pub.track
-          if (!track) continue
+          const track = pub.track;
+          if (!track) continue;
           out.push({
             participantId: identityToPid(p.identity),
             kind: trackKind(track),
             source: trackSource(pub.source),
-            track,
-          })
+            track
+          });
         }
       }
-      return out
+      return out;
     },
     setScreenShareEnabled: async (on, opts2) => {
-      await room.localParticipant.setScreenShareEnabled(on, { audio: opts2?.audio ?? false })
+      await room.localParticipant.setScreenShareEnabled(on, { audio: opts2?.audio ?? false });
     },
     isScreenShareEnabled: () => room.localParticipant.isScreenShareEnabled,
-    getLocalScreenTrack: () =>
-      room.localParticipant.getTrackPublication(import_livekit_client.Track.Source.ScreenShare)
-        ?.videoTrack ?? null,
+    getLocalScreenTrack: () => room.localParticipant.getTrackPublication(import_livekit_client.Track.Source.ScreenShare)?.videoTrack ?? null,
     leave: async () => {
-      await room.disconnect()
+      await room.disconnect();
+    }
+  };
+};
+
+// src/textSession.ts
+async function startTextSession(opts) {
+  const f = opts.fetch ?? fetch;
+  const tokenQs = `?token=${encodeURIComponent(opts.token)}`;
+  const startUrl = `${opts.baseUrl}/v1/agents/${opts.agentId}/chat${tokenQs}`;
+  const startBody = opts.text ? JSON.stringify({ text: opts.text }) : "{}";
+  const res = await f(startUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
+    body: startBody
+  });
+  if (!res.ok || !res.body) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`startTextSession failed: ${res.status} ${text}`);
+  }
+  const iter = parseSse(res.body);
+  let chatId = "";
+  let callId = "";
+  const buffered = [];
+  const it = iter[Symbol.asyncIterator]();
+  while (true) {
+    const { value, done } = await it.next();
+    if (done) break;
+    if (value.type === "chat.started") {
+      chatId = value.chatId;
+      callId = value.callId;
+      break;
+    }
+    buffered.push(value);
+  }
+  return {
+    id: chatId,
+    callId,
+    greeting: replayThen(buffered, { [Symbol.asyncIterator]: () => it }),
+    async send(text) {
+      const r = await f(`${opts.baseUrl}/v1/chats/${chatId}/messages${tokenQs}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
+        body: JSON.stringify({ text })
+      });
+      if (!r.ok || !r.body) {
+        const errText = await r.text().catch(() => "");
+        throw new Error(`send failed: ${r.status} ${errText}`);
+      }
+      return parseSse(r.body);
     },
+    async end() {
+      await f(`${opts.baseUrl}/v1/calls/${callId}`, { method: "DELETE" });
+    }
+  };
+}
+async function* parseSse(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) return;
+    buf += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buf.indexOf("\n\n")) >= 0) {
+      const chunk = buf.slice(0, idx);
+      buf = buf.slice(idx + 2);
+      let event = "message";
+      let data = "";
+      for (const line of chunk.split("\n")) {
+        if (line.startsWith(":")) continue;
+        if (line.startsWith("event:")) event = line.slice(6).trim();
+        else if (line.startsWith("data:")) data += line.slice(5).trim();
+      }
+      if (!data) continue;
+      try {
+        const parsed = JSON.parse(data);
+        yield { type: event, ...parsed };
+      } catch {
+      }
+    }
   }
 }
+async function* replayThen(buffered, rest) {
+  for (const x of buffered) yield x;
+  for await (const x of rest) yield x;
+}
 
 // src/incomingCall.ts
 var parseIncomingCall = (raw) => {
-  if (typeof raw !== 'object' || raw === null) {
-    throw new Error('parseIncomingCall: payload must be an object')
-  }
-  const p = raw
-  if (typeof p.token !== 'string' || !p.token.startsWith('ct_')) {
-    throw new Error('parseIncomingCall: missing or invalid `token` (expected a ct_ string)')
-  }
-  if (typeof p.agentId !== 'string' || p.agentId.length === 0) {
-    throw new Error('parseIncomingCall: missing `agentId`')
-  }
-  const transport = p.transport === 'webrtc' ? 'webrtc' : 'ws'
-  const out = { token: p.token, agentId: p.agentId, transport }
-  if (transport === 'webrtc' && typeof p.webrtcGatewayBase === 'string') {
-    out.webrtcGatewayBase = p.webrtcGatewayBase
-  }
-  if (typeof p.expiresAt === 'number') out.expiresAt = p.expiresAt
-  if (typeof p.agentName === 'string') out.agentName = p.agentName
-  if (typeof p.agentAvatarUrl === 'string') out.agentAvatarUrl = p.agentAvatarUrl
-  return out
-}
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("parseIncomingCall: payload must be an object");
+  }
+  const p = raw;
+  if (typeof p.token !== "string" || !p.token.startsWith("ct_")) {
+    throw new Error("parseIncomingCall: missing or invalid `token` (expected a ct_ string)");
+  }
+  if (typeof p.agentId !== "string" || p.agentId.length === 0) {
+    throw new Error("parseIncomingCall: missing `agentId`");
+  }
+  const transport = p.transport === "webrtc" ? "webrtc" : "ws";
+  const out = { token: p.token, agentId: p.agentId, transport };
+  if (transport === "webrtc" && typeof p.webrtcGatewayBase === "string") {
+    out.webrtcGatewayBase = p.webrtcGatewayBase;
+  }
+  if (typeof p.expiresAt === "number") out.expiresAt = p.expiresAt;
+  if (typeof p.agentName === "string") out.agentName = p.agentName;
+  if (typeof p.agentAvatarUrl === "string") out.agentAvatarUrl = p.agentAvatarUrl;
+  return out;
+};
 
 // src/browser.ts
-var browserWsFactory = (url) => new globalThis.WebSocket(url)
+var browserWsFactory = (url) => new globalThis.WebSocket(url);
 var BrowserVoiceFactory = class {
   constructor(config) {
     this.startCall = async (options) => {
       if (!options.agentId) {
-        throw new Error('startCall: agentId is required')
+        throw new Error("startCall: agentId is required");
       }
-      const { context, metadata } = mergeStartCallContext(this.config, options)
+      const { context, metadata } = mergeStartCallContext(this.config, options);
       const fetchArgs = {
         agentId: options.agentId,
         userId: options.userId,
         context,
-        metadata,
-      }
-      let resolved
+        metadata
+      };
+      let resolved;
       if (options.token) {
-        resolved = { token: options.token, transport: 'ws' }
+        resolved = { token: options.token, transport: "ws" };
       } else {
-        const r = await this.config.fetchToken(fetchArgs)
+        const r = await this.config.fetchToken(fetchArgs);
         if (!r) {
-          throw new Error('configureVoiceClient.fetchToken returned empty token')
+          throw new Error("configureVoiceClient.fetchToken returned empty token");
         }
-        resolved = typeof r === 'string' ? { token: r, transport: 'ws' } : r
+        resolved = typeof r === "string" ? { token: r, transport: "ws" } : r;
         if (!resolved.token) {
-          throw new Error('configureVoiceClient.fetchToken returned an object without `token`')
+          throw new Error("configureVoiceClient.fetchToken returned an object without `token`");
         }
       }
-      if (resolved.transport === 'webrtc') {
+      if (resolved.transport === "webrtc") {
         return createWebRtcCall({
           agentId: options.agentId,
           apiBase: this.config.apiBase,
@@ -1288,13 +1368,11 @@ var BrowserVoiceFactory = class {
           // Synthesise a minimal CallEndEvent. WebRTC doesn't carry an end reason
           // from the server yet — use 'agent_ended' as placeholder. durationMs is
           // tracked at 0 until the followup lands (see spec Followups section).
-          onEnd: options.onEnd
-            ? () => options.onEnd({ reason: 'agent_ended', durationMs: 0 })
-            : void 0,
+          onEnd: options.onEnd ? () => options.onEnd({ reason: "agent_ended", durationMs: 0 }) : void 0,
           onInterrupt: options.onInterrupt,
           onAgentTurnStart: options.onAgentTurnStart,
-          clientTools: options.clientTools,
-        })
+          clientTools: options.clientTools
+        });
       }
       const client = new BrowserVoiceClient({
         config: this.config,
@@ -1302,11 +1380,11 @@ var BrowserVoiceFactory = class {
         // see what the SDK saw.
         options: { ...options, context, metadata },
         token: resolved.token,
-        wsFactory: browserWsFactory,
-      })
-      await client.start()
-      return client
-    }
+        wsFactory: browserWsFactory
+      });
+      await client.start();
+      return client;
+    };
     // Multi-party rooms (Phase 7 video).
     //
     // The guest's browser calls this with the roomId + joinCode it parsed
@@ -1314,24 +1392,31 @@ var BrowserVoiceFactory = class {
     // JWT against `${apiBase}/v1/rooms/:roomId/join` (an AUTH-EXEMPT
     // endpoint — the opaque code is the only credential), then connects
     // to LiveKit and returns a typed event surface.
-    this.joinRoom = (opts) => joinRoom({ apiBase: this.config.apiBase, ...opts })
-    this.config = config
-  }
-}
+    this.joinRoom = (opts) => joinRoom({ apiBase: this.config.apiBase, ...opts });
+    // Text-channel chat session (no microphone / audio).
+    // Mint a `ct_` token with `channel: 'text'` on your backend, then call
+    // this to open an SSE stream against the chat API.
+    this.startTextSession = (opts) => startTextSession({
+      ...opts,
+      baseUrl: this.config.apiBase
+    });
+    this.config = config;
+  }
+};
 function configureVoiceClient(config) {
-  return new BrowserVoiceFactory(normalizeConfig(config))
+  return new BrowserVoiceFactory(normalizeConfig(config));
 }
 // Annotate the CommonJS export names for ESM import in node:
-0 &&
-  (module.exports = {
-    buildWsUrl,
-    configureVoiceClient,
-    createAudioCapture,
-    createAudioPlayback,
-    createProtocolState,
-    createReconnectingWebSocket,
-    handleServerMessage,
-    joinRoom,
-    parseIncomingCall,
-  })
-//# sourceMappingURL=browser.js.map
+0 && (module.exports = {
+  buildWsUrl,
+  configureVoiceClient,
+  createAudioCapture,
+  createAudioPlayback,
+  createProtocolState,
+  createReconnectingWebSocket,
+  handleServerMessage,
+  joinRoom,
+  parseIncomingCall,
+  startTextSession
+});
+//# sourceMappingURL=browser.js.map