@deepgram/sdk 5.0.0 → 5.1.0

package/dist/cjs/middleware/core/WebSocketProxy.js

@@ -1,169 +0,0 @@
-"use strict";
-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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketProxy = void 0;
-const node_url_1 = require("node:url");
-const ws_1 = __importDefault(require("ws"));
-const jwt_js_1 = require("./jwt.js");
-/**
- * Handles WebSocket proxying to Deepgram API
- */
-class WebSocketProxy {
-    constructor(options) {
-        var _a, _b;
-        this.apiKey = options.apiKey;
-        this.tokenMode = (_a = options.tokenMode) !== null && _a !== void 0 ? _a : "deepgram";
-        // Convert HTTP(S) base URL to WebSocket URL
-        this.baseUrl = ((_b = options.baseUrl) !== null && _b !== void 0 ? _b : "https://api.deepgram.com")
-            .replace(/^https:/, "wss:")
-            .replace(/^http:/, "ws:");
-    }
-    /**
-     * Handle WebSocket upgrade request
-     */
-    handleUpgrade(req, socket, head) {
-        this.handleUpgradeAsync(req, socket, head).catch((error) => {
-            console.error("WebSocket upgrade error:", error);
-            socket.destroy();
-        });
-    }
-    /**
-     * Async version of handleUpgrade to support JWT verification
-     */
-    handleUpgradeAsync(req, socket, head) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Build Deepgram WebSocket URL
-                const targetUrl = this.buildWebSocketUrl(req);
-                // Prepare headers (may verify JWT)
-                const headers = yield this.prepareHeaders(req);
-                // Connect to Deepgram WebSocket
-                const deepgramSocket = new ws_1.default(targetUrl, { headers });
-                // Handle connection open
-                deepgramSocket.on("open", () => {
-                    // Complete the client upgrade
-                    socket.write("HTTP/1.1 101 Switching Protocols\r\n" +
-                        "Upgrade: websocket\r\n" +
-                        "Connection: Upgrade\r\n" +
-                        "\r\n");
-                    // Create client WebSocket
-                    const clientSocket = new ws_1.default(null, null);
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- WebSocket internals
-                    clientSocket.setSocket(socket, head, { maxPayload: 100 * 1024 * 1024 });
-                    // Forward messages bidirectionally
-                    this.forwardMessages(clientSocket, deepgramSocket);
-                });
-                // Handle connection errors
-                deepgramSocket.on("error", (error) => {
-                    console.error("WebSocket proxy error (Deepgram):", error);
-                    socket.destroy();
-                });
-            }
-            catch (error) {
-                console.error("WebSocket upgrade error:", error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Build WebSocket URL for Deepgram
-     */
-    buildWebSocketUrl(req) {
-        var _a;
-        // Strip /api/deepgram prefix if present
-        const cleanUrl = ((_a = req.url) !== null && _a !== void 0 ? _a : "/").replace(/^\/api\/deepgram/, "");
-        const url = new node_url_1.URL(cleanUrl, this.baseUrl);
-        return url.toString();
-    }
-    /**
-     * Prepare headers for Deepgram WebSocket connection
-     */
-    prepareHeaders(req) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const headers = {};
-            // Copy relevant headers
-            const allowedHeaders = [
-                "user-agent",
-                "x-fern-language",
-                "x-fern-sdk-name",
-                "x-fern-sdk-version",
-                "x-deepgram-session-id",
-            ];
-            for (const header of allowedHeaders) {
-                const value = req.headers[header];
-                if (value) {
-                    headers[header] = Array.isArray(value) ? value[0] : value;
-                }
-            }
-            // Authentication logic (similar to ProxyHandler)
-            const clientAuth = req.headers.authorization;
-            if (clientAuth && this.tokenMode === "jwt" && clientAuth.startsWith("Bearer ")) {
-                const token = clientAuth.replace("Bearer ", "");
-                console.log(`[WebSocketProxy] Client provided JWT token, verifying...`);
-                try {
-                    yield (0, jwt_js_1.verifyProxyToken)(token, this.apiKey);
-                    console.log(`[WebSocketProxy] JWT verified successfully, using server API key`);
-                    headers.authorization = `Token ${this.apiKey}`;
-                }
-                catch (error) {
-                    console.error(`[WebSocketProxy] JWT verification failed:`, error);
-                    throw new Error("Invalid or expired token");
-                }
-            }
-            else {
-                // Use server API key
-                headers.authorization = `Token ${this.apiKey}`;
-            }
-            return headers;
-        });
-    }
-    /**
-     * Forward WebSocket messages bidirectionally
-     */
-    forwardMessages(clientSocket, deepgramSocket) {
-        // Forward client messages to Deepgram
-        clientSocket.on("message", (data, isBinary) => {
-            if (deepgramSocket.readyState === ws_1.default.OPEN) {
-                deepgramSocket.send(data, { binary: isBinary });
-            }
-        });
-        // Forward Deepgram messages to client
-        deepgramSocket.on("message", (data, isBinary) => {
-            if (clientSocket.readyState === ws_1.default.OPEN) {
-                clientSocket.send(data, { binary: isBinary });
-            }
-        });
-        // Handle closures
-        clientSocket.on("close", (code, reason) => {
-            if (deepgramSocket.readyState === ws_1.default.OPEN) {
-                deepgramSocket.close(code, reason);
-            }
-        });
-        deepgramSocket.on("close", (code, reason) => {
-            if (clientSocket.readyState === ws_1.default.OPEN) {
-                clientSocket.close(code, reason);
-            }
-        });
-        // Handle errors
-        clientSocket.on("error", (error) => {
-            console.error("WebSocket error (client):", error);
-            deepgramSocket.close();
-        });
-        deepgramSocket.on("error", (error) => {
-            console.error("WebSocket error (Deepgram):", error);
-            clientSocket.close();
-        });
-    }
-}
-exports.WebSocketProxy = WebSocketProxy;

