@jchaffin/voicekit 0.2.0

package/dist/adapters/openai.mjs

@@ -0,0 +1,294 @@
+import {
+  emitToolResult
+} from "../chunk-T3II3DRG.mjs";
+import {
+  EventEmitter
+} from "../chunk-22WLZIXO.mjs";
+
+// src/adapters/openai.ts
+import {
+  RealtimeSession,
+  RealtimeAgent,
+  OpenAIRealtimeWebRTC,
+  tool as sdkTool
+} from "@openai/agents/realtime";
+function convertTool(def) {
+  return sdkTool({
+    name: def.name,
+    description: def.description,
+    parameters: {
+      type: "object",
+      properties: def.parameters.properties,
+      required: def.parameters.required || [],
+      additionalProperties: false
+    },
+    execute: async (input) => {
+      try {
+        const result = await def.execute(input);
+        emitToolResult(def.name, input, result);
+        return result;
+      } catch (error) {
+        const errorResult = { success: false, error: String(error) };
+        emitToolResult(def.name, input, errorResult);
+        return errorResult;
+      }
+    }
+  });
+}
+var OpenAISession = class extends EventEmitter {
+  constructor(agent, options) {
+    super();
+    this.session = null;
+    this.responseInFlight = false;
+    this.agent = agent;
+    this.options = options;
+  }
+  async connect(config) {
+    const audioElement = config.audioElement;
+    this.session = new RealtimeSession(this.agent, {
+      transport: new OpenAIRealtimeWebRTC({
+        audioElement,
+        ...this.options.codec === "g711" && {
+          changePeerConnection: async (pc) => {
+            pc.getTransceivers().forEach((transceiver) => {
+              if (transceiver.sender.track?.kind === "audio") {
+                transceiver.setCodecPreferences([
+                  { mimeType: "audio/PCMU", clockRate: 8e3 },
+                  { mimeType: "audio/PCMA", clockRate: 8e3 }
+                ]);
+              }
+            });
+            return pc;
+          }
+        }
+      }),
+      model: this.options.model || "gpt-realtime",
+      config: {
+        inputAudioFormat: this.options.codec === "g711" ? "g711_ulaw" : "pcm16",
+        outputAudioFormat: this.options.codec === "g711" ? "g711_ulaw" : "pcm16",
+        inputAudioTranscription: {
+          model: this.options.transcriptionModel || "gpt-4o-transcribe",
+          language: this.options.language || "en"
+        }
+      },
+      outputGuardrails: config.outputGuardrails ?? [],
+      context: config.context ?? {}
+    });
+    this.wireEvents(this.session);
+    await this.session.connect({ apiKey: config.authToken });
+    this.emit("status_change", "CONNECTED");
+  }
+  async disconnect() {
+    if (this.session) {
+      try {
+        await this.session.close();
+      } catch {
+      }
+      this.session = null;
+    }
+    this.removeAllListeners();
+    this.emit("status_change", "DISCONNECTED");
+  }
+  async sendMessage(text) {
+    if (!this.session) throw new Error("Session not connected");
+    if (this.responseInFlight) {
+      this.session.interrupt();
+      await new Promise((resolve) => {
+        const onDone = (event) => {
+          if (event.type === "response.done" || event.type === "response.cancelled") {
+            this.off("raw_event", onDone);
+            resolve();
+          }
+        };
+        this.on("raw_event", onDone);
+        setTimeout(resolve, 1500);
+      });
+    }
+    this.session.sendMessage(text);
+  }
+  interrupt() {
+    this.session?.interrupt();
+  }
+  mute(muted) {
+    this.session?.mute(muted);
+  }
+  sendRawEvent(event) {
+    this.session?.transport.sendEvent(event);
+  }
+  // Map OpenAI SDK events -> normalized SessionEvents
+  wireEvents(session) {
+    session.on("transport_event", (event) => {
+      const type = event.type;
+      switch (type) {
+        case "input_audio_buffer.speech_started":
+          this.emit("user_speech_started");
+          break;
+        case "conversation.item.input_audio_transcription.delta":
+          this.emit("user_transcript", {
+            itemId: event.item_id,
+            delta: event.delta || "",
+            isFinal: false
+          });
+          break;
+        case "conversation.item.input_audio_transcription.completed":
+          this.emit("user_transcript", {
+            itemId: event.item_id,
+            text: event.transcript || "",
+            isFinal: true
+          });
+          break;
+        case "response.audio_transcript.delta":
+        case "response.output_audio_transcript.delta":
+          this.emit("assistant_transcript", {
+            itemId: event.item_id,
+            delta: event.delta || "",
+            isFinal: false
+          });
+          break;
+        case "response.audio_transcript.done":
+        case "response.output_audio_transcript.done":
+          this.emit("assistant_transcript", {
+            itemId: event.item_id,
+            text: event.transcript || "",
+            isFinal: true
+          });
+          break;
+        case "response.audio.delta":
+        case "response.output_audio.delta":
+          this.emit("audio_delta", event.item_id, event.delta);
+          break;
+        case "response.created":
+          this.responseInFlight = true;
+          this.emit("raw_event", event);
+          break;
+        case "response.done":
+          this.responseInFlight = false;
+          this.emit("raw_event", event);
+          break;
+        case "conversation.item.truncated":
+          this.emit("raw_event", event);
+          break;
+        default:
+          this.emit("raw_event", event);
+          break;
+      }
+    });
+    session.on("agent_tool_start", ((...args) => {
+      const functionCall = args[2];
+      if (functionCall) {
+        this.emit("tool_call_start", functionCall.name, functionCall.arguments);
+      }
+    }));
+    session.on("agent_tool_end", ((...args) => {
+      const functionCall = args[2];
+      const result = args[3];
+      if (functionCall) {
+        this.emit("tool_call_end", functionCall.name, functionCall.arguments, result);
+      }
+    }));
+    session.on("agent_handoff", ((...args) => {
+      const item = args[0];
+      const context = item?.context;
+      const history = context?.history;
+      if (history?.length) {
+        const lastMessage = history[history.length - 1];
+        const agentName = (lastMessage.name || "").split("transfer_to_").pop() || "";
+        this.emit("agent_handoff", "", agentName);
+      }
+    }));
+    session.on("guardrail_tripped", ((...args) => {
+      this.emit("guardrail_tripped", args);
+    }));
+    session.on("history_updated", ((...args) => {
+      this.emit("raw_event", { type: "history_updated", items: args[0] });
+    }));
+    session.on("history_added", ((...args) => {
+      this.emit("raw_event", { type: "history_added", item: args[0] });
+    }));
+    session.on("error", (error) => {
+      if (error instanceof Error) {
+        this.emit("error", error);
+      } else if (error && typeof error === "object") {
+        const obj = error;
+        const msg = obj.message || obj.error?.message || JSON.stringify(error);
+        this.emit("error", new Error(msg));
+      } else {
+        this.emit("error", new Error(String(error)));
+      }
+    });
+  }
+};
+function openai(options = {}) {
+  return {
+    name: "openai",
+    createSession(agentConfig, sessionOpts) {
+      const merged = { ...options, ...sessionOpts };
+      const agent = buildRealtimeAgent(agentConfig);
+      return new OpenAISession(agent, merged);
+    }
+  };
+}
+function buildRealtimeAgent(config) {
+  const tools = (config.tools || []).map(convertTool);
+  return new RealtimeAgent({
+    name: config.name,
+    instructions: config.instructions,
+    tools
+  });
+}
+function openaiServer(config = {}) {
+  const getSessionToken = async (overrides = {}) => {
+    const merged = { ...config, ...overrides };
+    const apiKey = merged.apiKey || process.env.OPENAI_API_KEY;
+    if (!apiKey) return { error: "OpenAI API key not configured" };
+    try {
+      const response = await fetch("https://api.openai.com/v1/realtime/client_secrets", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          expires_after: {
+            anchor: "created_at",
+            seconds: merged.expiresIn || 600
+          },
+          session: {
+            type: "realtime",
+            model: merged.model || "gpt-realtime",
+            ...merged.voice && { audio: { output: { voice: merged.voice } } },
+            ...merged.instructions && { instructions: merged.instructions }
+          }
+        })
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        console.error("OpenAI client_secrets error:", text);
+        return { error: `OpenAI API error: ${response.status}` };
+      }
+      const data = await response.json();
+      if (!data.value) return { error: "Invalid response from OpenAI" };
+      return { token: data.value };
+    } 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 openai_default = openai;
+export {
+  openai_default as default,
+  openai,
+  openaiServer
+};

