@deepgram/sdk 5.0.0-alpha.2 → 5.0.0-beta.1

package/dist/esm/CustomClient.mjs

@@ -20,11 +20,13 @@ import { V1Socket as AgentV1Socket } from "./api/resources/agent/resources/v1/cl
 import { V1Socket as ListenV1Socket } from "./api/resources/listen/resources/v1/client/Socket.mjs";
 import { V2Socket as ListenV2Socket } from "./api/resources/listen/resources/v2/client/Socket.mjs";
 import { V1Socket as SpeakV1Socket } from "./api/resources/speak/resources/v1/client/Socket.mjs";
-import { mergeHeaders, mergeOnlyDefinedHeaders } from "./core/headers.mjs";
+import { mergeHeaders } from "./core/headers.mjs";
 import { fromJson } from "./core/json.mjs";
 import * as core from "./core/index.mjs";
 import * as environments from "./environments.mjs";
 import { RUNTIME } from "./core/runtime/index.mjs";
+// Default WebSocket connection timeout in milliseconds
+const DEFAULT_CONNECTION_TIMEOUT_MS = 10000;
 // Import ws library for Node.js (will be undefined in browser)
 let NodeWebSocket;
 try {
@@ -37,13 +39,108 @@ catch (_a) {
     // ws not available (e.g., in browser)
     NodeWebSocket = undefined;
 }
+// Helper function to generate UUID that works in both Node.js and browser
+function generateUUID() {
+    // Try global crypto.randomUUID first (works in both Node.js 14.18+ and modern browsers)
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return crypto.randomUUID();
+    }
+    // Fallback for Node.js: use the crypto module
+    if (RUNTIME.type === "node") {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const nodeCrypto = require("crypto");
+            return nodeCrypto.randomUUID();
+        }
+        catch (_a) {
+            // Fallback if crypto module is not available
+        }
+    }
+    // Final fallback: manual UUID generation (RFC4122 version 4)
+    // This should work everywhere but is less secure than crypto.randomUUID()
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Wrapper auth provider that adds "Token " prefix to API keys.
+ * The auto-generated HeaderAuthProvider doesn't add the prefix, so we wrap it here.
+ */
+class ApiKeyAuthProviderWrapper {
+    constructor(originalProvider) {
+        this.originalProvider = originalProvider;
+    }
+    getAuthRequest(arg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const authRequest = yield this.originalProvider.getAuthRequest(arg);
+            const authHeader = ((_a = authRequest.headers) === null || _a === void 0 ? void 0 : _a.Authorization) || ((_b = authRequest.headers) === null || _b === void 0 ? void 0 : _b.authorization);
+            // If the header doesn't already have a scheme prefix, add "Token " prefix for API keys
+            if (authHeader && typeof authHeader === "string") {
+                // Only add prefix if it doesn't already have Bearer or Token prefix
+                if (!authHeader.startsWith("Bearer ") && !authHeader.startsWith("Token ") && !authHeader.startsWith("token ")) {
+                    return {
+                        headers: Object.assign(Object.assign({}, authRequest.headers), { Authorization: `Token ${authHeader}` }),
+                    };
+                }
+            }
+            return authRequest;
+        });
+    }
+}
+/**
+ * Wrapper auth provider that checks for accessToken first (Bearer scheme)
+ * before falling back to the original auth provider (Token scheme for API keys).
+ */
+class AccessTokenAuthProviderWrapper {
+    constructor(originalProvider, accessToken) {
+        this.originalProvider = originalProvider;
+        this.accessToken = accessToken;
+    }
+    getAuthRequest(arg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Check for access token first (highest priority)
+            // Access tokens use Bearer scheme, API keys use Token scheme
+            const accessToken = (_a = (yield core.Supplier.get(this.accessToken))) !== null && _a !== void 0 ? _a : (_b = process.env) === null || _b === void 0 ? void 0 : _b.DEEPGRAM_ACCESS_TOKEN;
+            if (accessToken != null) {
+                return {
+                    headers: { Authorization: `Bearer ${accessToken}` },
+                };
+            }
+            // Fall back to original provider (which handles API keys)
+            return this.originalProvider.getAuthRequest(arg);
+        });
+    }
+}
 /**
  * Custom wrapper around DeepgramClient that ensures the custom websocket implementation
  * from ws.ts is always used, even if the auto-generated code changes.
  */
 export class CustomDeepgramClient extends DeepgramClient {
     constructor(options = {}) {
-        super(options);
+        // Generate a UUID for the session ID
+        const sessionId = generateUUID();
+        // Add the session ID to headers so it's included in all REST requests
+        const optionsWithSessionId = Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, options.headers), { "x-deepgram-session-id": sessionId }) });
+        super(optionsWithSessionId);
+        this._sessionId = sessionId;
+        // Always wrap the auth provider to add "Token " prefix to API keys
+        // The auto-generated HeaderAuthProvider doesn't add the prefix
+        this._options.authProvider = new ApiKeyAuthProviderWrapper(this._options.authProvider);
+        // Wrap again to handle accessToken if provided
+        // This ensures accessToken takes priority over apiKey/env var
+        if (options.accessToken != null) {
+            this._options.authProvider = new AccessTokenAuthProviderWrapper(this._options.authProvider, options.accessToken);
+        }
+    }
+    /**
+     * Get the session ID that was generated for this client instance.
+     */
+    get sessionId() {
+        return this._sessionId;
     }
     /**
      * Override the agent getter to return a wrapped client that ensures
@@ -81,6 +178,11 @@ export class CustomDeepgramClient extends DeepgramClient {
 }
 /**
  * Wrapper for AgentClient that ensures custom websocket implementation is used.
+ *
+ * This wrapper exists to guarantee that our custom WebSocket implementation
+ * (from ws.ts) continues to be used even after the SDK code is auto-generated
+ * by Fern. Without this wrapper, Fern regeneration could overwrite the client
+ * with a different WebSocket implementation.
  */
 class WrappedAgentClient extends AgentClientImpl {
     get v1() {
@@ -89,6 +191,11 @@ class WrappedAgentClient extends AgentClientImpl {
 }
 /**
  * Wrapper for ListenClient that ensures custom websocket implementation is used.
+ *
+ * This wrapper exists to guarantee that our custom WebSocket implementation
+ * (from ws.ts) continues to be used even after the SDK code is auto-generated
+ * by Fern. Without this wrapper, Fern regeneration could overwrite the client
+ * with a different WebSocket implementation.
  */
 class WrappedListenClient extends ListenClientImpl {
     get v1() {
@@ -100,12 +207,36 @@ class WrappedListenClient extends ListenClientImpl {
 }
 /**
  * Wrapper for SpeakClient that ensures custom websocket implementation is used.
+ *
+ * This wrapper exists to guarantee that our custom WebSocket implementation
+ * (from ws.ts) continues to be used even after the SDK code is auto-generated
+ * by Fern. Without this wrapper, Fern regeneration could overwrite the client
+ * with a different WebSocket implementation.
  */
 class WrappedSpeakClient extends SpeakClientImpl {
     get v1() {
         return new WrappedSpeakV1Client(this._options);
     }
 }
+/**
+ * Helper function to resolve Suppliers in headers to their actual values.
+ */
+function resolveHeaders(headers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resolved = {};
+        for (const [key, value] of Object.entries(headers)) {
+            if (value == null) {
+                continue;
+            }
+            // Resolve Supplier if it's a Supplier, otherwise use the value directly
+            const resolvedValue = yield core.Supplier.get(value);
+            if (resolvedValue != null) {
+                resolved[key] = resolvedValue;
+            }
+        }
+        return resolved;
+    });
+}
 /**
  * Helper function to get WebSocket class and handle headers/protocols based on runtime.
  * In Node.js, use the 'ws' library which supports headers.
@@ -115,6 +246,8 @@ function getWebSocketOptions(headers) {
     const options = {};
     // Check if we're in a browser environment (browser or web-worker)
     const isBrowser = RUNTIME.type === "browser" || RUNTIME.type === "web-worker";
+    // Extract session ID header
+    const sessionIdHeader = headers["x-deepgram-session-id"] || headers["X-Deepgram-Session-Id"];
     // In Node.js, ensure we use the 'ws' library which supports headers
     if (RUNTIME.type === "node" && NodeWebSocket) {
         options.WebSocket = NodeWebSocket;
@@ -125,10 +258,14 @@ function getWebSocketOptions(headers) {
         // Extract Authorization header and use Sec-WebSocket-Protocol instead
         const authHeader = headers.Authorization || headers.authorization;
         const browserHeaders = Object.assign({}, headers);
-        // Remove Authorization from headers since it won't work in browser
+        // Remove Authorization and session ID from headers since they won't work in browser
         delete browserHeaders.Authorization;
         delete browserHeaders.authorization;
+        delete browserHeaders["x-deepgram-session-id"];
+        delete browserHeaders["X-Deepgram-Session-Id"];
         options.headers = browserHeaders;
+        // Build protocols array for browser WebSocket
+        const protocols = [];
         // If we have an Authorization header, extract the token and format as protocols
         // Deepgram expects:
         // - For API keys: Sec-WebSocket-Protocol: token,API_KEY_GOES_HERE
@@ -138,18 +275,25 @@ function getWebSocketOptions(headers) {
             if (authHeader.startsWith("Token ")) {
                 // API key: "Token API_KEY" -> ["token", "API_KEY"]
                 const apiKey = authHeader.substring(6); // Remove "Token " prefix
-                options.protocols = ["token", apiKey];
+                protocols.push("token", apiKey);
             }
             else if (authHeader.startsWith("Bearer ")) {
                 // Access token: "Bearer TOKEN" -> ["bearer", "TOKEN"]
                 const token = authHeader.substring(7); // Remove "Bearer " prefix
-                options.protocols = ["bearer", token];
+                protocols.push("bearer", token);
             }
             else {
                 // Fallback: use the entire header value if it doesn't match expected format
-                options.protocols = [authHeader];
+                protocols.push(authHeader);
             }
         }
+        // Add session ID as a protocol for browser WebSocket
+        if (sessionIdHeader && typeof sessionIdHeader === "string") {
+            protocols.push("x-deepgram-session-id", sessionIdHeader);
+        }
+        if (protocols.length > 0) {
+            options.protocols = protocols;
+        }
     }
     else {
         // Fallback for other environments
@@ -157,32 +301,108 @@ function getWebSocketOptions(headers) {
     }
     return options;
 }
+/**
+ * Helper function to setup binary-aware message handling for WebSocket sockets.
+ * Handles both text (JSON) and binary messages correctly.
+ */
+function setupBinaryHandling(socket, eventHandlers) {
+    var _a;
+    const binaryAwareHandler = (event) => {
+        var _a, _b, _c;
+        // Handle both text (JSON) and binary messages
+        if (typeof event.data === "string") {
+            try {
+                const data = fromJson(event.data);
+                (_a = eventHandlers.message) === null || _a === void 0 ? void 0 : _a.call(eventHandlers, data);
+            }
+            catch (error) {
+                // If JSON parsing fails, pass the raw string
+                (_b = eventHandlers.message) === null || _b === void 0 ? void 0 : _b.call(eventHandlers, event.data);
+            }
+        }
+        else {
+            // Binary data - pass through as-is
+            (_c = eventHandlers.message) === null || _c === void 0 ? void 0 : _c.call(eventHandlers, event.data);
+        }
+    };
+    // Remove the original handler and add our binary-aware one
+    const socketAny = socket;
+    if ((_a = socketAny._listeners) === null || _a === void 0 ? void 0 : _a.message) {
+        // Remove all message listeners
+        socketAny._listeners.message.forEach((listener) => {
+            socket.removeEventListener("message", listener);
+        });
+    }
+    // Add our binary-aware handler
+    socket.addEventListener("message", binaryAwareHandler);
+    return binaryAwareHandler;
+}
+/**
+ * Helper function to reset socket connection state before connecting.
+ * Ensures _connectLock is reset if the socket is in CLOSED state.
+ */
+function resetSocketConnectionState(socket) {
+    if (socket.readyState === socket.CLOSED) {
+        // Force a fresh reconnect to ensure _connectLock is reset
+        socket._connectLock = false;
+        socket._shouldReconnect = true;
+    }
+}
+/**
+ * Helper function to create a WebSocket connection with common setup logic.
+ * Handles authentication, header merging, and WebSocket configuration.
+ * This reduces duplication across all Wrapped*Client classes.
+ */
+function createWebSocketConnection(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ options, urlPath, environmentKey, queryParams, headers, debug, reconnectAttempts, }) {
+        var _b, _c, _d, _e, _f, _g;
+        // Get Authorization from authProvider (cast to any to access internal property)
+        const authRequest = yield ((_b = options.authProvider) === null || _b === void 0 ? void 0 : _b.getAuthRequest());
+        // Merge headers from options (which includes session ID), auth headers, and request headers
+        const mergedHeaders = mergeHeaders((_c = options.headers) !== null && _c !== void 0 ? _c : {}, (_d = authRequest === null || authRequest === void 0 ? void 0 : authRequest.headers) !== null && _d !== void 0 ? _d : {}, headers);
+        // Resolve any Suppliers in headers to actual values
+        const _headers = yield resolveHeaders(mergedHeaders);
+        // Get WebSocket options with proper header handling
+        const wsOptions = getWebSocketOptions(_headers);
+        // Get the appropriate base URL for the environment
+        const baseUrl = (_e = (yield core.Supplier.get(options.baseUrl))) !== null && _e !== void 0 ? _e : ((_f = (yield core.Supplier.get(options.environment))) !== null && _f !== void 0 ? _f : environments.DeepgramEnvironment.Production)[environmentKey];
+        // Create and return the ReconnectingWebSocket
+        return new ReconnectingWebSocket({
+            url: core.url.join(baseUrl, urlPath),
+            protocols: (_g = wsOptions.protocols) !== null && _g !== void 0 ? _g : [],
+            queryParameters: queryParams,
+            headers: wsOptions.headers,
+            options: {
+                WebSocket: wsOptions.WebSocket,
+                debug: debug !== null && debug !== void 0 ? debug : false,
+                maxRetries: reconnectAttempts !== null && reconnectAttempts !== void 0 ? reconnectAttempts : 30,
+                startClosed: true,
+                connectionTimeout: DEFAULT_CONNECTION_TIMEOUT_MS,
+            },
+        });
+    });
+}
 /**
  * Wrapper for Agent V1Client that overrides connect to use custom websocket.
+ *
+ * This wrapper ensures that the connect() method uses our custom ReconnectingWebSocket
+ * implementation instead of any auto-generated WebSocket handling. This guarantees
+ * consistent behavior across Fern regenerations and allows us to customize
+ * connection setup, authentication, and header handling.
  */
 class WrappedAgentV1Client extends AgentV1Client {
     connect() {
         return __awaiter(this, arguments, void 0, function* (args = {}) {
-            var _a, _b, _c, _d, _e;
             const { headers, debug, reconnectAttempts } = args;
-            // Get Authorization from authProvider (matching the working version)
-            const authRequest = yield ((_a = this._options.authProvider) === null || _a === void 0 ? void 0 : _a.getAuthRequest());
-            const _headers = mergeHeaders((_b = authRequest === null || authRequest === void 0 ? void 0 : authRequest.headers) !== null && _b !== void 0 ? _b : {}, headers);
-            // Get WebSocket options with proper header handling
-            const wsOptions = getWebSocketOptions(_headers);
-            // Explicitly use the custom ReconnectingWebSocket from ws.ts
-            const socket = new ReconnectingWebSocket({
-                url: core.url.join((_c = (yield core.Supplier.get(this._options.baseUrl))) !== null && _c !== void 0 ? _c : ((_d = (yield core.Supplier.get(this._options.environment))) !== null && _d !== void 0 ? _d : environments.DeepgramEnvironment.Production).agent, "/v1/agent/converse"),
-                protocols: (_e = wsOptions.protocols) !== null && _e !== void 0 ? _e : [],
-                queryParameters: {},
-                headers: wsOptions.headers,
-                options: {
-                    WebSocket: wsOptions.WebSocket,
-                    debug: debug !== null && debug !== void 0 ? debug : false,
-                    maxRetries: reconnectAttempts !== null && reconnectAttempts !== void 0 ? reconnectAttempts : 30,
-                    startClosed: true,
-                    connectionTimeout: 10000, // Increase timeout to 10 seconds
-                },
+            // Use shared connection helper
+            const socket = yield createWebSocketConnection({
+                options: this._options,
+                urlPath: "/v1/agent/converse",
+                environmentKey: 'agent',
+                queryParams: {},
+                headers,
+                debug,
+                reconnectAttempts,
             });
             return new WrappedAgentV1Socket({ socket });
         });
@@ -190,6 +410,11 @@ class WrappedAgentV1Client extends AgentV1Client {
 }
 /**
  * Wrapper for Agent V1Socket that handles binary messages correctly.
+ *
+ * This wrapper ensures that both text (JSON) and binary WebSocket messages are
+ * handled properly. The auto-generated socket class may not handle binary data
+ * correctly, so we override the message handling to support both formats.
+ * This is critical for audio and other binary data streaming.
  */
 class WrappedAgentV1Socket extends AgentV1Socket {
     constructor(args) {
@@ -197,50 +422,10 @@ class WrappedAgentV1Socket extends AgentV1Socket {
         this.setupBinaryHandling();
     }
     setupBinaryHandling() {
-        var _a;
-        // Create a binary-aware message handler
-        this.binaryAwareHandler = (event) => {
-            var _a, _b, _c, _d, _e, _f;
-            // Handle both text (JSON) and binary messages
-            if (typeof event.data === "string") {
-                try {
-                    const data = fromJson(event.data);
-                    (_b = (_a = this.eventHandlers).message) === null || _b === void 0 ? void 0 : _b.call(_a, data);
-                }
-                catch (error) {
-                    // If JSON parsing fails, pass the raw string
-                    (_d = (_c = this.eventHandlers).message) === null || _d === void 0 ? void 0 : _d.call(_c, event.data);
-                }
-            }
-            else {
-                // Binary data - pass through as-is
-                (_f = (_e = this.eventHandlers).message) === null || _f === void 0 ? void 0 : _f.call(_e, event.data);
-            }
-        };
-        // Remove the original handler and add our binary-aware one
-        // The original handler was added in super() constructor
-        // We need to replace it
-        const socketAny = this.socket;
-        if ((_a = socketAny._listeners) === null || _a === void 0 ? void 0 : _a.message) {
-            // Remove all message listeners
-            socketAny._listeners.message.forEach((listener) => {
-                this.socket.removeEventListener("message", listener);
-            });
-        }
-        // Add our binary-aware handler
-        if (this.binaryAwareHandler) {
-            this.socket.addEventListener("message", this.binaryAwareHandler);
-        }
+        this.binaryAwareHandler = setupBinaryHandling(this.socket, this.eventHandlers);
     }
     connect() {
-        // Ensure socket is ready to connect - if _connectLock is stuck, force reconnect
-        // by closing and reconnecting
-        if (this.socket.readyState === this.socket.CLOSED) {
-            // Force a fresh reconnect to ensure _connectLock is reset
-            this.socket._connectLock = false;
-            this.socket._shouldReconnect = true;
-        }
-        // Call parent connect, but then ensure our binary handler is still active
+        resetSocketConnectionState(this.socket);
         super.connect();
         // Re-setup binary handling in case connect() re-registered handlers
         this.setupBinaryHandling();
@@ -249,11 +434,15 @@ class WrappedAgentV1Socket extends AgentV1Socket {
 }
 /**
  * Wrapper for Listen V1Client that overrides connect to use custom websocket.
+ *
+ * This wrapper ensures that the connect() method uses our custom ReconnectingWebSocket
+ * implementation instead of any auto-generated WebSocket handling. This guarantees
+ * consistent behavior across Fern regenerations and allows us to customize
+ * connection setup, authentication, and header handling.
  */
 class WrappedListenV1Client extends ListenV1Client {
     connect(args) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
             // Extract all the args (same as the original implementation)
             const { callback, callback_method: callbackMethod, channels, diarize, dictation, encoding, endpointing, extra, interim_results: interimResults, keyterm, keywords, language, mip_opt_out: mipOptOut, model, multichannel, numerals, profanity_filter: profanityFilter, punctuate, redact, replace, sample_rate: sampleRate, search, smart_format: smartFormat, tag, utterance_end_ms: utteranceEndMs, vad_events: vadEvents, version, headers, debug, reconnectAttempts, } = args;
             // Build query params (same as original)
@@ -311,24 +500,15 @@ class WrappedListenV1Client extends ListenV1Client {
                 _queryParams.vad_events = vadEvents;
             if (version != null)
                 _queryParams.version = version;
-            // Get Authorization from authProvider (matching the working version)
-            const authRequest = yield this._options.authProvider.getAuthRequest();
-            const _headers = mergeHeaders(authRequest.headers, headers);
-            // Get WebSocket options with proper header handling
-            const wsOptions = getWebSocketOptions(_headers);
-            // Explicitly use the custom ReconnectingWebSocket from ws.ts
-            const socket = new ReconnectingWebSocket({
-                url: core.url.join((_a = (yield core.Supplier.get(this._options.baseUrl))) !== null && _a !== void 0 ? _a : ((_b = (yield core.Supplier.get(this._options.environment))) !== null && _b !== void 0 ? _b : environments.DeepgramEnvironment.Production).production, "/v1/listen"),
-                protocols: (_c = wsOptions.protocols) !== null && _c !== void 0 ? _c : [],
-                queryParameters: _queryParams,
-                headers: wsOptions.headers,
-                options: {
-                    WebSocket: wsOptions.WebSocket,
-                    debug: debug !== null && debug !== void 0 ? debug : false,
-                    maxRetries: reconnectAttempts !== null && reconnectAttempts !== void 0 ? reconnectAttempts : 30,
-                    startClosed: true,
-                    connectionTimeout: 10000, // Increase timeout to 10 seconds
-                },
+            // Use shared connection helper
+            const socket = yield createWebSocketConnection({
+                options: this._options,
+                urlPath: "/v1/listen",
+                environmentKey: 'production',
+                queryParams: _queryParams,
+                headers,
+                debug,
+                reconnectAttempts,
             });
             return new WrappedListenV1Socket({ socket });
         });
@@ -336,6 +516,11 @@ class WrappedListenV1Client extends ListenV1Client {
 }
 /**
  * Wrapper for Listen V1Socket that handles binary messages correctly.
+ *
+ * This wrapper ensures that both text (JSON) and binary WebSocket messages are
+ * handled properly. The auto-generated socket class may not handle binary data
+ * correctly, so we override the message handling to support both formats.
+ * This is critical for audio and other binary data streaming.
  */
 class WrappedListenV1Socket extends ListenV1Socket {
     constructor(args) {
@@ -343,44 +528,10 @@ class WrappedListenV1Socket extends ListenV1Socket {
         this.setupBinaryHandling();
     }
     setupBinaryHandling() {
-        var _a;
-        // Create a binary-aware message handler
-        this.binaryAwareHandler = (event) => {
-            var _a, _b, _c, _d, _e, _f;
-            // Handle both text (JSON) and binary messages
-            if (typeof event.data === "string") {
-                try {
-                    const data = fromJson(event.data);
-                    (_b = (_a = this.eventHandlers).message) === null || _b === void 0 ? void 0 : _b.call(_a, data);
-                }
-                catch (error) {
-                    // If JSON parsing fails, pass the raw string
-                    (_d = (_c = this.eventHandlers).message) === null || _d === void 0 ? void 0 : _d.call(_c, event.data);
-                }
-            }
-            else {
-                // Binary data - pass through as-is
-                (_f = (_e = this.eventHandlers).message) === null || _f === void 0 ? void 0 : _f.call(_e, event.data);
-            }
-        };
-        // Remove the original handler and add our binary-aware one
-        const socketAny = this.socket;
-        if ((_a = socketAny._listeners) === null || _a === void 0 ? void 0 : _a.message) {
-            socketAny._listeners.message.forEach((listener) => {
-                this.socket.removeEventListener("message", listener);
-            });
-        }
-        if (this.binaryAwareHandler) {
-            this.socket.addEventListener("message", this.binaryAwareHandler);
-        }
+        this.binaryAwareHandler = setupBinaryHandling(this.socket, this.eventHandlers);
     }
     connect() {
-        // Ensure socket is ready to connect - if _connectLock is stuck, force reconnect
-        if (this.socket.readyState === this.socket.CLOSED) {
-            // Force a fresh reconnect to ensure _connectLock is reset
-            this.socket._connectLock = false;
-            this.socket._shouldReconnect = true;
-        }
+        resetSocketConnectionState(this.socket);
         super.connect();
         this.setupBinaryHandling();
         return this;
@@ -388,11 +539,15 @@ class WrappedListenV1Socket extends ListenV1Socket {
 }
 /**
  * Wrapper for Listen V2Client that overrides connect to use custom websocket.
+ *
+ * This wrapper ensures that the connect() method uses our custom ReconnectingWebSocket
+ * implementation instead of any auto-generated WebSocket handling. This guarantees
+ * consistent behavior across Fern regenerations and allows us to customize
+ * connection setup, authentication, and header handling.
  */
 class WrappedListenV2Client extends ListenV2Client {
     connect(args) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
             const { model, encoding, sample_rate: sampleRate, eager_eot_threshold: eagerEotThreshold, eot_threshold: eotThreshold, eot_timeout_ms: eotTimeoutMs, keyterm, mip_opt_out: mipOptOut, tag, headers, debug, reconnectAttempts, } = args;
             const _queryParams = {};
             _queryParams.model = model;
@@ -412,31 +567,28 @@ class WrappedListenV2Client extends ListenV2Client {
                 _queryParams.mip_opt_out = mipOptOut;
             if (tag != null)
                 _queryParams.tag = tag;
-            // Get Authorization from authProvider (matching the working version)
-            const authRequest = yield ((_a = this._options.authProvider) === null || _a === void 0 ? void 0 : _a.getAuthRequest());
-            const _headers = mergeHeaders((_b = authRequest === null || authRequest === void 0 ? void 0 : authRequest.headers) !== null && _b !== void 0 ? _b : {}, headers);
-            // Get WebSocket options with proper header handling
-            const wsOptions = getWebSocketOptions(_headers);
-            // Explicitly use the custom ReconnectingWebSocket from ws.ts
-            const socket = new ReconnectingWebSocket({
-                url: core.url.join((_c = (yield core.Supplier.get(this._options.baseUrl))) !== null && _c !== void 0 ? _c : ((_d = (yield core.Supplier.get(this._options.environment))) !== null && _d !== void 0 ? _d : environments.DeepgramEnvironment.Production).production, "/v2/listen"),
-                protocols: (_e = wsOptions.protocols) !== null && _e !== void 0 ? _e : [],
-                queryParameters: _queryParams,
-                headers: wsOptions.headers,
-                options: {
-                    WebSocket: wsOptions.WebSocket,
-                    debug: debug !== null && debug !== void 0 ? debug : false,
-                    maxRetries: reconnectAttempts !== null && reconnectAttempts !== void 0 ? reconnectAttempts : 30,
-                    startClosed: true,
-                    connectionTimeout: 10000, // Increase timeout to 10 seconds
-                },
+            // Use shared connection helper
+            const socket = yield createWebSocketConnection({
+                options: this._options,
+                urlPath: "/v2/listen",
+                environmentKey: 'production',
+                queryParams: _queryParams,
+                headers,
+                debug,
+                reconnectAttempts,
             });
             return new WrappedListenV2Socket({ socket });
         });
     }
 }
 /**
- * Wrapper for Listen V2Socket that handles binary messages correctly.
+ * Wrapper for Listen V2Socket that handles binary messages correctly and adds ping support.
+ *
+ * This wrapper ensures that both text (JSON) and binary WebSocket messages are
+ * handled properly. The auto-generated socket class may not handle binary data
+ * correctly, so we override the message handling to support both formats.
+ * Additionally, this wrapper adds a ping() method for sending WebSocket ping
+ * frames to keep connections alive (Node.js only).
  */
 class WrappedListenV2Socket extends ListenV2Socket {
     constructor(args) {
@@ -444,56 +596,56 @@ class WrappedListenV2Socket extends ListenV2Socket {
         this.setupBinaryHandling();
     }
     setupBinaryHandling() {
-        var _a;
-        // Create a binary-aware message handler
-        this.binaryAwareHandler = (event) => {
-            var _a, _b, _c, _d, _e, _f;
-            // Handle both text (JSON) and binary messages
-            if (typeof event.data === "string") {
-                try {
-                    const data = fromJson(event.data);
-                    (_b = (_a = this.eventHandlers).message) === null || _b === void 0 ? void 0 : _b.call(_a, data);
-                }
-                catch (error) {
-                    // If JSON parsing fails, pass the raw string
-                    (_d = (_c = this.eventHandlers).message) === null || _d === void 0 ? void 0 : _d.call(_c, event.data);
-                }
-            }
-            else {
-                // Binary data - pass through as-is
-                (_f = (_e = this.eventHandlers).message) === null || _f === void 0 ? void 0 : _f.call(_e, event.data);
-            }
-        };
-        // Remove the original handler and add our binary-aware one
-        const socketAny = this.socket;
-        if ((_a = socketAny._listeners) === null || _a === void 0 ? void 0 : _a.message) {
-            socketAny._listeners.message.forEach((listener) => {
-                this.socket.removeEventListener("message", listener);
-            });
-        }
-        if (this.binaryAwareHandler) {
-            this.socket.addEventListener("message", this.binaryAwareHandler);
-        }
+        this.binaryAwareHandler = setupBinaryHandling(this.socket, this.eventHandlers);
     }
     connect() {
-        // Ensure socket is ready to connect - if _connectLock is stuck, force reconnect
-        if (this.socket.readyState === this.socket.CLOSED) {
-            // Force a fresh reconnect to ensure _connectLock is reset
-            this.socket._connectLock = false;
-            this.socket._shouldReconnect = true;
-        }
+        resetSocketConnectionState(this.socket);
         super.connect();
         this.setupBinaryHandling();
         return this;
     }
+    /**
+     * Send a WebSocket ping frame to keep the connection alive.
+     *
+     * In Node.js, this uses the native WebSocket ping() method from the 'ws' library.
+     * In browsers, WebSocket ping/pong is handled automatically by the browser and
+     * cannot be manually triggered, so this method will throw an error.
+     *
+     * @param data Optional data to send with the ping (Node.js only)
+     * @throws Error if not in Node.js environment or WebSocket is not connected
+     */
+    ping(data) {
+        const ws = this.socket._ws;
+        if (!ws) {
+            throw new Error("WebSocket is not connected. Call connect() and waitForOpen() first.");
+        }
+        if (ws.readyState !== ws.OPEN) {
+            throw new Error("WebSocket is not in OPEN state.");
+        }
+        // Check if we're in Node.js and the WebSocket has a ping method (from 'ws' library)
+        if (RUNTIME.type === "node" && typeof ws.ping === "function") {
+            // Call the native ping method from the 'ws' library
+            ws.ping(data);
+        }
+        else {
+            // In browsers, WebSocket ping/pong is automatic and not exposed to JavaScript
+            throw new Error("WebSocket ping is not supported in browser environments. " +
+                "Browser WebSocket connections handle ping/pong automatically. " +
+                "If you need keepalive in the browser, consider sending periodic audio data or using a timer.");
+        }
+    }
 }
 /**
  * Wrapper for Speak V1Client that overrides connect to use custom websocket.
+ *
+ * This wrapper ensures that the connect() method uses our custom ReconnectingWebSocket
+ * implementation instead of any auto-generated WebSocket handling. This guarantees
+ * consistent behavior across Fern regenerations and allows us to customize
+ * connection setup, authentication, and header handling.
  */
 class WrappedSpeakV1Client extends SpeakV1Client {
     connect(args) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
             const { encoding, mip_opt_out: mipOptOut, model, sample_rate: sampleRate, headers, debug, reconnectAttempts, } = args;
             const _queryParams = {};
             if (encoding != null)
@@ -504,24 +656,15 @@ class WrappedSpeakV1Client extends SpeakV1Client {
                 _queryParams.model = model;
             if (sampleRate != null)
                 _queryParams.sample_rate = sampleRate;
-            // Get Authorization from authProvider (matching the working version)
-            const authRequest = yield this._options.authProvider.getAuthRequest();
-            const _headers = mergeHeaders(authRequest.headers, headers);
-            // Get WebSocket options with proper header handling
-            const wsOptions = getWebSocketOptions(_headers);
-            // Explicitly use the custom ReconnectingWebSocket from ws.ts
-            const socket = new ReconnectingWebSocket({
-                url: core.url.join((_a = (yield core.Supplier.get(this._options.baseUrl))) !== null && _a !== void 0 ? _a : ((_b = (yield core.Supplier.get(this._options.environment))) !== null && _b !== void 0 ? _b : environments.DeepgramEnvironment.Production).production, "/v1/speak"),
-                protocols: (_c = wsOptions.protocols) !== null && _c !== void 0 ? _c : [],
-                queryParameters: _queryParams,
-                headers: wsOptions.headers,
-                options: {
-                    WebSocket: wsOptions.WebSocket,
-                    debug: debug !== null && debug !== void 0 ? debug : false,
-                    maxRetries: reconnectAttempts !== null && reconnectAttempts !== void 0 ? reconnectAttempts : 30,
-                    startClosed: true,
-                    connectionTimeout: 10000, // Increase timeout to 10 seconds
-                },
+            // Use shared connection helper
+            const socket = yield createWebSocketConnection({
+                options: this._options,
+                urlPath: "/v1/speak",
+                environmentKey: 'production',
+                queryParams: _queryParams,
+                headers,
+                debug,
+                reconnectAttempts,
             });
             return new WrappedSpeakV1Socket({ socket });
         });
@@ -529,6 +672,11 @@ class WrappedSpeakV1Client extends SpeakV1Client {
 }
 /**
  * Wrapper for Speak V1Socket that handles binary messages correctly.
+ *
+ * This wrapper ensures that both text (JSON) and binary WebSocket messages are
+ * handled properly. The auto-generated socket class may not handle binary data
+ * correctly, so we override the message handling to support both formats.
+ * This is critical for audio and other binary data streaming.
  */
 class WrappedSpeakV1Socket extends SpeakV1Socket {
     constructor(args) {
@@ -536,44 +684,10 @@ class WrappedSpeakV1Socket extends SpeakV1Socket {
         this.setupBinaryHandling();
     }
     setupBinaryHandling() {
-        var _a;
-        // Create a binary-aware message handler
-        this.binaryAwareHandler = (event) => {
-            var _a, _b, _c, _d, _e, _f;
-            // Handle both text (JSON) and binary messages
-            if (typeof event.data === "string") {
-                try {
-                    const data = fromJson(event.data);
-                    (_b = (_a = this.eventHandlers).message) === null || _b === void 0 ? void 0 : _b.call(_a, data);
-                }
-                catch (error) {
-                    // If JSON parsing fails, pass the raw string
-                    (_d = (_c = this.eventHandlers).message) === null || _d === void 0 ? void 0 : _d.call(_c, event.data);
-                }
-            }
-            else {
-                // Binary data - pass through as-is
-                (_f = (_e = this.eventHandlers).message) === null || _f === void 0 ? void 0 : _f.call(_e, event.data);
-            }
-        };
-        // Remove the original handler and add our binary-aware one
-        const socketAny = this.socket;
-        if ((_a = socketAny._listeners) === null || _a === void 0 ? void 0 : _a.message) {
-            socketAny._listeners.message.forEach((listener) => {
-                this.socket.removeEventListener("message", listener);
-            });
-        }
-        if (this.binaryAwareHandler) {
-            this.socket.addEventListener("message", this.binaryAwareHandler);
-        }
+        this.binaryAwareHandler = setupBinaryHandling(this.socket, this.eventHandlers);
     }
     connect() {
-        // Ensure socket is ready to connect - if _connectLock is stuck, force reconnect
-        if (this.socket.readyState === this.socket.CLOSED) {
-            // Force a fresh reconnect to ensure _connectLock is reset
-            this.socket._connectLock = false;
-            this.socket._shouldReconnect = true;
-        }
+        resetSocketConnectionState(this.socket);
         super.connect();
         this.setupBinaryHandling();
         return this;