package/dist/cjs/middleware/core/jwt.d.ts

@@ -1,71 +0,0 @@
-/**
- * Options for creating a proxy token
- */
-export interface ProxyTokenOptions {
-    /** Optional user or session identifier */
-    identity?: string;
-    /** Token time-to-live (e.g., "1h", "30m", 3600). Defaults to "1h" */
-    ttl?: string | number;
-    /** Optional scopes/permissions for the token */
-    scopes?: string[];
-    /** Optional custom metadata to include in token */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Decoded proxy token payload
- */
-export interface ProxyTokenPayload {
-    /** Issuer - the project ID extracted from API key */
-    iss: string;
-    /** Subject - optional user/session identifier */
-    sub?: string;
-    /** Issued at timestamp */
-    iat: number;
-    /** Expiration timestamp */
-    exp: number;
-    /** Not before timestamp */
-    nbf: number;
-    /** Optional scopes/permissions */
-    scopes?: string[];
-    /** Optional custom metadata */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Creates a proxy token signed with the Deepgram API key.
- * This token should be generated on the backend and sent to browser clients.
- * The browser uses this token to connect to the proxy middleware.
- *
- * @param apiKey - Deepgram API key (used as signing secret)
- * @param options - Token configuration options
- * @returns JWT token string
- *
- * @example
- * ```typescript
- * const token = await createProxyToken(process.env.DEEPGRAM_API_KEY, {
- *   identity: 'user-123',
- *   ttl: '1h',
- *   scopes: ['listen', 'speak']
- * });
- * ```
- */
-export declare function createProxyToken(apiKey: string, options?: ProxyTokenOptions): Promise<string>;
-/**
- * Verifies a proxy token and returns the decoded payload.
- * This should be called by the proxy middleware to validate tokens from clients.
- *
- * @param token - JWT token to verify
- * @param apiKey - Deepgram API key (used to verify signature)
- * @returns Decoded token payload
- * @throws Error if token is invalid, expired, or signature doesn't match
- *
- * @example
- * ```typescript
- * try {
- *   const payload = await verifyProxyToken(token, process.env.DEEPGRAM_API_KEY);
- *   console.log('Valid token for user:', payload.sub);
- * } catch (error) {
- *   console.error('Invalid token:', error);
- * }
- * ```
- */
-export declare function verifyProxyToken(token: string, apiKey: string): Promise<ProxyTokenPayload>;

package/dist/cjs/middleware/core/jwt.js

@@ -1,136 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-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.createProxyToken = createProxyToken;
-exports.verifyProxyToken = verifyProxyToken;
-const jose = __importStar(require("jose"));
-/**
- * Creates a proxy token signed with the Deepgram API key.
- * This token should be generated on the backend and sent to browser clients.
- * The browser uses this token to connect to the proxy middleware.
- *
- * @param apiKey - Deepgram API key (used as signing secret)
- * @param options - Token configuration options
- * @returns JWT token string
- *
- * @example
- * ```typescript
- * const token = await createProxyToken(process.env.DEEPGRAM_API_KEY, {
- *   identity: 'user-123',
- *   ttl: '1h',
- *   scopes: ['listen', 'speak']
- * });
- * ```
- */
-function createProxyToken(apiKey_1) {
-    return __awaiter(this, arguments, void 0, function* (apiKey, options = {}) {
-        const { identity, ttl = "1h", scopes, metadata } = options;
-        const projectId = extractProjectId(apiKey);
-        const secret = new TextEncoder().encode(apiKey);
-        const payload = {};
-        if (scopes !== undefined) {
-            payload.scopes = scopes;
-        }
-        if (metadata !== undefined) {
-            payload.metadata = metadata;
-        }
-        const expirationTime = typeof ttl === "number"
-            ? Math.floor(Date.now() / 1000) + ttl
-            : ttl;
-        const jwt = new jose.SignJWT(payload)
-            .setProtectedHeader({ alg: "HS256" })
-            .setIssuer(projectId)
-            .setIssuedAt()
-            .setNotBefore(new Date())
-            .setExpirationTime(expirationTime);
-        if (identity !== undefined) {
-            jwt.setSubject(identity);
-        }
-        return jwt.sign(secret);
-    });
-}
-/**
- * Verifies a proxy token and returns the decoded payload.
- * This should be called by the proxy middleware to validate tokens from clients.
- *
- * @param token - JWT token to verify
- * @param apiKey - Deepgram API key (used to verify signature)
- * @returns Decoded token payload
- * @throws Error if token is invalid, expired, or signature doesn't match
- *
- * @example
- * ```typescript
- * try {
- *   const payload = await verifyProxyToken(token, process.env.DEEPGRAM_API_KEY);
- *   console.log('Valid token for user:', payload.sub);
- * } catch (error) {
- *   console.error('Invalid token:', error);
- * }
- * ```
- */
-function verifyProxyToken(token, apiKey) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const secret = new TextEncoder().encode(apiKey);
-        const projectId = extractProjectId(apiKey);
-        const { payload } = yield jose.jwtVerify(token, secret, {
-            algorithms: ["HS256"],
-            issuer: projectId,
-        });
-        return payload;
-    });
-}
-/**
- * Extracts the project ID from a Deepgram API key.
- * API keys are formatted as: {project_id}:{secret}
- *
- * @param apiKey - Deepgram API key
- * @returns Project ID portion of the API key
- */
-function extractProjectId(apiKey) {
-    const parts = apiKey.split(":");
-    if (parts.length < 2) {
-        throw new Error("Invalid API key format");
-    }
-    return parts[0];
-}

