@deepgram/sdk 5.0.0-beta.3 → 5.0.0

package/dist/cjs/api/types/UsageBreakdownV1Response.d.ts

@@ -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/cjs/api/types/UsageFieldsV1Response.d.ts

@@ -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/cjs/api/types/UsageV1Response.d.ts

@@ -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/cjs/api/types/index.d.ts

@@ -88,7 +88,8 @@ export * from "./ListProjectMembersV1Response.js";
 export * from "./ListProjectPurchasesV1Response.js";
 export * from "./ListProjectRequestsV1Response.js";
 export * from "./ListProjectsV1Response.js";
-export * from "./OpenAi.js";
+export * from "./OpenAiSpeakProvider.js";
+export * from "./OpenAiThinkProvider.js";
 export * from "./ProjectRequestResponse.js";
 export * from "./ReadV1Request.js";
 export * from "./ReadV1RequestText.js";
@@ -108,6 +109,7 @@ export * from "./SpeakV1Model.js";
 export * from "./SpeakV1Response.js";
 export * from "./SpeakV1SampleRate.js";
 export * from "./ThinkSettingsV1.js";
+export * from "./ThinkSettingsV1Provider.js";
 export * from "./UpdateProjectMemberScopesV1Response.js";
 export * from "./UpdateProjectV1Response.js";
 export * from "./UsageBreakdownV1Response.js";

package/dist/cjs/api/types/index.js

@@ -104,7 +104,8 @@ __exportStar(require("./ListProjectMembersV1Response.js"), exports);
 __exportStar(require("./ListProjectPurchasesV1Response.js"), exports);
 __exportStar(require("./ListProjectRequestsV1Response.js"), exports);
 __exportStar(require("./ListProjectsV1Response.js"), exports);
-__exportStar(require("./OpenAi.js"), exports);
+__exportStar(require("./OpenAiSpeakProvider.js"), exports);
+__exportStar(require("./OpenAiThinkProvider.js"), exports);
 __exportStar(require("./ProjectRequestResponse.js"), exports);
 __exportStar(require("./ReadV1Request.js"), exports);
 __exportStar(require("./ReadV1RequestText.js"), exports);
@@ -124,6 +125,7 @@ __exportStar(require("./SpeakV1Model.js"), exports);
 __exportStar(require("./SpeakV1Response.js"), exports);
 __exportStar(require("./SpeakV1SampleRate.js"), exports);
 __exportStar(require("./ThinkSettingsV1.js"), exports);
+__exportStar(require("./ThinkSettingsV1Provider.js"), exports);
 __exportStar(require("./UpdateProjectMemberScopesV1Response.js"), exports);
 __exportStar(require("./UpdateProjectV1Response.js"), exports);
 __exportStar(require("./UsageBreakdownV1Response.js"), exports);

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

@@ -156,7 +156,13 @@ function getHeaders(args) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         const newHeaders = new Headers_js_1.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);
         }
