@deepgram/sdk 5.0.0-beta.4 → 5.1.0

package/dist/cjs/core/fetcher/makeRequest.js

@@ -10,8 +10,35 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeRequest = void 0;
+exports.isCacheNoStoreSupported = isCacheNoStoreSupported;
+exports.resetCacheNoStoreSupported = resetCacheNoStoreSupported;
 const signals_js_1 = require("./signals.js");
-const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex) => __awaiter(void 0, void 0, void 0, function* () {
+/**
+ * Cached result of checking whether the current runtime supports
+ * the `cache` option in `Request`. Some runtimes (e.g. Cloudflare Workers)
+ * throw a TypeError when this option is used.
+ */
+let _cacheNoStoreSupported;
+function isCacheNoStoreSupported() {
+    if (_cacheNoStoreSupported != null) {
+        return _cacheNoStoreSupported;
+    }
+    try {
+        new Request("http://localhost", { cache: "no-store" });
+        _cacheNoStoreSupported = true;
+    }
+    catch (_a) {
+        _cacheNoStoreSupported = false;
+    }
+    return _cacheNoStoreSupported;
+}
+/**
+ * Reset the cached result of `isCacheNoStoreSupported`. Exposed for testing only.
+ */
+function resetCacheNoStoreSupported() {
+    _cacheNoStoreSupported = undefined;
+}
+const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex, disableCache) => __awaiter(void 0, void 0, void 0, function* () {
     const signals = [];
     let timeoutAbortId;
     if (timeoutMs != null) {
@@ -23,15 +50,9 @@ const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abor
         signals.push(abortSignal);
     }
     const newSignals = (0, signals_js_1.anySignal)(signals);
-    const response = yield fetchFn(url, {
-        method: method,
-        headers,
-        body: requestBody,
-        signal: newSignals,
-        credentials: withCredentials ? "include" : undefined,
+    const response = yield fetchFn(url, Object.assign({ method: method, headers, body: requestBody, signal: newSignals, credentials: withCredentials ? "include" : undefined, 
         // @ts-ignore
-        duplex,
-    });
+        duplex }, (disableCache && isCacheNoStoreSupported() ? { cache: "no-store" } : {})));
     if (timeoutAbortId != null) {
         clearTimeout(timeoutAbortId);
     }

package/dist/cjs/core/file/file.js

@@ -85,7 +85,7 @@ function getFileWithMetadata(file_1) {
         }
         if ("path" in file) {
             const fs = yield Promise.resolve().then(() => __importStar(require("fs")));
-            if (!fs || !fs.createReadStream) {
+            if (!(fs === null || fs === void 0 ? void 0 : fs.createReadStream)) {
                 throw new Error("File path uploads are not supported in this environment.");
             }
             const data = fs.createReadStream(file.path);
@@ -126,9 +126,10 @@ function isFileLike(value) {
 }
 function tryGetFileSizeFromPath(path) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         try {
             const fs = yield Promise.resolve().then(() => __importStar(require("fs")));
-            if (!fs || !fs.promises || !fs.promises.stat) {
+            if (!((_a = fs === null || fs === void 0 ? void 0 : fs.promises) === null || _a === void 0 ? void 0 : _a.stat)) {
                 return undefined;
             }
             const fileStat = yield fs.promises.stat(path);

package/dist/cjs/core/runtime/runtime.js

@@ -84,17 +84,18 @@ function evaluateRuntime() {
     }
     /**
      * A constant that indicates whether the environment the code is running is Node.JS.
+     *
+     * We assign `process` to a local variable first to avoid being flagged by
+     * bundlers that perform static analysis on `process.versions` (e.g. Next.js
+     * Edge Runtime warns about Node.js APIs even when they are guarded).
      */
-    const isNode = typeof process !== "undefined" &&
-        "version" in process &&
-        !!process.version &&
-        "versions" in process &&
-        !!((_e = process.versions) === null || _e === void 0 ? void 0 : _e.node);
+    const _process = typeof process !== "undefined" ? process : undefined;
+    const isNode = typeof _process !== "undefined" && typeof ((_e = _process.versions) === null || _e === void 0 ? void 0 : _e.node) === "string";
     if (isNode) {
         return {
             type: "node",
-            version: process.versions.node,
-            parsedVersion: Number(process.versions.node.split(".")[0]),
+            version: _process.versions.node,
+            parsedVersion: Number(_process.versions.node.split(".")[0]),
         };
     }
     return {

package/dist/cjs/core/url/QueryStringBuilder.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Creates a fluent builder for constructing URL query strings.
+ *
+ * Each `.add()` call serializes its value immediately (like C#'s builder),
+ * so no format tracking is needed — the style is applied at add-time.
+ *
+ * Usage (generated code):
+ *
+ *     const qs = core.url.queryBuilder()
+ *         .add("limit", limit)
+ *         .add("tags", tags, { style: "comma" })   // explode: false
+ *         .mergeAdditional(requestOptions?.queryParams)
+ *         .build();
+ */
+export declare function queryBuilder(): QueryStringBuilder;
+declare class QueryStringBuilder {
+    private parts;
+    /**
+     * Adds a query parameter, serializing it immediately.
+     *
+     * By default arrays use "repeat" format (`key=a&key=b`).
+     * Pass `{ style: "comma" }` for OpenAPI `explode: false` parameters
+     * to get comma-separated values (`key=a,b,c`).
+     *
+     * Null / undefined values are silently skipped.
+     */
+    add(key: string, value: unknown, options?: {
+        style?: "comma";
+    }): this;
+    /**
+     * Adds multiple query parameters at once from a record.
+     * All parameters use the default "repeat" array format.
+     * Null / undefined values are silently skipped.
+     */
+    addMany(params: Record<string, unknown>): this;
+    /**
+     * Merges additional query parameters supplied at call-time via
+     * `requestOptions.queryParams`. Overrides existing keys (last-write-wins).
+     */
+    mergeAdditional(additionalParams?: Record<string, unknown>): this;
+    /**
+     * Returns the assembled query string (without the leading `?`).
+     * Returns an empty string when no parameters were added.
+     */
+    build(): string;
+}
+export {};

package/dist/cjs/core/url/QueryStringBuilder.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryBuilder = queryBuilder;
+const qs_js_1 = require("./qs.js");
+/**
+ * Creates a fluent builder for constructing URL query strings.
+ *
+ * Each `.add()` call serializes its value immediately (like C#'s builder),
+ * so no format tracking is needed — the style is applied at add-time.
+ *
+ * Usage (generated code):
+ *
+ *     const qs = core.url.queryBuilder()
+ *         .add("limit", limit)
+ *         .add("tags", tags, { style: "comma" })   // explode: false
+ *         .mergeAdditional(requestOptions?.queryParams)
+ *         .build();
+ */
+function queryBuilder() {
+    return new QueryStringBuilder();
+}
+class QueryStringBuilder {
+    constructor() {
+        this.parts = new Map();
+    }
+    /**
+     * Adds a query parameter, serializing it immediately.
+     *
+     * By default arrays use "repeat" format (`key=a&key=b`).
+     * Pass `{ style: "comma" }` for OpenAPI `explode: false` parameters
+     * to get comma-separated values (`key=a,b,c`).
+     *
+     * Null / undefined values are silently skipped.
+     */
+    add(key, value, options) {
+        if (value === undefined || value === null) {
+            return this;
+        }
+        const serialized = (0, qs_js_1.toQueryString)({ [key]: value }, { arrayFormat: (options === null || options === void 0 ? void 0 : options.style) === "comma" ? "comma" : "repeat" });
+        if (serialized.length > 0) {
+            this.parts.set(key, serialized);
+        }
+        return this;
+    }
+    /**
+     * Adds multiple query parameters at once from a record.
+     * All parameters use the default "repeat" array format.
+     * Null / undefined values are silently skipped.
+     */
+    addMany(params) {
+        if (params != null) {
+            for (const [key, value] of Object.entries(params)) {
+                this.add(key, value);
+            }
+        }
+        return this;
+    }
+    /**
+     * Merges additional query parameters supplied at call-time via
+     * `requestOptions.queryParams`. Overrides existing keys (last-write-wins).
+     */
+    mergeAdditional(additionalParams) {
+        if (additionalParams != null) {
+            for (const [key, value] of Object.entries(additionalParams)) {
+                if (value === undefined || value === null) {
+                    continue;
+                }
+                const serialized = (0, qs_js_1.toQueryString)({ [key]: value }, { arrayFormat: "repeat" });
+                if (serialized.length > 0) {
+                    this.parts.set(key, serialized);
+                }
+            }
+        }
+        return this;
+    }
+    /**
+     * Returns the assembled query string (without the leading `?`).
+     * Returns an empty string when no parameters were added.
+     */
+    build() {
+        return [...this.parts.values()].join("&");
+    }
+}

package/dist/cjs/core/url/index.d.ts

@@ -1,3 +1,4 @@
 export { encodePathParam } from "./encodePathParam.js";
 export { join } from "./join.js";
+export { queryBuilder } from "./QueryStringBuilder.js";
 export { toQueryString } from "./qs.js";

package/dist/cjs/core/url/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toQueryString = exports.join = exports.encodePathParam = void 0;
+exports.toQueryString = exports.queryBuilder = exports.join = exports.encodePathParam = void 0;
 var encodePathParam_js_1 = require("./encodePathParam.js");
 Object.defineProperty(exports, "encodePathParam", { enumerable: true, get: function () { return encodePathParam_js_1.encodePathParam; } });
 var join_js_1 = require("./join.js");
 Object.defineProperty(exports, "join", { enumerable: true, get: function () { return join_js_1.join; } });
+var QueryStringBuilder_js_1 = require("./QueryStringBuilder.js");
+Object.defineProperty(exports, "queryBuilder", { enumerable: true, get: function () { return QueryStringBuilder_js_1.queryBuilder; } });
 var qs_js_1 = require("./qs.js");
 Object.defineProperty(exports, "toQueryString", { enumerable: true, get: function () { return qs_js_1.toQueryString; } });

package/dist/cjs/core/url/qs.d.ts

@@ -1,5 +1,6 @@
+type ArrayFormat = "indices" | "repeat" | "comma";
 interface QueryStringOptions {
-    arrayFormat?: "indices" | "repeat";
+    arrayFormat?: ArrayFormat;
     encode?: boolean;
 }
 export declare function toQueryString(obj: unknown, options?: QueryStringOptions): string;

package/dist/cjs/core/url/qs.js

@@ -26,19 +26,31 @@ function stringifyObject(obj, prefix = "", options) {
             if (value.length === 0) {
                 continue;
             }
-            for (let i = 0; i < value.length; i++) {
-                const item = value[i];
-                if (item === undefined) {
-                    continue;
+            const effectiveFormat = options.arrayFormat;
+            if (effectiveFormat === "comma") {
+                const encodedKey = options.encode ? encodeURIComponent(fullKey) : fullKey;
+                const encodedValues = value
+                    .filter((item) => item !== undefined && item !== null)
+                    .map((item) => encodeValue(item, options.encode));
+                if (encodedValues.length > 0) {
+                    parts.push(`${encodedKey}=${encodedValues.join(",")}`);
                 }
-                if (typeof item === "object" && !Array.isArray(item) && item !== null) {
-                    const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
-                    parts.push(...stringifyObject(item, arrayKey, options));
-                }
-                else {
-                    const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
-                    const encodedKey = options.encode ? encodeURIComponent(arrayKey) : arrayKey;
-                    parts.push(`${encodedKey}=${encodeValue(item, options.encode)}`);
+            }
+            else {
+                for (let i = 0; i < value.length; i++) {
+                    const item = value[i];
+                    if (item === undefined) {
+                        continue;
+                    }
+                    if (typeof item === "object" && !Array.isArray(item) && item !== null) {
+                        const arrayKey = effectiveFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+                        parts.push(...stringifyObject(item, arrayKey, options));
+                    }
+                    else {
+                        const arrayKey = effectiveFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+                        const encodedKey = options.encode ? encodeURIComponent(arrayKey) : arrayKey;
+                        parts.push(`${encodedKey}=${encodeValue(item, options.encode)}`);
+                    }
                 }
             }
         }

package/dist/cjs/core/websocket/ws.d.ts

@@ -9,6 +9,7 @@ export declare namespace ReconnectingWebSocket {
         options?: ReconnectingWebSocket.Options;
         headers?: Record<string, unknown>;
         queryParameters?: Record<string, unknown>;
+        abortSignal?: AbortSignal;
     }
     type Options = {
         WebSocket?: any;
@@ -47,7 +48,8 @@ export declare class ReconnectingWebSocket {
     private readonly _options;
     private readonly _headers?;
     private readonly _queryParameters?;
-    constructor({ url, protocols, options, headers, queryParameters }: ReconnectingWebSocket.Args);
+    private readonly _abortSignal?;
+    constructor({ url, protocols, options, headers, queryParameters, abortSignal }: ReconnectingWebSocket.Args);
     static readonly CONNECTING = 0;
     static readonly OPEN = 1;
     static readonly CLOSING = 2;
@@ -83,7 +85,7 @@ export declare class ReconnectingWebSocket {
     /**
      * The current state of the connection; this is one of the Ready state constants
      */
-    get readyState(): number;
+    get readyState(): ReconnectingWebSocket.ReadyState;
     /**
      * The URL as resolved by the constructor
      */
@@ -133,6 +135,7 @@ export declare class ReconnectingWebSocket {
     private _wait;
     private _getNextUrl;
     private _connect;
+    private _handleAbort;
     private _handleTimeout;
     private _disconnect;
     private _acceptOpen;
@@ -145,3 +148,12 @@ export declare class ReconnectingWebSocket {
     private _addListeners;
     private _clearTimeouts;
 }
+export declare namespace ReconnectingWebSocket {
+    const ReadyState: {
+        readonly CONNECTING: 0;
+        readonly OPEN: 1;
+        readonly CLOSING: 2;
+        readonly CLOSED: 3;
+    };
+    type ReadyState = (typeof ReadyState)[keyof typeof ReadyState];
+}

package/dist/cjs/core/websocket/ws.js

@@ -39,13 +39,13 @@ const index_js_1 = require("../runtime/index.js");
 const qs_js_1 = require("../url/qs.js");
 const Events = __importStar(require("./events.js"));
 const getGlobalWebSocket = () => {
-    if (typeof WebSocket !== "undefined") {
+    if (index_js_1.RUNTIME.type === "node" || index_js_1.RUNTIME.type === "bun" || index_js_1.RUNTIME.type === "deno") {
+        return ws_1.WebSocket;
+    }
+    else if (typeof WebSocket !== "undefined") {
         // @ts-ignore
         return WebSocket;
     }
-    else if (index_js_1.RUNTIME.type === "node") {
-        return ws_1.WebSocket;
-    }
     return undefined;
 };
 /**
@@ -64,7 +64,7 @@ const DEFAULT_OPTIONS = {
     debug: false,
 };
 class ReconnectingWebSocket {
-    constructor({ url, protocols, options, headers, queryParameters }) {
+    constructor({ url, protocols, options, headers, queryParameters, abortSignal }) {
         this._listeners = {
             error: [],
             message: [],
@@ -98,6 +98,27 @@ class ReconnectingWebSocket {
          * this indicates that the connection is ready to send and receive data
          */
         this.onopen = null;
+        this._handleAbort = () => {
+            if (this._closeCalled) {
+                return;
+            }
+            this._debug("abort signal fired");
+            this._shouldReconnect = false;
+            this._closeCalled = true;
+            this._clearTimeouts();
+            if (this._ws) {
+                this._removeListeners();
+                // Absorb async errors emitted by ws when closing during CONNECTING state
+                this._ws.addEventListener("error", () => { });
+                try {
+                    this._ws.close(1000, "aborted");
+                    this._handleClose(new Events.CloseEvent(1000, "aborted", this));
+                }
+                catch (_error) {
+                    // ignore
+                }
+            }
+        };
         this._handleOpen = (event) => {
             this._debug("open event");
             const { minUptime = DEFAULT_OPTIONS.minUptime } = this._options;
@@ -148,6 +169,10 @@ class ReconnectingWebSocket {
         this._options = options !== null && options !== void 0 ? options : DEFAULT_OPTIONS;
         this._headers = headers;
         this._queryParameters = queryParameters;
+        this._abortSignal = abortSignal;
+        if (this._abortSignal) {
+            this._abortSignal.addEventListener("abort", this._handleAbort, { once: true });
+        }
         if (this._options.startClosed) {
             this._shouldReconnect = false;
         }
@@ -211,7 +236,9 @@ class ReconnectingWebSocket {
         if (this._ws) {
             return this._ws.readyState;
         }
-        return this._options.startClosed ? ReconnectingWebSocket.CLOSED : ReconnectingWebSocket.CONNECTING;
+        return this._options.startClosed
+            ? ReconnectingWebSocket.ReadyState.CLOSED
+            : ReconnectingWebSocket.ReadyState.CONNECTING;
     }
     /**
      * The URL as resolved by the constructor
@@ -340,9 +367,14 @@ class ReconnectingWebSocket {
         throw Error("Invalid URL");
     }
     _connect() {
+        var _a;
         if (this._connectLock || !this._shouldReconnect) {
             return;
         }
+        if ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
+            this._debug("connect aborted");
+            return;
+        }
         this._connectLock = true;
         const { maxRetries = DEFAULT_OPTIONS.maxRetries, connectionTimeout = DEFAULT_OPTIONS.connectionTimeout, WebSocket = getGlobalWebSocket(), } = this._options;
         if (this._retryCount >= maxRetries) {
@@ -358,7 +390,9 @@ class ReconnectingWebSocket {
         this._wait()
             .then(() => this._getNextUrl(this._url))
             .then((url) => {
-            if (this._closeCalled) {
+            var _a;
+            if (this._closeCalled || ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+                this._connectLock = false;
                 return;
             }
             const options = {};
@@ -388,6 +422,8 @@ class ReconnectingWebSocket {
             return;
         }
         this._removeListeners();
+        // Absorb async errors emitted by ws when closing during CONNECTING state
+        this._ws.addEventListener("error", () => { });
         try {
             this._ws.close(code, reason);
             this._handleClose(new Events.CloseEvent(code, reason, this));
@@ -442,3 +478,11 @@ ReconnectingWebSocket.CONNECTING = 0;
 ReconnectingWebSocket.OPEN = 1;
 ReconnectingWebSocket.CLOSING = 2;
 ReconnectingWebSocket.CLOSED = 3;
+(function (ReconnectingWebSocket) {
+    ReconnectingWebSocket.ReadyState = {
+        CONNECTING: 0,
+        OPEN: 1,
+        CLOSING: 2,
+        CLOSED: 3,
+    };
+})(ReconnectingWebSocket || (exports.ReconnectingWebSocket = ReconnectingWebSocket = {}));

package/dist/cjs/environments.d.ts

@@ -1,18 +1,18 @@
 export interface DeepgramEnvironmentUrls {
     base: string;
-    production: string;
     agent: string;
+    production: string;
 }
 export declare const DeepgramEnvironment: {
     readonly Production: {
         readonly base: "https://api.deepgram.com";
-        readonly production: "wss://api.deepgram.com";
         readonly agent: "wss://agent.deepgram.com";
+        readonly production: "wss://api.deepgram.com";
     };
     readonly Agent: {
         readonly base: "https://agent.deepgram.com";
-        readonly production: "wss://api.deepgram.com";
         readonly agent: "wss://agent.deepgram.com";
+        readonly production: "wss://api.deepgram.com";
     };
 };
 export type DeepgramEnvironment = typeof DeepgramEnvironment.Production | typeof DeepgramEnvironment.Agent;

package/dist/cjs/environments.js

@@ -5,12 +5,12 @@ exports.DeepgramEnvironment = void 0;
 exports.DeepgramEnvironment = {
     Production: {
         base: "https://api.deepgram.com",
-        production: "wss://api.deepgram.com",
         agent: "wss://agent.deepgram.com",
+        production: "wss://api.deepgram.com",
     },
     Agent: {
         base: "https://agent.deepgram.com",
-        production: "wss://api.deepgram.com",
         agent: "wss://agent.deepgram.com",
+        production: "wss://api.deepgram.com",
     },
 };

package/dist/cjs/errors/DeepgramError.d.ts

@@ -3,10 +3,12 @@ export declare class DeepgramError extends Error {
     readonly statusCode?: number;
     readonly body?: unknown;
     readonly rawResponse?: core.RawResponse;
-    constructor({ message, statusCode, body, rawResponse, }: {
+    readonly cause?: unknown;
+    constructor({ message, statusCode, body, rawResponse, cause, }: {
         message?: string;
         statusCode?: number;
         body?: unknown;
         rawResponse?: core.RawResponse;
+        cause?: unknown;
     });
 }

package/dist/cjs/errors/DeepgramError.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeepgramError = void 0;
 const json_js_1 = require("../core/json.js");
 class DeepgramError extends Error {
-    constructor({ message, statusCode, body, rawResponse, }) {
+    constructor({ message, statusCode, body, rawResponse, cause, }) {
         super(buildMessage({ message, statusCode, body }));
         Object.setPrototypeOf(this, new.target.prototype);
         if (Error.captureStackTrace) {
@@ -14,6 +14,9 @@ class DeepgramError extends Error {
         this.statusCode = statusCode;
         this.body = body;
         this.rawResponse = rawResponse;
+        if (cause != null) {
+            this.cause = cause;
+        }
     }
 }
 exports.DeepgramError = DeepgramError;

package/dist/cjs/errors/DeepgramTimeoutError.d.ts

@@ -1,3 +1,6 @@
 export declare class DeepgramTimeoutError extends Error {
-    constructor(message: string);
+    readonly cause?: unknown;
+    constructor(message: string, opts?: {
+        cause?: unknown;
+    });
 }

package/dist/cjs/errors/DeepgramTimeoutError.js

@@ -3,13 +3,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeepgramTimeoutError = void 0;
 class DeepgramTimeoutError extends Error {
-    constructor(message) {
+    constructor(message, opts) {
         super(message);
         Object.setPrototypeOf(this, new.target.prototype);
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, this.constructor);
         }
         this.name = this.constructor.name;
+        if ((opts === null || opts === void 0 ? void 0 : opts.cause) != null) {
+            this.cause = opts.cause;
+        }
     }
 }
 exports.DeepgramTimeoutError = DeepgramTimeoutError;

package/dist/cjs/errors/handleNonStatusCodeError.js

@@ -50,11 +50,14 @@ function handleNonStatusCodeError(error, rawResponse, method, path) {
                 rawResponse: rawResponse,
             });
         case "timeout":
-            throw new errors.DeepgramTimeoutError(`Timeout exceeded when calling ${method} ${path}.`);
+            throw new errors.DeepgramTimeoutError(`Timeout exceeded when calling ${method} ${path}.`, {
+                cause: error.cause,
+            });
         case "unknown":
             throw new errors.DeepgramError({
                 message: error.errorMessage,
                 rawResponse: rawResponse,
+                cause: error.cause,
             });
         default:
             throw new errors.DeepgramError({

package/dist/cjs/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.0.320";
+export declare const SDK_VERSION = "5.0.1";

package/dist/cjs/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "0.0.320";
+exports.SDK_VERSION = "5.0.1";

package/dist/esm/BaseClient.mjs

@@ -5,9 +5,9 @@ import * as core from "./core/index.mjs";
 export function normalizeClientOptions(options) {
     const headers = mergeHeaders({
         "X-Fern-Language": "JavaScript",
-        "X-Fern-SDK-Name": "",
-        "X-Fern-SDK-Version": "0.0.320",
-        "User-Agent": "/0.0.320",
+        "X-Fern-SDK-Name": "@deepgram/sdk",
+        "X-Fern-SDK-Version": "5.0.1",
+        "User-Agent": "@deepgram/sdk/5.0.1",
         "X-Fern-Runtime": core.RUNTIME.type,
         "X-Fern-Runtime-Version": core.RUNTIME.version,
     }, options === null || options === void 0 ? void 0 : options.headers);

package/dist/esm/Client.d.mts

@@ -5,8 +5,10 @@ import { ManageClient } from "./api/resources/manage/client/Client.mjs";
 import { ReadClient } from "./api/resources/read/client/Client.mjs";
 import { SelfHostedClient } from "./api/resources/selfHosted/client/Client.mjs";
 import { SpeakClient } from "./api/resources/speak/client/Client.mjs";
+import { VoiceAgentClient } from "./api/resources/voiceAgent/client/Client.mjs";
 import type { BaseClientOptions, BaseRequestOptions } from "./BaseClient.mjs";
 import { type NormalizedClientOptionsWithAuth } from "./BaseClient.mjs";
+import * as core from "./core/index.mjs";
 export declare namespace DeepgramClient {
     type Options = BaseClientOptions;
     interface RequestOptions extends BaseRequestOptions {
@@ -21,6 +23,7 @@ export declare class DeepgramClient {
     protected _read: ReadClient | undefined;
     protected _selfHosted: SelfHostedClient | undefined;
     protected _speak: SpeakClient | undefined;
+    protected _voiceAgent: VoiceAgentClient | undefined;
     constructor(options?: DeepgramClient.Options);
     get agent(): AgentClient;
     get auth(): AuthClient;
@@ -29,4 +32,16 @@ export declare class DeepgramClient {
     get read(): ReadClient;
     get selfHosted(): SelfHostedClient;
     get speak(): SpeakClient;
+    get voiceAgent(): VoiceAgentClient;
+    /**
+     * Make a passthrough request using the SDK's configured auth, retry, logging, etc.
+     * This is useful for making requests to endpoints not yet supported in the SDK.
+     * The input can be a URL string, URL object, or Request object. Relative paths are resolved against the configured base URL.
+     *
+     * @param {Request | string | URL} input - The URL, path, or Request object.
+     * @param {RequestInit} init - Standard fetch RequestInit options.
+     * @param {core.PassthroughRequest.RequestOptions} requestOptions - Per-request overrides (timeout, retries, headers, abort signal).
+     * @returns {Promise<Response>} A standard Response object.
+     */
+    fetch(input: Request | string | URL, init?: RequestInit, requestOptions?: core.PassthroughRequest.RequestOptions): Promise<Response>;
 }