package/dist/cjs/middleware/core/types.d.ts

@@ -1,37 +0,0 @@
-/**
- * Options for configuring the Deepgram proxy middleware
- */
-export interface MiddlewareOptions {
-    /** Deepgram API key for server-side authentication */
-    apiKey: string;
-    /** Enable temporary token generation endpoint (GET /token) */
-    enableTokenAuth?: boolean;
-    /**
-     * Token mode: how tokens are generated and verified
-     * - "deepgram": Use Deepgram's native temporary token API (legacy)
-     * - "jwt": Use JWT tokens signed with API key (recommended for browser clients)
-     *
-     * @default "deepgram"
-     */
-    tokenMode?: "deepgram" | "jwt";
-    /** Custom Deepgram API base URL (e.g., for EU endpoint) */
-    baseUrl?: string;
-    /** Default token expiration in seconds (default: 3600 = 1 hour) */
-    defaultTokenExpiration?: number;
-}
-/**
- * Request body for token generation
- */
-export interface TokenRequest {
-    /** Token time-to-live in seconds */
-    ttlSeconds?: number;
-}
-/**
- * Response from token generation
- */
-export interface TokenResponse {
-    /** The generated access token */
-    token: string;
-    /** Token expiration time in seconds */
-    expiresIn: number;
-}

