@inkibra/voice-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,673 @@
+// src/client.ts
+function sessionStartMessage(options) {
+  return {
+    type: "session.start",
+    developer: options.developer
+  };
+}
+
+class LiveVoiceClient {
+  endpoint;
+  callbacks;
+  socket;
+  microphone;
+  output;
+  preparation;
+  resolvePrepared;
+  rejectPrepared;
+  prepared = false;
+  sessionToken;
+  starting;
+  resolveStarted;
+  rejectStarted;
+  constructor(endpoint, callbacks) {
+    this.endpoint = endpoint;
+    this.callbacks = callbacks;
+  }
+  async prepare(token) {
+    if (this.prepared && this.sessionToken === token && this.socket?.readyState === WebSocket.OPEN)
+      return;
+    if (this.preparation && this.sessionToken === token)
+      return this.preparation;
+    if (this.socket)
+      this.stop();
+    this.sessionToken = token;
+    this.callbacks.onConnection("connecting");
+    const endpoint = this.endpoint.replace(/\/$/u, "");
+    const socket = new WebSocket(withSessionToken(`${endpoint}/${crypto.randomUUID()}`, token));
+    this.socket = socket;
+    socket.binaryType = "arraybuffer";
+    socket.addEventListener("message", (event) => this.onMessage(event.data));
+    socket.addEventListener("close", (event) => {
+      if (this.socket !== socket)
+        return;
+      const wasPrepared = this.prepared;
+      if (!wasPrepared)
+        this.rejectPrepared?.(new Error("Session connection closed before preparation completed."));
+      this.microphone?.stop();
+      this.microphone = undefined;
+      this.output?.clear();
+      this.output = undefined;
+      this.socket = undefined;
+      this.prepared = false;
+      this.preparation = undefined;
+      this.resolvePrepared = undefined;
+      this.rejectPrepared = undefined;
+      this.sessionToken = undefined;
+      this.rejectStarted?.(new Error("Session connection closed before startup completed."));
+      this.clearStarting();
+      this.callbacks.onConnection("closed", event.reason || undefined);
+    });
+    socket.addEventListener("error", () => {
+      if (this.socket !== socket)
+        return;
+      const message = "Durable Object WebSocket failed.";
+      this.failPreparation(message);
+      this.rejectStarted?.(new Error(message));
+      this.clearStarting();
+      this.callbacks.onConnection("error", message);
+    });
+    this.preparation = new Promise((resolve, reject) => {
+      this.resolvePrepared = resolve;
+      this.rejectPrepared = reject;
+    });
+    await waitForOpen(socket);
+    socket.send(JSON.stringify({ type: "session.prepare", protocolVersion: 1 }));
+    return this.preparation;
+  }
+  async start(options) {
+    await this.prepare(options.token);
+    this.output = new OutputAudio((receipt) => {
+      if (this.socket?.readyState === WebSocket.OPEN)
+        this.socket.send(JSON.stringify({ type: "output.receipt", ...receipt }));
+    });
+    await this.output.resume();
+    this.starting = new Promise((resolve, reject) => {
+      this.resolveStarted = resolve;
+      this.rejectStarted = reject;
+    });
+    this.socket?.send(JSON.stringify(sessionStartMessage(options)));
+    await this.starting;
+    this.microphone = new Microphone((buffer) => {
+      if (this.socket?.readyState === WebSocket.OPEN)
+        this.socket.send(buffer);
+    }, (level) => {
+      this.output?.sidechain(level);
+      this.callbacks.onLevel(level);
+    });
+    await this.microphone.start();
+    this.callbacks.onConnection("live");
+  }
+  stop() {
+    this.microphone?.stop();
+    this.microphone = undefined;
+    this.output?.clear();
+    this.output = undefined;
+    if (this.socket?.readyState === WebSocket.OPEN)
+      this.socket.send(JSON.stringify({ type: "session.stop" }));
+    this.socket?.close(1000, "stopped");
+    this.socket = undefined;
+    this.prepared = false;
+    this.preparation = undefined;
+    this.resolvePrepared = undefined;
+    this.rejectPrepared = undefined;
+    this.sessionToken = undefined;
+    this.rejectStarted?.(new Error("Session stopped before startup completed."));
+    this.clearStarting();
+    this.callbacks.onConnection("closed");
+  }
+  dispose() {
+    this.stop();
+  }
+  playUiCue(cue) {
+    if (this.socket?.readyState === WebSocket.OPEN)
+      this.socket.send(JSON.stringify({ type: "cue.request", cue }));
+  }
+  onMessage(raw) {
+    if (typeof raw !== "string")
+      return;
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const type = String(message.type ?? "");
+    if (type === "session.prepared") {
+      this.prepared = true;
+      this.resolvePrepared?.();
+      this.resolvePrepared = undefined;
+      this.rejectPrepared = undefined;
+      return;
+    }
+    if (type === "session.prepare_failed") {
+      this.failPreparation(String(message.message ?? "Session preparation failed."));
+      return;
+    }
+    if (type === "session.started") {
+      this.resolveStarted?.();
+      this.clearStarting();
+      return;
+    }
+    if (type === "public.event") {
+      this.callbacks.onPublicEvent({
+        name: String(message.name ?? "unknown"),
+        payload: asRecord(message.payload),
+        ...Number.isFinite(Number(message.atMs)) ? { atMs: Number(message.atMs) } : {}
+      });
+      return;
+    }
+    if (type === "tool.call") {
+      this.handleToolCall(message);
+      return;
+    }
+    if (type === "session.limit") {
+      this.callbacks.onSessionLimit?.(String(message.reason ?? "SESSION_LIMIT"), Number.isFinite(Number(message.durationSeconds)) ? Number(message.durationSeconds) : undefined);
+      return;
+    }
+    if (type === "output.block") {
+      this.output?.blockForeground(String(message.generationId ?? ""));
+      return;
+    }
+    if (type === "output.audio" && typeof message.delta === "string") {
+      this.output?.enqueue({
+        encoded: message.delta,
+        lane: message.queue === "reaction" ? "REACTION" : "FOREGROUND",
+        generationId: String(message.generationId ?? ""),
+        mode: message.mode === "play" ? "play" : "buffer",
+        gain: clamp01(Number(message.gain ?? 1))
+      });
+      return;
+    }
+    if (type === "output.release") {
+      this.output?.release(String(message.generationId ?? ""), clamp01(Number(message.gain ?? 1)));
+      return;
+    }
+    if (type === "output.cancel") {
+      this.output?.cancel(String(message.generationId ?? ""));
+      return;
+    }
+    if (type === "output.done") {
+      this.output?.done(message.queue === "reaction" ? "REACTION" : "FOREGROUND", String(message.generationId ?? ""));
+      return;
+    }
+    this.callbacks.onUnknown?.(message);
+  }
+  async handleToolCall(message) {
+    const callId = String(message.callId ?? "");
+    const name = String(message.name ?? "");
+    if (!callId || !name || this.socket?.readyState !== WebSocket.OPEN)
+      return;
+    try {
+      if (!this.callbacks.onToolCall)
+        throw new Error(`No browser handler is registered for tool ${name}`);
+      const output = await this.callbacks.onToolCall({ callId, name, input: asRecord(message.input) });
+      this.socket?.send(JSON.stringify({ type: "tool.result", callId, ok: true, output: output ?? null }));
+    } catch (error) {
+      this.socket?.send(JSON.stringify({
+        type: "tool.result",
+        callId,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      }));
+    }
+  }
+  failPreparation(message) {
+    if (!this.prepared)
+      this.rejectPrepared?.(new Error(message));
+    this.preparation = undefined;
+    this.resolvePrepared = undefined;
+    this.rejectPrepared = undefined;
+  }
+  clearStarting() {
+    this.starting = undefined;
+    this.resolveStarted = undefined;
+    this.rejectStarted = undefined;
+  }
+}
+function withSessionToken(value, token) {
+  if (!token)
+    return value;
+  const url = new URL(value);
+  url.searchParams.set("token", token);
+  return url.toString();
+}
+var OPTICAL_SIDECHAIN = {
+  thresholdDb: -42,
+  ratio: 4,
+  maxReductionDb: 12,
+  attackSeconds: 0.12,
+  releaseSeconds: 0.36
+};
+
+class OutputAudio {
+  onReceipt;
+  context = new AudioContext({ sampleRate: 24000, latencyHint: "interactive" });
+  foregroundGain = this.context.createGain();
+  reactionGain = this.context.createGain();
+  outputBus = this.context.createGain();
+  nextStart = 0;
+  sources = new Map;
+  buffered = new Map;
+  released = new Set;
+  blockers = new Set;
+  started = new Set;
+  startedTimers = new Map;
+  completed = new Set;
+  doneGenerations = new Map;
+  playedSamples = new Map;
+  constructor(onReceipt) {
+    this.onReceipt = onReceipt;
+    this.foregroundGain.connect(this.outputBus);
+    this.reactionGain.connect(this.outputBus);
+    this.outputBus.connect(this.context.destination);
+  }
+  async resume() {
+    await this.context.resume();
+  }
+  sidechain(level) {
+    const gain = opticalSidechainGain(level);
+    const now = this.context.currentTime;
+    const current = this.foregroundGain.gain.value;
+    this.foregroundGain.gain.cancelAndHoldAtTime(now);
+    this.foregroundGain.gain.setTargetAtTime(gain, now, gain < current ? OPTICAL_SIDECHAIN.attackSeconds : OPTICAL_SIDECHAIN.releaseSeconds);
+  }
+  blockForeground(generationId) {
+    if (generationId)
+      this.blockers.add(generationId);
+  }
+  enqueue(chunk) {
+    if (!chunk.generationId)
+      return;
+    if (chunk.lane === "REACTION")
+      this.blockers.add(chunk.generationId);
+    const blocked = chunk.lane === "FOREGROUND" && this.blockers.size > 0;
+    if (blocked || chunk.mode === "buffer" && !this.released.has(chunk.generationId)) {
+      const queue = this.buffered.get(chunk.generationId) ?? [];
+      queue.push({ encoded: chunk.encoded, lane: chunk.lane, gain: chunk.gain });
+      this.buffered.set(chunk.generationId, queue);
+      return;
+    }
+    this.schedule(chunk.encoded, chunk.lane, chunk.generationId, chunk.gain);
+  }
+  release(generationId, gain = 1) {
+    if (!generationId)
+      return;
+    const chunks = this.buffered.get(generationId);
+    if (chunks?.[0]?.lane === "REACTION") {
+      for (const chunk of chunks)
+        chunk.gain = gain;
+    }
+    this.released.add(generationId);
+    const lane = this.buffered.get(generationId)?.[0]?.lane ?? this.doneGenerations.get(generationId);
+    if (lane === "REACTION" || !this.blockers.size)
+      this.flush(generationId);
+  }
+  done(lane, generationId) {
+    this.doneGenerations.set(generationId, lane);
+    this.finishIfComplete(generationId);
+  }
+  cancel(generationId) {
+    if (!generationId)
+      return;
+    const bufferedLane = this.buffered.get(generationId)?.[0]?.lane;
+    const sourceLane = [...this.sources.values()].find((value) => value.generationId === generationId)?.lane;
+    const lane = sourceLane ?? bufferedLane ?? this.doneGenerations.get(generationId) ?? "FOREGROUND";
+    this.buffered.delete(generationId);
+    this.released.delete(generationId);
+    this.blockers.delete(generationId);
+    this.doneGenerations.delete(generationId);
+    for (const [source, metadata] of this.sources) {
+      if (metadata.generationId !== generationId)
+        continue;
+      const elapsed = Math.max(0, this.context.currentTime - metadata.startAt);
+      const played = Math.min(metadata.samples, Math.floor(elapsed * 24000));
+      this.playedSamples.set(generationId, (this.playedSamples.get(generationId) ?? 0) + played);
+      source.onended = null;
+      this.sources.delete(source);
+      try {
+        source.stop();
+      } catch {}
+    }
+    this.recomputeNextStart();
+    const timer = this.startedTimers.get(generationId);
+    if (timer !== undefined)
+      window.clearTimeout(timer);
+    this.startedTimers.delete(generationId);
+    this.flushReleasedForeground();
+    this.onReceipt({ event: "cancelled", lane, generationId, playedSamples: this.playedSamples.get(generationId) ?? 0 });
+  }
+  clear() {
+    for (const source of this.sources.keys())
+      try {
+        source.stop();
+      } catch {}
+    for (const timer of this.startedTimers.values())
+      window.clearTimeout(timer);
+    this.sources.clear();
+    this.buffered.clear();
+    this.released.clear();
+    this.blockers.clear();
+    this.started.clear();
+    this.startedTimers.clear();
+    this.completed.clear();
+    this.doneGenerations.clear();
+    this.playedSamples.clear();
+    this.nextStart = 0;
+    this.context.close();
+  }
+  flush(generationId) {
+    const chunks = this.buffered.get(generationId);
+    if (!chunks)
+      return;
+    this.buffered.delete(generationId);
+    for (const chunk of chunks)
+      this.schedule(chunk.encoded, chunk.lane, generationId, chunk.gain);
+  }
+  flushReleasedForeground() {
+    if (this.blockers.size)
+      return;
+    for (const generationId of this.released)
+      this.flush(generationId);
+  }
+  schedule(encoded, lane, generationId, gain) {
+    const binary = atob(encoded);
+    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    const pcm = new Int16Array(bytes.buffer);
+    const audio = this.context.createBuffer(1, pcm.length, 24000);
+    const samples = audio.getChannelData(0);
+    for (let index = 0;index < pcm.length; index += 1)
+      samples[index] = pcm[index] / 32768;
+    const source = this.context.createBufferSource();
+    const chunkGain = this.context.createGain();
+    chunkGain.gain.value = lane === "REACTION" ? gain : 1;
+    source.buffer = audio;
+    source.connect(chunkGain).connect(lane === "REACTION" ? this.reactionGain : this.foregroundGain);
+    const startAt = Math.max(this.context.currentTime + 0.008, this.nextStart);
+    this.nextStart = startAt + audio.duration;
+    this.sources.set(source, { generationId, lane, samples: pcm.length, startAt });
+    source.onended = () => {
+      const metadata = this.sources.get(source);
+      this.sources.delete(source);
+      this.recomputeNextStart();
+      if (!metadata)
+        return;
+      this.playedSamples.set(generationId, (this.playedSamples.get(generationId) ?? 0) + metadata.samples);
+      this.finishIfComplete(generationId);
+    };
+    source.start(startAt);
+    if (!this.started.has(generationId)) {
+      this.started.add(generationId);
+      const timer = window.setTimeout(() => {
+        this.startedTimers.delete(generationId);
+        if ([...this.sources.values()].some((value) => value.generationId === generationId)) {
+          this.onReceipt({ event: "started", lane, generationId, playedSamples: 0 });
+        }
+      }, Math.max(0, (startAt - this.context.currentTime) * 1000));
+      this.startedTimers.set(generationId, timer);
+    }
+  }
+  recomputeNextStart() {
+    this.nextStart = Math.max(this.context.currentTime, ...[...this.sources.values()].map((source) => source.startAt + source.samples / 24000));
+  }
+  finishIfComplete(generationId) {
+    const lane = this.doneGenerations.get(generationId);
+    if (!lane || this.completed.has(generationId) || this.buffered.has(generationId))
+      return;
+    if ([...this.sources.values()].some((value) => value.generationId === generationId))
+      return;
+    this.completed.add(generationId);
+    if (lane === "REACTION") {
+      this.blockers.delete(generationId);
+      this.flushReleasedForeground();
+    }
+    this.onReceipt({ event: "completed", lane, generationId, playedSamples: this.playedSamples.get(generationId) ?? 0 });
+  }
+}
+function opticalSidechainGain(level) {
+  const safeLevel = Math.max(Number.EPSILON, level);
+  const inputDb = 20 * Math.log10(safeLevel);
+  if (inputDb <= OPTICAL_SIDECHAIN.thresholdDb)
+    return 1;
+  const compressedDb = Math.min(OPTICAL_SIDECHAIN.maxReductionDb, (inputDb - OPTICAL_SIDECHAIN.thresholdDb) * (1 - 1 / OPTICAL_SIDECHAIN.ratio));
+  return 10 ** (-compressedDb / 20);
+}
+
+class Microphone {
+  onFrame;
+  onLevel;
+  context;
+  stream;
+  node;
+  samples = [];
+  constructor(onFrame, onLevel) {
+    this.onFrame = onFrame;
+    this.onLevel = onLevel;
+  }
+  async start() {
+    this.stream = await navigator.mediaDevices.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true, channelCount: 1 } });
+    this.context = new AudioContext({ sampleRate: 24000, latencyHint: "interactive" });
+    const sourceCode = `class LiveVoiceMic extends AudioWorkletProcessor { process(inputs) { const input=inputs[0]?.[0]; if(input) this.port.postMessage(input.slice()); return true; } } registerProcessor('live-voice-mic', LiveVoiceMic);`;
+    const moduleUrl = URL.createObjectURL(new Blob([sourceCode], { type: "text/javascript" }));
+    await this.context.audioWorklet.addModule(moduleUrl);
+    URL.revokeObjectURL(moduleUrl);
+    const source = this.context.createMediaStreamSource(this.stream);
+    this.node = new AudioWorkletNode(this.context, "live-voice-mic");
+    const silent = this.context.createGain();
+    silent.gain.value = 0;
+    source.connect(this.node).connect(silent).connect(this.context.destination);
+    this.node.port.onmessage = (event) => this.accept(event.data);
+    await this.context.resume();
+  }
+  stop() {
+    this.node?.disconnect();
+    this.stream?.getTracks().forEach((track) => track.stop());
+    this.context?.close();
+  }
+  accept(input) {
+    for (const value of input)
+      this.samples.push(value);
+    while (this.samples.length >= 480) {
+      const frame = this.samples.splice(0, 480);
+      const pcm = new Int16Array(480);
+      let energy = 0;
+      for (let index = 0;index < frame.length; index += 1) {
+        const value = Math.max(-1, Math.min(1, frame[index]));
+        energy += value * value;
+        pcm[index] = value < 0 ? value * 32768 : value * 32767;
+      }
+      this.onLevel(Math.sqrt(energy / frame.length));
+      this.onFrame(pcm.buffer);
+    }
+  }
+}
+function waitForOpen(socket) {
+  return new Promise((resolve, reject) => {
+    const timeout = window.setTimeout(() => reject(new Error("Durable Object connection timed out.")), 1e4);
+    socket.addEventListener("open", () => {
+      window.clearTimeout(timeout);
+      resolve();
+    }, { once: true });
+    socket.addEventListener("error", () => {
+      window.clearTimeout(timeout);
+      reject(new Error("Could not connect to the Durable Object."));
+    }, { once: true });
+  });
+}
+function clamp01(value) {
+  return Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 1;
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+
+// src/public.ts
+var defaultEndpoint = "wss://inkibra-voice.inkibra.workers.dev/v1/live";
+
+class LiveVoiceSession {
+  client;
+  tools;
+  listeners = new Map;
+  currentPhase;
+  constructor(client, tools) {
+    this.client = client;
+    this.tools = tools;
+  }
+  static async connect(options) {
+    if (!options.token)
+      throw new Error("A short-lived Live Voice session token is required.");
+    let session;
+    const client = new LiveVoiceClient(options.endpoint ?? defaultEndpoint, {
+      onConnection: (state, detail) => {
+        session?.emit("connection", { state, detail });
+        if (state === "error")
+          session?.emit("error", { code: "CONNECTION_ERROR", message: detail ?? "Live Voice connection failed." });
+      },
+      onPublicEvent: (event) => session?.acceptPublicEvent(event.name, event.payload, event.atMs),
+      onLevel: () => {},
+      onUnknown: (message) => session?.emit("unknown", { message }),
+      onSessionLimit: (reason, durationSeconds) => session?.emit("limit", { reason, durationSeconds }),
+      onToolCall: async (call) => session.executeTool(call)
+    });
+    session = new LiveVoiceSession(client, options.tools ?? {});
+    await client.start({
+      token: options.token,
+      developer: {
+        prompt: options.prompt ?? "",
+        conversation: options.conversation,
+        tools: Object.entries(options.tools ?? {}).map(([name, tool]) => ({
+          type: "function",
+          name,
+          description: tool.description,
+          parameters: tool.parameters
+        }))
+      }
+    });
+    return session;
+  }
+  on(event, handler) {
+    const handlers = this.listeners.get(event) ?? new Set;
+    handlers.add(handler);
+    this.listeners.set(event, handlers);
+    return () => handlers.delete(handler);
+  }
+  get phase() {
+    return this.currentPhase;
+  }
+  stop() {
+    this.client.stop();
+  }
+  dispose() {
+    this.client.dispose();
+    this.listeners.clear();
+  }
+  emit(event, value) {
+    for (const handler of this.listeners.get(event) ?? [])
+      handler(value);
+  }
+  acceptPublicEvent(name, payload, atMs) {
+    if (name === "transcript.instantaneous" && typeof payload.text === "string") {
+      this.emit("transcript.instantaneous", { text: payload.text });
+      return;
+    }
+    if (name === "transcript.canonical" && Array.isArray(payload.turns)) {
+      const turns = [];
+      for (const value of payload.turns) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+          continue;
+        const turn = value;
+        const role = turn.role;
+        if (typeof turn.id !== "string" || role !== "user" && role !== "assistant" || typeof turn.text !== "string")
+          continue;
+        turns.push({
+          id: turn.id,
+          role,
+          text: turn.text,
+          ...typeof turn.truncated === "boolean" ? { truncated: turn.truncated } : {}
+        });
+      }
+      this.emit("transcript.canonical", { turns });
+      return;
+    }
+    if (name === "floor" && (payload.owner === "USER" || payload.owner === "ASSISTANT") && typeof payload.assistantAudible === "boolean") {
+      this.emit("floor", { owner: payload.owner, assistantAudible: payload.assistantAudible });
+      return;
+    }
+    if (name === "phase" && typeof payload.phase === "string") {
+      const event = {
+        phase: payload.phase,
+        source: payload.source === "floor" ? "floor" : "initial",
+        ...typeof payload.previousPhase === "string" ? { previousPhase: payload.previousPhase } : {}
+      };
+      this.currentPhase = event.phase;
+      this.emit("phase", event);
+      return;
+    }
+    if (name === "quick-reaction" && typeof payload.reaction === "string" && (payload.status === "prepared" || payload.status === "playing" || payload.status === "completed" || payload.status === "cancelled")) {
+      this.emit("quick-reaction", { reaction: payload.reaction, status: payload.status });
+      return;
+    }
+    if (name === "assistant.energy" && Number.isFinite(Number(payload.current)) && Array.isArray(payload.predictions)) {
+      const predictions = [];
+      let valid = true;
+      for (const value of payload.predictions) {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+          valid = false;
+          break;
+        }
+        const prediction = value;
+        const startMs = Number(prediction.startMs);
+        const endMs = Number(prediction.endMs);
+        const energy = Number(prediction.energy);
+        if (!Number.isFinite(startMs) || startMs < 0 || !Number.isFinite(endMs) || endMs <= startMs || !Number.isFinite(energy)) {
+          valid = false;
+          break;
+        }
+        predictions.push({ startMs, endMs, energy: Math.max(0, Math.min(1, energy)) });
+      }
+      if (valid) {
+        this.emit("assistant.energy", {
+          current: Math.max(0, Math.min(1, Number(payload.current))),
+          predictions
+        });
+        return;
+      }
+    }
+    if (name === "error" && typeof payload.code === "string" && typeof payload.message === "string") {
+      this.emit("error", { code: payload.code, message: payload.message });
+      return;
+    }
+    this.emit("unknown", { message: { type: "public.event", name, payload, ...atMs === undefined ? {} : { atMs } } });
+  }
+  async executeTool(call) {
+    this.emit("tool.call", call);
+    const tool = this.tools[call.name];
+    if (!tool) {
+      const message = `No handler is registered for tool ${call.name}`;
+      this.emit("tool.result", { ...call, ok: false, error: message });
+      throw new Error(message);
+    }
+    try {
+      const output = await tool.execute(call.input);
+      this.emit("tool.result", { ...call, ok: true, output });
+      return output;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.emit("tool.result", { ...call, ok: false, error: message });
+      throw error;
+    }
+  }
+}
+
+class LiveVoice {
+  static connect(options) {
+    return LiveVoiceSession.connect(options);
+  }
+}
+
+// src/index.ts
+var src_default = LiveVoice;
+export {
+  LiveVoiceSession,
+  src_default as default
+};