package/dist/chunk-22WLZIXO.mjs

@@ -0,0 +1,33 @@
+// 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();
+  }
+};
+
+export {
+  EventEmitter
+};

package/dist/chunk-T3II3DRG.mjs

@@ -0,0 +1,178 @@
+// src/tools.ts
+function defineTool(config) {
+  return {
+    name: config.name,
+    description: config.description,
+    parameters: {
+      type: "object",
+      properties: config.parameters,
+      required: config.required
+    },
+    execute: config.execute
+  };
+}
+function createNavigationTool(sections) {
+  return defineTool({
+    name: "navigate",
+    description: `Navigate to a section. Available: ${sections.join(", ")}`,
+    parameters: {
+      section: {
+        type: "string",
+        enum: sections,
+        description: "Section to scroll to"
+      }
+    },
+    required: ["section"],
+    execute: ({ section }) => {
+      if (typeof window !== "undefined") {
+        const el = document.getElementById(section);
+        if (el) {
+          el.scrollIntoView({ behavior: "smooth" });
+          return { success: true, section };
+        }
+      }
+      return { success: false, error: "Section not found" };
+    }
+  });
+}
+function createEventTool(config) {
+  return defineTool({
+    name: config.name,
+    description: config.description,
+    parameters: config.parameters,
+    required: config.required,
+    execute: (params) => {
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(new CustomEvent(config.eventType, {
+          detail: { toolName: config.name, params }
+        }));
+      }
+      return { success: true, ...params };
+    }
+  });
+}
+function createAPITool(config) {
+  return defineTool({
+    name: config.name,
+    description: config.description,
+    parameters: config.parameters,
+    required: config.required,
+    execute: async (params) => {
+      try {
+        const url = typeof config.endpoint === "function" ? config.endpoint(params) : config.endpoint;
+        const isPost = config.method === "POST";
+        const response = await fetch(url, {
+          method: config.method || "GET",
+          headers: {
+            ...isPost ? { "Content-Type": "application/json" } : {},
+            ...config.headers
+          },
+          body: isPost ? JSON.stringify(params) : void 0
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        return config.transform ? config.transform(data) : data;
+      } catch (error) {
+        return { success: false, error: String(error) };
+      }
+    }
+  });
+}
+function createSearchTool(config) {
+  const paramName = config.searchParam || "query";
+  return defineTool({
+    name: config.name,
+    description: config.description,
+    parameters: {
+      [paramName]: {
+        type: "string",
+        description: `The ${paramName} to search for`
+      }
+    },
+    required: [paramName],
+    execute: async (params) => {
+      const query = params[paramName];
+      try {
+        let result;
+        if (config.fetch) {
+          result = await config.fetch(query);
+        } else if (config.endpoint) {
+          const res = await fetch(config.endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ query })
+          });
+          if (!res.ok) throw new Error(`HTTP ${res.status}`);
+          result = await res.json();
+        } else {
+          throw new Error("Must provide either endpoint or fetch function");
+        }
+        const finalResult = config.transform ? config.transform(result) : result;
+        if (config.eventType && typeof window !== "undefined") {
+          window.dispatchEvent(new CustomEvent(config.eventType, {
+            detail: { query, result: finalResult }
+          }));
+        }
+        return finalResult;
+      } catch (error) {
+        return { success: false, error: String(error) };
+      }
+    }
+  });
+}
+function createRAGTool(config) {
+  return defineTool({
+    name: config.name,
+    description: config.description,
+    parameters: {
+      query: { type: "string", description: "Search query" },
+      ...config.repo ? {} : { repo: { type: "string", description: "Optional: filter by repository name" } }
+    },
+    required: ["query"],
+    execute: async (params) => {
+      const { query, repo } = params;
+      try {
+        const res = await fetch(config.endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            query,
+            repo: config.repo || repo,
+            limit: config.limit || 10
+          })
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const result = await res.json();
+        if (config.eventType && typeof window !== "undefined") {
+          window.dispatchEvent(new CustomEvent(config.eventType, {
+            detail: { query, result }
+          }));
+        }
+        return result;
+      } catch (error) {
+        return { success: false, error: String(error) };
+      }
+    }
+  });
+}
+var TOOL_RESULT_EVENT = "voicekit:tool-result";
+function emitToolResult(name, input, result) {
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent(TOOL_RESULT_EVENT, {
+      detail: { name, input, result, timestamp: Date.now() }
+    }));
+  }
+}
+
+export {
+  defineTool,
+  createNavigationTool,
+  createEventTool,
+  createAPITool,
+  createSearchTool,
+  createRAGTool,
+  TOOL_RESULT_EVENT,
+  emitToolResult
+};

package/dist/chunk-UZ2VGPZD.mjs

@@ -0,0 +1,33 @@
+// 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 "${String(event)}":`, e);
+      }
+    });
+  }
+  removeAllListeners() {
+    this.handlers.clear();
+  }
+};
+
+export {
+  EventEmitter
+};

package/dist/chunk-Y6FXYEAI.mjs

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};