package/dist/cjs/middleware/index.d.ts

@@ -1,55 +0,0 @@
-/**
- * Deepgram SDK Middleware
- *
- * This module provides middleware for integrating Deepgram API proxying
- * into Node.js web frameworks like Express and Fastify.
- *
- * ## Features
- * - Server-side API key injection (hide keys from clients)
- * - Temporary token generation (client requests token, uses it temporarily)
- * - WebSocket proxying for Live/Agent APIs
- * - Framework integration (Raw Node.js, Express, Fastify)
- *
- * @example Express
- * ```typescript
- * import express from 'express';
- * import { createDeepgramProxy, createWebSocketHandler } from '@deepgram/sdk';
- *
- * const app = express();
- * const options = {
- *   apiKey: process.env.DEEPGRAM_API_KEY!,
- *   enableTokenAuth: true
- * };
- *
- * app.use('/api/deepgram', createDeepgramProxy(options));
- *
- * const server = app.listen(3000);
- * server.on('upgrade', createWebSocketHandler(options));
- * ```
- *
- * @example Fastify
- * ```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 });
- * ```
- *
- * @packageDocumentation
- */
-export type { MiddlewareOptions, TokenRequest, TokenResponse } from "./core/types.js";
-export { createHttpHandler, createUpgradeHandler as createHttpUpgradeHandler, createDeepgramHttpServer, type HttpRequestHandler, type UpgradeHandler as HttpUpgradeHandler, } from "./adapters/http.js";
-export { createDeepgramProxy, createDeepgramMiddleware, createWebSocketHandler, type ExpressMiddleware, type UpgradeHandler, } from "./adapters/express.js";
-export { fastifyDeepgramProxy, deepgramProxyPlugin, type FastifyDeepgramProxyOptions, } from "./adapters/fastify.js";
-export { createProxyToken, verifyProxyToken, type ProxyTokenOptions, type ProxyTokenPayload, } from "./core/jwt.js";
-export { ProxyHandler } from "./core/ProxyHandler.js";
-export { TokenManager } from "./core/TokenManager.js";
-export { WebSocketProxy } from "./core/WebSocketProxy.js";

package/dist/cjs/middleware/index.js

