@deepgram/sdk 5.0.0-alpha.3 → 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 {
@@ -39,29 +41,55 @@ catch (_a) {
 }
 // Helper function to generate UUID that works in both Node.js and browser
 function generateUUID() {
-    // In Node.js, use the crypto module
+    // 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 crypto = require("crypto");
-            return crypto.randomUUID();
+            const nodeCrypto = require("crypto");
+            return nodeCrypto.randomUUID();
         }
         catch (_a) {
             // Fallback if crypto module is not available
         }
     }
-    // In browser or as fallback, use global crypto if available
-    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-        return crypto.randomUUID();
-    }
-    // Fallback UUID generation (RFC4122 version 4)
-    // This is a simple fallback that should work everywhere
+    // 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).
@@ -99,7 +127,10 @@ export class CustomDeepgramClient extends DeepgramClient {
         const optionsWithSessionId = Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, options.headers), { "x-deepgram-session-id": sessionId }) });
         super(optionsWithSessionId);
         this._sessionId = sessionId;
-        // Wrap the auth provider to handle accessToken if provided
+        // 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);
@@ -147,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() {
@@ -155,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() {
@@ -166,6 +207,11 @@ 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() {
@@ -255,35 +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, _f;
             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());
-            // Merge headers from options (which includes session ID), auth headers, and request headers
-            const mergedHeaders = mergeHeaders((_b = this._options.headers) !== null && _b !== void 0 ? _b : {}, (_c = authRequest === null || authRequest === void 0 ? void 0 : authRequest.headers) !== null && _c !== void 0 ? _c : {}, 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);
-            // Explicitly use the custom ReconnectingWebSocket from ws.ts
-            const socket = new ReconnectingWebSocket({
-                url: core.url.join((_d = (yield core.Supplier.get(this._options.baseUrl))) !== null && _d !== void 0 ? _d : ((_e = (yield core.Supplier.get(this._options.environment))) !== null && _e !== void 0 ? _e : environments.DeepgramEnvironment.Production).agent, "/v1/agent/converse"),
-                protocols: (_f = wsOptions.protocols) !== null && _f !== void 0 ? _f : [],
-                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 });
         });
@@ -291,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) {
@@ -298,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();
@@ -350,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, _d;
             // 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)
@@ -412,27 +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();
-            // Merge headers from options (which includes session ID), auth headers, and request headers
-            const mergedHeaders = mergeHeaders((_a = this._options.headers) !== null && _a !== void 0 ? _a : {}, authRequest.headers, 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);
-            // Explicitly use the custom ReconnectingWebSocket from ws.ts
-            const socket = new ReconnectingWebSocket({
-                url: core.url.join((_b = (yield core.Supplier.get(this._options.baseUrl))) !== null && _b !== void 0 ? _b : ((_c = (yield core.Supplier.get(this._options.environment))) !== null && _c !== void 0 ? _c : environments.DeepgramEnvironment.Production).production, "/v1/listen"),
-                protocols: (_d = wsOptions.protocols) !== null && _d !== void 0 ? _d : [],
-                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 });
         });
@@ -440,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) {
@@ -447,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;
@@ -492,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, _f;
             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;
@@ -516,34 +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());
-            // Merge headers from options (which includes session ID), auth headers, and request headers
-            const mergedHeaders = mergeHeaders((_b = this._options.headers) !== null && _b !== void 0 ? _b : {}, (_c = authRequest === null || authRequest === void 0 ? void 0 : authRequest.headers) !== null && _c !== void 0 ? _c : {}, 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);
-            // Explicitly use the custom ReconnectingWebSocket from ws.ts
-            const socket = new ReconnectingWebSocket({
-                url: core.url.join((_d = (yield core.Supplier.get(this._options.baseUrl))) !== null && _d !== void 0 ? _d : ((_e = (yield core.Supplier.get(this._options.environment))) !== null && _e !== void 0 ? _e : environments.DeepgramEnvironment.Production).production, "/v2/listen"),
-                protocols: (_f = wsOptions.protocols) !== null && _f !== void 0 ? _f : [],
-                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) {
@@ -551,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, _d;
             const { encoding, mip_opt_out: mipOptOut, model, sample_rate: sampleRate, headers, debug, reconnectAttempts, } = args;
             const _queryParams = {};
             if (encoding != null)
@@ -611,27 +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();
-            // Merge headers from options (which includes session ID), auth headers, and request headers
-            const mergedHeaders = mergeHeaders((_a = this._options.headers) !== null && _a !== void 0 ? _a : {}, authRequest.headers, 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);
-            // Explicitly use the custom ReconnectingWebSocket from ws.ts
-            const socket = new ReconnectingWebSocket({
-                url: core.url.join((_b = (yield core.Supplier.get(this._options.baseUrl))) !== null && _b !== void 0 ? _b : ((_c = (yield core.Supplier.get(this._options.environment))) !== null && _c !== void 0 ? _c : environments.DeepgramEnvironment.Production).production, "/v1/speak"),
-                protocols: (_d = wsOptions.protocols) !== null && _d !== void 0 ? _d : [],
-                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 });
         });
@@ -639,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) {
@@ -646,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;