@deepgram/sdk 5.3.0 → 5.5.0

package/dist/cjs/BaseClient.d.ts

@@ -1,6 +1,7 @@
 import { HeaderAuthProvider } from "./auth/HeaderAuthProvider.js";
 import * as core from "./core/index.js";
 import type * as environments from "./environments.js";
+export type AuthOption = false | core.AuthProvider["getAuthRequest"] | core.AuthProvider | HeaderAuthProvider.AuthOptions;
 export type BaseClientOptions = {
     environment?: core.Supplier<environments.DeepgramEnvironment | environments.DeepgramEnvironmentUrls>;
     /** Specify a custom URL to connect the client to. */
@@ -16,6 +17,8 @@ export type BaseClientOptions = {
     fetcher?: core.FetchFunction;
     /** Configure logging for the client. */
     logging?: core.logging.LogConfig | core.logging.Logger;
+    /** Override auth. Pass false to disable, a function returning auth headers, an AuthProvider, or auth options. */
+    auth?: AuthOption;
 } & HeaderAuthProvider.AuthOptions;
 export interface BaseRequestOptions {
     /** The maximum time to wait for a response in seconds. */

package/dist/cjs/BaseClient.js

@@ -39,12 +39,15 @@ exports.normalizeClientOptionsWithAuth = normalizeClientOptionsWithAuth;
 const HeaderAuthProvider_js_1 = require("./auth/HeaderAuthProvider.js");
 const headers_js_1 = require("./core/headers.js");
 const core = __importStar(require("./core/index.js"));
+// Derive the SDK version from the single source of truth (src/version.ts), which
+// carries the release-please marker. Avoids a second hardcoded version that drifts.
+const version_js_1 = require("./version.js");
 function normalizeClientOptions(options) {
     const headers = (0, headers_js_1.mergeHeaders)({
         "X-Fern-Language": "JavaScript",
         "X-Fern-SDK-Name": "@deepgram/sdk",
-        "X-Fern-SDK-Version": "5.2.1",
-        "User-Agent": "@deepgram/sdk/5.2.1",
+        "X-Fern-SDK-Version": version_js_1.SDK_VERSION,
+        "User-Agent": `@deepgram/sdk/${version_js_1.SDK_VERSION}`,
         "X-Fern-Runtime": core.RUNTIME.type,
         "X-Fern-Runtime-Version": core.RUNTIME.version,
     }, options === null || options === void 0 ? void 0 : options.headers);
@@ -53,6 +56,21 @@ function normalizeClientOptions(options) {
 function normalizeClientOptionsWithAuth(options) {
     var _a;
     const normalized = normalizeClientOptions(options);
+    if (options.auth === false) {
+        normalized.authProvider = new core.NoOpAuthProvider();
+        return normalized;
+    }
+    if (options.auth != null) {
+        if (typeof options.auth === "function") {
+            normalized.authProvider = { getAuthRequest: options.auth };
+            return normalized;
+        }
+        if (core.isAuthProvider(options.auth)) {
+            normalized.authProvider = options.auth;
+            return normalized;
+        }
+        Object.assign(normalized, options.auth);
+    }
     const normalizedWithNoOpAuthProvider = withNoOpAuthProvider(normalized);
     (_a = normalized.authProvider) !== null && _a !== void 0 ? _a : (normalized.authProvider = new HeaderAuthProvider_js_1.HeaderAuthProvider(normalizedWithNoOpAuthProvider));
     return normalized;

package/dist/cjs/CustomClient.d.ts

@@ -2,36 +2,105 @@ import { DeepgramClient } from "./Client.js";
 import type { AgentClient } from "./api/resources/agent/client/Client.js";
 import type { ListenClient } from "./api/resources/listen/client/Client.js";
 import type { SpeakClient } from "./api/resources/speak/client/Client.js";
+import { V1Client as AgentV1Client } from "./api/resources/agent/resources/v1/client/Client.js";
+import { V1Client as ListenV1Client } from "./api/resources/listen/resources/v1/client/Client.js";
+import { V2Client as ListenV2Client } from "./api/resources/listen/resources/v2/client/Client.js";
+import { V1Client as SpeakV1Client } from "./api/resources/speak/resources/v1/client/Client.js";
+import { V1Socket as AgentV1Socket } from "./api/resources/agent/resources/v1/client/Socket.js";
+import { V1Socket as ListenV1Socket } from "./api/resources/listen/resources/v1/client/Socket.js";
+import { V2Socket as ListenV2Socket } from "./api/resources/listen/resources/v2/client/Socket.js";
+import { V1Socket as SpeakV1Socket } from "./api/resources/speak/resources/v1/client/Socket.js";
 import * as core from "./core/index.js";
+import type { DeepgramTransportFactory } from "./transport.js";
+export type AgentV1ConnectionArgs = Omit<AgentV1Client.ConnectArgs, "Authorization"> & {
+    Authorization?: string;
+};
+export type ListenV1ConnectionArgs = Omit<ListenV1Client.ConnectArgs, "Authorization"> & {
+    Authorization?: string;
+};
+export type ListenV2ConnectionArgs = Omit<ListenV2Client.ConnectArgs, "Authorization" | "keyterm"> & {
+    Authorization?: string;
+    keyterm?: string | string[];
+};
+export type SpeakV1ConnectionArgs = Omit<SpeakV1Client.ConnectArgs, "Authorization"> & {
+    Authorization?: string;
+};
+export interface AgentV1ClientWithWebSocket extends AgentV1Client {
+    connect(args?: AgentV1ConnectionArgs): Promise<AgentV1Socket>;
+    createConnection(args?: AgentV1ConnectionArgs): Promise<AgentV1Socket>;
+}
+export interface ListenV1ClientWithWebSocket extends ListenV1Client {
+    connect(args: ListenV1ConnectionArgs): Promise<ListenV1Socket>;
+    createConnection(args: ListenV1ConnectionArgs): Promise<ListenV1Socket>;
+}
+export interface ListenV2ClientWithWebSocket extends ListenV2Client {
+    connect(args: ListenV2ConnectionArgs): Promise<ListenV2Socket>;
+    createConnection(args: ListenV2ConnectionArgs): Promise<ListenV2Socket>;
+}
+export interface SpeakV1ClientWithWebSocket extends SpeakV1Client {
+    connect(args: SpeakV1ConnectionArgs): Promise<SpeakV1Socket>;
+    createConnection(args: SpeakV1ConnectionArgs): Promise<SpeakV1Socket>;
+}
+export interface AgentClientWithWebSockets extends AgentClient {
+    readonly v1: AgentV1ClientWithWebSocket;
+}
+export interface ListenClientWithWebSockets extends ListenClient {
+    readonly v1: ListenV1ClientWithWebSocket;
+    readonly v2: ListenV2ClientWithWebSocket;
+}
+export interface SpeakClientWithWebSockets extends SpeakClient {
+    readonly v1: SpeakV1ClientWithWebSocket;
+}
 /**
  * Custom wrapper around DeepgramClient that ensures the custom websocket implementation
  * from ws.ts is always used, even if the auto-generated code changes.
  */
+export interface CustomDeepgramClientOptions extends DeepgramClient.Options {
+    accessToken?: core.Supplier<string | undefined>;
+    transportFactory?: DeepgramTransportFactory;
+    /**
+     * Whether the SDK should retry streaming connections at the wrapper level
+     * after a transport failure. Defaults to `true` for native websocket
+     * connections. When a `transportFactory` is provided, this is auto-set to
+     * `false` because custom transports own their own retry/reconnect lifecycle
+     * — wrapping a self-retrying transport in another retry layer creates
+     * double-retry storms under burst load. Pass `reconnect: true` together
+     * with `transportFactory` to opt back into wrapper-level retries.
+     */
+    reconnect?: boolean;
+}
 export declare class CustomDeepgramClient extends DeepgramClient {
     private _customAgent;
     private _customListen;
     private _customSpeak;
     private readonly _sessionId;
-    constructor(options?: DeepgramClient.Options & {
-        accessToken?: core.Supplier<string | undefined>;
-    });
+    private readonly _reconnect;
+    constructor(options?: CustomDeepgramClientOptions);
     /**
      * Get the session ID that was generated for this client instance.
      */
     get sessionId(): string;
+    /**
+     * 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(): boolean;
     /**
      * Override the agent getter to return a wrapped client that ensures
      * the custom websocket implementation is used.
      */
-    get agent(): AgentClient;
+    get agent(): AgentClientWithWebSockets;
     /**
      * Override the listen getter to return a wrapped client that ensures
      * the custom websocket implementation is used.
      */
-    get listen(): ListenClient;
+    get listen(): ListenClientWithWebSockets;
     /**
      * Override the speak getter to return a wrapped client that ensures
      * the custom websocket implementation is used.
      */
-    get speak(): SpeakClient;
+    get speak(): SpeakClientWithWebSockets;
 }