@volley/recognition-client-sdk 0.1.424 → 0.1.621

package/dist/recog-client-sdk.browser.js

@@ -1,4 +1,4 @@
-// ../../node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
+// ../../node_modules/.pnpm/zod@3.22.5/node_modules/zod/lib/index.mjs
 var util;
 (function(util2) {
   util2.assertEqual = (val) => val;
@@ -3741,6 +3741,10 @@ var RecognitionProvider;
   RecognitionProvider2["GEMINI_BATCH"] = "gemini-batch";
   RecognitionProvider2["OPENAI_BATCH"] = "openai-batch";
   RecognitionProvider2["OPENAI_REALTIME"] = "openai-realtime";
+  RecognitionProvider2["MISTRAL_VOXTRAL"] = "mistral-voxtral";
+  RecognitionProvider2["DASHSCOPE"] = "dashscope";
+  RecognitionProvider2["TEST_ASR_PROVIDER_QUOTA"] = "test-asr-provider-quota";
+  RecognitionProvider2["TEST_ASR_STREAMING"] = "test-asr-streaming";
 })(RecognitionProvider || (RecognitionProvider = {}));
 var RecognitionMode;
 (function(RecognitionMode2) {
@@ -3786,8 +3790,18 @@ var ElevenLabsModel;
 })(ElevenLabsModel || (ElevenLabsModel = {}));
 var OpenAIRealtimeModel;
 (function(OpenAIRealtimeModel2) {
+  OpenAIRealtimeModel2["GPT_4O_TRANSCRIBE"] = "gpt-4o-transcribe";
   OpenAIRealtimeModel2["GPT_4O_MINI_TRANSCRIBE"] = "gpt-4o-mini-transcribe";
 })(OpenAIRealtimeModel || (OpenAIRealtimeModel = {}));
+var MistralVoxtralModel;
+(function(MistralVoxtralModel2) {
+  MistralVoxtralModel2["VOXTRAL_MINI_REALTIME_2602"] = "voxtral-mini-transcribe-realtime-2602";
+})(MistralVoxtralModel || (MistralVoxtralModel = {}));
+var DashScopeModel;
+(function(DashScopeModel2) {
+  DashScopeModel2["QWEN3_ASR_FLASH_REALTIME_2602"] = "qwen3-asr-flash-realtime-2026-02-10";
+  DashScopeModel2["QWEN3_ASR_FLASH_REALTIME"] = "qwen3-asr-flash-realtime";
+})(DashScopeModel || (DashScopeModel = {}));
 
 // ../../libs/types/dist/recognition-result-v1.types.js
 var RecognitionResultTypeV1;
