@jchaffin/voicekit 0.2.0

package/dist/adapters/elevenlabs.mjs

@@ -0,0 +1,250 @@
+import {
+  EventEmitter
+} from "../chunk-22WLZIXO.mjs";
+
+// src/adapters/elevenlabs.ts
+var ELEVENLABS_WS_BASE = "wss://api.elevenlabs.io/v1/convai/conversation";
+var ElevenLabsSession = class extends EventEmitter {
+  constructor(agent, agentId, options) {
+    super();
+    this.ws = null;
+    this.mediaStream = null;
+    this.audioContext = null;
+    this.scriptProcessor = null;
+    this.playbackCtx = null;
+    this.agent = agent;
+    this.agentId = agentId;
+    this.options = options;
+  }
+  async connect(config) {
+    const wsUrl = config.authToken?.startsWith("wss://") ? config.authToken : `${ELEVENLABS_WS_BASE}?agent_id=${this.agentId}`;
+    this.ws = new WebSocket(wsUrl);
+    await new Promise((resolve, reject) => {
+      const ws = this.ws;
+      ws.onopen = () => resolve();
+      ws.onerror = () => reject(new Error("ElevenLabs WebSocket connection failed"));
+    });
+    this.ws.onmessage = (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        this.handleMessage(msg, config.audioElement);
+      } catch {
+        this.emit("raw_event", event.data);
+      }
+    };
+    this.ws.onclose = () => {
+      this.emit("status_change", "DISCONNECTED");
+    };
+    this.ws.onerror = () => {
+      this.emit("error", new Error("ElevenLabs WebSocket error"));
+    };
+    if (this.agent.instructions) {
+      this.ws.send(JSON.stringify({
+        type: "contextual_update",
+        text: this.agent.instructions
+      }));
+    }
+    this.mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    this.audioContext = new AudioContext({ sampleRate: 16e3 });
+    const source = this.audioContext.createMediaStreamSource(this.mediaStream);
+    this.scriptProcessor = this.audioContext.createScriptProcessor(4096, 1, 1);
+    this.scriptProcessor.onaudioprocess = (e) => {
+      if (this.ws?.readyState !== WebSocket.OPEN) return;
+      const input = e.inputBuffer.getChannelData(0);
+      const pcm16 = new Int16Array(input.length);
+      for (let i = 0; i < input.length; i++) {
+        const s = Math.max(-1, Math.min(1, input[i]));
+        pcm16[i] = s < 0 ? s * 32768 : s * 32767;
+      }
+      const bytes = new Uint8Array(pcm16.buffer);
+      let binary = "";
+      for (let j = 0; j < bytes.length; j++) binary += String.fromCharCode(bytes[j]);
+      const base64 = btoa(binary);
+      this.ws.send(JSON.stringify({ user_audio_chunk: base64 }));
+    };
+    source.connect(this.scriptProcessor);
+    this.scriptProcessor.connect(this.audioContext.destination);
+    this.emit("status_change", "CONNECTED");
+  }
+  async disconnect() {
+    this.scriptProcessor?.disconnect();
+    this.audioContext?.close();
+    this.mediaStream?.getTracks().forEach((t) => t.stop());
+    this.playbackCtx?.close();
+    this.scriptProcessor = null;
+    this.audioContext = null;
+    this.mediaStream = null;
+    this.playbackCtx = null;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.removeAllListeners();
+  }
+  sendMessage(text) {
+    this.ws?.send(JSON.stringify({ type: "user_message", text }));
+  }
+  interrupt() {
+    this.ws?.send(JSON.stringify({ type: "interrupt" }));
+  }
+  mute(muted) {
+    this.mediaStream?.getAudioTracks().forEach((t) => {
+      t.enabled = !muted;
+    });
+  }
+  sendRawEvent(event) {
+    this.ws?.send(JSON.stringify(event));
+  }
+  handleMessage(msg, audioElement) {
+    switch (msg.type) {
+      case "user_transcript":
+        this.emit("user_transcript", {
+          itemId: msg.id || "",
+          text: msg.user_transcript_event?.user_transcript || msg.text || "",
+          isFinal: msg.user_transcript_event?.is_final ?? true
+        });
+        break;
+      case "agent_response":
+        this.emit("assistant_transcript", {
+          itemId: msg.id || "",
+          delta: msg.agent_response_event?.agent_response || msg.delta || "",
+          isFinal: false
+        });
+        break;
+      case "agent_response_correction":
+        this.emit("assistant_transcript", {
+          itemId: msg.id || "",
+          text: msg.agent_response_correction_event?.corrected_text || "",
+          isFinal: true
+        });
+        break;
+      case "audio": {
+        const audioData = msg.audio_event?.audio_base_64 || msg.audio;
+        if (audioData) {
+          this.emit("audio_delta", msg.id || "", audioData);
+          this.playAudioChunk(audioData, audioElement);
+        }
+        break;
+      }
+      case "client_tool_call":
+        this.emit("tool_call_start", msg.client_tool_call?.tool_name || "", msg.client_tool_call?.parameters);
+        this.executeToolCall(msg);
+        break;
+      case "vad":
+        if (msg.vad_event?.type === "SPEECH_START") {
+          this.emit("user_speech_started");
+        }
+        break;
+      case "error":
+        this.emit("error", new Error(msg.message || msg.error || "ElevenLabs error"));
+        break;
+      default:
+        this.emit("raw_event", msg);
+        break;
+    }
+  }
+  async executeToolCall(msg) {
+    const toolCall = msg.client_tool_call;
+    if (!toolCall) return;
+    const toolDef = this.agent.tools?.find((t) => t.name === toolCall.tool_name);
+    if (!toolDef) {
+      this.ws?.send(JSON.stringify({
+        type: "client_tool_result",
+        tool_call_id: toolCall.tool_call_id,
+        result: JSON.stringify({ error: `Tool ${toolCall.tool_name} not found` })
+      }));
+      return;
+    }
+    try {
+      const result = await toolDef.execute(toolCall.parameters || {});
+      this.emit("tool_call_end", toolCall.tool_name, toolCall.parameters, result);
+      this.ws?.send(JSON.stringify({
+        type: "client_tool_result",
+        tool_call_id: toolCall.tool_call_id,
+        result: JSON.stringify(result)
+      }));
+    } catch (err) {
+      const errorResult = { error: String(err) };
+      this.emit("tool_call_end", toolCall.tool_name, toolCall.parameters, errorResult);
+      this.ws?.send(JSON.stringify({
+        type: "client_tool_result",
+        tool_call_id: toolCall.tool_call_id,
+        result: JSON.stringify(errorResult)
+      }));
+    }
+  }
+  playAudioChunk(base64, audioElement) {
+    if (!audioElement) return;
+    try {
+      if (!this.playbackCtx) {
+        this.playbackCtx = new AudioContext({ sampleRate: 22050 });
+      }
+      const binary = atob(base64);
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+      const samples = new Float32Array(bytes.length / 2);
+      const view = new DataView(bytes.buffer);
+      for (let i = 0; i < samples.length; i++) {
+        samples[i] = view.getInt16(i * 2, true) / 32768;
+      }
+      const buffer = this.playbackCtx.createBuffer(1, samples.length, 22050);
+      buffer.copyToChannel(samples, 0);
+      const src = this.playbackCtx.createBufferSource();
+      src.buffer = buffer;
+      src.connect(this.playbackCtx.destination);
+      src.start();
+    } catch {
+    }
+  }
+};
+function elevenlabs(options) {
+  return {
+    name: "elevenlabs",
+    createSession(agent, sessionOpts) {
+      return new ElevenLabsSession(agent, options.agentId, { ...options, ...sessionOpts });
+    }
+  };
+}
+function elevenlabsServer(config = {}) {
+  const getSessionToken = async (overrides = {}) => {
+    const merged = { ...config, ...overrides };
+    const apiKey = merged.apiKey || process.env.ELEVENLABS_API_KEY;
+    const agentId = merged.agentId || process.env.ELEVENLABS_AGENT_ID;
+    if (!apiKey) return { error: "ElevenLabs API key not configured" };
+    if (!agentId) return { error: "ElevenLabs agent ID not configured" };
+    try {
+      const res = await fetch(
+        `https://api.elevenlabs.io/v1/convai/conversation/get_signed_url?agent_id=${agentId}`,
+        {
+          method: "GET",
+          headers: { "xi-api-key": apiKey }
+        }
+      );
+      if (!res.ok) {
+        return { error: `ElevenLabs API error: ${res.status}` };
+      }
+      const data = await res.json();
+      return { token: data.signed_url || "" };
+    } catch (err) {
+      return { error: String(err) };
+    }
+  };
+  return {
+    getSessionToken,
+    createSessionHandler(overrides) {
+      return async (_request) => {
+        const result = await getSessionToken(overrides);
+        if (result.error) {
+          return Response.json({ error: result.error }, { status: 500 });
+        }
+        return Response.json({ ephemeralKey: result.token });
+      };
+    }
+  };
+}
+var elevenlabs_default = elevenlabs;
+export {
+  elevenlabs_default as default,
+  elevenlabs,
+  elevenlabsServer
+};

