@shogo-ai/voice 1.9.13 → 2.4.1

package/dist/react/conversation.cjs

@@ -0,0 +1,789 @@
+"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 });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/conversation.ts
+var conversation_exports = {};
+__export(conversation_exports, {
+  ShogoVoiceProvider: () => ShogoVoiceProvider,
+  useLiveVoiceConversation: () => useLiveVoiceConversation,
+  useVoiceConversation: () => useVoiceConversation
+});
+module.exports = __toCommonJS(conversation_exports);
+
+// src/react/useVoiceConversation.ts
+var import_react = require("react");
+var import_react2 = require("@elevenlabs/react");
+
+// src/shared/postJson.ts
+function createPostJson({
+  authHeaders,
+  fetchCredentials
+}) {
+  return async function postJson(path, body) {
+    return fetch(path, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...authHeaders() },
+      credentials: fetchCredentials,
+      body: JSON.stringify(body)
+    });
+  };
+}
+
+// src/shared/memory.ts
+function createMemoryAddTool({
+  postJson,
+  memoryAddPath
+}) {
+  return async (params) => {
+    const fact = typeof params.fact === "string" ? params.fact : "";
+    if (!fact.trim()) return "Memory save failed: empty fact.";
+    try {
+      const res = await postJson(memoryAddPath, { fact });
+      if (!res.ok) return "Failed to save memory.";
+      return "Memory saved.";
+    } catch {
+      return "Memory save failed.";
+    }
+  };
+}
+function createMemoryContextInjector({
+  postJson,
+  memoryRetrievePath,
+  conversationRef,
+  enabled,
+  lastInjectedRef
+}) {
+  return async function inject(userText) {
+    if (!enabled) return;
+    try {
+      const res = await postJson(memoryRetrievePath, { query: userText, limit: 4 });
+      if (!res.ok) return;
+      const data = await res.json();
+      const results = data.results ?? [];
+      if (!results.length) return;
+      const lines = results.map((r) => `- ${r.chunk.trim().replace(/\s+/g, " ").slice(0, 200)}`).join("\n");
+      if (lines === lastInjectedRef.current) return;
+      lastInjectedRef.current = lines;
+      const payload = `Relevant memory about this user:
+${lines}`;
+      conversationRef.current?.sendContextualUpdate(payload);
+    } catch {
+    }
+  };
+}
+
+// src/audioTags.ts
+var AUDIO_TAGS = [
+  // Emotions
+  { tag: "happy", group: "emotion", label: "Happy", description: "Warm, upbeat delivery.", example: "[happy] Oh, I\u2019m so glad you stopped by." },
+  { tag: "sad", group: "emotion", label: "Sad", description: "Subdued, heavy-hearted tone.", example: "[sad] I wish things had gone differently." },
+  { tag: "excited", group: "emotion", label: "Excited", description: "Energized, eager delivery.", example: "[excited] Wait until you hear this!" },
+  { tag: "curious", group: "emotion", label: "Curious", description: "Inquisitive, rising inflection.", example: "[curious] Hmm, what did they look like?" },
+  { tag: "sarcastic", group: "emotion", label: "Sarcastic", description: "Dry, ironic tone.", example: "[sarcastic] Oh, fantastic. Another Monday." },
+  { tag: "angry", group: "emotion", label: "Angry", description: "Sharp, irritated edge.", example: "[angry] I told you not to touch that." },
+  { tag: "nervous", group: "emotion", label: "Nervous", description: "Uneasy, faltering delivery.", example: "[nervous] I\u2014 I didn\u2019t think you\u2019d actually come." },
+  { tag: "confident", group: "emotion", label: "Confident", description: "Grounded, assured delivery.", example: "[confident] Trust me. I\u2019ve done this before." },
+  // Delivery
+  { tag: "whispers", group: "delivery", label: "Whispers", description: "Hushed, close-mic delivery.", example: "[whispers] Don\u2019t say it too loud." },
+  { tag: "shouts", group: "delivery", label: "Shouts", description: "Loud, projected delivery.", example: "[shouts] Look out behind you!" },
+  { tag: "softly", group: "delivery", label: "Softly", description: "Gentle, quiet tone.", example: "[softly] It\u2019s okay. I\u2019m here." },
+  { tag: "slowly", group: "delivery", label: "Slowly", description: "Deliberate pacing.", example: "[slowly] Tell me\u2026 exactly\u2026 what happened." },
+  { tag: "quickly", group: "delivery", label: "Quickly", description: "Rapid, urgent pacing.", example: "[quickly] We need to go, right now." },
+  // Reactions (non-verbal sounds)
+  { tag: "laughs", group: "reaction", label: "Laughs", description: "A genuine laugh.", example: "That\u2019s ridiculous [laughs]." },
+  { tag: "chuckles", group: "reaction", label: "Chuckles", description: "A small, warm chuckle.", example: "[chuckles] You always say that." },
+  { tag: "sighs", group: "reaction", label: "Sighs", description: "An audible sigh.", example: "[sighs] Alright, fine. Let\u2019s do it." },
+  { tag: "gasps", group: "reaction", label: "Gasps", description: "A sharp inhale of surprise.", example: "[gasps] You didn\u2019t!" },
+  { tag: "hesitates", group: "reaction", label: "Hesitates", description: "A pause with uncertainty.", example: "[hesitates] I\u2019m not sure I should say." },
+  { tag: "clears throat", group: "reaction", label: "Clears throat", description: "Throat-clearing beat.", example: "[clears throat] As I was saying\u2026" }
+];
+var KNOWN_TAG_SET = new Set(AUDIO_TAGS.map((t) => t.tag.toLowerCase()));
+function stripAudioTags(text) {
+  if (!text) return "";
+  return text.replace(/\[([a-z][a-z ]{0,24})\]/gi, (match, inner) => {
+    const key = inner.trim().toLowerCase();
+    return KNOWN_TAG_SET.has(key) ? "" : match;
+  }).replace(/[ \t]{2,}/g, " ").replace(/\s+([,.!?;:])/g, "$1").trim();
+}
+
+// src/shared/transcript.ts
+function createTranscriptDisconnectHandler({
+  isRestartingRef,
+  weStartedSessionRef,
+  transcriptRef,
+  onTranscript,
+  transcriptIngestPath,
+  postJson
+}) {
+  return function handleTranscriptOnDisconnect() {
+    if (isRestartingRef.current) {
+      return;
+    }
+    if (!weStartedSessionRef.current) {
+      transcriptRef.current = [];
+      return;
+    }
+    weStartedSessionRef.current = false;
+    const transcript = transcriptRef.current.join("\n");
+    transcriptRef.current = [];
+    if (onTranscript) {
+      void onTranscript(transcript);
+      return;
+    }
+    const trimmed = transcript.trim();
+    if (trimmed.length < 20) return;
+    void postJson(transcriptIngestPath, { transcript: trimmed }).catch(() => {
+    });
+  };
+}
+function appendTranscriptLine(msg, { transcriptRef, weStartedSessionRef }) {
+  if (!msg?.message || !msg?.source) return;
+  if (!weStartedSessionRef.current) return;
+  const speaker = msg.source === "user" ? "User" : "Agent";
+  const cleaned = msg.source === "user" ? msg.message : stripAudioTags(msg.message);
+  if (!cleaned) return;
+  transcriptRef.current.push(`${speaker}: ${cleaned}`);
+}
+
+// src/shared/sessionPayload.ts
+function sanitizeDynamicVariables(raw) {
+  if (raw == null) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (v == null) continue;
+    out[k] = typeof v === "string" ? v : String(v);
+  }
+  return out;
+}
+function buildSessionPayload(opts) {
+  const dynamicVariables = {
+    ...sanitizeDynamicVariables(opts.dynamicVariables),
+    character_name: opts.characterName,
+    user_context: opts.userContext
+  };
+  if (typeof opts.conversationId === "string" && opts.conversationId.length > 0) {
+    dynamicVariables.conversation_id = opts.conversationId;
+  }
+  const payload = {
+    signedUrl: opts.signedUrl,
+    dynamicVariables
+  };
+  const agentOverrides = {};
+  if (opts.suppressFirstMessage) {
+    agentOverrides.firstMessage = "";
+  }
+  if (typeof opts.agentPromptOverride === "string" && opts.agentPromptOverride.length > 0) {
+    agentOverrides.prompt = { prompt: opts.agentPromptOverride };
+  }
+  if (Object.keys(agentOverrides).length > 0) {
+    payload.overrides = { agent: agentOverrides };
+  }
+  return payload;
+}
+async function fetchSignedUrl({
+  path,
+  fetchCredentials,
+  authHeaders
+}) {
+  const res = await fetch(path, {
+    credentials: fetchCredentials,
+    headers: authHeaders()
+  });
+  if (!res.ok) throw new Error(`Signed URL request failed: ${res.status}`);
+  return await res.json();
+}
+function withProjectQuery(signedUrlPath, params) {
+  const tail = [];
+  if (typeof params.projectId === "string" && params.projectId.length > 0) {
+    tail.push(`projectId=${encodeURIComponent(params.projectId)}`);
+  }
+  if (typeof params.agentName === "string" && params.agentName.length > 0) {
+    tail.push(`agentName=${encodeURIComponent(params.agentName)}`);
+  }
+  if (tail.length === 0) return signedUrlPath;
+  const sep = signedUrlPath.includes("?") ? "&" : "?";
+  return `${signedUrlPath}${sep}${tail.join("&")}`;
+}
+
+// src/react/mic-access.ts
+var MIC_BLOCKED_MESSAGE = "Microphone access is blocked. Allow it in your system or browser settings (on macOS: System Settings > Privacy & Security > Microphone), then try again.";
+var MIC_NOT_FOUND_MESSAGE = "No microphone was found. Connect one and try again.";
+async function requestMicStream(constraints = { audio: true }) {
+  const desktop = globalThis.shogoDesktop;
+  if (desktop?.isDesktop && desktop.ensureMicAccess) {
+    const access = await desktop.ensureMicAccess().catch(() => "granted");
+    if (access !== "granted") throw new Error(MIC_BLOCKED_MESSAGE);
+  }
+  try {
+    return await navigator.mediaDevices.getUserMedia(constraints);
+  } catch (err) {
+    const name = err?.name;
+    if (name === "NotAllowedError" || name === "SecurityError") throw new Error(MIC_BLOCKED_MESSAGE);
+    if (name === "NotFoundError" || name === "OverconstrainedError") throw new Error(MIC_NOT_FOUND_MESSAGE);
+    throw err;
+  }
+}
+
+// src/react/useVoiceConversation.ts
+function useVoiceConversation(options) {
+  const {
+    characterName,
+    signedUrlPath = "/api/voice/signed-url",
+    memoryAddPath = "/api/memory/add",
+    memoryRetrievePath = "/api/memory/retrieve",
+    transcriptIngestPath = "/api/memory/ingest",
+    autoInjectMemory = true,
+    includeMemoryTool = true,
+    clientTools = {},
+    onTranscript,
+    shogoApiKey,
+    projectId,
+    agentName,
+    fetchCredentials = shogoApiKey ? "omit" : "same-origin",
+    onError,
+    onMessage,
+    conversationId: optionConversationId,
+    dynamicVariables
+  } = options;
+  const authHeaders = (0, import_react.useCallback)(() => {
+    return shogoApiKey ? { authorization: `Bearer ${shogoApiKey}` } : {};
+  }, [shogoApiKey]);
+  const resolvedSignedUrlPath = withProjectQuery(signedUrlPath, { projectId, agentName });
+  const transcriptRef = (0, import_react.useRef)([]);
+  const lastInjectedRef = (0, import_react.useRef)("");
+  const weStartedSessionRef = (0, import_react.useRef)(false);
+  const [convaiConversationId, setConvaiConversationId] = (0, import_react.useState)(null);
+  const isRestartingRef = (0, import_react.useRef)(false);
+  const conversationRef = (0, import_react.useRef)(null);
+  const postJson = (0, import_react.useCallback)(
+    createPostJson({ authHeaders, fetchCredentials }),
+    [fetchCredentials, authHeaders]
+  );
+  const injectMemoryContext = (0, import_react.useCallback)(
+    createMemoryContextInjector({
+      postJson,
+      memoryRetrievePath,
+      conversationRef,
+      enabled: autoInjectMemory,
+      lastInjectedRef
+    }),
+    [autoInjectMemory, memoryRetrievePath, postJson]
+  );
+  const handleTranscriptOnDisconnect = (0, import_react.useCallback)(
+    createTranscriptDisconnectHandler({
+      isRestartingRef,
+      weStartedSessionRef,
+      transcriptRef,
+      onTranscript,
+      transcriptIngestPath,
+      postJson
+    }),
+    [onTranscript, postJson, transcriptIngestPath]
+  );
+  const builtInTools = includeMemoryTool ? { add_memory: createMemoryAddTool({ postJson, memoryAddPath }) } : {};
+  const mergedClientTools = { ...builtInTools, ...clientTools };
+  const conversation = (0, import_react2.useConversation)({
+    clientTools: mergedClientTools,
+    onConnect: (info) => {
+      const id = info?.conversationId;
+      if (typeof id === "string" && id.length > 0) {
+        setConvaiConversationId(id);
+      }
+      if (!isRestartingRef.current) {
+        transcriptRef.current = [];
+        lastInjectedRef.current = "";
+      }
+    },
+    onDisconnect: () => {
+      handleTranscriptOnDisconnect();
+      if (!isRestartingRef.current) {
+        setConvaiConversationId(null);
+      }
+    },
+    onError: (e) => {
+      onError?.(e);
+    },
+    onMessage: (m) => {
+      const msg = m;
+      if (!msg?.message || !msg?.source) return;
+      appendTranscriptLine(msg, { transcriptRef, weStartedSessionRef });
+      onMessage?.({ source: msg.source, message: msg.message });
+      if (autoInjectMemory && msg.source === "user" && msg.message.trim().length >= 3 && weStartedSessionRef.current) {
+        void injectMemoryContext(msg.message);
+      }
+    }
+  });
+  const { status, isSpeaking, isListening, isMuted, setMuted, startSession, endSession } = conversation;
+  conversationRef.current = conversation;
+  (0, import_react.useEffect)(() => {
+    const onHide = () => {
+      if (!weStartedSessionRef.current || transcriptRef.current.length === 0) return;
+      const transcript = transcriptRef.current.join("\n").trim();
+      transcriptRef.current = [];
+      if (transcript.length < 20) return;
+      try {
+        const blob = new Blob([JSON.stringify({ transcript })], { type: "application/json" });
+        navigator.sendBeacon(transcriptIngestPath, blob);
+      } catch {
+      }
+    };
+    window.addEventListener("pagehide", onHide);
+    return () => window.removeEventListener("pagehide", onHide);
+  }, [transcriptIngestPath]);
+  const startInternal = (0, import_react.useCallback)(
+    async (opts) => {
+      if (status === "connected" || status === "connecting") {
+        try {
+          endSession();
+          await new Promise((r) => setTimeout(r, 120));
+        } catch {
+        }
+      }
+      const micStream = await requestMicStream({ audio: true });
+      micStream.getTracks().forEach((track) => track.stop());
+      const data = await fetchSignedUrl({
+        path: resolvedSignedUrlPath,
+        fetchCredentials,
+        authHeaders
+      });
+      const ctx = data.userContext || "No prior memories yet.";
+      weStartedSessionRef.current = true;
+      const sessionPayload = buildSessionPayload({
+        signedUrl: data.signedUrl,
+        characterName,
+        userContext: ctx,
+        agentPromptOverride: data.agentPromptOverride,
+        suppressFirstMessage: opts?.suppressFirstMessage,
+        conversationId: optionConversationId,
+        dynamicVariables
+      });
+      await startSession(sessionPayload);
+    },
+    [
+      status,
+      endSession,
+      resolvedSignedUrlPath,
+      fetchCredentials,
+      dynamicVariables,
+      startSession,
+      characterName,
+      authHeaders,
+      optionConversationId
+    ]
+  );
+  const start = (0, import_react.useCallback)(
+    async (options2) => {
+      await startInternal(options2);
+    },
+    [startInternal]
+  );
+  const end = (0, import_react.useCallback)(() => {
+    endSession();
+  }, [endSession]);
+  const restart = (0, import_react.useCallback)(
+    async (options2) => {
+      const suppress = options2?.suppressFirstMessage ?? true;
+      isRestartingRef.current = true;
+      try {
+        try {
+          endSession();
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 120));
+        await startInternal({ suppressFirstMessage: suppress });
+      } finally {
+        isRestartingRef.current = false;
+      }
+    },
+    [endSession, startInternal]
+  );
+  const sendContextualUpdate = (0, import_react.useCallback)((text) => {
+    conversationRef.current?.sendContextualUpdate(text);
+  }, []);
+  const sendUserMessage = (0, import_react.useCallback)((text) => {
+    const ref = conversationRef.current;
+    if (!ref) return;
+    if (typeof ref.sendUserMessage === "function") {
+      ref.sendUserMessage(text);
+      return;
+    }
+    ref.sendContextualUpdate(text);
+    try {
+      ref.sendUserActivity?.();
+    } catch {
+    }
+  }, []);
+  const sendUserActivity = (0, import_react.useCallback)(() => {
+    conversationRef.current?.sendUserActivity?.();
+  }, []);
+  const getOutputByteFrequencyData = (0, import_react.useCallback)(() => {
+    try {
+      const fn = conversation.getOutputByteFrequencyData;
+      return fn ? fn() : null;
+    } catch {
+      return null;
+    }
+  }, [conversation]);
+  return {
+    start,
+    end,
+    restart,
+    status,
+    isSpeaking,
+    isListening,
+    isMuted,
+    setMuted,
+    getOutputByteFrequencyData,
+    sendContextualUpdate,
+    sendUserMessage,
+    sendUserActivity,
+    conversationId: optionConversationId ?? convaiConversationId,
+    convaiConversationId
+  };
+}
+
+// src/react/useLiveVoiceConversation.ts
+var import_react3 = require("react");
+function parseEvent(data) {
+  try {
+    const text = typeof data === "string" ? data : String(data);
+    const event = JSON.parse(text);
+    return event && typeof event === "object" ? event : null;
+  } catch {
+    return null;
+  }
+}
+function waitForIceGathering(pc) {
+  if (pc.iceGatheringState === "complete") return Promise.resolve();
+  return new Promise((resolve) => {
+    const onStateChange = () => {
+      if (pc.iceGatheringState === "complete") {
+        pc.removeEventListener("icegatheringstatechange", onStateChange);
+        resolve();
+      }
+    };
+    pc.addEventListener("icegatheringstatechange", onStateChange);
+    window.setTimeout(() => {
+      pc.removeEventListener("icegatheringstatechange", onStateChange);
+      resolve();
+    }, 2e3);
+  });
+}
+function splitContext(text) {
+  const chunks = [];
+  for (let offset = 0; offset < text.length; offset += 1800) {
+    chunks.push(text.slice(offset, offset + 1800));
+  }
+  return chunks.length ? chunks : [""];
+}
+var TRANSCRIPT_HISTORY_MAX = 30;
+function useLiveVoiceConversation(options) {
+  const { mintSession } = options;
+  const [status, setStatus] = (0, import_react3.useState)("disconnected");
+  const [isSpeaking, setIsSpeaking] = (0, import_react3.useState)(false);
+  const [isListening, setIsListening] = (0, import_react3.useState)(false);
+  const [isMuted, setIsMuted] = (0, import_react3.useState)(false);
+  const [sessionId, setSessionId] = (0, import_react3.useState)(null);
+  const optionsRef = (0, import_react3.useRef)(options);
+  optionsRef.current = options;
+  const pcRef = (0, import_react3.useRef)(null);
+  const dataChannelRef = (0, import_react3.useRef)(null);
+  const mediaStreamRef = (0, import_react3.useRef)(null);
+  const audioRef = (0, import_react3.useRef)(null);
+  const analyserRef = (0, import_react3.useRef)(null);
+  const frequencyRef = (0, import_react3.useRef)(null);
+  const audioContextRef = (0, import_react3.useRef)(null);
+  const speakingFrameRef = (0, import_react3.useRef)(null);
+  const inputTranscriptRef = (0, import_react3.useRef)("");
+  const outputTranscriptRef = (0, import_react3.useRef)("");
+  const historyRef = (0, import_react3.useRef)([]);
+  const closingRef = (0, import_react3.useRef)(false);
+  const mutedRef = (0, import_react3.useRef)(false);
+  const emit = (0, import_react3.useCallback)((source, message) => {
+    const text = message.trim();
+    if (!text) return;
+    const history = historyRef.current;
+    history.push({ role: source === "user" ? "user" : "assistant", text });
+    if (history.length > TRANSCRIPT_HISTORY_MAX) history.splice(0, history.length - TRANSCRIPT_HISTORY_MAX);
+    optionsRef.current.onMessage?.({ source, message: text });
+  }, []);
+  const flushTranscripts = (0, import_react3.useCallback)(() => {
+    const input = inputTranscriptRef.current.trim();
+    const output = outputTranscriptRef.current.trim();
+    inputTranscriptRef.current = "";
+    outputTranscriptRef.current = "";
+    if (input) emit("user", input);
+    if (output) emit("agent", output);
+  }, [emit]);
+  const sendEvent = (0, import_react3.useCallback)((event) => {
+    const channel = dataChannelRef.current;
+    if (channel?.readyState === "open") channel.send(JSON.stringify(event));
+  }, []);
+  const updateSpeaking = (0, import_react3.useCallback)(() => {
+    const analyser = analyserRef.current;
+    if (analyser) {
+      const data = frequencyRef.current ?? new Uint8Array(analyser.frequencyBinCount);
+      frequencyRef.current = data;
+      analyser.getByteFrequencyData(data);
+      let sum = 0;
+      for (const value of data) sum += value;
+      setIsSpeaking(data.length > 0 && sum / data.length > 8);
+    }
+    if (pcRef.current) speakingFrameRef.current = requestAnimationFrame(updateSpeaking);
+  }, []);
+  const handleEvent = (0, import_react3.useCallback)(async (event) => {
+    const nested = event.type === "response.event" && event.event ? event.event : event;
+    const type = nested.type ?? "";
+    if (type === "session.started" || type === "session.created") {
+      setStatus("connected");
+      setIsListening(!mutedRef.current);
+      const id = typeof nested.session?.id === "string" ? nested.session.id : null;
+      if (id) setSessionId(id);
+    }
+    if (type === "session.closed") {
+      flushTranscripts();
+      setStatus("disconnected");
+      setIsListening(false);
+    }
+    if (type === "error") {
+      optionsRef.current.onError?.(new Error(event.error?.message || "GPT-Live error"));
+    }
+    if (type === "session.input_transcript.delta" || type === "input_audio_transcription.delta") {
+      inputTranscriptRef.current += event.delta ?? "";
+    }
+    if (type === "session.output_transcript.delta" || type === "response.audio_transcript.delta") {
+      outputTranscriptRef.current += event.delta ?? "";
+    }
+    if (type === "session.input_transcript.done" || type === "input_audio_transcription.completed" || type === "session.output_transcript.done" || type === "response.audio_transcript.done" || type === "response.done" || type === "response.completed") {
+      flushTranscripts();
+    }
+    if (type === "session.delegation.created" && nested.delegation?.target !== "responses" && typeof nested.delegation?.id === "string") {
+      const onDelegation = optionsRef.current.onDelegation;
+      if (!onDelegation) return;
+      const delegationId = nested.delegation.id;
+      flushTranscripts();
+      let result;
+      try {
+        result = await onDelegation({ delegationId, transcript: [...historyRef.current] });
+      } catch (error) {
+        optionsRef.current.onError?.(error);
+        result = "That request failed before it could finish. Nothing was confirmed.";
+      }
+      const text = typeof result === "string" ? result.trim() : "";
+      if (!text) return;
+      for (const content of splitContext(text)) {
+        sendEvent({
+          type: "session.commentary.append",
+          delegation_id: delegationId,
+          content
+        });
+      }
+      return;
+    }
+    const item = nested.item;
+    if (type === "response.output_item.done" && item?.type === "function_call") {
+      const tool = optionsRef.current.clientTools?.[item.name ?? ""];
+      if (!tool || !item.call_id) return;
+      let args = {};
+      try {
+        const parsed = JSON.parse(item.arguments || "{}");
+        if (parsed && typeof parsed === "object") args = parsed;
+      } catch {
+      }
+      let output;
+      try {
+        output = String(await tool(args));
+      } catch (error) {
+        output = `Tool failed: ${error instanceof Error ? error.message : String(error)}`;
+      }
+      sendEvent({
+        type: "response.item.create",
+        item: {
+          type: "function_call_output",
+          call_id: item.call_id,
+          output
+        }
+      });
+      sendEvent({ type: "response.create" });
+    }
+  }, [flushTranscripts, sendEvent]);
+  const end = (0, import_react3.useCallback)(() => {
+    closingRef.current = true;
+    flushTranscripts();
+    sendEvent({ type: "session.close" });
+    dataChannelRef.current?.close();
+    pcRef.current?.close();
+    mediaStreamRef.current?.getTracks().forEach((track) => track.stop());
+    audioRef.current?.pause();
+    if (speakingFrameRef.current !== null) cancelAnimationFrame(speakingFrameRef.current);
+    speakingFrameRef.current = null;
+    pcRef.current = null;
+    dataChannelRef.current = null;
+    mediaStreamRef.current = null;
+    analyserRef.current = null;
+    frequencyRef.current = null;
+    audioContextRef.current?.close().catch(() => {
+    });
+    audioContextRef.current = null;
+    setIsSpeaking(false);
+    setIsListening(false);
+    setSessionId(null);
+    setStatus("disconnected");
+  }, [flushTranscripts, sendEvent]);
+  const startInternal = (0, import_react3.useCallback)(async () => {
+    if (status === "connected" || status === "connecting") end();
+    closingRef.current = false;
+    setStatus("connecting");
+    try {
+      const stream = await requestMicStream({ audio: true });
+      mediaStreamRef.current = stream;
+      const pc = new RTCPeerConnection();
+      pcRef.current = pc;
+      stream.getTracks().forEach((track) => pc.addTrack(track, stream));
+      const channel = pc.createDataChannel("oai-events");
+      dataChannelRef.current = channel;
+      channel.onopen = () => {
+        if (!closingRef.current) setIsListening(!mutedRef.current);
+      };
+      channel.onmessage = (message) => {
+        const event = parseEvent(message.data);
+        if (event) void handleEvent(event);
+      };
+      channel.onerror = (event) => optionsRef.current.onError?.(event);
+      pc.ontrack = (event) => {
+        const remoteStream = event.streams[0];
+        if (!remoteStream) return;
+        const audio = new Audio();
+        audio.autoplay = true;
+        audio.srcObject = remoteStream;
+        audioRef.current = audio;
+        void audio.play().catch(() => {
+        });
+        try {
+          const AudioContextImpl = window.AudioContext || window.webkitAudioContext;
+          if (AudioContextImpl) {
+            const context = new AudioContextImpl();
+            const source = context.createMediaStreamSource(remoteStream);
+            const analyser = context.createAnalyser();
+            analyser.fftSize = 256;
+            source.connect(analyser);
+            audioContextRef.current = context;
+            analyserRef.current = analyser;
+            frequencyRef.current = new Uint8Array(analyser.frequencyBinCount);
+            if (speakingFrameRef.current === null) {
+              speakingFrameRef.current = requestAnimationFrame(updateSpeaking);
+            }
+          }
+        } catch {
+        }
+      };
+      pc.onconnectionstatechange = () => {
+        if (["failed", "disconnected", "closed"].includes(pc.connectionState) && !closingRef.current) {
+          optionsRef.current.onError?.(new Error(`GPT-Live connection ${pc.connectionState}`));
+          end();
+        }
+      };
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      await waitForIceGathering(pc);
+      const localSdp = pc.localDescription?.sdp;
+      if (!localSdp) throw new Error("Failed to create a WebRTC offer");
+      const answer = await mintSession(localSdp);
+      await pc.setRemoteDescription({ type: "answer", sdp: answer.sdp });
+      setSessionId(answer.sessionId);
+      setStatus("connected");
+    } catch (error) {
+      end();
+      optionsRef.current.onError?.(error);
+      throw error;
+    }
+  }, [end, handleEvent, mintSession, status, updateSpeaking]);
+  const start = (0, import_react3.useCallback)(async () => {
+    await startInternal();
+  }, [startInternal]);
+  const restart = (0, import_react3.useCallback)(async () => {
+    end();
+    await new Promise((resolve) => window.setTimeout(resolve, 120));
+    await startInternal();
+  }, [end, startInternal]);
+  const setMuted = (0, import_react3.useCallback)((muted) => {
+    mutedRef.current = muted;
+    mediaStreamRef.current?.getAudioTracks().forEach((track) => {
+      track.enabled = !muted;
+    });
+    sendEvent({ type: muted ? "session.input_audio.mute" : "session.input_audio.unmute" });
+    setIsMuted(muted);
+    setIsListening(!muted && status === "connected");
+  }, [sendEvent, status]);
+  const sendContextualUpdate = (0, import_react3.useCallback)((text) => {
+    for (const content of splitContext(text)) {
+      sendEvent({
+        type: "session.thinking.append",
+        delegation_id: null,
+        content
+      });
+    }
+  }, [sendEvent]);
+  const sendUserMessage = (0, import_react3.useCallback)((text) => {
+    sendEvent({
+      type: "session.commentary.append",
+      delegation_id: null,
+      content: text
+    });
+  }, [sendEvent]);
+  const sendUserActivity = (0, import_react3.useCallback)(() => {
+    sendEvent({ type: "session.input_audio.commit" });
+  }, [sendEvent]);
+  const getOutputByteFrequencyData = (0, import_react3.useCallback)(() => {
+    return frequencyRef.current;
+  }, []);
+  const getTranscript = (0, import_react3.useCallback)(() => [...historyRef.current], []);
+  (0, import_react3.useEffect)(() => () => end(), [end]);
+  return {
+    start,
+    end,
+    restart,
+    status,
+    isSpeaking,
+    isListening,
+    isMuted,
+    setMuted,
+    getOutputByteFrequencyData,
+    sendContextualUpdate,
+    sendUserMessage,
+    sendUserActivity,
+    getTranscript,
+    conversationId: sessionId,
+    convaiConversationId: sessionId
+  };
+}
+
+// src/react/ShogoVoiceProvider.tsx
+var import_react4 = require("@elevenlabs/react");
+var import_jsx_runtime = require("react/jsx-runtime");
+function ShogoVoiceProvider(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.ConversationProvider, { children: props.children });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ShogoVoiceProvider,
+  useLiveVoiceConversation,
+  useVoiceConversation
+});
+//# sourceMappingURL=conversation.cjs.map