@@ -3803,8 +3817,10 @@ var TranscriptionResultSchemaV1 = z.object({
   type: z.literal(RecognitionResultTypeV1.TRANSCRIPTION),
   audioUtteranceId: z.string(),
   finalTranscript: z.string(),
+  finalTranscriptRaw: z.string(),
   finalTranscriptConfidence: z.number().min(0).max(1).optional(),
   pendingTranscript: z.string().optional(),
+  pendingTranscriptRaw: z.string().optional(),
   pendingTranscriptConfidence: z.number().min(0).max(1).optional(),
   is_finished: z.boolean(),
   voiceStart: z.number().optional(),
@@ -3813,8 +3829,9 @@ var TranscriptionResultSchemaV1 = z.object({
   startTimestamp: z.number().optional(),
   endTimestamp: z.number().optional(),
   receivedAtMs: z.number().optional(),
-  accumulatedAudioTimeMs: z.number().optional()
-  // accumulated audio time watermark in milliseconds. Total duration of all audio chunks sent. Optional.
+  accumulatedAudioTimeMs: z.number().optional(),
+  rawAudioTimeMs: z.number().optional()
+  // Total audio duration sent to provider (includes prefix)
 });
 var FunctionCallResultSchemaV1 = z.object({
   type: z.literal(RecognitionResultTypeV1.FUNCTION_CALL),
@@ -3827,11 +3844,22 @@ var TranscriptOutcomeType;
   TranscriptOutcomeType2["WITH_CONTENT"] = "with_content";
   TranscriptOutcomeType2["EMPTY"] = "empty";
   TranscriptOutcomeType2["NEVER_SENT"] = "never_sent";
+  TranscriptOutcomeType2["ERROR_AUTHENTICATION"] = "error_authentication";
+  TranscriptOutcomeType2["ERROR_VALIDATION"] = "error_validation";
+  TranscriptOutcomeType2["ERROR_PROVIDER"] = "error_provider";
+  TranscriptOutcomeType2["ERROR_TIMEOUT"] = "error_timeout";
+  TranscriptOutcomeType2["ERROR_QUOTA"] = "error_quota";
+  TranscriptOutcomeType2["ERROR_INTERNAL_QUOTA"] = "error_internal_quota";
+  TranscriptOutcomeType2["ERROR_CONNECTION"] = "error_connection";
+  TranscriptOutcomeType2["ERROR_NO_AUDIO"] = "error_no_audio";
+  TranscriptOutcomeType2["ERROR_CIRCUIT_BREAKER"] = "error_circuit_breaker";
+  TranscriptOutcomeType2["ERROR_UNKNOWN"] = "error_unknown";
 })(TranscriptOutcomeType || (TranscriptOutcomeType = {}));
 var MetadataResultSchemaV1 = z.object({
   type: z.literal(RecognitionResultTypeV1.METADATA),
   audioUtteranceId: z.string(),
   // Timing information
+  connectionInitiatedAtMs: z.number().optional(),
   recordingStartMs: z.number().optional(),
   recordingEndMs: z.number().optional(),
   transcriptEndMs: z.number().optional(),
@@ -3840,6 +3868,7 @@ var MetadataResultSchemaV1 = z.object({
   duration: z.number().optional(),
   volume: z.number().optional(),
   accumulatedAudioTimeMs: z.number().optional(),
+  rawAudioTimeMs: z.number().optional(),
   // Cost Information
   costInUSD: z.number().default(0).optional(),
   // ASR API Type
@@ -3849,7 +3878,22 @@ var MetadataResultSchemaV1 = z.object({
   // Raw ASR metadata payload as provided by the provider (stringified if needed)
   rawAsrMetadata: z.string().optional(),
   // Transcript outcome - categorizes the final transcript state
-  transcriptOutcome: z.nativeEnum(TranscriptOutcomeType).optional()
+  transcriptOutcome: z.nativeEnum(TranscriptOutcomeType).optional(),
+  // Audio metrics - embedded audio quality metrics (from AudioMetricsAccumulator)
+  // Omit 'type' field since it's embedded in METADATA, not a separate message
+  audioMetrics: z.object({
+    valid: z.boolean(),
+    audioBeginMs: z.number(),
+    audioEndMs: z.number(),
+    maxVolume: z.number(),
+    minVolume: z.number(),
+    avgVolume: z.number(),
+    silenceRatio: z.number(),
+    clippingRatio: z.number(),
+    snrEstimate: z.number().nullable(),
+    lastNonSilenceMs: z.number(),
+    timestamp: z.string()
+  }).optional()
 });
 var ErrorTypeV1;
 (function(ErrorTypeV12) {
@@ -3858,7 +3902,10 @@ var ErrorTypeV1;
   ErrorTypeV12["PROVIDER_ERROR"] = "provider_error";
   ErrorTypeV12["TIMEOUT_ERROR"] = "timeout_error";
   ErrorTypeV12["QUOTA_EXCEEDED"] = "quota_exceeded";
+  ErrorTypeV12["INTERNAL_QUOTA_EXHAUSTED"] = "internal_quota_exhausted";
   ErrorTypeV12["CONNECTION_ERROR"] = "connection_error";
+  ErrorTypeV12["NO_AUDIO_ERROR"] = "no_audio_error";
+  ErrorTypeV12["CIRCUIT_BREAKER_OPEN"] = "circuit_breaker_open";
   ErrorTypeV12["UNKNOWN_ERROR"] = "unknown_error";
 })(ErrorTypeV1 || (ErrorTypeV1 = {}));
 var ErrorResultSchemaV1 = z.object({
@@ -4075,6 +4122,12 @@ var TimerSchema = z.object({
    * Provider that generated this message
    */
   provider: z.nativeEnum(RecognitionProvider).optional(),
+  /**
+   * Timestamp when provider connection was initiated (in milliseconds)
+   * Set before doConnect() - captures the moment before WebSocket creation starts
+   * @example 1704095999800
+   */
+  connectionInitiatedAtMs: z.number().optional(),
   /**
    * Timestamp when recording started (in milliseconds)
    * @example 1704096000000
@@ -4208,6 +4261,14 @@ var ConnectionExceptionSchema = BaseRecognitionExceptionSchema.extend({
   /** Underlying error message */
   underlyingError: z.string().optional()
 });
+var CircuitBreakerExceptionSchema = BaseRecognitionExceptionSchema.extend({
+  errorType: z.literal(ErrorTypeV1.CIRCUIT_BREAKER_OPEN),
+  isImmediatelyAvailable: z.literal(true),
+  /** Provider that is unavailable */
+  provider: z.nativeEnum(RecognitionProvider).optional(),
+  /** Model that is unavailable */
+  model: z.string().optional()
+});
 var UnknownExceptionSchema = BaseRecognitionExceptionSchema.extend({
   errorType: z.literal(ErrorTypeV1.UNKNOWN_ERROR),
   isImmediatelyAvailable: z.literal(false),
@@ -4223,6 +4284,7 @@ var RecognitionExceptionSchema = z.discriminatedUnion("errorType", [
   TimeoutExceptionSchema,
   QuotaExceededExceptionSchema,
   ConnectionExceptionSchema,
+  CircuitBreakerExceptionSchema,
   UnknownExceptionSchema
 ]);
 
@@ -4238,6 +4300,12 @@ var ControlSignalTypeV1;
   ControlSignalTypeV12["START_RECORDING"] = "start_recording";
   ControlSignalTypeV12["STOP_RECORDING"] = "stop_recording";
 })(ControlSignalTypeV1 || (ControlSignalTypeV1 = {}));
+var PrefixMode;
+(function(PrefixMode2) {
+  PrefixMode2["NONE"] = "none";
+  PrefixMode2["CLIENT"] = "client";
+  PrefixMode2["STORED"] = "stored";
+})(PrefixMode || (PrefixMode = {}));
 var SlotMapSchema = z.record(z.string(), z.array(z.string()));
 var GameContextSchemaV1 = z.object({
   type: z.literal(RecognitionContextTypeV1.GAME_CONTEXT),
@@ -4269,6 +4337,19 @@ var RequestDebugCommandSchema = z.object({
   // Enable experimental pilot models for testing new features
   enablePilotModels: z.boolean().optional().default(false)
 }).optional();
+var FallbackASRConfigSchema = z.object({
+  // Required - the fallback provider to use
+  provider: z.string(),
+  // Optional - inherits from primary if not specified
+  model: z.string().optional(),
+  language: z.string().optional(),
+  sampleRate: z.number().optional(),
+  encoding: z.number().optional(),
+  // Recognition options - optional, inherits from primary
+  interimResults: z.boolean().optional(),
+  useContext: z.boolean().optional(),
+  finalTranscriptStability: z.string().optional()
+});
 var ASRRequestSchemaV1 = z.object({
   type: z.literal(RecognitionContextTypeV1.ASR_REQUEST),
   // Session identification
@@ -4284,6 +4365,16 @@ var ASRRequestSchemaV1 = z.object({
   useContext: z.boolean().optional().default(false),
   // Final transcript stability mode (timeout for fallback final transcript)
   finalTranscriptStability: z.string().optional(),
+  // Traffic control priority (affects quota slot allocation)
+  // 'high' = can use all quota slots (reserved for critical games like song-quiz)
+  // 'low' = limited to non-reserved slots (default for most requests)
+  priority: z.enum(["low", "high"]).optional().default("low"),
+  // Fallback providers - tried in order if primary provider is unavailable (circuit breaker open)
+  fallbackModels: z.array(FallbackASRConfigSchema).optional(),
+  // Prefix audio configuration
+  prefixMode: z.nativeEnum(PrefixMode).optional().default(PrefixMode.NONE),
+  prefixId: z.string().optional(),
+  prefixTextToRemove: z.array(z.string()).optional(),
   // Debug options (FOR DEBUG/TESTING ONLY - not for production use)
   debugCommand: RequestDebugCommandSchema
 });
@@ -4301,6 +4392,8 @@ var RecognitionGameInfoSchema = z.object({
   accountId: z.string().optional(),
   gameId: z.string().optional(),
   gamePhase: z.string().optional(),
+  questionAskedId: z.string().optional(),
+  /** @deprecated Use questionAskedId instead. Kept for backward compatibility during migration. */
   questionAnswerId: z.string().optional(),
   platform: z.string().optional()
   // Platform for audio recording device (use the definition of platform teams)
@@ -4435,6 +4528,7 @@ var AudioEncoding;
   }
   AudioEncoding2.isNameValid = isNameValid;
 })(AudioEncoding || (AudioEncoding = {}));
+var PREFIX_AUDIO_ENCODING_OFFSET = 128;
 var SampleRate;
 (function(SampleRate2) {
   SampleRate2[SampleRate2["RATE_8000"] = 8e3] = "RATE_8000";
@@ -4527,6 +4621,7 @@ var FinalTranscriptStability;
 var PlumbingType;
 (function(PlumbingType2) {
   PlumbingType2["AUDIO"] = "audio";
+  PlumbingType2["PREFIX_AUDIO"] = "prefix_audio";
   PlumbingType2["CONTROL"] = "control";
   PlumbingType2["RESULT"] = "result";
   PlumbingType2["RECOGNITION_CONTEXT"] = "recognition_context";
@@ -4605,6 +4700,11 @@ var StatsIncrementType;
   StatsIncrementType2["SUCCESS"] = "success";
   StatsIncrementType2["FAIL"] = "fail";
 })(StatsIncrementType || (StatsIncrementType = {}));
+var QuotaPriority;
+(function(QuotaPriority2) {
+  QuotaPriority2[QuotaPriority2["LOW"] = 0] = "LOW";
+  QuotaPriority2[QuotaPriority2["HIGH"] = 1] = "HIGH";
+})(QuotaPriority || (QuotaPriority = {}));
 
 // ../../libs/types/dist/stages.types.js
 var STAGES = {
@@ -4781,7 +4881,7 @@ var WebSocketAudioClient = class {
 // ../../libs/websocket/dist/core/audio-upload-websocket-server.js
 import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
 
-// ../../node_modules/.pnpm/uuid@11.0.0/node_modules/uuid/dist/esm-browser/stringify.js
+// ../../node_modules/.pnpm/uuid@11.1.0/node_modules/uuid/dist/esm-browser/stringify.js
 var byteToHex = [];
 for (let i = 0; i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
@@ -4790,7 +4890,7 @@ function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
 
-// ../../node_modules/.pnpm/uuid@11.0.0/node_modules/uuid/dist/esm-browser/rng.js
+// ../../node_modules/.pnpm/uuid@11.1.0/node_modules/uuid/dist/esm-browser/rng.js
 var getRandomValues;
 var rnds8 = new Uint8Array(16);
 function rng() {
@@ -4803,21 +4903,27 @@ function rng() {
   return getRandomValues(rnds8);
 }
 
-// ../../node_modules/.pnpm/uuid@11.0.0/node_modules/uuid/dist/esm-browser/native.js
+// ../../node_modules/.pnpm/uuid@11.1.0/node_modules/uuid/dist/esm-browser/native.js
 var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
 var native_default = { randomUUID };
 
-// ../../node_modules/.pnpm/uuid@11.0.0/node_modules/uuid/dist/esm-browser/v4.js
+// ../../node_modules/.pnpm/uuid@11.1.0/node_modules/uuid/dist/esm-browser/v4.js
 function v4(options, buf, offset) {
   if (native_default.randomUUID && !buf && !options) {
     return native_default.randomUUID();
   }
   options = options || {};
-  const rnds = options.random || (options.rng || rng)();
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
   rnds[6] = rnds[6] & 15 | 64;
   rnds[8] = rnds[8] & 63 | 128;
   if (buf) {
     offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
     for (let i = 0; i < 16; ++i) {
       buf[offset + i] = rnds[i];
     }
@@ -5191,6 +5297,9 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
       highWM: config.highWaterMark ?? 512e3,
       lowWM: config.lowWaterMark ?? 128e3
     });
+    this.prefixBuffer = [];
+    // Buffer prefix audio until READY
+    this.prefixBufferBytes = 0;
     this.state = "initial" /* INITIAL */;
     // Debug control (internal state, controlled by debugCommand in ASRRequest)
     this.isDebugLogEnabled = false;
@@ -5247,6 +5356,9 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
   static {
     this.PROTOCOL_VERSION = 1;
   }
+  static {
+    this.MAX_PREFIX_BUFFER_BYTES = 10 * 1024 * 1024;
+  }
   // ==========================================================================
   // PRIVATE HELPERS
   // ==========================================================================
@@ -5272,6 +5384,8 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
   cleanup() {
     this.log("debug", "Cleaning up resources");
     this.audioBuffer.clear();
+    this.prefixBuffer = [];
+    this.prefixBufferBytes = 0;
     this.audioBytesSent = 0;
     this.audioChunksSent = 0;
     this.lastAudioStatsLog = 0;
@@ -5488,6 +5602,25 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
   isBufferOverflowing() {
     return this.audioBuffer.isOverflowing();
   }
+  isServerReady() {
+    return this.state === "ready" /* READY */;
+  }
+  sendGameContext(context) {
+    if (this.state !== "connected" /* CONNECTED */ && this.state !== "ready" /* READY */) {
+      this.log("warn", "sendGameContext called in wrong state", { state: this.state });
+      return;
+    }
+    this.log("debug", "Sending game context (deferred)", {
+      gameId: context.gameId,
+      gamePhase: context.gamePhase,
+      hasSlotMap: !!context.slotMap
+    });
+    super.sendMessage(
+      _RealTimeTwoWayWebSocketRecognitionClient.PROTOCOL_VERSION,
+      "message",
+      context
+    );
+  }
   getStats() {
     const bufferStats = this.audioBuffer.getStats();
     return {
@@ -5513,6 +5646,7 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
       if (this.isDebugLogEnabled) {
         this.log("debug", "Sending ASR request", this.config.asrRequestConfig);
       }
+      const fallbackModels = this.config.asrRequestConfig.fallbackModels;
       const asrRequest = {
         type: RecognitionContextTypeV1.ASR_REQUEST,
         audioUtteranceId: this.config.audioUtteranceId,
@@ -5528,7 +5662,20 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
         ...this.config.asrRequestConfig.finalTranscriptStability && {
           finalTranscriptStability: this.config.asrRequestConfig.finalTranscriptStability
         },
-        ...debugCommand && { debugCommand }
+        // Include fallbackModels if provided (for circuit breaker fallback)
+        ...fallbackModels && { fallbackModels },
+        ...debugCommand && { debugCommand },
+        // Include prefix mode if provided (for server-side stored prefix injection)
+        ...this.config.asrRequestConfig.prefixMode && {
+          prefixMode: this.config.asrRequestConfig.prefixMode
+        },
+        ...this.config.asrRequestConfig.prefixId && {
+          prefixId: this.config.asrRequestConfig.prefixId
+        },
+        // Include prefix text to remove if provided (for server-side prefix text removal)
+        ...this.config.asrRequestConfig.prefixTextToRemove && {
+          prefixTextToRemove: this.config.asrRequestConfig.prefixTextToRemove
+        }
       };
       super.sendMessage(
         _RealTimeTwoWayWebSocketRecognitionClient.PROTOCOL_VERSION,
@@ -5635,6 +5782,12 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
         this.log("debug", "Server ready for audio upload");
         this.state = "ready" /* READY */;
         this.messageHandler.setSessionStartTime(Date.now());
+        if (this.prefixBuffer.length > 0) {
+          this.log("debug", "Flushing buffered prefix audio", { chunks: this.prefixBuffer.length });
+          this.prefixBuffer.forEach((chunk) => this.sendPrefixAudioNow(chunk));
+          this.prefixBuffer = [];
+          this.prefixBufferBytes = 0;
+        }
         const bufferedChunks = this.audioBuffer.flush();
         if (bufferedChunks.length > 0) {
           this.log("debug", "Flushing buffered audio", { chunks: bufferedChunks.length });
@@ -5666,6 +5819,74 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
     this.audioBytesSent += byteLength;
     this.audioChunksSent++;
   }
+  /**
+   * Send prefix audio to the server.
+   * Prefix audio is sent before user audio and is used for context/priming.
+   * The server will process it but adjust timing so transcripts reflect user audio timing.
+   *
+   * Note: Prefix audio is buffered until READY state, then flushed before user audio.
+   * This ensures proper ordering even if called before server is ready.
+   *
+   * @param audioData - Prefix audio data (ArrayBuffer, ArrayBufferView, or Blob)
+   */
+  sendPrefixAudio(audioData) {
+    if (audioData instanceof Blob) {
+      blobToArrayBuffer(audioData).then((arrayBuffer) => {
+        this.sendPrefixAudioInternal(arrayBuffer);
+      }).catch((error) => {
+        this.log("error", "Failed to convert Blob to ArrayBuffer for prefix audio", error);
+      });
+      return;
+    }
+    this.sendPrefixAudioInternal(audioData);
+  }
+  /**
+   * Internal method to handle prefix audio with buffering
+   * Buffers if not READY, sends immediately if READY
+   */
+  sendPrefixAudioInternal(audioData) {
+    const bytes = ArrayBuffer.isView(audioData) ? audioData.byteLength : audioData.byteLength;
+    if (bytes === 0) return;
+    if (this.state === "stopped" /* STOPPED */ || this.state === "failed" /* FAILED */) {
+      this.log("debug", "Ignoring prefix audio in terminal state", { bytes, state: this.state });
+      return;
+    }
+    if (this.state === "ready" /* READY */) {
+      this.log("debug", "Sending prefix audio immediately", { bytes });
+      this.sendPrefixAudioNow(audioData);
+    } else {
+      if (this.prefixBufferBytes + bytes > _RealTimeTwoWayWebSocketRecognitionClient.MAX_PREFIX_BUFFER_BYTES) {
+        this.log("warn", "Prefix buffer limit exceeded, dropping chunk", {
+          bytes,
+          current: this.prefixBufferBytes,
+          max: _RealTimeTwoWayWebSocketRecognitionClient.MAX_PREFIX_BUFFER_BYTES
+        });
+        return;
+      }
+      this.log("debug", "Buffering prefix audio until READY", { bytes, state: this.state });
+      this.prefixBuffer.push(audioData);
+      this.prefixBufferBytes += bytes;
+    }
+  }
+  /**
+   * Send prefix audio immediately to the server (without buffering)
+   * Uses encoding offset to mark as prefix audio
+   * @param audioData - Prefix audio data to send
+   */
+  sendPrefixAudioNow(audioData) {
+    const byteLength = ArrayBuffer.isView(audioData) ? audioData.byteLength : audioData.byteLength;
+    if (byteLength === 0) return;
+    const baseEncodingId = this.config.asrRequestConfig?.encoding || AudioEncoding.LINEAR16;
+    const prefixEncodingId = baseEncodingId + PREFIX_AUDIO_ENCODING_OFFSET;
+    const sampleRate = typeof this.config.asrRequestConfig?.sampleRate === "number" ? this.config.asrRequestConfig.sampleRate : SampleRate.RATE_16000;
+    this.log("debug", "Sending prefix audio", { bytes: byteLength, encoding: prefixEncodingId });
+    super.sendAudio(
+      audioData,
+      _RealTimeTwoWayWebSocketRecognitionClient.PROTOCOL_VERSION,
+      prefixEncodingId,
+      sampleRate
+    );
+  }
 };
 export {
   AudioEncoding,