@deepgram/sdk 5.0.0-beta.3 → 5.0.0

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

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

package/dist/esm/index.mjs

@@ -1,4 +1,10 @@
+// Export everything under Deepgram namespace for backwards compatibility
 export * as Deepgram from "./api/index.mjs";
+// 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;
+export * from "./api/types/index.mjs";
+export * from "./api/resources/index.mjs";
 export { DeepgramClient as DefaultDeepgramClient } from "./Client.mjs";
 export { CustomDeepgramClient as DeepgramClient } from "./CustomClient.mjs";
 export { DeepgramEnvironment } from "./environments.mjs";

package/dist/esm/middleware/adapters/express.d.mts

@@ -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.mjs";
+/**
+ * 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/esm/middleware/adapters/express.mjs

@@ -0,0 +1,136 @@
+/**
+ * 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());
+    });
+};
+import { ProxyHandler } from "../core/ProxyHandler.mjs";
+import { TokenManager } from "../core/TokenManager.mjs";
+import { WebSocketProxy } from "../core/WebSocketProxy.mjs";
+/**
+ * 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 function createDeepgramProxy(options) {
+    const proxyHandler = new ProxyHandler(options);
+    const tokenManager = options.enableTokenAuth
+        ? new 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!
+ * }));
+ * ```
+ */
+export function createWebSocketHandler(options) {
+    const wsProxy = new 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);
+ * ```
+ */
+export function createDeepgramMiddleware(options) {
+    const middleware = createDeepgramProxy(options);
+    const upgradeHandler = createWebSocketHandler(options);
+    return {
+        middleware,
+        upgradeHandler,
+        server: (httpServer) => {
+            httpServer.on("upgrade", upgradeHandler);
+        },
+    };
+}

package/dist/esm/middleware/adapters/fastify.d.mts

@@ -0,0 +1,32 @@
+/**
+ * Fastify plugin for proxying Deepgram API requests.
+ *
+ * @packageDocumentation
+ *
+ * **Peer Dependencies Required:**
+ * ```bash
+ * npm install fastify fastify-plugin
+ * # or
+ * pnpm add fastify fastify-plugin
+ * ```
+ *
+ * This module provides a Fastify plugin for proxying requests to the Deepgram API,
+ * including REST endpoints and WebSocket connections.
+ */
+import type { FastifyPluginAsync, FastifyPluginOptions } from "fastify";
+import type { MiddlewareOptions } from "../core/types.mjs";
+/**
+ * Fastify plugin options
+ */
+export interface FastifyDeepgramProxyOptions extends MiddlewareOptions, FastifyPluginOptions {
+    /** URL prefix for the proxy routes (default: "") */
+    prefix?: string;
+}
+/**
+ * Export as Fastify plugin with proper typing
+ */
+export declare const fastifyDeepgramProxy: FastifyPluginAsync<FastifyDeepgramProxyOptions>;
+/**
+ * Alternative export for direct usage (without fastify-plugin wrapper)
+ */
+export declare const deepgramProxyPlugin: FastifyPluginAsync<FastifyDeepgramProxyOptions>;

package/dist/esm/middleware/adapters/fastify.mjs

@@ -0,0 +1,157 @@
+/**
+ * Fastify plugin for proxying Deepgram API requests.
+ *
+ * @packageDocumentation
+ *
+ * **Peer Dependencies Required:**
+ * ```bash
+ * npm install fastify fastify-plugin
+ * # or
+ * pnpm add fastify fastify-plugin
+ * ```
+ *
+ * This module provides a Fastify plugin 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());
+    });
+};
+import { ProxyHandler } from "../core/ProxyHandler.mjs";
+import { TokenManager } from "../core/TokenManager.mjs";
+import { WebSocketProxy } from "../core/WebSocketProxy.mjs";
+// Lazy-load fastify-plugin
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Dynamic loading
+let fp = null;
+function loadFastifyPlugin() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (fp) {
+            return fp;
+        }
+        try {
+            const module = yield import("fastify-plugin");
+            fp = module.default || module;
+            return fp;
+        }
+        catch (_a) {
+            throw new Error("fastify-plugin is required for Fastify middleware. Install it with: npm install fastify-plugin");
+        }
+    });
+}
+/**
+ * Fastify plugin for proxying Deepgram API requests
+ *
+ * @param fastify - Fastify instance
+ * @param options - Plugin configuration options
+ *
+ * @example
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import { fastifyDeepgramProxy } from '@deepgram/sdk';
+ *
+ * const fastify = Fastify();
+ *
+ * fastify.register(fastifyDeepgramProxy, {
+ *   prefix: '/api/deepgram',
+ *   apiKey: process.env.DEEPGRAM_API_KEY!,
+ *   enableTokenAuth: true
+ * });
+ *
+ * fastify.listen({ port: 3000 });
+ * ```
+ */
+const fastifyDeepgramProxyPlugin = (fastify, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const proxyHandler = new ProxyHandler(options);
+    const tokenManager = options.enableTokenAuth
+        ? new TokenManager(options)
+        : null;
+    const wsProxy = new WebSocketProxy(options);
+    // NOTE: We do NOT add a custom content type parser here because:
+    // 1. fastify-plugin breaks encapsulation, so it would affect ALL routes
+    // 2. We handle body reconstruction in our route handlers instead
+    // This allows users to use their own body parsers for their routes
+    // Register token endpoint if token auth is enabled
+    if (tokenManager) {
+        fastify.get("/token", (request, reply) => {
+            reply.hijack();
+            tokenManager.handleTokenRequest(request.raw, reply.raw).catch((error) => {
+                console.error("Token generation error:", error);
+            });
+        });
+    }
+    // Register wildcard route to catch ALL paths
+    // This must match any path depth: /, /v1, /v1/listen, /v1/listen/more/paths
+    fastify.all("/*", (request, reply) => {
+        reply.hijack();
+        // Fastify has already consumed the request body stream, so we need to
+        // write the parsed body back to the raw request
+        if (request.body && (request.method === 'POST' || request.method === 'PUT' || request.method === 'PATCH')) {
+            const bodyString = typeof request.body === 'string' ? request.body : JSON.stringify(request.body);
+            // Write the body to the raw request stream
+            process.nextTick(() => {
+                request.raw.emit('data', Buffer.from(bodyString));
+                request.raw.emit('end');
+            });
+        }
+        proxyHandler.handleRequest(request.raw, reply.raw).catch((error) => {
+            console.error("[Fastify] Proxy error:", error);
+        });
+    });
+    // Also catch root path explicitly
+    fastify.all("/", (request, reply) => {
+        reply.hijack();
+        // Reconstruct body if needed
+        if (request.body && (request.method === 'POST' || request.method === 'PUT' || request.method === 'PATCH')) {
+            const bodyString = typeof request.body === 'string' ? request.body : JSON.stringify(request.body);
+            process.nextTick(() => {
+                request.raw.emit('data', Buffer.from(bodyString));
+                request.raw.emit('end');
+            });
+        }
+        proxyHandler.handleRequest(request.raw, reply.raw).catch((error) => {
+            console.error("[Fastify] Root proxy error:", error);
+        });
+    });
+    // Register WebSocket upgrade handler
+    if (fastify.server) {
+        const prefix = (_a = options.prefix) !== null && _a !== void 0 ? _a : "";
+        fastify.server.on("upgrade", (req, socket, head) => {
+            var _a;
+            // Only handle requests matching our prefix
+            if ((_a = req.url) === null || _a === void 0 ? void 0 : _a.startsWith(prefix)) {
+                // Remove prefix from URL before proxying
+                const originalUrl = req.url;
+                req.url = originalUrl.slice(prefix.length);
+                wsProxy.handleUpgrade(req, socket, head);
+            }
+        });
+    }
+});
+/**
+ * Lazy-loaded Fastify plugin (only loads fastify-plugin when called)
+ */
+let _fastifyDeepgramProxy = null;
+/**
+ * Export as Fastify plugin with proper typing
+ */
+export const fastifyDeepgramProxy = (fastify, options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!_fastifyDeepgramProxy) {
+        const pluginWrapper = yield loadFastifyPlugin();
+        _fastifyDeepgramProxy = pluginWrapper(fastifyDeepgramProxyPlugin, {
+            fastify: ">=4.0.0",
+            name: "@deepgram/sdk-middleware",
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Guaranteed to be set above
+    return _fastifyDeepgramProxy(fastify, options);
+});
+/**
+ * Alternative export for direct usage (without fastify-plugin wrapper)
+ */
+export const deepgramProxyPlugin = fastifyDeepgramProxyPlugin;