@volley/recognition-client-sdk 0.1.211 → 0.1.255

package/dist/recog-client-sdk.browser.d.ts

@@ -1,2 +1,2 @@
-export { f as AudioEncoding, h as ControlSignal, G as GameContextV1, c as RealTimeTwoWayWebSocketRecognitionClient, a as RealTimeTwoWayWebSocketRecognitionClientConfig, g as RecognitionContextTypeV1, d as TranscriptionResult } from './browser-C4ZssGoU.js';
+export { h as AudioEncoding, k as ControlSignal, G as GameContextV1, e as RealTimeTwoWayWebSocketRecognitionClient, c as RealTimeTwoWayWebSocketRecognitionClientConfig, j as RecognitionContextTypeV1, f as TranscriptionResult } from './browser-BZs4BL_w.js';
 import 'zod';

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

@@ -19,6 +19,11 @@ var RecognitionMode;
   RecognitionMode2["STREAMING"] = "streaming";
   RecognitionMode2["BATCH"] = "batch";
 })(RecognitionMode || (RecognitionMode = {}));
+var ASRApiType;
+(function(ASRApiType2) {
+  ASRApiType2["STREAMING"] = "streaming";
+  ASRApiType2["FILE_BASED"] = "file-based";
+})(ASRApiType || (ASRApiType = {}));
 var DeepgramModel;
 (function(DeepgramModel2) {
   DeepgramModel2["NOVA_2"] = "nova-2";
@@ -82,6 +87,8 @@ var MetadataResultSchemaV1 = z.object({
   accumulatedAudioTimeMs: z.number().optional(),
   // Cost Information
   costInUSD: z.number().default(0).optional(),
+  // ASR API Type
+  apiType: z.nativeEnum(ASRApiType).optional(),
   // ASR configuration as JSON string (no type validation)
   asrConfig: z.string().optional(),
   // Raw ASR metadata payload as provided by the provider (stringified if needed)
@@ -94,6 +101,7 @@ var ErrorTypeV1;
   ErrorTypeV12["PROVIDER_ERROR"] = "provider_error";
   ErrorTypeV12["TIMEOUT_ERROR"] = "timeout_error";
   ErrorTypeV12["QUOTA_EXCEEDED"] = "quota_exceeded";
+  ErrorTypeV12["CONNECTION_ERROR"] = "connection_error";
   ErrorTypeV12["UNKNOWN_ERROR"] = "unknown_error";
 })(ErrorTypeV1 || (ErrorTypeV1 = {}));
 var ErrorResultSchemaV1 = z.object({
@@ -214,7 +222,27 @@ var TranscriptMessageSchema = z.object({
    * Whether this transcript is finalized (won't change)
    * @example true
    */
-  is_final: z.boolean()
+  is_final: z.boolean(),
+  /**
+   * Accumulated confirmed transcript (all finalized text received so far)
+   * Contains only the completed/finalized portions
+   * @example "hello world how are you"
+   */
+  confirmedTranscript: z.string().optional(),
+  /**
+   * New pending transcript (current interim text since last confirmation)
+   * Contains only the unconfirmed interim text
+   * @example "I'm doing"
+   */
+  newPendingTranscript: z.string().optional(),
+  /**
+   * Whether this is a fallback transcript (forced due to timeout)
+   * True when provider didn't send is_final=true within expected timeframe
+   * Used for monitoring/debugging fallback scenarios
+   * @example true
+   * @default false
+   */
+  is_fallback: z.boolean().optional()
 });
 var VADEndSignalSchema = z.object({
   type: z.literal(ProviderMessageType.VAD_END_SIGNAL),
@@ -302,7 +330,20 @@ var TimerSchema = z.object({
    * Total duration of all audio chunks sent to this provider session
    * @example 2500 (2.5 seconds of audio has been sent)
    */
-  accumulatedAudioTimeMs: z.number().optional()
+  accumulatedAudioTimeMs: z.number().optional(),
+  /**
+   * Estimated cost in USD for this session
+   * Calculated by the job based on audio duration and provider pricing
+   * @example 0.0025 (quarter of a cent)
+   */
+  costInUSD: z.number().optional().default(0),
+  /**
+   * ASR API type from the job
+   * - STREAMING: Real-time streaming APIs (Deepgram, AssemblyAI, Google)
+   * - FILE_BASED: File upload/batch APIs (OpenAI Batch, Gemini Batch)
+   * @example ASRApiType.STREAMING
+   */
+  apiType: z.nativeEnum(ASRApiType).optional()
 });
 var RawMessageSchema = z.object({
   type: z.literal(ProviderMessageType.RAW),
@@ -391,6 +432,16 @@ var QuotaExceededExceptionSchema = BaseRecognitionExceptionSchema.extend({
   /** How long to wait in seconds before retry */
   retryAfterSeconds: z.number().optional()
 });
+var ConnectionExceptionSchema = BaseRecognitionExceptionSchema.extend({
+  errorType: z.literal(ErrorTypeV1.CONNECTION_ERROR),
+  isImmediatelyAvailable: z.literal(true),
+  /** Number of connection attempts made */
+  attempts: z.number().optional(),
+  /** URL that failed to connect */
+  url: z.string().optional(),
+  /** Underlying error message */
+  underlyingError: z.string().optional()
+});
 var UnknownExceptionSchema = BaseRecognitionExceptionSchema.extend({
   errorType: z.literal(ErrorTypeV1.UNKNOWN_ERROR),
   isImmediatelyAvailable: z.literal(false),
@@ -405,6 +456,7 @@ z.discriminatedUnion("errorType", [
   ProviderExceptionSchema,
   TimeoutExceptionSchema,
   QuotaExceededExceptionSchema,
+  ConnectionExceptionSchema,
   UnknownExceptionSchema
 ]);
 var RecognitionContextTypeV1;
@@ -1178,8 +1230,16 @@ __name(getRecognitionServiceBase, "getRecognitionServiceBase");
 
 // src/utils/url-builder.ts
 function buildWebSocketUrl(config) {
-  const defaultBase = getRecognitionServiceBase("production");
-  const baseUrl = config.url || `${defaultBase.wsBase}/ws/v1/recognize`;
+  let baseUrl;
+  if (config.url) {
+    baseUrl = config.url;
+  } else if (config.stage) {
+    const stageBase = getRecognitionServiceBase(config.stage);
+    baseUrl = `${stageBase.wsBase}/ws/v1/recognize`;
+  } else {
+    const defaultBase = getRecognitionServiceBase("production");
+    baseUrl = `${defaultBase.wsBase}/ws/v1/recognize`;
+  }
   const url = new URL(baseUrl);
   url.searchParams.set("audioUtteranceId", config.audioUtteranceId);
   if (config.callbackUrls && config.callbackUrls.length > 0) {
@@ -1435,6 +1495,41 @@ var MessageHandler = class {
   }
 };
 
+// src/errors.ts
+var RecognitionError = class extends Error {
+  static {
+    __name(this, "RecognitionError");
+  }
+  errorType;
+  timestamp;
+  constructor(errorType, message) {
+    super(message);
+    this.name = "RecognitionError";
+    this.errorType = errorType;
+    this.timestamp = Date.now();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var ConnectionError = class extends RecognitionError {
+  static {
+    __name(this, "ConnectionError");
+  }
+  attempts;
+  url;
+  underlyingError;
+  constructor(message, attempts, url, underlyingError) {
+    super(ErrorTypeV1.CONNECTION_ERROR, message);
+    this.name = "ConnectionError";
+    this.attempts = attempts;
+    this.url = url;
+    if (underlyingError !== void 0) {
+      this.underlyingError = underlyingError;
+    }
+  }
+};
+
 // src/recognition-client.ts
 async function blobToArrayBuffer(blob) {
   if (typeof blob.arrayBuffer === "function") {
@@ -1472,6 +1567,9 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
       ...config.url && {
         url: config.url
       },
+      ...config.stage && {
+        stage: config.stage
+      },
       ...config.callbackUrls && {
         callbackUrls: config.callbackUrls
       },
@@ -1502,6 +1600,9 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
       highWM: config.highWaterMark ?? 512e3,
       lowWM: config.lowWaterMark ?? 128e3
     });
+    const retryConfig = config.connectionRetry || {};
+    const maxAttempts = Math.max(1, Math.min(5, retryConfig.maxAttempts ?? 4));
+    const delayMs = retryConfig.delayMs ?? 200;
     this.config = {
       url,
       audioUtteranceId,
@@ -1530,6 +1631,10 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
       lowWaterMark: config.lowWaterMark ?? 128e3,
       maxBufferDurationSec: config.maxBufferDurationSec ?? 60,
       chunksPerSecond: config.chunksPerSecond ?? 100,
+      connectionRetry: {
+        maxAttempts,
+        delayMs
+      },
       ...config.logger && {
         logger: config.logger
       }
@@ -1587,9 +1692,8 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
   // ==========================================================================
   async connect() {
     if (this.connectionPromise) {
-      this.log("debug", "Returning existing connection promise", {
-        state: this.state,
-        hasPromise: true
+      this.log("debug", "Returning existing connection promise (already connecting)", {
+        state: this.state
       });
       return this.connectionPromise;
     }
@@ -1599,43 +1703,97 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
       });
       return Promise.resolve();
     }
-    this.log("debug", "Creating new connection to WebSocket", {
-      url: this.config.url
-    });
-    this.state = ClientState.CONNECTING;
-    const connectionStartTime = Date.now();
-    this.connectionPromise = new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.log("warn", "Connection timeout", {
-          timeout: 1e4
-        });
-        this.state = ClientState.FAILED;
-        reject(new Error("Timeout"));
-      }, 1e4);
-      const originalOnConnected = this.onConnected.bind(this);
-      this.onConnected = () => {
-        clearTimeout(timeout);
-        const connectionTime = Date.now() - connectionStartTime;
-        this.log("debug", "Connection established successfully", {
-          connectionTimeMs: connectionTime,
-          url: this.config.url
-        });
-        this.state = ClientState.CONNECTED;
-        originalOnConnected();
-        resolve();
-      };
-      const originalOnError = this.onError.bind(this);
-      this.onError = (error) => {
-        clearTimeout(timeout);
-        this.log("warn", "Connection error", error);
-        this.state = ClientState.FAILED;
-        originalOnError(error);
-        reject(error);
-      };
-      super.connect();
-    });
+    this.connectionPromise = this.connectWithRetry();
     return this.connectionPromise;
   }
+  /**
+  * Attempt to connect with retry logic
+  * Only retries on initial connection establishment, not mid-stream interruptions
+  */
+  async connectWithRetry() {
+    const { maxAttempts, delayMs } = this.config.connectionRetry;
+    const connectionTimeout = 1e4;
+    let lastError;
+    const originalOnConnected = this.onConnected.bind(this);
+    const originalOnError = this.onError.bind(this);
+    try {
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const attemptLogLevel = attempt === 1 ? "debug" : "info";
+        this.log(attemptLogLevel, `Connection attempt ${attempt}/${maxAttempts}`, {
+          url: this.config.url,
+          delayMs: attempt > 1 ? delayMs : 0
+        });
+        this.state = ClientState.CONNECTING;
+        const connectionStartTime = Date.now();
+        try {
+          await new Promise((resolve, reject) => {
+            let settled = false;
+            const timeout = setTimeout(() => {
+              if (settled) return;
+              settled = true;
+              this.log("warn", "Connection timeout", {
+                timeout: connectionTimeout,
+                attempt
+              });
+              this.state = ClientState.FAILED;
+              reject(new Error(`Connection timeout after ${connectionTimeout}ms`));
+            }, connectionTimeout);
+            this.onConnected = () => {
+              if (settled) return;
+              settled = true;
+              clearTimeout(timeout);
+              const connectionTime = Date.now() - connectionStartTime;
+              this.log("debug", "Connection established successfully", {
+                connectionTimeMs: connectionTime,
+                url: this.config.url,
+                attempt
+              });
+              this.state = ClientState.CONNECTED;
+              originalOnConnected();
+              resolve();
+            };
+            this.onError = (error) => {
+              if (settled) return;
+              settled = true;
+              clearTimeout(timeout);
+              this.log("warn", "Connection error", {
+                error,
+                attempt
+              });
+              this.state = ClientState.FAILED;
+              reject(error);
+            };
+            super.connect();
+          });
+          const successLogLevel = attempt === 1 ? "debug" : "info";
+          this.log(successLogLevel, `Connection successful on attempt ${attempt}`, {
+            totalAttempts: attempt
+          });
+          return;
+        } catch (error) {
+          lastError = error;
+          if (attempt < maxAttempts) {
+            const logLevel = attempt < 3 ? "info" : "warn";
+            this.log(logLevel, `Connection attempt ${attempt} failed, retrying after ${delayMs}ms`, {
+              error: lastError.message,
+              nextAttempt: attempt + 1
+            });
+            this.state = ClientState.INITIAL;
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+          } else {
+            this.log("warn", `All ${maxAttempts} connection attempts failed`, {
+              error: lastError.message
+            });
+          }
+        }
+      }
+      throw new ConnectionError(`Failed to establish connection after ${maxAttempts} attempts`, maxAttempts, this.config.url, lastError);
+    } finally {
+      this.onConnected = originalOnConnected;
+      this.onError = originalOnError;
+      this.connectionPromise = void 0;
+    }
+  }
   sendAudio(audioData) {
     if (audioData instanceof Blob) {
       blobToArrayBuffer(audioData).then((arrayBuffer) => {
@@ -1710,6 +1868,9 @@ var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRec
   getAudioUtteranceId() {
     return this.config.audioUtteranceId;
   }
+  getUrl() {
+    return this.config.url;
+  }
   getState() {
     return this.state;
   }