@deepgram/sdk 5.0.0-beta.4 → 5.0.0

package/dist/esm/api/types/ReadV1ResponseMetadata.d.mts

@@ -1,36 +1,36 @@
 export interface ReadV1ResponseMetadata {
-    metadata?: ReadV1ResponseMetadata.Metadata;
+    metadata?: ReadV1ResponseMetadata.Metadata | undefined;
 }
 export declare namespace ReadV1ResponseMetadata {
     interface Metadata {
-        request_id?: string;
-        created?: string;
-        language?: string;
-        summary_info?: Metadata.SummaryInfo;
-        sentiment_info?: Metadata.SentimentInfo;
-        topics_info?: Metadata.TopicsInfo;
-        intents_info?: Metadata.IntentsInfo;
+        request_id?: string | undefined;
+        created?: string | undefined;
+        language?: string | undefined;
+        summary_info?: Metadata.SummaryInfo | undefined;
+        sentiment_info?: Metadata.SentimentInfo | undefined;
+        topics_info?: Metadata.TopicsInfo | undefined;
+        intents_info?: Metadata.IntentsInfo | undefined;
     }
     namespace Metadata {
         interface SummaryInfo {
-            model_uuid?: string;
-            input_tokens?: number;
-            output_tokens?: number;
+            model_uuid?: string | undefined;
+            input_tokens?: number | undefined;
+            output_tokens?: number | undefined;
         }
         interface SentimentInfo {
-            model_uuid?: string;
-            input_tokens?: number;
-            output_tokens?: number;
+            model_uuid?: string | undefined;
+            input_tokens?: number | undefined;
+            output_tokens?: number | undefined;
         }
         interface TopicsInfo {
-            model_uuid?: string;
-            input_tokens?: number;
-            output_tokens?: number;
+            model_uuid?: string | undefined;
+            input_tokens?: number | undefined;
+            output_tokens?: number | undefined;
         }
         interface IntentsInfo {
-            model_uuid?: string;
-            input_tokens?: number;
-            output_tokens?: number;
+            model_uuid?: string | undefined;
+            input_tokens?: number | undefined;
+            output_tokens?: number | undefined;
         }
     }
 }

package/dist/esm/api/types/ReadV1ResponseResults.d.mts

@@ -1,7 +1,7 @@
 import type * as Deepgram from "../index.mjs";
 export interface ReadV1ResponseResults {
-    summary?: Deepgram.ReadV1ResponseResultsSummary;
-    topics?: Deepgram.SharedTopics;
-    intents?: Deepgram.SharedIntents;
-    sentiments?: Deepgram.SharedSentiments;
+    summary?: Deepgram.ReadV1ResponseResultsSummary | undefined;
+    topics?: Deepgram.SharedTopics | undefined;
+    intents?: Deepgram.SharedIntents | undefined;
+    sentiments?: Deepgram.SharedSentiments | undefined;
 }

package/dist/esm/api/types/ReadV1ResponseResultsSummary.d.mts

@@ -2,15 +2,15 @@
  * Output whenever `summary=true` is used
  */
 export interface ReadV1ResponseResultsSummary {
-    results?: ReadV1ResponseResultsSummary.Results;
+    results?: ReadV1ResponseResultsSummary.Results | undefined;
 }
 export declare namespace ReadV1ResponseResultsSummary {
     interface Results {
-        summary?: Results.Summary;
+        summary?: Results.Summary | undefined;
     }
     namespace Results {
         interface Summary {
-            text?: string;
+            text?: string | undefined;
         }
     }
 }

package/dist/esm/api/types/SharedIntents.d.mts

