@deepgram/sdk 5.0.0-beta.3 → 5.0.0

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

@@ -0,0 +1,136 @@
+"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

@@ -0,0 +1,37 @@
+/**
+ * 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/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,55 @@
+/**
+ * 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

@@ -0,0 +1,75 @@
+"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

@@ -0,0 +1,124 @@
+/**
+ * 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();
+})();

package/dist/cjs/version.d.ts

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

package/dist/cjs/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "0.0.283";
+exports.SDK_VERSION = "4.11.4";

package/dist/esm/BaseClient.mjs

@@ -5,9 +5,9 @@ import * as core from "./core/index.mjs";
 export function normalizeClientOptions(options) {
     const headers = mergeHeaders({
         "X-Fern-Language": "JavaScript",
-        "X-Fern-SDK-Name": "",
-        "X-Fern-SDK-Version": "0.0.283",
-        "User-Agent": "/0.0.283",
+        "X-Fern-SDK-Name": "@deepgram/sdk",
+        "X-Fern-SDK-Version": "4.11.4",
+        "User-Agent": "@deepgram/sdk/4.11.4",
         "X-Fern-Runtime": core.RUNTIME.type,
         "X-Fern-Runtime-Version": core.RUNTIME.version,
     }, options === null || options === void 0 ? void 0 : options.headers);