@@ -200,7 +206,7 @@ function fetcherImpl(args) {
         }
         try {
             const response = yield (0, requestWithRetries_js_1.requestWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
-                return (0, makeRequest_js_1.makeRequest)(fetchFn, url, args.method, headers, requestBody, args.timeoutMs, args.abortSignal, args.withCredentials, args.duplex);
+                return (0, makeRequest_js_1.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/cjs/core/fetcher/makeRequest.d.ts

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

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

@@ -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,25 @@ 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;
@@ -148,6 +167,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;
         }
@@ -340,9 +363,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 +386,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 = {};

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/index.d.ts

@@ -1,4 +1,6 @@
 export * as Deepgram from "./api/index.js";
+export * from "./api/types/index.js";
+export * from "./api/resources/index.js";
 export type { BaseClientOptions, BaseRequestOptions } from "./BaseClient.js";
 export { DeepgramClient as DefaultDeepgramClient } from "./Client.js";
 export { CustomDeepgramClient as DeepgramClient } from "./CustomClient.js";

package/dist/cjs/index.js

@@ -37,7 +37,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeepgramTimeoutError = exports.DeepgramError = exports.DeepgramEnvironment = exports.DeepgramClient = exports.DefaultDeepgramClient = exports.Deepgram = void 0;
+// Export everything under Deepgram namespace for backwards compatibility
 exports.Deepgram = __importStar(require("./api/index.js"));
+// ALSO export all types directly for better discoverability and IDE autocomplete
+// This allows: import { ListenV1Response } from "@deepgram/sdk"
+// While still supporting: import { Deepgram } from "@deepgram/sdk"; type Response = Deepgram.ListenV1Response;
+__exportStar(require("./api/types/index.js"), exports);
+__exportStar(require("./api/resources/index.js"), exports);
 var Client_js_1 = require("./Client.js");
 Object.defineProperty(exports, "DefaultDeepgramClient", { enumerable: true, get: function () { return Client_js_1.DeepgramClient; } });
 var CustomClient_js_1 = require("./CustomClient.js");

package/dist/cjs/middleware/adapters/express.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Express middleware for proxying Deepgram API requests.
+ *
+ * @packageDocumentation
+ *
+ * **Peer Dependencies Required:**
+ * ```bash
+ * npm install express
+ * # or
+ * pnpm add express
+ * ```
+ *
+ * This module provides Express-compatible middleware for proxying requests to the
+ * Deepgram API, including REST endpoints and WebSocket connections.
+ */
+import type { IncomingMessage, Server, ServerResponse } from "node:http";
+import type { Duplex } from "node:stream";
+import type { MiddlewareOptions } from "../core/types.js";
+/**
+ * Express middleware type
+ */
+export type ExpressMiddleware = (req: IncomingMessage, res: ServerResponse, next: (error?: Error) => void) => void | Promise<void>;
+/**
+ * WebSocket upgrade handler type
+ */
+export type UpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
+/**
+ * Create Express middleware for proxying Deepgram API requests
+ *
+ * @param options - Middleware configuration options
+ * @returns Express middleware function
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createDeepgramProxy, createWebSocketHandler } from '@deepgram/sdk';
+ *
+ * const app = express();
+ * const proxyOptions = {
+ *   apiKey: process.env.DEEPGRAM_API_KEY!,
+ *   enableTokenAuth: true
+ * };
+ *
+ * // REST API proxy
+ * app.use('/api/deepgram', createDeepgramProxy(proxyOptions));
+ *
+ * // WebSocket upgrade handler
+ * const server = app.listen(3000);
+ * server.on('upgrade', createWebSocketHandler(proxyOptions));
+ * ```
+ */
+export declare function createDeepgramProxy(options: MiddlewareOptions): ExpressMiddleware;
+/**
+ * Create WebSocket upgrade handler for Express
+ *
+ * This must be registered on the HTTP server, not the Express app.
+ *
+ * @param options - Middleware configuration options
+ * @returns Upgrade handler function
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createWebSocketHandler } from '@deepgram/sdk';
+ *
+ * const app = express();
+ * const server = app.listen(3000);
+ *
+ * // Register WebSocket handler on the server
+ * server.on('upgrade', createWebSocketHandler({
+ *   apiKey: process.env.DEEPGRAM_API_KEY!
+ * }));
+ * ```
+ */
+export declare function createWebSocketHandler(options: MiddlewareOptions): UpgradeHandler;
+/**
+ * Combined helper that returns both middleware and upgrade handler
+ *
+ * @param options - Middleware configuration options
+ * @returns Object with middleware and upgrade handler
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createDeepgramMiddleware } from '@deepgram/sdk';
+ *
+ * const app = express();
+ * const { middleware, upgradeHandler } = createDeepgramMiddleware({
+ *   apiKey: process.env.DEEPGRAM_API_KEY!,
+ *   enableTokenAuth: true
+ * });
+ *
+ * app.use('/api/deepgram', middleware);
+ *
+ * const server = app.listen(3000);
+ * server.on('upgrade', upgradeHandler);
+ * ```
+ */
+export declare function createDeepgramMiddleware(options: MiddlewareOptions): {
+    middleware: ExpressMiddleware;
+    upgradeHandler: UpgradeHandler;
+    server: (httpServer: Server) => void;
+};

package/dist/cjs/middleware/adapters/express.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Express middleware for proxying Deepgram API requests.
+ *
+ * @packageDocumentation
+ *
+ * **Peer Dependencies Required:**
+ * ```bash
+ * npm install express
+ * # or
+ * pnpm add express
+ * ```
+ *
+ * This module provides Express-compatible middleware for proxying requests to the
+ * Deepgram API, including REST endpoints and WebSocket connections.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeepgramProxy = createDeepgramProxy;
+exports.createWebSocketHandler = createWebSocketHandler;
+exports.createDeepgramMiddleware = createDeepgramMiddleware;
+const ProxyHandler_js_1 = require("../core/ProxyHandler.js");
+const TokenManager_js_1 = require("../core/TokenManager.js");
+const WebSocketProxy_js_1 = require("../core/WebSocketProxy.js");
+/**
+ * Create Express middleware for proxying Deepgram API requests
+ *
+ * @param options - Middleware configuration options
+ * @returns Express middleware function
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createDeepgramProxy, createWebSocketHandler } from '@deepgram/sdk';
+ *
+ * const app = express();
+ * const proxyOptions = {
+ *   apiKey: process.env.DEEPGRAM_API_KEY!,
+ *   enableTokenAuth: true
+ * };
+ *
+ * // REST API proxy
+ * app.use('/api/deepgram', createDeepgramProxy(proxyOptions));
+ *
+ * // WebSocket upgrade handler
+ * const server = app.listen(3000);
+ * server.on('upgrade', createWebSocketHandler(proxyOptions));
+ * ```
+ */
+function createDeepgramProxy(options) {
+    const proxyHandler = new ProxyHandler_js_1.ProxyHandler(options);
+    const tokenManager = options.enableTokenAuth
+        ? new TokenManager_js_1.TokenManager(options)
+        : null;
+    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Handle token generation requests
+            if (options.enableTokenAuth &&
+                req.url === "/token" &&
+                req.method === "GET") {
+                yield tokenManager.handleTokenRequest(req, res);
+                return;
+            }
+            // Handle all other requests (proxy to Deepgram)
+            yield proxyHandler.handleRequest(req, res);
+        }
+        catch (error) {
+            next(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+}
+/**
+ * Create WebSocket upgrade handler for Express
+ *
+ * This must be registered on the HTTP server, not the Express app.
+ *
+ * @param options - Middleware configuration options
+ * @returns Upgrade handler function
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createWebSocketHandler } from '@deepgram/sdk';
+ *
+ * const app = express();
+ * const server = app.listen(3000);
+ *
+ * // Register WebSocket handler on the server
+ * server.on('upgrade', createWebSocketHandler({
+ *   apiKey: process.env.DEEPGRAM_API_KEY!
+ * }));
+ * ```
+ */
+function createWebSocketHandler(options) {
+    const wsProxy = new WebSocketProxy_js_1.WebSocketProxy(options);
+    return (req, socket, head) => {
+        wsProxy.handleUpgrade(req, socket, head);
+    };
+}
+/**
+ * Combined helper that returns both middleware and upgrade handler
+ *
+ * @param options - Middleware configuration options
+ * @returns Object with middleware and upgrade handler
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createDeepgramMiddleware } from '@deepgram/sdk';
+ *
+ * const app = express();
+ * const { middleware, upgradeHandler } = createDeepgramMiddleware({
+ *   apiKey: process.env.DEEPGRAM_API_KEY!,
+ *   enableTokenAuth: true
+ * });
+ *
+ * app.use('/api/deepgram', middleware);
+ *
+ * const server = app.listen(3000);
+ * server.on('upgrade', upgradeHandler);
+ * ```
+ */
+function createDeepgramMiddleware(options) {
+    const middleware = createDeepgramProxy(options);
+    const upgradeHandler = createWebSocketHandler(options);
+    return {
+        middleware,
+        upgradeHandler,
+        server: (httpServer) => {
+            httpServer.on("upgrade", upgradeHandler);
+        },
+    };
+}