@@ -2,31 +2,31 @@
  * Output whenever `intents=true` is used
  */
 export interface SharedIntents {
-    results?: SharedIntents.Results;
+    results?: SharedIntents.Results | undefined;
 }
 export declare namespace SharedIntents {
     interface Results {
-        intents?: Results.Intents;
+        intents?: Results.Intents | undefined;
     }
     namespace Results {
         interface Intents {
-            segments?: Intents.Segments.Item[];
+            segments?: Intents.Segments.Item[] | undefined;
         }
         namespace Intents {
             type Segments = Segments.Item[];
             namespace Segments {
                 interface Item {
-                    text?: string;
-                    start_word?: number;
-                    end_word?: number;
-                    intents?: Item.Intents.Item[];
+                    text?: string | undefined;
+                    start_word?: number | undefined;
+                    end_word?: number | undefined;
+                    intents?: Item.Intents.Item[] | undefined;
                 }
                 namespace Item {
                     type Intents = Intents.Item[];
                     namespace Intents {
                         interface Item {
-                            intent?: string;
-                            confidence_score?: number;
+                            intent?: string | undefined;
+                            confidence_score?: number | undefined;
                         }
                     }
                 }

package/dist/esm/api/types/SharedSentiments.d.mts

@@ -2,22 +2,22 @@
  * Output whenever `sentiment=true` is used
  */
 export interface SharedSentiments {
-    segments?: SharedSentiments.Segments.Item[];
-    average?: SharedSentiments.Average;
+    segments?: SharedSentiments.Segments.Item[] | undefined;
+    average?: SharedSentiments.Average | undefined;
 }
 export declare namespace SharedSentiments {
     type Segments = Segments.Item[];
     namespace Segments {
         interface Item {
-            text?: string;
-            start_word?: number;
-            end_word?: number;
-            sentiment?: string;
-            sentiment_score?: number;
+            text?: string | undefined;
+            start_word?: number | undefined;
+            end_word?: number | undefined;
+            sentiment?: string | undefined;
+            sentiment_score?: number | undefined;
         }
     }
     interface Average {
-        sentiment?: string;
-        sentiment_score?: number;
+        sentiment?: string | undefined;
+        sentiment_score?: number | undefined;
     }
 }

package/dist/esm/api/types/SharedTopics.d.mts

@@ -2,31 +2,31 @@
  * Output whenever `topics=true` is used
  */
 export interface SharedTopics {
-    results?: SharedTopics.Results;
+    results?: SharedTopics.Results | undefined;
 }
 export declare namespace SharedTopics {
     interface Results {
-        topics?: Results.Topics;
+        topics?: Results.Topics | undefined;
     }
     namespace Results {
         interface Topics {
-            segments?: Topics.Segments.Item[];
+            segments?: Topics.Segments.Item[] | undefined;
         }
         namespace Topics {
             type Segments = Segments.Item[];
             namespace Segments {
                 interface Item {
-                    text?: string;
-                    start_word?: number;
-                    end_word?: number;
-                    topics?: Item.Topics.Item[];
+                    text?: string | undefined;
+                    start_word?: number | undefined;
+                    end_word?: number | undefined;
+                    topics?: Item.Topics.Item[] | undefined;
                 }
                 namespace Item {
                     type Topics = Topics.Item[];
                     namespace Topics {
                         interface Item {
-                            topic?: string;
-                            confidence_score?: number;
+                            topic?: string | undefined;
+                            confidence_score?: number | undefined;
                         }
                     }
                 }

package/dist/esm/api/types/SpeakSettingsV1.d.mts

@@ -5,7 +5,7 @@ export interface SpeakSettingsV1 {
      * Optional if provider is Deepgram. Required for non-Deepgram TTS providers.
      * When present, must include url field and headers object. Valid schemes are https and wss with wss only supported for Eleven Labs.
      */
-    endpoint?: SpeakSettingsV1.Endpoint;
+    endpoint?: SpeakSettingsV1.Endpoint | undefined;
 }
 export declare namespace SpeakSettingsV1 {
     /**
@@ -14,7 +14,7 @@ export declare namespace SpeakSettingsV1 {
      */
     interface Endpoint {
         /** Custom TTS endpoint URL. Cannot contain `output_format` or `model_id` query parameters when the provider is Eleven Labs. */
-        url?: string;
-        headers?: Record<string, string>;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
     }
 }

package/dist/esm/api/types/ThinkSettingsV1.d.mts

@@ -2,11 +2,11 @@ import type * as Deepgram from "../index.mjs";
 export interface ThinkSettingsV1 {
     provider: Deepgram.ThinkSettingsV1Provider;
     /** Optional for non-Deepgram LLM providers. When present, must include url field and headers object */
-    endpoint?: ThinkSettingsV1.Endpoint;
-    functions?: ThinkSettingsV1.Functions.Item[];
-    prompt?: string;
+    endpoint?: ThinkSettingsV1.Endpoint | undefined;
+    functions?: ThinkSettingsV1.Functions.Item[] | undefined;
+    prompt?: string | undefined;
     /** Specifies the number of characters retained in context between user messages, agent responses, and function calls. This setting is only configurable when a custom think endpoint is used */
-    context_length?: ThinkSettingsV1.ContextLength;
+    context_length?: ThinkSettingsV1.ContextLength | undefined;
 }
 export declare namespace ThinkSettingsV1 {
     /**
@@ -14,21 +14,21 @@ export declare namespace ThinkSettingsV1 {
      */
     interface Endpoint {
         /** Custom LLM endpoint URL */
-        url?: string;
+        url?: string | undefined;
         /** Custom headers for the endpoint */
-        headers?: Record<string, string>;
+        headers?: Record<string, string> | undefined;
     }
     type Functions = Functions.Item[];
     namespace Functions {
         interface Item {
             /** Function name */
-            name?: string;
+            name?: string | undefined;
             /** Function description */
-            description?: string;
+            description?: string | undefined;
             /** Function parameters */
-            parameters?: Record<string, unknown>;
+            parameters?: Record<string, unknown> | undefined;
             /** The Function endpoint to call. if not passed, function is called client-side */
-            endpoint?: Item.Endpoint;
+            endpoint?: Item.Endpoint | undefined;
         }
         namespace Item {
             /**
@@ -36,10 +36,10 @@ export declare namespace ThinkSettingsV1 {
              */
             interface Endpoint {
                 /** Endpoint URL */
-                url?: string;
+                url?: string | undefined;
                 /** HTTP method */
-                method?: string;
-                headers?: Record<string, string>;
+                method?: string | undefined;
+                headers?: Record<string, string> | undefined;
             }
         }
     }

package/dist/esm/api/types/UpdateProjectMemberScopesV1Response.d.mts

@@ -1,4 +1,4 @@
 export interface UpdateProjectMemberScopesV1Response {
     /** confirmation message */
-    message?: string;
+    message?: string | undefined;
 }

package/dist/esm/api/types/UpdateProjectV1Response.d.mts

@@ -1,4 +1,4 @@
 export interface UpdateProjectV1Response {
     /** confirmation message */
-    message?: string;
+    message?: string | undefined;
 }

package/dist/esm/api/types/UsageBreakdownV1Response.d.mts

@@ -35,23 +35,23 @@ export declare namespace UsageBreakdownV1Response {
         namespace Item {
             interface Grouping {
                 /** Start date for this group */
-                start?: string;
+                start?: string | undefined;
                 /** End date for this group */
-                end?: string;
+                end?: string | undefined;
                 /** Optional accessor identifier */
-                accessor?: string;
+                accessor?: string | undefined;
                 /** Optional endpoint identifier */
-                endpoint?: string;
+                endpoint?: string | undefined;
                 /** Optional feature set identifier */
-                feature_set?: string;
+                feature_set?: string | undefined;
                 /** Optional models identifier */
-                models?: string;
+                models?: string | undefined;
                 /** Optional method identifier */
-                method?: string;
+                method?: string | undefined;
                 /** Optional tags */
-                tags?: string;
+                tags?: string | undefined;
                 /** Optional deployment identifier */
-                deployment?: string;
+                deployment?: string | undefined;
             }
         }
     }

package/dist/esm/api/types/UsageFieldsV1Response.d.mts

@@ -1,25 +1,25 @@
 export interface UsageFieldsV1Response {
     /** List of tags associated with the project */
-    tags?: string[];
+    tags?: string[] | undefined;
     /** List of models available for the project. */
-    models?: UsageFieldsV1Response.Models.Item[];
+    models?: UsageFieldsV1Response.Models.Item[] | undefined;
     /** Processing methods supported by the API */
-    processing_methods?: string[];
+    processing_methods?: string[] | undefined;
     /** API features available to the project */
-    features?: string[];
+    features?: string[] | undefined;
 }
 export declare namespace UsageFieldsV1Response {
     type Models = Models.Item[];
     namespace Models {
         interface Item {
             /** Name of the model. */
-            name?: string;
+            name?: string | undefined;
             /** The language supported by the model (IETF language tag). */
-            language?: string;
+            language?: string | undefined;
             /** Version identifier of the model, typically with a date and a revision number. */
-            version?: string;
+            version?: string | undefined;
             /** Unique identifier for the model. */
-            model_id?: string;
+            model_id?: string | undefined;
         }
     }
 }

package/dist/esm/api/types/UsageV1Response.d.mts

@@ -1,11 +1,11 @@
 export interface UsageV1Response {
-    start?: string;
-    end?: string;
-    resolution?: UsageV1Response.Resolution;
+    start?: string | undefined;
+    end?: string | undefined;
+    resolution?: UsageV1Response.Resolution | undefined;
 }
 export declare namespace UsageV1Response {
     interface Resolution {
-        units?: string;
-        amount?: number;
+        units?: string | undefined;
+        amount?: number | undefined;
     }
 }

package/dist/esm/core/fetcher/Fetcher.mjs

@@ -152,7 +152,13 @@ function getHeaders(args) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         const newHeaders = new Headers();
-        newHeaders.set("Accept", args.responseType === "json" ? "application/json" : args.responseType === "text" ? "text/plain" : "*/*");
+        newHeaders.set("Accept", args.responseType === "json"
+            ? "application/json"
+            : args.responseType === "text"
+                ? "text/plain"
+                : args.responseType === "sse"
+                    ? "text/event-stream"
+                    : "*/*");
         if (args.body !== undefined && args.contentType != null) {
             newHeaders.set("Content-Type", args.contentType);
         }
@@ -196,7 +202,7 @@ export function fetcherImpl(args) {
         }
         try {
             const response = yield requestWithRetries(() => __awaiter(this, void 0, void 0, function* () {
-                return makeRequest(fetchFn, url, args.method, headers, requestBody, args.timeoutMs, args.abortSignal, args.withCredentials, args.duplex);
+                return makeRequest(fetchFn, url, args.method, headers, requestBody, args.timeoutMs, args.abortSignal, args.withCredentials, args.duplex, args.responseType === "streaming" || args.responseType === "sse");
             }), args.maxRetries);
             if (response.status >= 200 && response.status < 400) {
                 if (logger.isDebug()) {

package/dist/esm/core/fetcher/makeRequest.d.mts

@@ -1 +1,6 @@
-export declare const makeRequest: (fetchFn: (url: string, init: RequestInit) => Promise<Response>, url: string, method: string, headers: Headers | Record<string, string>, requestBody: BodyInit | undefined, timeoutMs?: number, abortSignal?: AbortSignal, withCredentials?: boolean, duplex?: "half") => Promise<Response>;
+export declare function isCacheNoStoreSupported(): boolean;
+/**
+ * Reset the cached result of `isCacheNoStoreSupported`. Exposed for testing only.
+ */
+export declare function resetCacheNoStoreSupported(): void;
+export declare const makeRequest: (fetchFn: (url: string, init: RequestInit) => Promise<Response>, url: string, method: string, headers: Headers | Record<string, string>, requestBody: BodyInit | undefined, timeoutMs?: number, abortSignal?: AbortSignal, withCredentials?: boolean, duplex?: "half", disableCache?: boolean) => Promise<Response>;

package/dist/esm/core/fetcher/makeRequest.mjs

@@ -8,7 +8,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { anySignal, getTimeoutSignal } from "./signals.mjs";
-export 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;
+export 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.
+ */
+export function resetCacheNoStoreSupported() {
+    _cacheNoStoreSupported = undefined;
+}
+export 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) {
@@ -20,15 +45,9 @@ export const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutM
         signals.push(abortSignal);
     }
     const newSignals = 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/esm/core/runtime/runtime.mjs

@@ -81,17 +81,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/esm/core/websocket/ws.d.mts

@@ -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;
@@ -133,6 +135,7 @@ export declare class ReconnectingWebSocket {
     private _wait;
     private _getNextUrl;
     private _connect;
+    private _handleAbort;
     private _handleTimeout;
     private _disconnect;
     private _acceptOpen;

package/dist/esm/core/websocket/ws.mjs

@@ -28,7 +28,7 @@ const DEFAULT_OPTIONS = {
     debug: false,
 };
 export class ReconnectingWebSocket {
-    constructor({ url, protocols, options, headers, queryParameters }) {
+    constructor({ url, protocols, options, headers, queryParameters, abortSignal }) {
         this._listeners = {
             error: [],
             message: [],
@@ -62,6 +62,25 @@ export 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();
+                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;
@@ -112,6 +131,10 @@ export 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;
         }
@@ -304,9 +327,14 @@ export 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) {
@@ -322,7 +350,9 @@ export 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 = {};

package/dist/esm/environments.d.mts

@@ -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/esm/environments.mjs

@@ -2,12 +2,12 @@
 export const 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/esm/version.d.mts

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

package/dist/esm/version.mjs

@@ -1 +1 @@
-export const SDK_VERSION = "0.0.320";
+export const SDK_VERSION = "4.11.4";