@deepgram/sdk 5.4.0 → 5.5.0

package/dist/esm/CustomClient.mjs

@@ -23,6 +23,7 @@ import { V1Socket as SpeakV1Socket } from "./api/resources/speak/resources/v1/cl
 import { mergeHeaders } from "./core/headers.mjs";
 import { fromJson } from "./core/json.mjs";
 import * as core from "./core/index.mjs";
+import * as websocketEvents from "./core/websocket/events.mjs";
 import * as environments from "./environments.mjs";
 import { RUNTIME } from "./core/runtime/index.mjs";
 // Default WebSocket connection timeout in milliseconds
@@ -32,6 +33,7 @@ const DEFAULT_CONNECTION_TIMEOUT_MS = 10000;
 const WEBSOCKET_OPTION_KEYS = new Set([
     "Authorization",
     "headers",
+    "protocols",
     "debug",
     "reconnectAttempts",
     "connectionTimeoutInSeconds",
@@ -151,18 +153,21 @@ class AccessTokenAuthProviderWrapper {
         });
     }
 }
-/**
- * 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 = {}) {
+        var _a;
         // 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 }) });
+        // Auto-disable wrapper-level reconnect when a custom transportFactory
+        // is in use: those transports own their retry lifecycle, and stacking
+        // a second retry layer on top causes storm-on-storm under burst load.
+        // Callers can still opt back in by explicitly passing reconnect: true.
+        const reconnect = (_a = options.reconnect) !== null && _a !== void 0 ? _a : options.transportFactory == null;
+        const optionsWithSessionId = Object.assign(Object.assign({}, options), { reconnect, headers: Object.assign(Object.assign({}, options.headers), { "x-deepgram-session-id": sessionId }) });
         super(optionsWithSessionId);
         this._sessionId = sessionId;
+        this._reconnect = reconnect;
         // 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);
@@ -178,6 +183,16 @@ export class CustomDeepgramClient extends DeepgramClient {
     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.
@@ -291,12 +306,364 @@ function buildQueryParams(args) {
     }
     return result;
 }
+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 = core.url.toQueryString(queryParams, { arrayFormat: "repeat" });
+    return queryString ? `${url}?${queryString}` : url;
+}
+function getTransportFactory(options) {
+    return options.transportFactory;
+}
+function getReconnect(options) {
+    return options.reconnect !== false;
+}
+class TransportWebSocketAdapter {
+    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 = undefined;
+            this._setTransportHandle(undefined);
+            if (transport) {
+                void transport.close(1000, "aborted");
+            }
+            this._readyState = ReconnectingWebSocket.ReadyState.CLOSED;
+            this._emitClose(1000, "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 !== void 0 ? _a : "";
+    }
+    get readyState() {
+        return this._readyState;
+    }
+    get url() {
+        return this._request.url;
+    }
+    close(code = 1000, reason) {
+        this._closeCalled = true;
+        this._shouldReconnect = false;
+        this._clearConnectTimeout();
+        this._readyState = ReconnectingWebSocket.ReadyState.CLOSING;
+        const transport = this._transport;
+        this._transport = undefined;
+        this._setTransportHandle(undefined);
+        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 = undefined;
+        this._setTransportHandle(undefined);
+        if (transport) {
+            void transport.close(code, reason);
+        }
+        void this._connect();
+    }
+    send(data) {
+        var _a;
+        if ((_a = this._transport) === null || _a === void 0 ? 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) {
+            // biome-ignore lint/suspicious/noConsole: transport debug logging mirrors websocket debug logging
+            console.log.apply(console, ["DG-TRANSPORT>", ...args]);
+        }
+    }
+    _connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this._connectLock || !this._shouldReconnect || ((_a = this._request.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+                return;
+            }
+            // When wrapper-level reconnect is disabled, allow only the initial
+            // attempt (_retryCount starts at -1 and increments to 0 on first
+            // _connect). Any subsequent re-entry from _handleError must short out
+            // so the transport's own retry logic is the single source of truth.
+            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 || _b === void 0 ? void 0 : _b.aborted)) {
+                    this._connectLock = false;
+                    yield transport.close(1000, "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 !== void 0 ? _a : 1000, (_b = event.reason) !== null && _b !== void 0 ? _b : "");
+        });
+    }
+    _armConnectTimeout() {
+        const timeoutMs = this._request.connectionTimeoutInSeconds != null
+            ? this._request.connectionTimeoutInSeconds * 1000
+            : DEFAULT_CONNECTION_TIMEOUT_MS;
+        this._connectTimeout = setTimeout(() => {
+            this._handleError(new Error("TIMEOUT"));
+        }, timeoutMs);
+    }
+    _clearConnectTimeout() {
+        if (this._connectTimeout != null) {
+            clearTimeout(this._connectTimeout);
+            this._connectTimeout = undefined;
+        }
+    }
+    _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 websocketEvents.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 websocketEvents.ErrorEvent(error, this);
+        if (this.onerror) {
+            this.onerror(event);
+        }
+        this._listeners.error.forEach((listener) => this._callEventListener(event, listener));
+        const transport = this._transport;
+        this._transport = undefined;
+        this._setTransportHandle(undefined);
+        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 = undefined;
+        this._readyState = ReconnectingWebSocket.ReadyState.CLOSED;
+        this._setTransportHandle(undefined);
+        if (code === 1000) {
+            this._shouldReconnect = false;
+        }
+        this._emitClose(code, reason);
+        if (this._shouldReconnect && !this._closeCalled) {
+            void this._connect();
+        }
+    }
+    _emitClose(code, reason) {
+        const event = new websocketEvents.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 = undefined;
+            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 || _a === void 0 ? void 0 : _a.call(transport, data));
+                }
+                : undefined,
+        };
+    }
+    _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;
 /**
  * Helper function to get WebSocket class and handle headers/protocols based on runtime.
  * In Node.js, use the 'ws' library which supports headers.
  * In browser, use Sec-WebSocket-Protocol for authentication since headers aren't supported.
  */
