@mastra/voice-xai-realtime 0.0.0

package/dist/index.js

@@ -0,0 +1,849 @@
+import { PassThrough, Readable } from 'stream';
+import { MastraVoice } from '@mastra/core/voice';
+import { WebSocket } from 'ws';
+import { isZodType, standardSchemaToJSONSchema, toStandardSchema } from '@mastra/schema-compat';
+import { zodToJsonSchema } from '@mastra/schema-compat/zod-to-json';
+
+// src/index.ts
+var isReadableStream = (obj) => {
+  return !!obj && obj instanceof Readable && typeof obj.read === "function" && typeof obj.pipe === "function" && obj.readable === true;
+};
+var int16ArrayToBase64 = (int16Array) => {
+  const buffer = new ArrayBuffer(int16Array.length * 2);
+  const view = new DataView(buffer);
+  for (let i = 0; i < int16Array.length; i++) {
+    view.setInt16(i * 2, int16Array[i], true);
+  }
+  return Buffer.from(buffer).toString("base64");
+};
+var readableToBuffer = async (stream) => {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+};
+var readableToBase64 = async (stream) => {
+  return (await readableToBuffer(stream)).toString("base64");
+};
+var transformTools = (tools, logger = console) => {
+  const xaiTools = [];
+  for (const [name, tool] of Object.entries(tools || {})) {
+    let parameters;
+    try {
+      if ("inputSchema" in tool && tool.inputSchema) {
+        parameters = schemaToJsonSchema(tool.inputSchema);
+      } else if ("parameters" in tool && tool.parameters) {
+        parameters = schemaToJsonSchema(tool.parameters);
+      } else {
+        continue;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to transform xAI realtime tool "${name}" schema: ${message}`);
+    }
+    if (!tool.execute) {
+      logger.warn(`Skipping xAI realtime tool "${name}" because it has no execute function.`);
+      continue;
+    }
+    xaiTools.push({
+      xaiTool: {
+        type: "function",
+        name,
+        description: tool.description || `Tool: ${name}`,
+        parameters
+      },
+      execute: async (args, options) => {
+        if (!tool.execute) {
+          throw new Error(`Tool ${name} has no execute function`);
+        }
+        const execute = tool.execute;
+        const callOptions = {
+          toolCallId: options.toolCallId,
+          messages: [],
+          requestContext: options.requestContext
+        };
+        return execute(args, callOptions);
+      }
+    });
+  }
+  return xaiTools;
+};
+function schemaToJsonSchema(schema) {
+  let jsonSchema;
+  if (isZodType(schema)) {
+    jsonSchema = zodToJsonSchema(schema);
+  } else {
+    jsonSchema = standardSchemaToJSONSchema(toStandardSchema(schema), { io: "input" });
+  }
+  delete jsonSchema.$schema;
+  return jsonSchema;
+}
+
+// src/index.ts
+var DEFAULT_URL = "wss://api.x.ai/v1/realtime";
+var DEFAULT_MODEL = "grok-voice-think-fast-1.0";
+var DEFAULT_VOICE = "eve";
+var DEFAULT_TURN_DETECTION = {
+  type: "server_vad"
+};
+var FUNCTION_CALL_ARGUMENT_TIMEOUT_MS = 3e4;
+var DEFAULT_AUDIO = {
+  input: { format: { type: "audio/pcm", rate: 24e3 } },
+  output: { format: { type: "audio/pcm", rate: 24e3 } }
+};
+var XAI_SPEAKERS = [
+  {
+    voiceId: "eve",
+    name: "Eve",
+    gender: "female",
+    description: "Energetic, upbeat default voice."
+  },
+  {
+    voiceId: "ara",
+    name: "Ara",
+    gender: "female",
+    description: "Warm, friendly conversational voice."
+  },
+  {
+    voiceId: "rex",
+    name: "Rex",
+    gender: "male",
+    description: "Confident, clear professional voice."
+  },
+  {
+    voiceId: "sal",
+    name: "Sal",
+    gender: "neutral",
+    description: "Smooth, balanced general-purpose voice."
+  },
+  {
+    voiceId: "leo",
+    name: "Leo",
+    gender: "male",
+    description: "Authoritative, strong instructional voice."
+  }
+];
+var XAIRealtimeVoice = class _XAIRealtimeVoice extends MastraVoice {
+  ws;
+  state = "closed";
+  events = /* @__PURE__ */ new Map();
+  queue = [];
+  speakerStreams = /* @__PURE__ */ new Map();
+  functionResponses = /* @__PURE__ */ new Map();
+  audioStreamCleanups = /* @__PURE__ */ new Set();
+  requestContext;
+  instructions;
+  tools;
+  transformedTools;
+  options;
+  debug;
+  closedByUser = false;
+  connectPromise;
+  sessionGeneration = 0;
+  fallbackResponseCounter = 0;
+  constructor(config = {}) {
+    const normalizedConfig = _XAIRealtimeVoice.normalizeConfig(config);
+    super(normalizedConfig);
+    this.options = normalizedConfig.realtimeConfig?.options || {};
+    this.instructions = this.options.instructions;
+    this.speaker = normalizedConfig.speaker || this.options.speaker || DEFAULT_VOICE;
+    this.debug = this.options.debug || false;
+  }
+  static normalizeConfig(config) {
+    if ("realtimeConfig" in config || "speechModel" in config || "listeningModel" in config) {
+      const voiceConfig = config;
+      const options = voiceConfig.realtimeConfig?.options || {};
+      return {
+        ...voiceConfig,
+        speaker: voiceConfig.speaker || options.speaker || DEFAULT_VOICE,
+        realtimeConfig: {
+          model: voiceConfig.realtimeConfig?.model || options.model || DEFAULT_MODEL,
+          apiKey: voiceConfig.realtimeConfig?.apiKey || options.apiKey,
+          options
+        }
+      };
+    }
+    const xaiConfig = config;
+    return {
+      speaker: xaiConfig.speaker || DEFAULT_VOICE,
+      realtimeConfig: {
+        model: xaiConfig.model || DEFAULT_MODEL,
+        apiKey: xaiConfig.apiKey,
+        options: xaiConfig
+      }
+    };
+  }
+  getSpeakers() {
+    return Promise.resolve(XAI_SPEAKERS);
+  }
+  async getListener() {
+    return { enabled: true };
+  }
+  addInstructions(instructions) {
+    this.instructions = instructions ?? "";
+    if (this.state === "open") {
+      this.updateConfig({ instructions: this.instructions });
+    }
+  }
+  addTools(tools) {
+    this.tools = tools || {};
+    this.transformedTools = void 0;
+    if (this.state === "open") {
+      this.updateConfig({ tools: this.buildSessionTools() });
+    }
+  }
+  updateConfig(sessionConfig) {
+    this.sendEvent({
+      type: "session.update",
+      session: this.stripUndefined(sessionConfig)
+    });
+  }
+  async connect({ requestContext } = {}) {
+    if (this.state === "open") {
+      return;
+    }
+    if (this.state === "connecting" && this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.connectPromise = this.openConnection({ requestContext });
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = void 0;
+    }
+  }
+  async openConnection({ requestContext } = {}) {
+    const apiKey = this.options.apiKey || this.realtimeConfig?.apiKey || process.env.XAI_API_KEY;
+    const ephemeralToken = this.options.ephemeralToken;
+    if (!apiKey && !ephemeralToken) {
+      throw new Error("xAI API key is required. Set XAI_API_KEY, pass apiKey, or pass ephemeralToken.");
+    }
+    this.requestContext = requestContext;
+    this.closedByUser = false;
+    this.state = "connecting";
+    this.sessionGeneration += 1;
+    const url = this.buildUrl();
+    const protocols = ephemeralToken ? [`xai-client-secret.${ephemeralToken}`] : void 0;
+    const wsOptions = !ephemeralToken && apiKey ? {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    } : void 0;
+    const ws = new WebSocket(url, protocols, wsOptions);
+    this.ws = ws;
+    this.setupEventListeners(ws);
+    try {
+      await this.waitForOpen(ws);
+      this.state = "open";
+      this.updateConfig(this.buildInitialSessionConfig());
+      this.flushQueue();
+    } catch (err) {
+      this.cleanupSessionState();
+      this.state = "closed";
+      this.ws = void 0;
+      ws.close();
+      throw err;
+    }
+  }
+  close() {
+    const ws = this.ws;
+    this.state = "closed";
+    this.closedByUser = true;
+    this.connectPromise = void 0;
+    this.ws = void 0;
+    this.cleanupSessionState();
+    ws?.close();
+    if (ws) {
+      this.emit("close", { code: 1e3, reason: "closed" });
+    }
+  }
+  disconnect() {
+    this.close();
+  }
+  async speak(input, options = {}) {
+    const text = typeof input === "string" ? input : (await this.readInputStream(input)).toString("utf-8");
+    if (text.trim().length === 0) {
+      throw new Error("Input text is empty");
+    }
+    if (options.speaker && options.speaker !== this.speaker) {
+      this.speaker = options.speaker;
+      this.updateConfig({ voice: options.speaker });
+    }
+    this.sendEvent({
+      type: "conversation.item.create",
+      item: {
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text }]
+      }
+    });
+    await this.answer({ response: options.response });
+  }
+  async listen(audioData, options = {}) {
+    if (!isReadableStream(audioData)) {
+      this.emit("error", { message: "Unsupported audio data format" });
+      return;
+    }
+    this.appendAudio(await readableToBase64(audioData));
+    if (options.commit ?? true) {
+      await this.commitAudioBuffer();
+    }
+    if (options.createResponse ?? true) {
+      await this.answer({ response: options.response });
+    }
+  }
+  async send(audioData, eventId) {
+    if (this.state !== "open" || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.emit("error", { message: "Cannot send audio before connect() is open" });
+      return;
+    }
+    if (isReadableStream(audioData)) {
+      const cleanup = () => {
+        audioData.removeListener("data", onData);
+        audioData.removeListener("error", onError);
+        audioData.removeListener("end", onEnd);
+        audioData.removeListener("close", onEnd);
+        this.audioStreamCleanups.delete(cleanup);
+      };
+      const onData = (chunk) => {
+        try {
+          const buffer = this.normalizeAudioChunk(chunk);
+          this.appendAudio(buffer.toString("base64"), eventId);
+        } catch (err) {
+          this.emitError(err);
+          cleanup();
+        }
+      };
+      const onError = (err) => {
+        this.emitError(err);
+        cleanup();
+      };
+      const onEnd = () => cleanup();
+      this.audioStreamCleanups.add(cleanup);
+      audioData.on("data", onData);
+      audioData.on("error", onError);
+      audioData.on("end", onEnd);
+      audioData.on("close", onEnd);
+      return;
+    }
+    if (audioData instanceof Int16Array) {
+      this.appendAudio(int16ArrayToBase64(audioData), eventId);
+      return;
+    }
+    this.emit("error", { message: "Unsupported audio data format" });
+  }
+  async commitAudioBuffer(eventId) {
+    this.sendEvent({ type: "input_audio_buffer.commit", event_id: eventId });
+  }
+  async clearAudioBuffer(eventId) {
+    this.sendEvent({ type: "input_audio_buffer.clear", event_id: eventId });
+  }
+  async cancelResponse(responseId, eventId) {
+    this.sendEvent({ type: "response.cancel", response_id: responseId, event_id: eventId });
+  }
+  async answer(options = {}) {
+    this.sendEvent({
+      type: "response.create",
+      ...options.response ? { response: options.response } : {}
+    });
+  }
+  on(event, callback) {
+    const callbacks = this.events.get(event) || [];
+    callbacks.push(callback);
+    this.events.set(event, callbacks);
+  }
+  off(event, callback) {
+    const callbacks = this.events.get(event);
+    if (!callbacks) {
+      return;
+    }
+    const index = callbacks.indexOf(callback);
+    if (index !== -1) {
+      callbacks.splice(index, 1);
+    }
+  }
+  buildUrl() {
+    const baseUrl = this.options.url || DEFAULT_URL;
+    const url = new URL(baseUrl);
+    url.searchParams.set("model", this.realtimeConfig?.model || this.options.model || DEFAULT_MODEL);
+    return url.toString();
+  }
+  buildInitialSessionConfig() {
+    const session = this.options.session || {};
+    return this.stripUndefined({
+      ...session,
+      instructions: this.instructions,
+      voice: this.speaker,
+      turn_detection: session.turn_detection ?? this.options.turnDetection ?? DEFAULT_TURN_DETECTION,
+      audio: session.audio ?? this.options.audio ?? DEFAULT_AUDIO,
+      tools: this.buildSessionTools()
+    });
+  }
+  buildSessionTools() {
+    const serverTools = [...this.options.session?.tools || [], ...this.options.serverTools || []];
+    const functionTools = this.getTransformedTools().map((tool) => tool.xaiTool);
+    return [...serverTools, ...functionTools];
+  }
+  getTransformedTools() {
+    this.transformedTools ??= transformTools(this.tools, this.logger);
+    return this.transformedTools;
+  }
+  setupEventListeners(ws) {
+    ws.on("message", (message) => {
+      if (this.ws !== ws) {
+        return;
+      }
+      try {
+        const event = JSON.parse(message.toString());
+        this.handleServerEvent(event);
+      } catch (err) {
+        this.emitError(err);
+      }
+    });
+    ws.on("error", (err) => {
+      if (this.ws !== ws) {
+        return;
+      }
+      if (this.state === "open") {
+        this.emitError(err);
+      }
+    });
+    ws.on("close", (code, reason) => {
+      if (this.ws !== ws) {
+        return;
+      }
+      this.state = "closed";
+      this.ws = void 0;
+      this.connectPromise = void 0;
+      this.cleanupSessionState();
+      this.emit("close", { code, reason: reason?.toString?.() });
+    });
+  }
+  handleServerEvent(event) {
+    if (this.debug) {
+      const { delta, ...fields } = event;
+      this.logger.debug(`[xAI realtime] ${event.type}`, { ...fields, deltaLength: delta?.length });
+    }
+    if (event.type !== "error") {
+      this.emit(event.type, event);
+    }
+    switch (event.type) {
+      case "session.created":
+      case "session.updated":
+      case "response.created":
+        if (event.type === "response.created") {
+          this.createSpeakerStream(this.getResponseId(event));
+        }
+        return;
+      case "response.output_audio.delta":
+      case "response.audio.delta":
+        this.handleAudioDelta(event);
+        return;
+      case "response.output_audio.done":
+      case "response.audio.done":
+        this.handleAudioDone(event);
+        return;
+      case "response.text.delta":
+      case "response.output_text.delta":
+      case "response.audio_transcript.delta":
+      case "response.output_audio_transcript.delta":
+        this.emit("writing", { text: event.delta || "", response_id: this.getResponseId(event), role: "assistant" });
+        return;
+      case "response.text.done":
+      case "response.output_text.done":
+      case "response.audio_transcript.done":
+      case "response.output_audio_transcript.done":
+        this.emit("writing", { text: "\n", response_id: this.getResponseId(event), role: "assistant" });
+        return;
+      case "conversation.item.input_audio_transcription.completed":
+      case "conversation.item.input_audio_transcription.done":
+        this.emit("writing", {
+          text: event.transcript || event.text || event.delta || "",
+          response_id: this.getResponseId(event),
+          role: "user"
+        });
+        return;
+      case "response.function_call_arguments.done":
+        this.handleFunctionCallEvent(event);
+        return;
+      case "response.done":
+        void this.handleResponseDone(event);
+        return;
+      case "error":
+        this.emit("error", {
+          message: event.error?.message || "xAI realtime error",
+          code: event.error?.code || event.error?.type,
+          details: event
+        });
+        return;
+      default:
+        return;
+    }
+  }
+  handleAudioDelta(event) {
+    const responseId = this.getResponseId(event);
+    const audio = event.delta || "";
+    const audioData = Buffer.from(audio, "base64");
+    const stream = this.createSpeakerStream(responseId);
+    stream.write(audioData);
+    this.emit("speaking", { audio, audioData, response_id: responseId });
+  }
+  handleAudioDone(event) {
+    const responseId = this.getResponseId(event);
+    this.emit("speaking.done", { response_id: responseId });
+    this.endSpeakerStream(responseId);
+  }
+  handleFunctionCallEvent(event) {
+    const call = this.normalizeFunctionCallEvent(event);
+    if (!call) {
+      this.emit("error", {
+        message: "Invalid xAI function call event",
+        details: event
+      });
+      return;
+    }
+    const state = this.getFunctionResponseState(call.responseId);
+    state.hasFunctionCall = true;
+    state.expectedCallIds.add(call.callId);
+    if (state.startedCallIds.has(call.callId)) {
+      return;
+    }
+    state.startedCallIds.add(call.callId);
+    const pending = this.executeFunctionCall(call).finally(() => {
+      state.completedCallIds.add(call.callId);
+      state.pending.delete(pending);
+      void this.maybeContinueAfterFunctionCalls(call.responseId);
+    });
+    state.pending.add(pending);
+  }
+  async handleResponseDone(event) {
+    const responseId = this.getResponseId(event);
+    this.endSpeakerStream(responseId);
+    const expectedCallIds = this.getFunctionCallIds(event);
+    const state = this.functionResponses.get(responseId) || (expectedCallIds.length > 0 ? this.getFunctionResponseState(responseId) : void 0);
+    if (!state) {
+      return;
+    }
+    for (const callId of expectedCallIds) {
+      state.expectedCallIds.add(callId);
+    }
+    state.hasFunctionCall ||= expectedCallIds.length > 0;
+    state.responseDone = true;
+    await this.maybeContinueAfterFunctionCalls(responseId);
+  }
+  getFunctionCallIds(event) {
+    return event.response?.output?.filter((output) => output.type === "function_call" && typeof output.call_id === "string").map((output) => output.call_id) || [];
+  }
+  async executeFunctionCall(call) {
+    const tool = this.tools?.[call.name];
+    const parsedArgs = this.parseFunctionArguments(call.arguments);
+    if (!parsedArgs.ok) {
+      if (!this.isCurrentSession(call.sessionGeneration)) {
+        return;
+      }
+      const message = `Failed to parse xAI function call arguments: ${parsedArgs.error.message}`;
+      this.sendFunctionOutput(call.callId, { error: message });
+      this.emit("error", {
+        message,
+        details: {
+          call_id: call.callId,
+          name: call.name,
+          arguments: parsedArgs.rawArguments,
+          error: parsedArgs.error
+        }
+      });
+      return;
+    }
+    const args = parsedArgs.value;
+    try {
+      if (!tool?.execute) {
+        throw new Error(`Tool "${call.name}" not found`);
+      }
+      this.emit("tool-call-start", {
+        toolCallId: call.callId,
+        toolName: call.name,
+        toolDescription: tool.description,
+        args
+      });
+      const result = await this.executeTool(call.name, call.callId, args);
+      if (!this.isCurrentSession(call.sessionGeneration)) {
+        return;
+      }
+      this.emit("tool-call-result", {
+        toolCallId: call.callId,
+        toolName: call.name,
+        toolDescription: tool.description,
+        args,
+        result
+      });
+      this.sendFunctionOutput(call.callId, result);
+    } catch (err) {
+      if (!this.isCurrentSession(call.sessionGeneration)) {
+        return;
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      this.sendFunctionOutput(call.callId, { error: message });
+      this.emit("error", {
+        message,
+        details: { call_id: call.callId, name: call.name }
+      });
+    }
+  }
+  async executeTool(name, callId, args) {
+    const transformedTool = this.getTransformedTools().find((tool) => tool.xaiTool.name === name);
+    if (!transformedTool) {
+      throw new Error(`Tool "${name}" not found`);
+    }
+    return transformedTool.execute(args, {
+      toolCallId: callId,
+      requestContext: this.requestContext
+    });
+  }
+  sendFunctionOutput(callId, output) {
+    this.sendEvent({
+      type: "conversation.item.create",
+      item: {
+        type: "function_call_output",
+        call_id: callId,
+        output: JSON.stringify(output ?? null)
+      }
+    });
+  }
+  isCurrentSession(sessionGeneration) {
+    return this.state === "open" && this.sessionGeneration === sessionGeneration;
+  }
+  async maybeContinueAfterFunctionCalls(responseId) {
+    const state = this.functionResponses.get(responseId);
+    const hasPendingExpectedCall = state?.expectedCallIds && [...state.expectedCallIds].some((callId) => !state.completedCallIds.has(callId));
+    if (state && hasPendingExpectedCall) {
+      this.scheduleMissingFunctionCallTimeout(responseId, state);
+    }
+    if (!state || !state.hasFunctionCall || state.continuationSent || !state.responseDone || state.pending.size > 0 || hasPendingExpectedCall) {
+      return;
+    }
+    state.continuationSent = true;
+    this.clearMissingFunctionCallTimeout(state);
+    this.sendEvent({ type: "response.create" });
+    this.functionResponses.delete(responseId);
+  }
+  scheduleMissingFunctionCallTimeout(responseId, state) {
+    if (state.missingCallTimeout || !state.responseDone) {
+      return;
+    }
+    state.missingCallTimeout = setTimeout(() => {
+      if (!this.isCurrentSession(state.sessionGeneration) || this.functionResponses.get(responseId) !== state) {
+        return;
+      }
+      state.missingCallTimeout = void 0;
+      const missingCallIds = [...state.expectedCallIds].filter((callId) => !state.startedCallIds.has(callId));
+      if (missingCallIds.length === 0) {
+        void this.maybeContinueAfterFunctionCalls(responseId);
+        return;
+      }
+      const message = `Timed out waiting for xAI function call arguments for ${missingCallIds.join(", ")}`;
+      for (const callId of missingCallIds) {
+        state.completedCallIds.add(callId);
+        this.sendFunctionOutput(callId, { error: message });
+      }
+      this.emit("error", { message, details: { response_id: responseId, call_ids: missingCallIds } });
+      void this.maybeContinueAfterFunctionCalls(responseId);
+    }, FUNCTION_CALL_ARGUMENT_TIMEOUT_MS);
+  }
+  clearMissingFunctionCallTimeout(state) {
+    if (state.missingCallTimeout) {
+      clearTimeout(state.missingCallTimeout);
+      state.missingCallTimeout = void 0;
+    }
+  }
+  getFunctionResponseState(responseId) {
+    let state = this.functionResponses.get(responseId);
+    if (!state) {
+      state = {
+        pending: /* @__PURE__ */ new Set(),
+        expectedCallIds: /* @__PURE__ */ new Set(),
+        startedCallIds: /* @__PURE__ */ new Set(),
+        completedCallIds: /* @__PURE__ */ new Set(),
+        sessionGeneration: this.sessionGeneration,
+        responseDone: false,
+        continuationSent: false,
+        hasFunctionCall: false
+      };
+      this.functionResponses.set(responseId, state);
+    }
+    return state;
+  }
+  normalizeFunctionCallEvent(event) {
+    if (!event.call_id || !event.name || typeof event.arguments !== "string") {
+      return void 0;
+    }
+    return {
+      responseId: this.getResponseId(event),
+      callId: event.call_id,
+      name: event.name,
+      arguments: event.arguments,
+      sessionGeneration: this.sessionGeneration
+    };
+  }
+  parseFunctionArguments(args) {
+    try {
+      return { ok: true, value: JSON.parse(args || "{}") };
+    } catch (err) {
+      return { ok: false, rawArguments: args, error: err };
+    }
+  }
+  appendAudio(audio, eventId) {
+    this.sendEvent({ type: "input_audio_buffer.append", audio, event_id: eventId });
+  }
+  normalizeAudioChunk(chunk) {
+    if (Buffer.isBuffer(chunk)) {
+      return chunk;
+    }
+    if (chunk instanceof ArrayBuffer) {
+      return Buffer.from(chunk);
+    }
+    if (ArrayBuffer.isView(chunk)) {
+      return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    }
+    throw new TypeError("Audio stream chunks must be Buffer, ArrayBuffer, or TypedArray values");
+  }
+  sendEvent(event) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || this.state !== "open") {
+      if (this.closedByUser) {
+        this.emit("error", { message: "Cannot send event after close()" });
+        return;
+      }
+      this.queue.push(event);
+      return;
+    }
+    try {
+      this.ws.send(JSON.stringify(this.stripUndefined(event)));
+    } catch (err) {
+      this.emitError(err);
+    }
+  }
+  flushQueue() {
+    const queuedEvents = this.queue.splice(0, this.queue.length);
+    for (const event of queuedEvents) {
+      this.sendEvent(event);
+    }
+  }
+  waitForOpen(ws) {
+    return new Promise((resolve, reject) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        resolve();
+        return;
+      }
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const onClose = () => {
+        cleanup();
+        reject(new Error("WebSocket closed before opening"));
+      };
+      const cleanup = () => {
+        ws.off?.("open", onOpen);
+        ws.off?.("error", onError);
+        ws.off?.("close", onClose);
+      };
+      ws.on("open", onOpen);
+      ws.on("error", onError);
+      ws.on("close", onClose);
+    });
+  }
+  getResponseId(event) {
+    return event.response_id || event.response?.id || event.item_id || `fallback:${this.sessionGeneration}:${++this.fallbackResponseCounter}`;
+  }
+  createSpeakerStream(responseId) {
+    const existing = this.speakerStreams.get(responseId);
+    if (existing) {
+      return existing;
+    }
+    const stream = new PassThrough();
+    stream.id = responseId;
+    this.speakerStreams.set(responseId, stream);
+    this.emit("speaker", stream);
+    return stream;
+  }
+  closeSpeakerStreams() {
+    for (const stream of this.speakerStreams.values()) {
+      stream.end();
+    }
+    this.speakerStreams.clear();
+  }
+  endSpeakerStream(responseId) {
+    this.speakerStreams.get(responseId)?.end();
+    this.speakerStreams.delete(responseId);
+  }
+  cleanupSessionState() {
+    this.sessionGeneration += 1;
+    this.queue.length = 0;
+    for (const cleanup of [...this.audioStreamCleanups]) {
+      cleanup();
+    }
+    this.audioStreamCleanups.clear();
+    for (const state of this.functionResponses.values()) {
+      this.clearMissingFunctionCallTimeout(state);
+    }
+    this.functionResponses.clear();
+    this.requestContext = void 0;
+    this.closeSpeakerStreams();
+  }
+  emit(event, ...args) {
+    const callbacks = this.events.get(event);
+    if (!callbacks) {
+      return;
+    }
+    for (const callback of callbacks) {
+      callback(...args);
+    }
+  }
+  emitError(err) {
+    this.emit("error", {
+      message: err instanceof Error ? err.message : String(err),
+      details: err
+    });
+  }
+  stripUndefined(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0, maxDepth = 100) {
+    if (!value || typeof value !== "object") {
+      return value;
+    }
+    if (depth >= maxDepth) {
+      throw new Error("Cannot serialize xAI realtime event: maximum object depth exceeded");
+    }
+    const objectValue = value;
+    if (Buffer.isBuffer(value) || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+      return value;
+    }
+    if (seen.has(objectValue)) {
+      return void 0;
+    }
+    seen.add(objectValue);
+    if (Array.isArray(value)) {
+      const result2 = value.map((item) => this.stripUndefined(item, seen, depth + 1, maxDepth)).filter((item) => item !== void 0);
+      seen.delete(objectValue);
+      return result2;
+    }
+    const result = Object.fromEntries(
+      Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, this.stripUndefined(entry, seen, depth + 1, maxDepth)]).filter(([, entry]) => entry !== void 0)
+    );
+    seen.delete(objectValue);
+    return result;
+  }
+  async readInputStream(input) {
+    const chunks = [];
+    for await (const chunk of input) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks);
+  }
+};
+
+export { XAIRealtimeVoice };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map