package/dist/adapters/livekit.d.mts

@@ -0,0 +1,44 @@
+import { i as SessionOptions, g as ServerSessionConfig, e as VoiceAdapter, S as ServerAdapter } from '../types-DY31oVB1.mjs';
+
+/**
+ * LiveKit adapter for VoiceKit.
+ *
+ * Peer dependency: livekit-client (>= 2.0.0)
+ *
+ * Usage:
+ * ```ts
+ * import { livekit } from '@jchaffin/voicekit/livekit';
+ *
+ * <VoiceProvider adapter={livekit({ serverUrl: 'wss://my-livekit.example.com' })} agent={agent}>
+ * ```
+ *
+ * Server-side: generate an access token containing room name + participant identity
+ * and return it from your session endpoint.
+ */
+
+interface LiveKitAdapterOptions extends SessionOptions {
+    /** LiveKit server WebSocket URL (e.g. wss://my-app.livekit.cloud) */
+    serverUrl: string;
+}
+/**
+ * Create a LiveKit adapter.
+ *
+ * ```ts
+ * import { livekit } from '@jchaffin/voicekit/livekit';
+ * <VoiceProvider adapter={livekit({ serverUrl: 'wss://...' })} agent={agent} />
+ * ```
+ */
+declare function livekit(options: LiveKitAdapterOptions): VoiceAdapter;
+interface LiveKitServerConfig extends ServerSessionConfig {
+    apiKey?: string;
+    apiSecret?: string;
+    /** Room name to grant access to */
+    roomName?: string;
+    /** Participant identity */
+    identity?: string;
+    /** Token TTL in seconds (default 600) */
+    ttl?: number;
+}
+declare function livekitServer(config?: LiveKitServerConfig): ServerAdapter;
+
+export { type LiveKitAdapterOptions, type LiveKitServerConfig, livekit as default, livekit, livekitServer };