-function getWebSocketOptions(headers) {
+function getWebSocketOptions(headers, requestedProtocols) {
     const options = {};
     // Check if we're in a browser environment (browser or web-worker)
     const isBrowser = RUNTIME.type === "browser" || RUNTIME.type === "web-worker";
@@ -306,6 +673,9 @@ function getWebSocketOptions(headers) {
     if (RUNTIME.type === "node" && NodeWebSocket) {
         options.WebSocket = NodeWebSocket;
         options.headers = headers;
+        if (requestedProtocols.length > 0) {
+            options.protocols = requestedProtocols;
+        }
     }
     else if (isBrowser) {
         // In browser, native WebSocket doesn't support custom headers
@@ -319,7 +689,7 @@ function getWebSocketOptions(headers) {
         delete browserHeaders["X-Deepgram-Session-Id"];
         options.headers = browserHeaders;
         // Build protocols array for browser WebSocket
-        const protocols = [];
+        const protocols = [...requestedProtocols];
         // 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
@@ -352,6 +722,9 @@ function getWebSocketOptions(headers) {
     else {
         // Fallback for other environments
         options.headers = headers;
+        if (requestedProtocols.length > 0) {
+            options.protocols = requestedProtocols;
+        }
     }
     return options;
 }
@@ -428,7 +801,7 @@ function resetSocketConnectionState(socket) {
  * 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, connectionTimeoutInSeconds, abortSignal, }) {
+    return __awaiter(this, arguments, void 0, function* ({ options, urlPath, environmentKey, queryParams, protocols, service, headers, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal, }) {
         var _b, _c, _d, _e, _f, _g;
         // Ensure ws is loaded for Node.js environments (no-op after first call)
         yield loadNodeWebSocket();
@@ -438,13 +811,38 @@ function createWebSocketConnection(_a) {
         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);
+        const normalizedProtocols = normalizeProtocols(protocols);
         // 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];
+        const url = core.url.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 !== void 0 ? debug : false,
+                reconnectAttempts: reconnectAttempts !== null && reconnectAttempts !== void 0 ? reconnectAttempts : 30,
+                connectionTimeoutInSeconds,
+                abortSignal,
+            };
+            return new TransportWebSocketAdapter({
+                factory: transportFactory,
+                request,
+                startClosed: true,
+                reconnect,
+            });
+        }
+        // Get WebSocket options with proper header handling
+        const wsOptions = getWebSocketOptions(_headers, normalizedProtocols);
         // Create and return the ReconnectingWebSocket
         return new ReconnectingWebSocket({
-            url: core.url.join(baseUrl, urlPath),
+            url,
             protocols: (_g = wsOptions.protocols) !== null && _g !== void 0 ? _g : [],
             queryParameters: queryParams,
             headers: wsOptions.headers,
@@ -470,12 +868,14 @@ function createWebSocketConnection(_a) {
 class WrappedAgentV1Client extends AgentV1Client {
     connect() {
         return __awaiter(this, arguments, void 0, 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,
@@ -547,12 +947,14 @@ class WrappedAgentV1Socket extends AgentV1Socket {
 class WrappedListenV1Client extends ListenV1Client {
     connect(args) {
         return __awaiter(this, void 0, void 0, 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,
@@ -623,12 +1025,14 @@ class WrappedListenV1Socket extends ListenV1Socket {
 class WrappedListenV2Client extends ListenV2Client {
     connect(args) {
         return __awaiter(this, void 0, void 0, 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,
@@ -730,12 +1134,14 @@ class WrappedListenV2Socket extends ListenV2Socket {
 class WrappedSpeakV1Client extends SpeakV1Client {
     connect(args) {
         return __awaiter(this, void 0, void 0, 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,

package/dist/esm/api/errors/BadRequestError.mjs

@@ -12,6 +12,6 @@ export class BadRequestError extends errors.DeepgramError {
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, this.constructor);
         }
-        this.name = this.constructor.name;
+        this.name = "BadRequestError";
     }
 }

package/dist/esm/api/resources/agent/resources/v1/types/AgentV1SettingsAgentListenProvider.d.mts

@@ -1,6 +1,10 @@
 import type * as Deepgram from "../../../../../index.mjs";
-export type AgentV1SettingsAgentListenProvider = Deepgram.agent.AgentV1SettingsAgentContextListenProvider;
+export type AgentV1SettingsAgentListenProvider = Deepgram.agent.AgentV1SettingsAgentListenProvider.V1 | Deepgram.agent.AgentV1SettingsAgentListenProvider.V2;
 export declare namespace AgentV1SettingsAgentListenProvider {
-    type V1 = Deepgram.agent.AgentV1SettingsAgentContextListenProvider.V1;
-    type V2 = Deepgram.agent.AgentV1SettingsAgentContextListenProvider.V2;
+    interface V1 extends Deepgram.DeepgramListenProviderV1 {
+        version: "v1";
+    }
+    interface V2 extends Deepgram.DeepgramListenProviderV2 {
+        version: "v2";
+    }
 }

package/dist/esm/api/resources/agent/resources/v1/types/AgentV1SettingsAgentListenProvider.mjs

@@ -1,8 +1,2 @@
-// Backward-compat alias for the type renamed by the 2026-05-06 regen to
-// `AgentV1SettingsAgentContextListenProvider`. The new V2 only adds an optional
-// `language_hint` field, so this alias is purely additive: every literal that
-// satisfied the old V2 still satisfies the new V2, and pinned-name callers
-// (`const p: AgentV1SettingsAgentListenProvider = ...`) keep compiling without
-// a cast. See AGENTS.md for the patch rationale; regression coverage in
-// tests/unit/compat-aliases.test.ts.
+// This file was auto-generated by Fern from our API Definition.
 export {};

package/dist/esm/api/resources/listen/resources/v1/client/Client.d.mts

@@ -11,6 +11,7 @@ export declare namespace V1Client {
         channels?: Deepgram.ListenV1Channels | undefined;
         detect_entities?: Deepgram.ListenV1DetectEntities;
         diarize?: Deepgram.ListenV1Diarize;
+        diarize_model?: Deepgram.listen.DiarizeModel;
         dictation?: Deepgram.ListenV1Dictation;
         encoding?: Deepgram.ListenV1Encoding;
         endpointing?: Deepgram.ListenV1Endpointing | undefined;

package/dist/esm/api/resources/listen/resources/v1/client/Client.mjs

@@ -26,13 +26,14 @@ export class V1Client {
     connect(args) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
-            const { callback, callback_method: callbackMethod, channels, detect_entities: detectEntities, 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, protocols, queryParams, headers, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal, } = args;
+            const { callback, callback_method: callbackMethod, channels, detect_entities: detectEntities, diarize, diarize_model: diarizeModel, 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, protocols, queryParams, headers, debug, reconnectAttempts, connectionTimeoutInSeconds, abortSignal, } = args;
             const _queryParams = {
                 callback: callback != null ? (typeof callback === "string" ? callback : toJson(callback)) : undefined,
                 callback_method: callbackMethod != null ? callbackMethod : undefined,
                 channels: channels != null ? (typeof channels === "string" ? channels : toJson(channels)) : undefined,
                 detect_entities: detectEntities != null ? detectEntities : undefined,
                 diarize: diarize != null ? diarize : undefined,
+                diarize_model: diarizeModel != null ? diarizeModel : undefined,
                 dictation: dictation != null ? dictation : undefined,
                 encoding: encoding != null ? encoding : undefined,
                 endpointing: endpointing != null ? (typeof endpointing === "string" ? endpointing : toJson(endpointing)) : undefined,

package/dist/esm/api/resources/listen/resources/v1/resources/media/client/requests/ListenV1RequestUrl.d.mts

@@ -71,9 +71,9 @@ export interface ListenV1RequestUrl {
     detect_entities?: boolean;
     /** Identifies the dominant language spoken in submitted audio */
     detect_language?: boolean;
-    /** Recognize speaker changes. Each word in the transcript will be assigned a speaker number starting at 0 */
+    /** Deprecated: use `diarize_model` instead. Recognize speaker changes. Each word in the transcript will be assigned a speaker number starting at 0. */
     diarize?: boolean;
-    /** Select and enable a specific batch diarization model version. If specifying this parameter, you should not set the deprecated `diarize=true` parameter. Not accepted on streaming requests. */
+    /** Select and enable a specific diarization model version. Specifying this parameter enables diarization and selects the model — you do not need to also set the deprecated `diarize=true` parameter. For batch, supported values are `latest` (currently v2), `v1`, and `v2`. For streaming, supported values are `latest` (currently v1) and `v1`; `v2` returns a validation error on streaming requests. */
     diarize_model?: Deepgram.listen.v1.MediaTranscribeRequestDiarizeModel;
     /** Dictation mode for controlling formatting with dictated speech */
     dictation?: boolean;

package/dist/esm/api/resources/listen/resources/v1/resources/media/client/requests/MediaTranscribeRequestOctetStream.d.mts

@@ -32,9 +32,9 @@ export interface MediaTranscribeRequestOctetStream {
     detect_entities?: boolean;
     /** Identifies the dominant language spoken in submitted audio */
     detect_language?: boolean;
-    /** Recognize speaker changes. Each word in the transcript will be assigned a speaker number starting at 0 */
+    /** Deprecated: use `diarize_model` instead. Recognize speaker changes. Each word in the transcript will be assigned a speaker number starting at 0. */
     diarize?: boolean;
-    /** Select and enable a specific batch diarization model version. If specifying this parameter, you should not set the deprecated `diarize=true` parameter. Not accepted on streaming requests. */
+    /** Select and enable a specific diarization model version. Specifying this parameter enables diarization and selects the model — you do not need to also set the deprecated `diarize=true` parameter. For batch, supported values are `latest` (currently v2), `v1`, and `v2`. For streaming, supported values are `latest` (currently v1) and `v1`; `v2` returns a validation error on streaming requests. */
     diarize_model?: Deepgram.listen.v1.MediaTranscribeRequestDiarizeModel;
     /** Dictation mode for controlling formatting with dictated speech */
     dictation?: boolean;

package/dist/esm/api/resources/listen/resources/v1/types/DiarizeModel.d.mts

@@ -0,0 +1,5 @@
+export declare const DiarizeModel: {
+    readonly Latest: "latest";
+    readonly V1: "v1";
+};
+export type DiarizeModel = (typeof DiarizeModel)[keyof typeof DiarizeModel] | string;

package/dist/esm/api/resources/listen/resources/v1/types/DiarizeModel.mjs

@@ -0,0 +1,5 @@
+// This file was auto-generated by Fern from our API Definition.
+export const DiarizeModel = {
+    Latest: "latest",
+    V1: "v1",
+};

package/dist/esm/api/resources/listen/resources/v1/types/index.d.mts

@@ -1,3 +1,4 @@
+export * from "./DiarizeModel.mjs";
 export * from "./ListenV1CloseStream.mjs";
 export * from "./ListenV1Finalize.mjs";
 export * from "./ListenV1KeepAlive.mjs";