@@ -1,75 +0,0 @@
-"use strict";
-/**
- * Deepgram SDK Middleware
- *
- * This module provides middleware for integrating Deepgram API proxying
- * into Node.js web frameworks like Express and Fastify.
- *
- * ## Features
- * - Server-side API key injection (hide keys from clients)
- * - Temporary token generation (client requests token, uses it temporarily)
- * - WebSocket proxying for Live/Agent APIs
- * - Framework integration (Raw Node.js, Express, Fastify)
- *
- * @example Express
- * ```typescript
- * import express from 'express';
- * import { createDeepgramProxy, createWebSocketHandler } from '@deepgram/sdk';
- *
- * const app = express();
- * const options = {
- *   apiKey: process.env.DEEPGRAM_API_KEY!,
- *   enableTokenAuth: true
- * };
- *
- * app.use('/api/deepgram', createDeepgramProxy(options));
- *
- * const server = app.listen(3000);
- * server.on('upgrade', createWebSocketHandler(options));
- * ```
- *
- * @example Fastify
- * ```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 });
- * ```
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketProxy = exports.TokenManager = exports.ProxyHandler = exports.verifyProxyToken = exports.createProxyToken = exports.deepgramProxyPlugin = exports.fastifyDeepgramProxy = exports.createWebSocketHandler = exports.createDeepgramMiddleware = exports.createDeepgramProxy = exports.createDeepgramHttpServer = exports.createHttpUpgradeHandler = exports.createHttpHandler = void 0;
-// Raw Node.js HTTP/HTTPS adapter (no dependencies)
-var http_js_1 = require("./adapters/http.js");
-Object.defineProperty(exports, "createHttpHandler", { enumerable: true, get: function () { return http_js_1.createHttpHandler; } });
-Object.defineProperty(exports, "createHttpUpgradeHandler", { enumerable: true, get: function () { return http_js_1.createUpgradeHandler; } });
-Object.defineProperty(exports, "createDeepgramHttpServer", { enumerable: true, get: function () { return http_js_1.createDeepgramHttpServer; } });
-// Express adapter
-var express_js_1 = require("./adapters/express.js");
-Object.defineProperty(exports, "createDeepgramProxy", { enumerable: true, get: function () { return express_js_1.createDeepgramProxy; } });
-Object.defineProperty(exports, "createDeepgramMiddleware", { enumerable: true, get: function () { return express_js_1.createDeepgramMiddleware; } });
-Object.defineProperty(exports, "createWebSocketHandler", { enumerable: true, get: function () { return express_js_1.createWebSocketHandler; } });
-// Fastify adapter
-var fastify_js_1 = require("./adapters/fastify.js");
-Object.defineProperty(exports, "fastifyDeepgramProxy", { enumerable: true, get: function () { return fastify_js_1.fastifyDeepgramProxy; } });
-Object.defineProperty(exports, "deepgramProxyPlugin", { enumerable: true, get: function () { return fastify_js_1.deepgramProxyPlugin; } });
-// JWT token management
-var jwt_js_1 = require("./core/jwt.js");
-Object.defineProperty(exports, "createProxyToken", { enumerable: true, get: function () { return jwt_js_1.createProxyToken; } });
-Object.defineProperty(exports, "verifyProxyToken", { enumerable: true, get: function () { return jwt_js_1.verifyProxyToken; } });
-// Core classes (for advanced usage)
-var ProxyHandler_js_1 = require("./core/ProxyHandler.js");
-Object.defineProperty(exports, "ProxyHandler", { enumerable: true, get: function () { return ProxyHandler_js_1.ProxyHandler; } });
-var TokenManager_js_1 = require("./core/TokenManager.js");
-Object.defineProperty(exports, "TokenManager", { enumerable: true, get: function () { return TokenManager_js_1.TokenManager; } });
-var WebSocketProxy_js_1 = require("./core/WebSocketProxy.js");
-Object.defineProperty(exports, "WebSocketProxy", { enumerable: true, get: function () { return WebSocketProxy_js_1.WebSocketProxy; } });

package/dist/cjs/tests/manual/test-custom-baseurl.js

@@ -1,124 +0,0 @@
-/**
- * Manual test: Verify baseUrl works for custom endpoints (like proxies)
- *
- * This test verifies that setting baseUrl to a custom endpoint correctly
- * routes ALL requests (auth, listen, manage) to that endpoint
- *
- * Run with: DEEPGRAM_API_KEY=your_key node dist/cjs/tests/manual/test-custom-baseurl.js
- */
-const { DeepgramClient } = require("../../dist/cjs/index.js");
-const http = require("http");
-// Simple mock proxy server that logs what endpoints are being hit
-function createMockProxyServer(port) {
-    const requestLog = [];
-    const server = http.createServer((req, res) => {
-        const requestInfo = {
-            method: req.method,
-            url: req.url,
-            path: new URL(req.url, `http://localhost:${port}`).pathname,
-            headers: req.headers,
-        };
-        console.log(`  [Proxy] ${req.method} ${requestInfo.path}`);
-        requestLog.push(requestInfo);
-        // Return a minimal valid response for different endpoints
-        res.writeHead(200, { "Content-Type": "application/json" });
-        if (requestInfo.path === "/v1/auth/grant") {
-            res.end(JSON.stringify({ token: "mock_token_12345" }));
-        }
-        else if (requestInfo.path === "/v1/projects") {
-            res.end(JSON.stringify({ projects: [{ project_id: "test", name: "Test Project" }] }));
-        }
-        else if (requestInfo.path === "/v1/listen") {
-            res.end(JSON.stringify({
-                metadata: { request_id: "test" },
-                results: {
-                    channels: [{
-                            alternatives: [{
-                                    transcript: "This is a mock transcription."
-                                }]
-                        }]
-                }
-            }));
-        }
-        else {
-            res.end(JSON.stringify({ success: true }));
-        }
-    });
-    return new Promise((resolve) => {
-        server.listen(port, () => {
-            console.log(`Mock proxy server listening on http://localhost:${port}\n`);
-            resolve({ server, requestLog });
-        });
-    });
-}
-async function testCustomBaseUrl() {
-    console.log("=== Testing Custom baseUrl Configuration ===\n");
-    const port = 9999;
-    const { server, requestLog } = await createMockProxyServer(port);
-    try {
-        // Create client with custom baseUrl
-        const client = new DeepgramClient({
-            apiKey: "test_key_12345",
-            baseUrl: `http://localhost:${port}`,
-        });
-        console.log("Client configured with:");
-        console.log(`  baseUrl: http://localhost:${port}`);
-        console.log("  (all requests should go to this URL)\n");
-        console.log("Running tests...\n");
-        // Test 1: Auth endpoint
-        console.log("Test 1: Auth endpoint");
-        await client.auth.v1.tokens.grant({ scopes: ["usage:write"] });
-        // Test 2: Management endpoint
-        console.log("Test 2: Management endpoint");
-        await client.manage.v1.projects.list();
-        // Test 3: Listen endpoint
-        console.log("Test 3: Listen endpoint");
-        await client.listen.v1.media.transcribeUrl({
-            url: "https://example.com/audio.wav",
-            model: "nova-3",
-        });
-        console.log("\n=== Results ===\n");
-        console.log("Requests received by proxy:");
-        requestLog.forEach((req, i) => {
-            console.log(`  ${i + 1}. ${req.method} ${req.path}`);
-        });
-        console.log("\n=== Verification ===\n");
-        // Verify all requests went to the custom baseUrl
-        const expectedPaths = ["/v1/auth/grant", "/v1/projects", "/v1/listen"];
-        const receivedPaths = requestLog.map((r) => r.path);
-        let allCorrect = true;
-        expectedPaths.forEach((expected) => {
-            if (receivedPaths.includes(expected)) {
-                console.log(`✓ ${expected} - Correctly routed to custom baseUrl`);
-            }
-            else {
-                console.log(`✗ ${expected} - NOT found in proxy logs!`);
-                allCorrect = false;
-            }
-        });
-        if (allCorrect) {
-            console.log("\n✓ All tests passed!");
-            console.log("All requests were correctly routed to the custom baseUrl.");
-        }
-        else {
-            console.log("\n✗ Some requests were NOT routed correctly!");
-            console.log("This indicates a bug in baseUrl handling.");
-            process.exit(1);
-        }
-    }
-    catch (error) {
-        console.error("\n✗ Test failed!");
-        console.error(`  Error: ${error.message}`);
-        if (error.stack) {
-            console.error(error.stack);
-        }
-        process.exit(1);
-    }
-    finally {
-        server.close();
-    }
-}
-// Run test
-(async () => {
-    await testCustomBaseUrl();
-})();