@livekit/agents 1.0.47 → 1.1.0-dev.0

package/dist/voice/wire_format.cjs

@@ -0,0 +1,798 @@
+"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);
+var wire_format_exports = {};
+__export(wire_format_exports, {
+  agentHandoffToWire: () => agentHandoffToWire,
+  agentHandoffWireSchema: () => agentHandoffWireSchema,
+  agentMetricsToWire: () => agentMetricsToWire,
+  agentMetricsWireSchema: () => agentMetricsWireSchema,
+  agentSessionUsageToWire: () => agentSessionUsageToWire,
+  agentSessionUsageWireSchema: () => agentSessionUsageWireSchema,
+  chatItemToWire: () => chatItemToWire,
+  chatItemWireSchema: () => chatItemWireSchema,
+  chatMessageToWire: () => chatMessageToWire,
+  chatMessageWireSchema: () => chatMessageWireSchema,
+  clientAgentStateChangedSchema: () => clientAgentStateChangedSchema,
+  clientConversationItemAddedSchema: () => clientConversationItemAddedSchema,
+  clientErrorSchema: () => clientErrorSchema,
+  clientEventSchema: () => clientEventSchema,
+  clientFunctionToolsExecutedSchema: () => clientFunctionToolsExecutedSchema,
+  clientMetricsCollectedSchema: () => clientMetricsCollectedSchema,
+  clientSessionUsageSchema: () => clientSessionUsageSchema,
+  clientUserInputTranscribedSchema: () => clientUserInputTranscribedSchema,
+  clientUserOverlappingSpeechSchema: () => clientUserOverlappingSpeechSchema,
+  clientUserStateChangedSchema: () => clientUserStateChangedSchema,
+  eouMetricsWireSchema: () => eouMetricsWireSchema,
+  functionCallOutputToWire: () => functionCallOutputToWire,
+  functionCallOutputWireSchema: () => functionCallOutputWireSchema,
+  functionCallToWire: () => functionCallToWire,
+  functionCallWireSchema: () => functionCallWireSchema,
+  getAgentInfoResponseSchema: () => getAgentInfoResponseSchema,
+  getChatHistoryResponseSchema: () => getChatHistoryResponseSchema,
+  getRTCStatsResponseSchema: () => getRTCStatsResponseSchema,
+  getSessionStateResponseSchema: () => getSessionStateResponseSchema,
+  getSessionUsageResponseSchema: () => getSessionUsageResponseSchema,
+  interruptionMetricsWireSchema: () => interruptionMetricsWireSchema,
+  interruptionModelUsageWireSchema: () => interruptionModelUsageWireSchema,
+  llmMetricsWireSchema: () => llmMetricsWireSchema,
+  llmModelUsageWireSchema: () => llmModelUsageWireSchema,
+  modelUsageToWire: () => modelUsageToWire,
+  modelUsageWireSchema: () => modelUsageWireSchema,
+  msToS: () => msToS,
+  realtimeModelMetricsWireSchema: () => realtimeModelMetricsWireSchema,
+  sendMessageRequestSchema: () => sendMessageRequestSchema,
+  sendMessageResponseSchema: () => sendMessageResponseSchema,
+  streamRequestSchema: () => streamRequestSchema,
+  streamResponseSchema: () => streamResponseSchema,
+  sttMetricsWireSchema: () => sttMetricsWireSchema,
+  sttModelUsageWireSchema: () => sttModelUsageWireSchema,
+  ttsMetricsWireSchema: () => ttsMetricsWireSchema,
+  ttsModelUsageWireSchema: () => ttsModelUsageWireSchema,
+  vadMetricsWireSchema: () => vadMetricsWireSchema
+});
+module.exports = __toCommonJS(wire_format_exports);
+var import_zod = require("zod");
+function msToS(ms) {
+  return ms / 1e3;
+}
+function omitUndefined(obj) {
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) {
+      result[k] = v;
+    }
+  }
+  return result;
+}
+function imageContentToWire(img) {
+  return omitUndefined({
+    id: img.id,
+    type: img.type,
+    image: typeof img.image === "string" ? img.image : void 0,
+    inference_detail: img.inferenceDetail,
+    inference_width: img.inferenceWidth,
+    inference_height: img.inferenceHeight,
+    mime_type: img.mimeType
+  });
+}
+function audioContentToWire(audio) {
+  return omitUndefined({
+    type: audio.type,
+    transcript: audio.transcript
+  });
+}
+function chatContentToWire(content) {
+  if (typeof content === "string") return content;
+  if (content.type === "image_content") return imageContentToWire(content);
+  return audioContentToWire(content);
+}
+function metricsReportToWire(m) {
+  return omitUndefined({
+    started_speaking_at: m.startedSpeakingAt,
+    stopped_speaking_at: m.stoppedSpeakingAt,
+    transcription_delay: m.transcriptionDelay,
+    end_of_turn_delay: m.endOfTurnDelay,
+    on_user_turn_completed_delay: m.onUserTurnCompletedDelay,
+    llm_node_ttft: m.llmNodeTtft,
+    tts_node_ttfb: m.ttsNodeTtfb,
+    e2e_latency: m.e2eLatency
+  });
+}
+function chatMessageToWire(msg) {
+  const result = {
+    id: msg.id,
+    type: msg.type,
+    role: msg.role,
+    content: msg.content.map(chatContentToWire),
+    interrupted: msg.interrupted,
+    created_at: msToS(msg.createdAt)
+  };
+  if (msg.transcriptConfidence !== void 0) {
+    result.transcript_confidence = msg.transcriptConfidence;
+  }
+  if (Object.keys(msg.metrics).length > 0) {
+    result.metrics = metricsReportToWire(msg.metrics);
+  }
+  if (Object.keys(msg.extra).length > 0) {
+    result.extra = msg.extra;
+  }
+  return result;
+}
+function functionCallToWire(fc) {
+  const result = {
+    id: fc.id,
+    type: fc.type,
+    call_id: fc.callId,
+    arguments: fc.args,
+    name: fc.name,
+    created_at: msToS(fc.createdAt)
+  };
+  if (Object.keys(fc.extra).length > 0) {
+    result.extra = fc.extra;
+  }
+  if (fc.groupId !== void 0) {
+    result.group_id = fc.groupId;
+  }
+  return result;
+}
+function functionCallOutputToWire(fco) {
+  return {
+    id: fco.id,
+    type: fco.type,
+    name: fco.name,
+    call_id: fco.callId,
+    output: fco.output,
+    is_error: fco.isError,
+    created_at: msToS(fco.createdAt)
+  };
+}
+function agentHandoffToWire(ah) {
+  const result = {
+    id: ah.id,
+    type: ah.type,
+    new_agent_id: ah.newAgentId,
+    created_at: msToS(ah.createdAt)
+  };
+  if (ah.oldAgentId !== void 0) {
+    result.old_agent_id = ah.oldAgentId;
+  }
+  return result;
+}
+function chatItemToWire(item) {
+  switch (item.type) {
+    case "message":
+      return chatMessageToWire(item);
+    case "function_call":
+      return functionCallToWire(item);
+    case "function_call_output":
+      return functionCallOutputToWire(item);
+    case "agent_handoff":
+      return agentHandoffToWire(item);
+  }
+}
+function metadataToWire(m) {
+  if (!m) return null;
+  return omitUndefined({
+    model_name: m.modelName,
+    model_provider: m.modelProvider
+  });
+}
+function llmMetricsToWire(m) {
+  return omitUndefined({
+    type: m.type,
+    label: m.label,
+    request_id: m.requestId,
+    timestamp: msToS(m.timestamp),
+    duration: msToS(m.durationMs),
+    ttft: msToS(m.ttftMs),
+    cancelled: m.cancelled,
+    completion_tokens: m.completionTokens,
+    prompt_tokens: m.promptTokens,
+    prompt_cached_tokens: m.promptCachedTokens,
+    total_tokens: m.totalTokens,
+    tokens_per_second: m.tokensPerSecond,
+    speech_id: m.speechId,
+    metadata: metadataToWire(m.metadata)
+  });
+}
+function sttMetricsToWire(m) {
+  return omitUndefined({
+    type: m.type,
+    label: m.label,
+    request_id: m.requestId,
+    timestamp: msToS(m.timestamp),
+    duration: msToS(m.durationMs),
+    audio_duration: msToS(m.audioDurationMs),
+    input_tokens: m.inputTokens,
+    output_tokens: m.outputTokens,
+    streamed: m.streamed,
+    metadata: metadataToWire(m.metadata)
+  });
+}
+function ttsMetricsToWire(m) {
+  return omitUndefined({
+    type: m.type,
+    label: m.label,
+    request_id: m.requestId,
+    timestamp: msToS(m.timestamp),
+    ttfb: msToS(m.ttfbMs),
+    duration: msToS(m.durationMs),
+    audio_duration: msToS(m.audioDurationMs),
+    cancelled: m.cancelled,
+    characters_count: m.charactersCount,
+    input_tokens: m.inputTokens,
+    output_tokens: m.outputTokens,
+    streamed: m.streamed,
+    segment_id: m.segmentId,
+    speech_id: m.speechId,
+    metadata: metadataToWire(m.metadata)
+  });
+}
+function vadMetricsToWire(m) {
+  return {
+    type: m.type,
+    label: m.label,
+    timestamp: msToS(m.timestamp),
+    idle_time: msToS(m.idleTimeMs),
+    inference_duration_total: msToS(m.inferenceDurationTotalMs),
+    inference_count: m.inferenceCount
+  };
+}
+function eouMetricsToWire(m) {
+  return omitUndefined({
+    type: m.type,
+    timestamp: msToS(m.timestamp),
+    end_of_utterance_delay: msToS(m.endOfUtteranceDelayMs),
+    transcription_delay: msToS(m.transcriptionDelayMs),
+    on_user_turn_completed_delay: msToS(m.onUserTurnCompletedDelayMs),
+    speech_id: m.speechId
+  });
+}
+function cachedTokenDetailsToWire(d) {
+  return {
+    audio_tokens: d.audioTokens,
+    text_tokens: d.textTokens,
+    image_tokens: d.imageTokens
+  };
+}
+function inputTokenDetailsToWire(d) {
+  return omitUndefined({
+    audio_tokens: d.audioTokens,
+    text_tokens: d.textTokens,
+    image_tokens: d.imageTokens,
+    cached_tokens: d.cachedTokens,
+    cached_tokens_details: d.cachedTokensDetails ? cachedTokenDetailsToWire(d.cachedTokensDetails) : void 0
+  });
+}
+function outputTokenDetailsToWire(d) {
+  return {
+    text_tokens: d.textTokens,
+    audio_tokens: d.audioTokens,
+    image_tokens: d.imageTokens
+  };
+}
+function realtimeModelMetricsToWire(m) {
+  return omitUndefined({
+    type: m.type,
+    label: m.label,
+    request_id: m.requestId,
+    timestamp: msToS(m.timestamp),
+    duration: msToS(m.durationMs),
+    session_duration: m.sessionDurationMs !== void 0 ? msToS(m.sessionDurationMs) : void 0,
+    ttft: msToS(m.ttftMs),
+    cancelled: m.cancelled,
+    input_tokens: m.inputTokens,
+    output_tokens: m.outputTokens,
+    total_tokens: m.totalTokens,
+    tokens_per_second: m.tokensPerSecond,
+    input_token_details: inputTokenDetailsToWire(m.inputTokenDetails),
+    output_token_details: outputTokenDetailsToWire(m.outputTokenDetails),
+    metadata: metadataToWire(m.metadata)
+  });
+}
+function interruptionMetricsToWire(m) {
+  return omitUndefined({
+    type: m.type,
+    timestamp: msToS(m.timestamp),
+    total_duration: msToS(m.totalDuration),
+    prediction_duration: msToS(m.predictionDuration),
+    detection_delay: msToS(m.detectionDelay),
+    num_interruptions: m.numInterruptions,
+    num_backchannels: m.numBackchannels,
+    num_requests: m.numRequests,
+    metadata: metadataToWire(m.metadata)
+  });
+}
+function agentMetricsToWire(m) {
+  switch (m.type) {
+    case "llm_metrics":
+      return llmMetricsToWire(m);
+    case "stt_metrics":
+      return sttMetricsToWire(m);
+    case "tts_metrics":
+      return ttsMetricsToWire(m);
+    case "vad_metrics":
+      return vadMetricsToWire(m);
+    case "eou_metrics":
+      return eouMetricsToWire(m);
+    case "realtime_model_metrics":
+      return realtimeModelMetricsToWire(m);
+    case "interruption_metrics":
+      return interruptionMetricsToWire(m);
+  }
+}
+function llmModelUsageToWire(u) {
+  return {
+    type: u.type,
+    provider: u.provider ?? "",
+    model: u.model ?? "",
+    input_tokens: u.inputTokens ?? 0,
+    input_cached_tokens: u.inputCachedTokens ?? 0,
+    input_audio_tokens: u.inputAudioTokens ?? 0,
+    input_cached_audio_tokens: u.inputCachedAudioTokens ?? 0,
+    input_text_tokens: u.inputTextTokens ?? 0,
+    input_cached_text_tokens: u.inputCachedTextTokens ?? 0,
+    input_image_tokens: u.inputImageTokens ?? 0,
+    input_cached_image_tokens: u.inputCachedImageTokens ?? 0,
+    output_tokens: u.outputTokens ?? 0,
+    output_audio_tokens: u.outputAudioTokens ?? 0,
+    output_text_tokens: u.outputTextTokens ?? 0,
+    session_duration: msToS(u.sessionDurationMs ?? 0)
+  };
+}
+function ttsModelUsageToWire(u) {
+  return {
+    type: u.type,
+    provider: u.provider ?? "",
+    model: u.model ?? "",
+    input_tokens: u.inputTokens ?? 0,
+    output_tokens: u.outputTokens ?? 0,
+    characters_count: u.charactersCount ?? 0,
+    audio_duration: msToS(u.audioDurationMs ?? 0)
+  };
+}
+function sttModelUsageToWire(u) {
+  return {
+    type: u.type,
+    provider: u.provider ?? "",
+    model: u.model ?? "",
+    input_tokens: u.inputTokens ?? 0,
+    output_tokens: u.outputTokens ?? 0,
+    audio_duration: msToS(u.audioDurationMs ?? 0)
+  };
+}
+function interruptionModelUsageToWire(u) {
+  return {
+    type: u.type,
+    provider: u.provider ?? "",
+    model: u.model ?? "",
+    total_requests: u.totalRequests ?? 0
+  };
+}
+function modelUsageToWire(u) {
+  switch (u.type) {
+    case "llm_usage":
+      return llmModelUsageToWire(u);
+    case "tts_usage":
+      return ttsModelUsageToWire(u);
+    case "stt_usage":
+      return sttModelUsageToWire(u);
+    case "interruption_usage":
+      return interruptionModelUsageToWire(u);
+    default:
+      return u;
+  }
+}
+function agentSessionUsageToWire(u) {
+  return {
+    model_usage: u.modelUsage.map(modelUsageToWire)
+  };
+}
+const imageContentWireSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.literal("image_content"),
+  image: import_zod.z.string(),
+  inference_detail: import_zod.z.enum(["auto", "high", "low"]).optional(),
+  inference_width: import_zod.z.number().optional(),
+  inference_height: import_zod.z.number().optional(),
+  mime_type: import_zod.z.string().optional()
+});
+const audioContentWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("audio_content"),
+  transcript: import_zod.z.string().nullable().optional()
+});
+const chatContentWireSchema = import_zod.z.union([import_zod.z.string(), imageContentWireSchema, audioContentWireSchema]);
+const metricsReportWireSchema = import_zod.z.object({
+  started_speaking_at: import_zod.z.number().optional(),
+  stopped_speaking_at: import_zod.z.number().optional(),
+  transcription_delay: import_zod.z.number().optional(),
+  end_of_turn_delay: import_zod.z.number().optional(),
+  on_user_turn_completed_delay: import_zod.z.number().optional(),
+  llm_node_ttft: import_zod.z.number().optional(),
+  tts_node_ttfb: import_zod.z.number().optional(),
+  e2e_latency: import_zod.z.number().optional()
+}).optional();
+const chatMessageWireSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.literal("message"),
+  role: import_zod.z.enum(["developer", "system", "user", "assistant"]),
+  content: import_zod.z.array(chatContentWireSchema),
+  interrupted: import_zod.z.boolean(),
+  created_at: import_zod.z.number(),
+  transcript_confidence: import_zod.z.number().optional(),
+  metrics: metricsReportWireSchema,
+  extra: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+const functionCallWireSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.literal("function_call"),
+  call_id: import_zod.z.string(),
+  arguments: import_zod.z.string(),
+  name: import_zod.z.string(),
+  created_at: import_zod.z.number(),
+  extra: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  group_id: import_zod.z.string().optional()
+});
+const functionCallOutputWireSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.literal("function_call_output"),
+  name: import_zod.z.string(),
+  call_id: import_zod.z.string(),
+  output: import_zod.z.string(),
+  is_error: import_zod.z.boolean(),
+  created_at: import_zod.z.number()
+});
+const agentHandoffWireSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.literal("agent_handoff"),
+  new_agent_id: import_zod.z.string(),
+  created_at: import_zod.z.number(),
+  old_agent_id: import_zod.z.string().optional()
+});
+const chatItemWireSchema = import_zod.z.discriminatedUnion("type", [
+  chatMessageWireSchema,
+  functionCallWireSchema,
+  functionCallOutputWireSchema,
+  agentHandoffWireSchema
+]);
+const metadataWireSchema = import_zod.z.object({
+  model_name: import_zod.z.string().optional(),
+  model_provider: import_zod.z.string().optional()
+}).nullable().optional();
+const llmMetricsWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("llm_metrics"),
+  label: import_zod.z.string(),
+  request_id: import_zod.z.string(),
+  timestamp: import_zod.z.number(),
+  duration: import_zod.z.number(),
+  ttft: import_zod.z.number(),
+  cancelled: import_zod.z.boolean(),
+  completion_tokens: import_zod.z.number(),
+  prompt_tokens: import_zod.z.number(),
+  prompt_cached_tokens: import_zod.z.number(),
+  total_tokens: import_zod.z.number(),
+  tokens_per_second: import_zod.z.number(),
+  speech_id: import_zod.z.string().nullable().optional(),
+  metadata: metadataWireSchema
+});
+const sttMetricsWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("stt_metrics"),
+  label: import_zod.z.string(),
+  request_id: import_zod.z.string(),
+  timestamp: import_zod.z.number(),
+  duration: import_zod.z.number(),
+  audio_duration: import_zod.z.number(),
+  input_tokens: import_zod.z.number().optional(),
+  output_tokens: import_zod.z.number().optional(),
+  streamed: import_zod.z.boolean(),
+  metadata: metadataWireSchema
+});
+const ttsMetricsWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("tts_metrics"),
+  label: import_zod.z.string(),
+  request_id: import_zod.z.string(),
+  timestamp: import_zod.z.number(),
+  ttfb: import_zod.z.number(),
+  duration: import_zod.z.number(),
+  audio_duration: import_zod.z.number(),
+  cancelled: import_zod.z.boolean(),
+  characters_count: import_zod.z.number(),
+  input_tokens: import_zod.z.number().optional(),
+  output_tokens: import_zod.z.number().optional(),
+  streamed: import_zod.z.boolean(),
+  segment_id: import_zod.z.string().nullable().optional(),
+  speech_id: import_zod.z.string().nullable().optional(),
+  metadata: metadataWireSchema
+});
+const vadMetricsWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("vad_metrics"),
+  label: import_zod.z.string(),
+  timestamp: import_zod.z.number(),
+  idle_time: import_zod.z.number(),
+  inference_duration_total: import_zod.z.number(),
+  inference_count: import_zod.z.number()
+});
+const eouMetricsWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("eou_metrics"),
+  timestamp: import_zod.z.number(),
+  end_of_utterance_delay: import_zod.z.number(),
+  transcription_delay: import_zod.z.number(),
+  on_user_turn_completed_delay: import_zod.z.number(),
+  speech_id: import_zod.z.string().nullable().optional()
+});
+const cachedTokenDetailsWireSchema = import_zod.z.object({
+  audio_tokens: import_zod.z.number(),
+  text_tokens: import_zod.z.number(),
+  image_tokens: import_zod.z.number()
+});
+const inputTokenDetailsWireSchema = import_zod.z.object({
+  audio_tokens: import_zod.z.number(),
+  text_tokens: import_zod.z.number(),
+  image_tokens: import_zod.z.number(),
+  cached_tokens: import_zod.z.number(),
+  cached_tokens_details: cachedTokenDetailsWireSchema.nullable().optional()
+});
+const outputTokenDetailsWireSchema = import_zod.z.object({
+  text_tokens: import_zod.z.number(),
+  audio_tokens: import_zod.z.number(),
+  image_tokens: import_zod.z.number()
+});
+const realtimeModelMetricsWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("realtime_model_metrics"),
+  label: import_zod.z.string(),
+  request_id: import_zod.z.string(),
+  timestamp: import_zod.z.number(),
+  duration: import_zod.z.number(),
+  session_duration: import_zod.z.number().optional(),
+  ttft: import_zod.z.number(),
+  cancelled: import_zod.z.boolean(),
+  input_tokens: import_zod.z.number(),
+  output_tokens: import_zod.z.number(),
+  total_tokens: import_zod.z.number(),
+  tokens_per_second: import_zod.z.number(),
+  input_token_details: inputTokenDetailsWireSchema,
+  output_token_details: outputTokenDetailsWireSchema,
+  metadata: metadataWireSchema
+});
+const interruptionMetricsWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("interruption_metrics"),
+  timestamp: import_zod.z.number(),
+  total_duration: import_zod.z.number(),
+  prediction_duration: import_zod.z.number(),
+  detection_delay: import_zod.z.number(),
+  num_interruptions: import_zod.z.number(),
+  num_backchannels: import_zod.z.number(),
+  num_requests: import_zod.z.number(),
+  metadata: metadataWireSchema
+});
+const agentMetricsWireSchema = import_zod.z.discriminatedUnion("type", [
+  llmMetricsWireSchema,
+  sttMetricsWireSchema,
+  ttsMetricsWireSchema,
+  vadMetricsWireSchema,
+  eouMetricsWireSchema,
+  realtimeModelMetricsWireSchema,
+  interruptionMetricsWireSchema
+]);
+const llmModelUsageWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("llm_usage"),
+  provider: import_zod.z.string().optional(),
+  model: import_zod.z.string().optional(),
+  input_tokens: import_zod.z.number().optional(),
+  input_cached_tokens: import_zod.z.number().optional(),
+  input_audio_tokens: import_zod.z.number().optional(),
+  input_cached_audio_tokens: import_zod.z.number().optional(),
+  input_text_tokens: import_zod.z.number().optional(),
+  input_cached_text_tokens: import_zod.z.number().optional(),
+  input_image_tokens: import_zod.z.number().optional(),
+  input_cached_image_tokens: import_zod.z.number().optional(),
+  output_tokens: import_zod.z.number().optional(),
+  output_audio_tokens: import_zod.z.number().optional(),
+  output_text_tokens: import_zod.z.number().optional(),
+  session_duration: import_zod.z.number().optional()
+});
+const ttsModelUsageWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("tts_usage"),
+  provider: import_zod.z.string().optional(),
+  model: import_zod.z.string().optional(),
+  input_tokens: import_zod.z.number().optional(),
+  output_tokens: import_zod.z.number().optional(),
+  characters_count: import_zod.z.number().optional(),
+  audio_duration: import_zod.z.number().optional()
+});
+const sttModelUsageWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("stt_usage"),
+  provider: import_zod.z.string().optional(),
+  model: import_zod.z.string().optional(),
+  input_tokens: import_zod.z.number().optional(),
+  output_tokens: import_zod.z.number().optional(),
+  audio_duration: import_zod.z.number().optional()
+});
+const interruptionModelUsageWireSchema = import_zod.z.object({
+  type: import_zod.z.literal("interruption_usage"),
+  provider: import_zod.z.string().optional(),
+  model: import_zod.z.string().optional(),
+  total_requests: import_zod.z.number().optional()
+});
+const modelUsageWireSchema = import_zod.z.discriminatedUnion("type", [
+  llmModelUsageWireSchema,
+  ttsModelUsageWireSchema,
+  sttModelUsageWireSchema,
+  interruptionModelUsageWireSchema
+]);
+const agentSessionUsageWireSchema = import_zod.z.object({
+  model_usage: import_zod.z.array(modelUsageWireSchema)
+});
+const agentStateSchema = import_zod.z.enum(["initializing", "idle", "listening", "thinking", "speaking"]);
+const userStateSchema = import_zod.z.enum(["speaking", "listening", "away"]);
+const clientAgentStateChangedSchema = import_zod.z.object({
+  type: import_zod.z.literal("agent_state_changed"),
+  old_state: agentStateSchema,
+  new_state: agentStateSchema,
+  created_at: import_zod.z.number()
+});
+const clientUserStateChangedSchema = import_zod.z.object({
+  type: import_zod.z.literal("user_state_changed"),
+  old_state: userStateSchema,
+  new_state: userStateSchema,
+  created_at: import_zod.z.number()
+});
+const clientConversationItemAddedSchema = import_zod.z.object({
+  type: import_zod.z.literal("conversation_item_added"),
+  item: chatMessageWireSchema,
+  created_at: import_zod.z.number()
+});
+const clientUserInputTranscribedSchema = import_zod.z.object({
+  type: import_zod.z.literal("user_input_transcribed"),
+  transcript: import_zod.z.string(),
+  is_final: import_zod.z.boolean(),
+  language: import_zod.z.string().nullable(),
+  created_at: import_zod.z.number()
+});
+const clientFunctionToolsExecutedSchema = import_zod.z.object({
+  type: import_zod.z.literal("function_tools_executed"),
+  function_calls: import_zod.z.array(functionCallWireSchema),
+  function_call_outputs: import_zod.z.array(functionCallOutputWireSchema.nullable()),
+  created_at: import_zod.z.number()
+});
+const clientMetricsCollectedSchema = import_zod.z.object({
+  type: import_zod.z.literal("metrics_collected"),
+  metrics: agentMetricsWireSchema,
+  created_at: import_zod.z.number()
+});
+const clientErrorSchema = import_zod.z.object({
+  type: import_zod.z.literal("error"),
+  message: import_zod.z.string(),
+  created_at: import_zod.z.number()
+});
+const clientUserOverlappingSpeechSchema = import_zod.z.object({
+  type: import_zod.z.literal("user_overlapping_speech"),
+  is_interruption: import_zod.z.boolean(),
+  created_at: import_zod.z.number(),
+  sent_at: import_zod.z.number(),
+  detection_delay: import_zod.z.number(),
+  overlap_started_at: import_zod.z.number().nullable()
+});
+const clientSessionUsageSchema = import_zod.z.object({
+  type: import_zod.z.literal("session_usage"),
+  usage: agentSessionUsageWireSchema,
+  created_at: import_zod.z.number()
+});
+const clientEventSchema = import_zod.z.discriminatedUnion("type", [
+  clientAgentStateChangedSchema,
+  clientUserStateChangedSchema,
+  clientConversationItemAddedSchema,
+  clientUserInputTranscribedSchema,
+  clientFunctionToolsExecutedSchema,
+  clientMetricsCollectedSchema,
+  clientErrorSchema,
+  clientUserOverlappingSpeechSchema,
+  clientSessionUsageSchema
+]);
+const sendMessageRequestSchema = import_zod.z.object({
+  text: import_zod.z.string()
+});
+const streamRequestSchema = import_zod.z.object({
+  request_id: import_zod.z.string(),
+  method: import_zod.z.string(),
+  payload: import_zod.z.string()
+});
+const streamResponseSchema = import_zod.z.object({
+  request_id: import_zod.z.string(),
+  payload: import_zod.z.string(),
+  error: import_zod.z.string().nullable().optional()
+});
+const getSessionStateResponseSchema = import_zod.z.object({
+  agent_state: agentStateSchema,
+  user_state: userStateSchema,
+  agent_id: import_zod.z.string(),
+  options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()),
+  created_at: import_zod.z.number()
+});
+const getChatHistoryResponseSchema = import_zod.z.object({
+  items: import_zod.z.array(chatItemWireSchema)
+});
+const getAgentInfoResponseSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  instructions: import_zod.z.string().nullable(),
+  tools: import_zod.z.array(import_zod.z.string()),
+  chat_ctx: import_zod.z.array(chatItemWireSchema)
+});
+const sendMessageResponseSchema = import_zod.z.object({
+  items: import_zod.z.array(chatItemWireSchema)
+});
+const getRTCStatsResponseSchema = import_zod.z.object({
+  publisher_stats: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())),
+  subscriber_stats: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()))
+});
+const getSessionUsageResponseSchema = import_zod.z.object({
+  usage: agentSessionUsageWireSchema,
+  created_at: import_zod.z.number()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  agentHandoffToWire,
+  agentHandoffWireSchema,
+  agentMetricsToWire,
+  agentMetricsWireSchema,
+  agentSessionUsageToWire,
+  agentSessionUsageWireSchema,
+  chatItemToWire,
+  chatItemWireSchema,
+  chatMessageToWire,
+  chatMessageWireSchema,
+  clientAgentStateChangedSchema,
+  clientConversationItemAddedSchema,
+  clientErrorSchema,
+  clientEventSchema,
+  clientFunctionToolsExecutedSchema,
+  clientMetricsCollectedSchema,
+  clientSessionUsageSchema,
+  clientUserInputTranscribedSchema,
+  clientUserOverlappingSpeechSchema,
+  clientUserStateChangedSchema,
+  eouMetricsWireSchema,
+  functionCallOutputToWire,
+  functionCallOutputWireSchema,
+  functionCallToWire,
+  functionCallWireSchema,
+  getAgentInfoResponseSchema,
+  getChatHistoryResponseSchema,
+  getRTCStatsResponseSchema,
+  getSessionStateResponseSchema,
+  getSessionUsageResponseSchema,
+  interruptionMetricsWireSchema,
+  interruptionModelUsageWireSchema,
+  llmMetricsWireSchema,
+  llmModelUsageWireSchema,
+  modelUsageToWire,
+  modelUsageWireSchema,
+  msToS,
+  realtimeModelMetricsWireSchema,
+  sendMessageRequestSchema,
+  sendMessageResponseSchema,
+  streamRequestSchema,
+  streamResponseSchema,
+  sttMetricsWireSchema,
+  sttModelUsageWireSchema,
+  ttsMetricsWireSchema,
+  ttsModelUsageWireSchema,
+  vadMetricsWireSchema
+});
+//# sourceMappingURL=wire_format.cjs.map