package/dist/adapters/livekit.d.ts

@@ -0,0 +1,44 @@
+import { i as SessionOptions, g as ServerSessionConfig, e as VoiceAdapter, S as ServerAdapter } from '../types-DY31oVB1.js';
+
+/**
+ * LiveKit adapter for VoiceKit.
+ *
+ * Peer dependency: livekit-client (>= 2.0.0)
+ *
+ * Usage:
+ * ```ts
+ * import { livekit } from '@jchaffin/voicekit/livekit';
+ *
+ * <VoiceProvider adapter={livekit({ serverUrl: 'wss://my-livekit.example.com' })} agent={agent}>
+ * ```
+ *
+ * Server-side: generate an access token containing room name + participant identity
+ * and return it from your session endpoint.
+ */
+
+interface LiveKitAdapterOptions extends SessionOptions {
+    /** LiveKit server WebSocket URL (e.g. wss://my-app.livekit.cloud) */
+    serverUrl: string;
+}
+/**
+ * Create a LiveKit adapter.
+ *
+ * ```ts
+ * import { livekit } from '@jchaffin/voicekit/livekit';
+ * <VoiceProvider adapter={livekit({ serverUrl: 'wss://...' })} agent={agent} />
+ * ```
+ */
+declare function livekit(options: LiveKitAdapterOptions): VoiceAdapter;
+interface LiveKitServerConfig extends ServerSessionConfig {
+    apiKey?: string;
+    apiSecret?: string;
+    /** Room name to grant access to */
+    roomName?: string;
+    /** Participant identity */
+    identity?: string;
+    /** Token TTL in seconds (default 600) */
+    ttl?: number;
+}
+declare function livekitServer(config?: LiveKitServerConfig): ServerAdapter;
+
+export { type LiveKitAdapterOptions, type LiveKitServerConfig, livekit as default, livekit, livekitServer };

package/dist/adapters/livekit.js

