@deepgram/sdk 5.4.0 → 5.5.0

package/dist/browser/index.global.js

@@ -130,9 +130,9 @@ var Deepgram = (() => {
     }
   });
 
-  // node_modules/.pnpm/ws@8.20.1/node_modules/ws/browser.js
+  // node_modules/.pnpm/ws@8.21.0/node_modules/ws/browser.js
   var require_browser = __commonJS({
-    "node_modules/.pnpm/ws@8.20.1/node_modules/ws/browser.js"(exports, module) {
+    "node_modules/.pnpm/ws@8.21.0/node_modules/ws/browser.js"(exports, module) {
       "use strict";
       module.exports = function() {
         throw new Error(
@@ -182,6 +182,7 @@ var Deepgram = (() => {
     ListenV1VadEvents: () => ListenV1VadEvents,
     ListenV2Encoding: () => ListenV2Encoding,
     ListenV2Model: () => ListenV2Model,
+    ListenV2ProfanityFilter: () => ListenV2ProfanityFilter,
     OpenAiSpeakProvider: () => OpenAiSpeakProvider,
     OpenAiThinkProvider: () => OpenAiThinkProvider,
     SpeakV1Encoding: () => SpeakV1Encoding,
@@ -227,6 +228,7 @@ var Deepgram = (() => {
     ListenV1VadEvents: () => ListenV1VadEvents,
     ListenV2Encoding: () => ListenV2Encoding,
     ListenV2Model: () => ListenV2Model,
+    ListenV2ProfanityFilter: () => ListenV2ProfanityFilter,
     OpenAiSpeakProvider: () => OpenAiSpeakProvider,
     OpenAiThinkProvider: () => OpenAiThinkProvider,
     SpeakV1Encoding: () => SpeakV1Encoding,
@@ -264,7 +266,7 @@ var Deepgram = (() => {
       if (Error.captureStackTrace) {
         Error.captureStackTrace(this, this.constructor);
       }
-      this.name = this.constructor.name;
+      this.name = "DeepgramError";
       this.statusCode = statusCode;
       this.body = body;
       this.rawResponse = rawResponse;
@@ -299,7 +301,7 @@ var Deepgram = (() => {
       if (Error.captureStackTrace) {
         Error.captureStackTrace(this, this.constructor);
       }
-      this.name = this.constructor.name;
+      this.name = "DeepgramTimeoutError";
       if ((opts == null ? void 0 : opts.cause) != null) {
         this.cause = opts.cause;
       }
@@ -319,7 +321,7 @@ var Deepgram = (() => {
       if (Error.captureStackTrace) {
         Error.captureStackTrace(this, this.constructor);
       }
-      this.name = this.constructor.name;
+      this.name = "BadRequestError";
     }
   };
 
@@ -433,6 +435,7 @@ var Deepgram = (() => {
   // src/api/resources/listen/index.ts
   var listen_exports = {};
   __export(listen_exports, {
+    DiarizeModel: () => DiarizeModel,
     ListenV1CloseStream: () => ListenV1CloseStream,
     ListenV1Finalize: () => ListenV1Finalize,
     ListenV1KeepAlive: () => ListenV1KeepAlive,
@@ -445,6 +448,7 @@ var Deepgram = (() => {
   // src/api/resources/listen/resources/v1/index.ts
   var v1_exports3 = {};
   __export(v1_exports3, {
+    DiarizeModel: () => DiarizeModel,
     ListenV1CloseStream: () => ListenV1CloseStream,
     ListenV1Finalize: () => ListenV1Finalize,
     ListenV1KeepAlive: () => ListenV1KeepAlive,
@@ -552,6 +556,12 @@ var Deepgram = (() => {
     Latest: "latest"
   };
 
+  // src/api/resources/listen/resources/v1/types/DiarizeModel.ts
+  var DiarizeModel = {
+    Latest: "latest",
+    V1: "v1"
+  };
+
   // src/api/resources/listen/resources/v1/types/ListenV1CloseStream.ts
   var ListenV1CloseStream;
   ((ListenV1CloseStream2) => {
@@ -593,8 +603,10 @@ var Deepgram = (() => {
   var ListenV2CloseStream;
   ((ListenV2CloseStream2) => {
     ListenV2CloseStream2.Type = {
+      /** @deprecated Use "CloseStream". Retained for backward compatibility. */
       Finalize: "Finalize",
       CloseStream: "CloseStream",
+      /** @deprecated Use "CloseStream". Retained for backward compatibility. */
       KeepAlive: "KeepAlive"
     };
   })(ListenV2CloseStream || (ListenV2CloseStream = {}));
@@ -1421,6 +1433,12 @@ var Deepgram = (() => {
     FluxGeneralMulti: "flux-general-multi"
   };
 
+  // src/api/types/ListenV2ProfanityFilter.ts
+  var ListenV2ProfanityFilter = {
+    True: "true",
+    False: "false"
+  };
+
   // src/api/types/OpenAiSpeakProvider.ts
   var OpenAiSpeakProvider;
   ((OpenAiSpeakProvider2) => {
@@ -1543,6 +1561,11 @@ var Deepgram = (() => {
     FortyEightThousand: "48000"
   };
 
+  // src/core/auth/AuthProvider.ts
+  function isAuthProvider(value) {
+    return typeof value === "object" && value !== null && "getAuthRequest" in value && typeof value.getAuthRequest === "function";
+  }
+
   // src/core/auth/NoOpAuthProvider.ts
   var NoOpAuthProvider = class {
     getAuthRequest() {
@@ -1787,6 +1810,14 @@ var Deepgram = (() => {
   }
 
   // src/core/fetcher/getResponseBody.ts
+  function retainResponse(target, response) {
+    Object.defineProperty(target, "__fern_response_ref", {
+      value: response,
+      enumerable: false,
+      configurable: true,
+      writable: false
+    });
+  }
   function getResponseBody(response, responseType) {
     return __async(this, null, function* () {
       switch (responseType) {
@@ -1806,6 +1837,7 @@ var Deepgram = (() => {
               }
             };
           }
+          retainResponse(response.body, response);
           return response.body;
         case "streaming":
           if (response.body == null) {
@@ -1817,6 +1849,7 @@ var Deepgram = (() => {
               }
             };
           }
+          retainResponse(response.body, response);
           return response.body;
         case "text":
           return yield response.text();
@@ -1984,11 +2017,15 @@ var Deepgram = (() => {
     for (const signal of signals) {
       if (signal.aborted) {
         controller.abort(signal == null ? void 0 : signal.reason);
-        break;
+        return controller.signal;
       }
       signal.addEventListener("abort", () => controller.abort(signal == null ? void 0 : signal.reason), {
         signal: controller.signal
       });
+      if (signal.aborted) {
+        controller.abort(signal == null ? void 0 : signal.reason);
+        return controller.signal;
+      }
     }
     return controller.signal;
   }
@@ -2067,6 +2104,9 @@ var Deepgram = (() => {
   var MAX_RETRY_DELAY = 6e4;
   var DEFAULT_MAX_RETRIES = 2;
   var JITTER_FACTOR = 0.2;
+  function isRetryableStatusCode(statusCode) {
+    return [408, 429].includes(statusCode) || statusCode >= 500;
+  }
   function addPositiveJitter(delay) {
     const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR;
     return delay * jitterMultiplier;
@@ -2106,7 +2146,7 @@ var Deepgram = (() => {
     return __async(this, arguments, function* (requestFn, maxRetries = DEFAULT_MAX_RETRIES) {
       let response = yield requestFn();
       for (let i = 0; i < maxRetries; ++i) {
-        if ([408, 429].includes(response.status) || response.status >= 500) {
+        if (isRetryableStatusCode(response.status)) {
           const delay = getRetryDelayFromHeaders(response, i);
           yield new Promise((resolve) => setTimeout(resolve, delay));
           response = yield requestFn();
@@ -3499,6 +3539,7 @@ var Deepgram = (() => {
   var PARAM_KEY = "apiKey";
   var ENV_HEADER_KEY = "DEEPGRAM_API_KEY";
   var HEADER_NAME = "Authorization";
+  var HEADER_PREFIX = "Token ";
   var HeaderAuthProvider = class _HeaderAuthProvider {
     constructor(options) {
       this.options = options;
@@ -3519,7 +3560,7 @@ var Deepgram = (() => {
           });
         }
         return {
-          headers: { [HEADER_NAME]: headerValue }
+          headers: { [HEADER_NAME]: `${HEADER_PREFIX}${headerValue}` }
         };
       });
     }
@@ -3557,14 +3598,17 @@ var Deepgram = (() => {
     return result;
   }
 
+  // src/version.ts
+  var SDK_VERSION = "5.5.0";
+
   // src/BaseClient.ts
   function normalizeClientOptions(options) {
     const headers = mergeHeaders(
       {
         "X-Fern-Language": "JavaScript",
         "X-Fern-SDK-Name": "@deepgram/sdk",
-        "X-Fern-SDK-Version": "5.2.1",
-        "User-Agent": "@deepgram/sdk/5.2.1",
+        "X-Fern-SDK-Version": SDK_VERSION,
+        "User-Agent": `@deepgram/sdk/${SDK_VERSION}`,
         "X-Fern-Runtime": RUNTIME.type,
         "X-Fern-Runtime-Version": RUNTIME.version
       },
@@ -3578,6 +3622,21 @@ var Deepgram = (() => {
   function normalizeClientOptionsWithAuth(options) {
     var _a;
     const normalized = normalizeClientOptions(options);
+    if (options.auth === false) {
+      normalized.authProvider = new NoOpAuthProvider();
+      return normalized;
+    }
+    if (options.auth != null) {
+      if (typeof options.auth === "function") {
+        normalized.authProvider = { getAuthRequest: options.auth };
+        return normalized;
+      }
+      if (isAuthProvider(options.auth)) {
+        normalized.authProvider = options.auth;
+        return normalized;
+      }
+      Object.assign(normalized, options.auth);
+    }
     const normalizedWithNoOpAuthProvider = withNoOpAuthProvider(normalized);
     (_a = normalized.authProvider) != null ? _a : normalized.authProvider = new HeaderAuthProvider(normalizedWithNoOpAuthProvider);
     return normalized;
@@ -4445,6 +4504,7 @@ var Deepgram = (() => {
           channels,
           detect_entities: detectEntities,
           diarize,
+          diarize_model: diarizeModel,
           dictation,
           encoding,
           endpointing,
@@ -4482,6 +4542,7 @@ var Deepgram = (() => {
           channels: channels != null ? typeof channels === "string" ? channels : toJson(channels) : void 0,
           detect_entities: detectEntities != null ? detectEntities : void 0,
           diarize: diarize != null ? diarize : void 0,
+          diarize_model: diarizeModel != null ? diarizeModel : void 0,
           dictation: dictation != null ? dictation : void 0,
           encoding: encoding != null ? encoding : void 0,
           endpointing: endpointing != null ? typeof endpointing === "string" ? endpointing : toJson(endpointing) : void 0,
@@ -4659,6 +4720,7 @@ var Deepgram = (() => {
           eot_timeout_ms: eotTimeoutMs,
           keyterm,
           language_hint: languageHint,
+          profanity_filter: profanityFilter,
           mip_opt_out: mipOptOut,
           tag,
           protocols,
@@ -4678,6 +4740,7 @@ var Deepgram = (() => {
           eot_timeout_ms: eotTimeoutMs != null ? typeof eotTimeoutMs === "string" ? eotTimeoutMs : toJson(eotTimeoutMs) : void 0,
           keyterm: Array.isArray(keyterm) ? keyterm.map((item) => typeof item === "string" ? item : toJson(item)) : keyterm != null ? typeof keyterm === "string" ? keyterm : toJson(keyterm) : void 0,
           language_hint: Array.isArray(languageHint) ? languageHint.map((item) => typeof item === "string" ? item : toJson(item)) : languageHint != null ? typeof languageHint === "string" ? languageHint : toJson(languageHint) : void 0,
+          profanity_filter: profanityFilter != null ? profanityFilter : void 0,
           mip_opt_out: mipOptOut != null ? typeof mipOptOut === "string" ? mipOptOut : toJson(mipOptOut) : void 0,
           tag: tag != null ? typeof tag === "string" ? tag : toJson(tag) : void 0
         };
@@ -8612,6 +8675,7 @@ var Deepgram = (() => {
   var WEBSOCKET_OPTION_KEYS = /* @__PURE__ */ new Set([
     "Authorization",
     "headers",
+    "protocols",
     "debug",
     "reconnectAttempts",
     "connectionTimeoutInSeconds",
@@ -8698,14 +8762,18 @@ var Deepgram = (() => {
   };
   var CustomDeepgramClient = class extends DeepgramClient {
     constructor(options = {}) {
+      var _a;
       const sessionId = generateUUID();
+      const reconnect = (_a = options.reconnect) != null ? _a : options.transportFactory == null;
       const optionsWithSessionId = __spreadProps(__spreadValues({}, options), {
+        reconnect,
         headers: __spreadProps(__spreadValues({}, options.headers), {
           "x-deepgram-session-id": sessionId
         })
       });
       super(optionsWithSessionId);
       this._sessionId = sessionId;
+      this._reconnect = reconnect;
       this._options.authProvider = new ApiKeyAuthProviderWrapper(this._options.authProvider);
       if (options.accessToken != null) {
         this._options.authProvider = new AccessTokenAuthProviderWrapper(
@@ -8720,6 +8788,16 @@ var Deepgram = (() => {
     get sessionId() {
       return this._sessionId;
     }
+    /**
+     * Whether the SDK will retry streaming connections at the wrapper level
+     * after a transport-side failure. Returns `false` when a `transportFactory`
+     * was supplied without an explicit `reconnect: true` override, signalling
+     * that the custom transport is expected to manage its own reconnect
+     * lifecycle.
+     */
+    get reconnect() {
+      return this._reconnect;
+    }
     /**
      * Override the agent getter to return a wrapped client that ensures
      * the custom websocket implementation is used.
@@ -8796,13 +8874,353 @@ var Deepgram = (() => {
     }
     return result;
   }
-  function getWebSocketOptions(headers) {
+  function normalizeProtocols(protocols) {
+    if (protocols == null) {
+      return [];
+    }
+    return Array.isArray(protocols) ? protocols : [protocols];
+  }
+  function stringifyHeaders(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+      result[key] = String(value);
+    }
+    return result;
+  }
+  function buildWebSocketUrl(url, queryParams) {
+    const queryString = url_exports.toQueryString(queryParams, { arrayFormat: "repeat" });
+    return queryString ? `${url}?${queryString}` : url;
+  }
+  function getTransportFactory(options) {
+    return options.transportFactory;
+  }
+  function getReconnect(options) {
+    return options.reconnect !== false;
+  }
+  var TransportWebSocketAdapter = class {
+    constructor(args) {
+      this._listeners = {
+        error: [],
+        message: [],
+        open: [],
+        close: []
+      };
+      this._retryCount = -1;
+      this._shouldReconnect = true;
+      this._connectLock = false;
+      this._binaryType = "blob";
+      this._closeCalled = false;
+      this._messageQueue = [];
+      this.CONNECTING = ReconnectingWebSocket.CONNECTING;
+      this.OPEN = ReconnectingWebSocket.OPEN;
+      this.CLOSING = ReconnectingWebSocket.CLOSING;
+      this.CLOSED = ReconnectingWebSocket.CLOSED;
+      this.onclose = null;
+      this.onerror = null;
+      this.onmessage = null;
+      this.onopen = null;
+      this._handleAbort = () => {
+        if (this._closeCalled) {
+          return;
+        }
+        this._debug("abort signal fired");
+        this._closeCalled = true;
+        this._shouldReconnect = false;
+        this._clearConnectTimeout();
+        const transport = this._transport;
+        this._transport = void 0;
+        this._setTransportHandle(void 0);
+        if (transport) {
+          void transport.close(1e3, "aborted");
+        }
+        this._readyState = ReconnectingWebSocket.ReadyState.CLOSED;
+        this._emitClose(1e3, "aborted");
+      };
+      this._factory = args.factory;
+      this._request = args.request;
+      this._reconnect = args.reconnect !== false;
+      this._readyState = args.startClosed ? ReconnectingWebSocket.ReadyState.CLOSED : ReconnectingWebSocket.ReadyState.CONNECTING;
+      if (this._request.abortSignal) {
+        this._request.abortSignal.addEventListener("abort", this._handleAbort, { once: true });
+      }
+      if (!args.startClosed) {
+        void this._connect();
+      }
+    }
+    get binaryType() {
+      return this._binaryType;
+    }
+    set binaryType(value) {
+      this._binaryType = value;
+    }
+    get retryCount() {
+      return Math.max(this._retryCount, 0);
+    }
+    get bufferedAmount() {
+      return this._messageQueue.reduce((acc, message) => {
+        if (typeof message === "string") {
+          return acc + message.length;
+        }
+        if (message instanceof Blob) {
+          return acc + message.size;
+        }
+        return acc + message.byteLength;
+      }, 0);
+    }
+    get extensions() {
+      return "";
+    }
+    get protocol() {
+      var _a;
+      return (_a = this._request.protocols[0]) != null ? _a : "";
+    }
+    get readyState() {
+      return this._readyState;
+    }
+    get url() {
+      return this._request.url;
+    }
+    close(code = 1e3, reason) {
+      this._closeCalled = true;
+      this._shouldReconnect = false;
+      this._clearConnectTimeout();
+      this._readyState = ReconnectingWebSocket.ReadyState.CLOSING;
+      const transport = this._transport;
+      this._transport = void 0;
+      this._setTransportHandle(void 0);
+      if (!transport) {
+        this._readyState = ReconnectingWebSocket.ReadyState.CLOSED;
+        return;
+      }
+      void transport.close(code, reason);
+      this._readyState = ReconnectingWebSocket.ReadyState.CLOSED;
+    }
+    reconnect(code, reason) {
+      this._shouldReconnect = true;
+      this._closeCalled = false;
+      this._retryCount = -1;
+      this._readyState = ReconnectingWebSocket.ReadyState.CONNECTING;
+      const transport = this._transport;
+      this._transport = void 0;
+      this._setTransportHandle(void 0);
+      if (transport) {
+        void transport.close(code, reason);
+      }
+      void this._connect();
+    }
+    send(data) {
+      var _a;
+      if ((_a = this._transport) == null ? void 0 : _a.isOpen()) {
+        void this._transport.send(data);
+        return;
+      }
+      this._messageQueue.push(data);
+    }
+    addEventListener(type, listener) {
+      if (this._listeners[type]) {
+        this._listeners[type].push(listener);
+      }
+    }
+    dispatchEvent(event) {
+      const listeners = this._listeners[event.type];
+      if (listeners) {
+        for (const listener of listeners) {
+          this._callEventListener(event, listener);
+        }
+      }
+      return true;
+    }
+    removeEventListener(type, listener) {
+      if (this._listeners[type]) {
+        this._listeners[type] = this._listeners[type].filter((registered) => registered !== listener);
+      }
+    }
+    _debug(...args) {
+      if (this._request.debug) {
+        console.log.apply(console, ["DG-TRANSPORT>", ...args]);
+      }
+    }
+    _connect() {
+      return __async(this, null, function* () {
+        var _a, _b;
+        if (this._connectLock || !this._shouldReconnect || ((_a = this._request.abortSignal) == null ? void 0 : _a.aborted)) {
+          return;
+        }
+        if (!this._reconnect && this._retryCount >= 0) {
+          this._debug("reconnect disabled, skipping retry");
+          return;
+        }
+        if (this._retryCount >= this._request.reconnectAttempts) {
+          this._debug("max retries reached", this._retryCount, ">=", this._request.reconnectAttempts);
+          return;
+        }
+        this._connectLock = true;
+        this._retryCount++;
+        this._readyState = ReconnectingWebSocket.ReadyState.CONNECTING;
+        this._clearConnectTimeout();
+        try {
+          const transport = yield this._factory(this._request.url, this._request.headers, this._request);
+          if (this._closeCalled || ((_b = this._request.abortSignal) == null ? void 0 : _b.aborted)) {
+            this._connectLock = false;
+            yield transport.close(1e3, "aborted");
+            return;
+          }
+          this._transport = transport;
+          this._setTransportHandle(transport);
+          this._bindTransport(transport);
+          this._armConnectTimeout();
+          this._connectLock = false;
+          if (transport.isOpen()) {
+            this._handleOpen(transport);
+          }
+        } catch (error) {
+          this._connectLock = false;
+          this._handleError(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+    }
+    _bindTransport(transport) {
+      transport.onOpen(() => {
+        if (this._transport !== transport) {
+          return;
+        }
+        this._handleOpen(transport);
+      });
+      transport.onMessage((message) => {
+        if (this._transport !== transport) {
+          return;
+        }
+        this._handleMessage(message);
+      });
+      transport.onError((error) => {
+        if (this._transport !== transport) {
+          return;
+        }
+        this._handleError(error);
+      });
+      transport.onClose((event) => {
+        var _a, _b;
+        if (this._transport !== transport) {
+          return;
+        }
+        this._handleClose((_a = event.code) != null ? _a : 1e3, (_b = event.reason) != null ? _b : "");
+      });
+    }
+    _armConnectTimeout() {
+      const timeoutMs = this._request.connectionTimeoutInSeconds != null ? this._request.connectionTimeoutInSeconds * 1e3 : DEFAULT_CONNECTION_TIMEOUT_MS;
+      this._connectTimeout = setTimeout(() => {
+        this._handleError(new Error("TIMEOUT"));
+      }, timeoutMs);
+    }
+    _clearConnectTimeout() {
+      if (this._connectTimeout != null) {
+        clearTimeout(this._connectTimeout);
+        this._connectTimeout = void 0;
+      }
+    }
+    _handleOpen(transport) {
+      if (this._transport !== transport || this._readyState === ReconnectingWebSocket.ReadyState.OPEN) {
+        return;
+      }
+      this._debug("open event");
+      this._clearConnectTimeout();
+      this._readyState = ReconnectingWebSocket.ReadyState.OPEN;
+      const queued = [...this._messageQueue];
+      this._messageQueue = [];
+      for (const message of queued) {
+        void transport.send(message);
+      }
+      const event = new Event("open", this);
+      if (this.onopen) {
+        this.onopen(event);
+      }
+      this._listeners.open.forEach((listener) => this._callEventListener(event, listener));
+    }
+    _handleMessage(message) {
+      const event = { type: "message", data: message, target: this };
+      if (this.onmessage) {
+        this.onmessage(event);
+      }
+      this._listeners.message.forEach((listener) => this._callEventListener(event, listener));
+    }
+    _handleError(error) {
+      this._debug("error event", error.message);
+      this._clearConnectTimeout();
+      this._readyState = ReconnectingWebSocket.ReadyState.CLOSED;
+      const event = new ErrorEvent(error, this);
+      if (this.onerror) {
+        this.onerror(event);
+      }
+      this._listeners.error.forEach((listener) => this._callEventListener(event, listener));
+      const transport = this._transport;
+      this._transport = void 0;
+      this._setTransportHandle(void 0);
+      if (transport) {
+        void transport.close(1011, error.message);
+      }
+      if (this._shouldReconnect && !this._closeCalled) {
+        void this._connect();
+      }
+    }
+    _handleClose(code, reason) {
+      this._debug("close event", code, reason);
+      this._clearConnectTimeout();
+      this._transport = void 0;
+      this._readyState = ReconnectingWebSocket.ReadyState.CLOSED;
+      this._setTransportHandle(void 0);
+      if (code === 1e3) {
+        this._shouldReconnect = false;
+      }
+      this._emitClose(code, reason);
+      if (this._shouldReconnect && !this._closeCalled) {
+        void this._connect();
+      }
+    }
+    _emitClose(code, reason) {
+      const event = new CloseEvent(code, reason, this);
+      if (this.onclose) {
+        this.onclose(event);
+      }
+      this._listeners.close.forEach((listener) => this._callEventListener(event, listener));
+    }
+    _setTransportHandle(transport) {
+      if (!transport) {
+        this._ws = void 0;
+        return;
+      }
+      this._ws = {
+        OPEN: this.OPEN,
+        get readyState() {
+          return transport.isOpen() ? ReconnectingWebSocket.ReadyState.OPEN : ReconnectingWebSocket.ReadyState.CLOSED;
+        },
+        ping: transport.ping ? (data) => {
+          var _a;
+          void ((_a = transport.ping) == null ? void 0 : _a.call(transport, data));
+        } : void 0
+      };
+    }
+    _callEventListener(event, listener) {
+      if (typeof listener === "object" && listener && "handleEvent" in listener) {
+        listener.handleEvent(event);
+      } else {
+        listener(event);
+      }
+    }
+  };
+  TransportWebSocketAdapter.CONNECTING = ReconnectingWebSocket.CONNECTING;
+  TransportWebSocketAdapter.OPEN = ReconnectingWebSocket.OPEN;
+  TransportWebSocketAdapter.CLOSING = ReconnectingWebSocket.CLOSING;
+  TransportWebSocketAdapter.CLOSED = ReconnectingWebSocket.CLOSED;
+  function getWebSocketOptions(headers, requestedProtocols) {
     const options = {};
     const isBrowser = RUNTIME.type === "browser" || RUNTIME.type === "web-worker";
     const sessionIdHeader = headers["x-deepgram-session-id"] || headers["X-Deepgram-Session-Id"];
     if (RUNTIME.type === "node" && NodeWebSocket2) {
       options.WebSocket = NodeWebSocket2;
       options.headers = headers;
+      if (requestedProtocols.length > 0) {
+        options.protocols = requestedProtocols;
+      }
     } else if (isBrowser) {
       const authHeader = headers.Authorization || headers.authorization;
       const browserHeaders = __spreadValues({}, headers);
@@ -8811,7 +9229,7 @@ var Deepgram = (() => {
       delete browserHeaders["x-deepgram-session-id"];
       delete browserHeaders["X-Deepgram-Session-Id"];
       options.headers = browserHeaders;
-      const protocols = [];
+      const protocols = [...requestedProtocols];
       if (authHeader && typeof authHeader === "string") {
         if (authHeader.startsWith("Token ")) {
           const apiKey = authHeader.substring(6);
@@ -8831,6 +9249,9 @@ var Deepgram = (() => {
       }
     } else {
       options.headers = headers;
+      if (requestedProtocols.length > 0) {
+        options.protocols = requestedProtocols;
+      }
     }
     return options;
   }
@@ -8884,6 +9305,8 @@ var Deepgram = (() => {
       urlPath,
       environmentKey,
       queryParams,
+      protocols,
+      service,
       headers,
       debug,
       reconnectAttempts,
@@ -8895,10 +9318,35 @@ var Deepgram = (() => {
       const authRequest = yield (_a = options.authProvider) == null ? void 0 : _a.getAuthRequest();
       const mergedHeaders = mergeHeaders((_b = options.headers) != null ? _b : {}, (_c = authRequest == null ? void 0 : authRequest.headers) != null ? _c : {}, headers);
       const _headers = yield resolveHeaders(mergedHeaders);
-      const wsOptions = getWebSocketOptions(_headers);
+      const normalizedProtocols = normalizeProtocols(protocols);
       const baseUrl = (_e = yield Supplier.get(options.baseUrl)) != null ? _e : ((_d = yield Supplier.get(options.environment)) != null ? _d : DeepgramEnvironment.Production)[environmentKey];
+      const url = url_exports.join(baseUrl, urlPath);
+      const fullUrl = buildWebSocketUrl(url, queryParams);
+      const transportFactory = getTransportFactory(options);
+      const reconnect = getReconnect(options);
+      if (transportFactory) {
+        const request = {
+          url: fullUrl,
+          headers: stringifyHeaders(_headers),
+          protocols: normalizedProtocols,
+          path: urlPath,
+          service,
+          queryParams,
+          debug: debug != null ? debug : false,
+          reconnectAttempts: reconnectAttempts != null ? reconnectAttempts : 30,
+          connectionTimeoutInSeconds,
+          abortSignal
+        };
+        return new TransportWebSocketAdapter({
+          factory: transportFactory,
+          request,
+          startClosed: true,
+          reconnect
+        });
+      }
+      const wsOptions = getWebSocketOptions(_headers, normalizedProtocols);
       return new ReconnectingWebSocket({
-        url: url_exports.join(baseUrl, urlPath),
+        url,
         protocols: (_f = wsOptions.protocols) != null ? _f : [],
         queryParameters: queryParams,
         headers: wsOptions.headers,
@@ -8916,12 +9364,14 @@ var Deepgram = (() => {
   var WrappedAgentV1Client = class extends V1Client {
     connect() {
       return __async(this, arguments, function* (args = {}) {
-        const { headers, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal } = args;
+        const { headers, protocols, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal } = args;
         const socket = yield createWebSocketConnection({
           options: this._options,
           urlPath: "/v1/agent/converse",
           environmentKey: "agent",
           queryParams: buildQueryParams(args),
+          protocols,
+          service: "agent.v1",
           headers,
           debug,
           reconnectAttempts,
@@ -8975,12 +9425,14 @@ var Deepgram = (() => {
   var WrappedListenV1Client = class extends V1Client3 {
     connect(args) {
       return __async(this, null, function* () {
-        const { headers, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal } = args;
+        const { headers, protocols, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal } = args;
         const socket = yield createWebSocketConnection({
           options: this._options,
           urlPath: "/v1/listen",
           environmentKey: "production",
           queryParams: buildQueryParams(args),
+          protocols,
+          service: "listen.v1",
           headers,
           debug,
           reconnectAttempts,
@@ -9034,12 +9486,14 @@ var Deepgram = (() => {
   var WrappedListenV2Client = class extends V2Client {
     connect(args) {
       return __async(this, null, function* () {
-        const { headers, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal } = args;
+        const { headers, protocols, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal } = args;
         const socket = yield createWebSocketConnection({
           options: this._options,
           urlPath: "/v2/listen",
           environmentKey: "production",
           queryParams: buildQueryParams(args),
+          protocols,
+          service: "listen.v2",
           headers,
           debug,
           reconnectAttempts,
@@ -9119,12 +9573,14 @@ var Deepgram = (() => {
   var WrappedSpeakV1Client = class extends V1Client7 {
     connect(args) {
       return __async(this, null, function* () {
-        const { headers, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal } = args;
+        const { headers, protocols, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal } = args;
         const socket = yield createWebSocketConnection({
           options: this._options,
           urlPath: "/v1/speak",
           environmentKey: "production",
           queryParams: buildQueryParams(args),
+          protocols,
+          service: "speak.v1",
           headers,
           debug,
           reconnectAttempts,