@@ -0,0 +1,225 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  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") {
+    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 });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/livekit.ts
+var livekit_exports = {};
+__export(livekit_exports, {
+  default: () => livekit_default,
+  livekit: () => livekit,
+  livekitServer: () => livekitServer
+});
+module.exports = __toCommonJS(livekit_exports);
+
+// src/core/EventEmitter.ts
+var EventEmitter = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+  }
+  emit(event, ...args) {
+    this.handlers.get(event)?.forEach((fn) => {
+      try {
+        fn(...args);
+      } catch (e) {
+        console.error(`EventEmitter error in "${event}":`, e);
+      }
+    });
+  }
+  removeAllListeners() {
+    this.handlers.clear();
+  }
+};
+
+// src/adapters/livekit.ts
+var LiveKitSession = class extends EventEmitter {
+  constructor(agent, serverUrl, options) {
+    super();
+    this.room = null;
+    this.agent = agent;
+    this.serverUrl = serverUrl;
+    this.options = options;
+  }
+  async connect(config) {
+    const { Room, RoomEvent, Track } = await import("livekit-client");
+    this.room = new Room();
+    this.room.on(RoomEvent.TrackSubscribed, (track, _pub, participant) => {
+      if (track.kind === Track.Kind.Audio) {
+        const el = config.audioElement || document.createElement("audio");
+        track.attach(el);
+        if (!config.audioElement) {
+          el.autoplay = true;
+          el.style.display = "none";
+          document.body.appendChild(el);
+        }
+      }
+    });
+    this.room.on(RoomEvent.DataReceived, (payload, participant, kind) => {
+      try {
+        const msg = JSON.parse(new TextDecoder().decode(payload));
+        this.handleDataMessage(msg, participant);
+      } catch {
+        this.emit("raw_event", { payload, participant, kind });
+      }
+    });
+    this.room.on(RoomEvent.Disconnected, () => {
+      this.emit("status_change", "DISCONNECTED");
+    });
+    this.room.on(RoomEvent.Reconnecting, () => {
+      this.emit("status_change", "CONNECTING");
+    });
+    this.room.on(RoomEvent.Reconnected, () => {
+      this.emit("status_change", "CONNECTED");
+    });
+    await this.room.connect(this.serverUrl, config.authToken);
+    await this.room.localParticipant.setMicrophoneEnabled(true);
+    this.emit("status_change", "CONNECTED");
+  }
+  async disconnect() {
+    if (this.room) {
+      await this.room.disconnect();
+      this.room = null;
+    }
+    this.removeAllListeners();
+  }
+  sendMessage(text) {
+    if (!this.room) throw new Error("Not connected");
+    const data = new TextEncoder().encode(JSON.stringify({ type: "user_message", text }));
+    this.room.localParticipant.publishData(data, { reliable: true });
+  }
+  interrupt() {
+    if (!this.room) return;
+    const data = new TextEncoder().encode(JSON.stringify({ type: "interrupt" }));
+    this.room.localParticipant.publishData(data, { reliable: true });
+  }
+  mute(muted) {
+    this.room?.localParticipant?.setMicrophoneEnabled(!muted);
+  }
+  sendRawEvent(event) {
+    if (!this.room) return;
+    const data = new TextEncoder().encode(JSON.stringify(event));
+    this.room.localParticipant.publishData(data, { reliable: true });
+  }
+  handleDataMessage(msg, _participant) {
+    switch (msg.type) {
+      case "user_transcript":
+        this.emit("user_transcript", {
+          itemId: msg.itemId || msg.id || "",
+          delta: msg.delta,
+          text: msg.text,
+          isFinal: msg.isFinal ?? !!msg.text
+        });
+        break;
+      case "assistant_transcript":
+        this.emit("assistant_transcript", {
+          itemId: msg.itemId || msg.id || "",
+          delta: msg.delta,
+          text: msg.text,
+          isFinal: msg.isFinal ?? !!msg.text
+        });
+        break;
+      case "tool_call_start":
+        this.emit("tool_call_start", msg.name, msg.input);
+        break;
+      case "tool_call_end":
+        this.emit("tool_call_end", msg.name, msg.input, msg.output);
+        break;
+      case "agent_handoff":
+        this.emit("agent_handoff", msg.from || "", msg.to || "");
+        break;
+      case "error":
+        this.emit("error", new Error(msg.message || "LiveKit error"));
+        break;
+      case "speech_started":
+        this.emit("user_speech_started");
+        break;
+      default:
+        this.emit("raw_event", msg);
+        break;
+    }
+  }
+};
+function livekit(options) {
+  return {
+    name: "livekit",
+    createSession(agent, sessionOpts) {
+      return new LiveKitSession(agent, options.serverUrl, { ...options, ...sessionOpts });
+    }
+  };
+}
+function livekitServer(config = {}) {
+  const getSessionToken = async (overrides = {}) => {
+    const merged = { ...config, ...overrides };
+    const apiKey = merged.apiKey || process.env.LIVEKIT_API_KEY;
+    const apiSecret = merged.apiSecret || process.env.LIVEKIT_API_SECRET;
+    if (!apiKey || !apiSecret) {
+      return { error: "LiveKit API key and secret are required" };
+    }
+    try {
+      const { AccessToken } = await import("livekit-server-sdk");
+      const roomName = merged.roomName || `room-${Date.now()}`;
+      const identity = merged.identity || `user-${Date.now()}`;
+      const at = new AccessToken(apiKey, apiSecret, {
+        identity,
+        ttl: (merged.ttl || 600).toString() + "s"
+      });
+      at.addGrant({ roomJoin: true, room: roomName });
+      return { token: await at.toJwt() };
+    } catch (err) {
+      return { error: String(err) };
+    }
+  };
+  return {
+    getSessionToken,
+    createSessionHandler(overrides) {
+      return async (_request) => {
+        const result = await getSessionToken(overrides);
+        if (result.error) {
+          return Response.json({ error: result.error }, { status: 500 });
+        }
+        return Response.json({ ephemeralKey: result.token });
+      };
+    }
+  };
+}
+var livekit_default = livekit;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  livekit,
+  livekitServer
+});