@wopr-network/platform-core 1.6.0 → 1.8.0

package/dist/monetization/adapters/embeddings-factory.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Embeddings adapter factory — instantiates all available embeddings adapters
+ * from environment config and returns them ready to register.
+ *
+ * Only adapters with valid config are created. The factory never touches
+ * the database — it returns plain ProviderAdapter instances that the caller
+ * registers with an ArbitrageRouter or AdapterSocket.
+ *
+ * Priority order (cheapest first, when all adapters available):
+ *   self-hosted-embeddings (GPU, cheapest — not yet implemented)
+ *   → OpenRouter ($0.02/1M tokens via text-embedding-3-small)
+ */
+import { type OpenRouterAdapterConfig } from "./openrouter.js";
+import type { ProviderAdapter } from "./types.js";
+/** Top-level factory config. Only providers with an API key are instantiated. */
+export interface EmbeddingsFactoryConfig {
+    /** OpenRouter API key. Omit or empty string to skip. */
+    openrouterApiKey?: string;
+    /** Per-adapter config overrides */
+    openrouter?: Omit<Partial<OpenRouterAdapterConfig>, "apiKey">;
+}
+/** Result of the factory — adapters + metadata for observability. */
+export interface EmbeddingsFactoryResult {
+    /** All instantiated adapters, ordered by cost priority (cheapest first). */
+    adapters: ProviderAdapter[];
+    /** Map of adapter name → ProviderAdapter for direct registration. */
+    adapterMap: Map<string, ProviderAdapter>;
+    /** Names of providers that were skipped (missing config). */
+    skipped: string[];
+}
+/**
+ * Create embeddings adapters from the provided config.
+ *
+ * Returns only adapters whose API key is present and non-empty.
+ * Order matches arbitrage priority: cheapest first.
+ */
+export declare function createEmbeddingsAdapters(config: EmbeddingsFactoryConfig): EmbeddingsFactoryResult;
+/**
+ * Create embeddings adapters from environment variables.
+ *
+ * Reads API keys from:
+ *   - OPENROUTER_API_KEY
+ *
+ * Accepts optional per-adapter overrides.
+ */
+export declare function createEmbeddingsAdaptersFromEnv(overrides?: Omit<EmbeddingsFactoryConfig, "openrouterApiKey">): EmbeddingsFactoryResult;

package/dist/monetization/adapters/embeddings-factory.js

@@ -0,0 +1,50 @@
+/**
+ * Embeddings adapter factory — instantiates all available embeddings adapters
+ * from environment config and returns them ready to register.
+ *
+ * Only adapters with valid config are created. The factory never touches
+ * the database — it returns plain ProviderAdapter instances that the caller
+ * registers with an ArbitrageRouter or AdapterSocket.
+ *
+ * Priority order (cheapest first, when all adapters available):
+ *   self-hosted-embeddings (GPU, cheapest — not yet implemented)
+ *   → OpenRouter ($0.02/1M tokens via text-embedding-3-small)
+ */
+import { createOpenRouterAdapter } from "./openrouter.js";
+/**
+ * Create embeddings adapters from the provided config.
+ *
+ * Returns only adapters whose API key is present and non-empty.
+ * Order matches arbitrage priority: cheapest first.
+ */
+export function createEmbeddingsAdapters(config) {
+    const adapters = [];
+    const skipped = [];
+    // OpenRouter — $0.02/1M tokens (text-embedding-3-small via OpenAI)
+    if (config.openrouterApiKey) {
+        adapters.push(createOpenRouterAdapter({ ...config.openrouter, apiKey: config.openrouterApiKey }));
+    }
+    else {
+        skipped.push("openrouter");
+    }
+    // Future: self-hosted-embeddings will go BEFORE openrouter (GPU tier, cheapest)
+    const adapterMap = new Map();
+    for (const adapter of adapters) {
+        adapterMap.set(adapter.name, adapter);
+    }
+    return { adapters, adapterMap, skipped };
+}
+/**
+ * Create embeddings adapters from environment variables.
+ *
+ * Reads API keys from:
+ *   - OPENROUTER_API_KEY
+ *
+ * Accepts optional per-adapter overrides.
+ */
+export function createEmbeddingsAdaptersFromEnv(overrides) {
+    return createEmbeddingsAdapters({
+        openrouterApiKey: process.env.OPENROUTER_API_KEY,
+        ...overrides,
+    });
+}

package/dist/monetization/adapters/embeddings-factory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/monetization/adapters/embeddings-factory.test.js

@@ -0,0 +1,105 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { createEmbeddingsAdapters, createEmbeddingsAdaptersFromEnv } from "./embeddings-factory.js";
+import * as openrouterModule from "./openrouter.js";
+describe("createEmbeddingsAdapters", () => {
+    it("creates adapter when API key provided", () => {
+        const result = createEmbeddingsAdapters({
+            openrouterApiKey: "sk-or",
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapterMap.size).toBe(1);
+        expect(result.skipped).toHaveLength(0);
+    });
+    it("adapter is openrouter", () => {
+        const result = createEmbeddingsAdapters({
+            openrouterApiKey: "sk-or",
+        });
+        expect(result.adapters[0].name).toBe("openrouter");
+    });
+    it("skips openrouter when no API key", () => {
+        const result = createEmbeddingsAdapters({});
+        expect(result.adapters).toHaveLength(0);
+        expect(result.skipped).toEqual(["openrouter"]);
+    });
+    it("skips adapter with empty string key", () => {
+        const result = createEmbeddingsAdapters({
+            openrouterApiKey: "",
+        });
+        expect(result.adapters).toHaveLength(0);
+        expect(result.skipped).toContain("openrouter");
+    });
+    it("adapter supports embeddings capability", () => {
+        const result = createEmbeddingsAdapters({
+            openrouterApiKey: "sk-or",
+        });
+        expect(result.adapters[0].capabilities).toContain("embeddings");
+    });
+    it("adapter implements embed", () => {
+        const result = createEmbeddingsAdapters({
+            openrouterApiKey: "sk-or",
+        });
+        expect(typeof result.adapters[0].embed).toBe("function");
+    });
+    it("adapterMap keys match adapter names", () => {
+        const result = createEmbeddingsAdapters({
+            openrouterApiKey: "sk-or",
+        });
+        for (const [key, adapter] of result.adapterMap) {
+            expect(key).toBe(adapter.name);
+        }
+    });
+    it("passes per-adapter config overrides to adapter constructor", () => {
+        const spy = vi.spyOn(openrouterModule, "createOpenRouterAdapter");
+        createEmbeddingsAdapters({
+            openrouterApiKey: "sk-or",
+            openrouter: { marginMultiplier: 1.5 },
+        });
+        expect(spy).toHaveBeenCalledWith(expect.objectContaining({
+            apiKey: "sk-or",
+            marginMultiplier: 1.5,
+        }));
+        spy.mockRestore();
+    });
+    it("apiKey cannot be overridden via openrouter config", () => {
+        // Ensure apiKey always comes from openrouterApiKey, not from spread
+        const result = createEmbeddingsAdapters({
+            openrouterApiKey: "sk-real",
+            openrouter: { apiKey: "sk-evil" },
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("openrouter");
+    });
+});
+describe("createEmbeddingsAdaptersFromEnv", () => {
+    beforeEach(() => {
+        vi.unstubAllEnvs();
+    });
+    afterAll(() => {
+        vi.unstubAllEnvs();
+    });
+    it("reads key from environment variable", () => {
+        vi.stubEnv("OPENROUTER_API_KEY", "env-or");
+        const result = createEmbeddingsAdaptersFromEnv();
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("openrouter");
+        expect(result.skipped).toHaveLength(0);
+    });
+    it("returns empty when no env var set", () => {
+        vi.stubEnv("OPENROUTER_API_KEY", "");
+        const result = createEmbeddingsAdaptersFromEnv();
+        expect(result.adapters).toHaveLength(0);
+        expect(result.skipped).toEqual(["openrouter"]);
+    });
+    it("passes per-adapter overrides alongside env key to adapter constructor", () => {
+        vi.stubEnv("OPENROUTER_API_KEY", "env-or");
+        const spy = vi.spyOn(openrouterModule, "createOpenRouterAdapter");
+        createEmbeddingsAdaptersFromEnv({
+            openrouter: { marginMultiplier: 1.2 },
+        });
+        expect(spy).toHaveBeenCalledWith(expect.objectContaining({
+            apiKey: "env-or",
+            marginMultiplier: 1.2,
+        }));
+        spy.mockRestore();
+    });
+});

package/dist/monetization/adapters/rate-table.js

@@ -61,9 +61,33 @@ export const RATE_TABLE = [
         margin: 1.3, // 30% — dashboard default; runtime uses getMargin()
         effectivePrice: 0.0000013, // = costPerUnit * margin ($1.30 per 1M tokens)
     },
+    // Transcription - Speech-to-Text
+    // NOTE: No self-hosted whisper adapter yet — only premium (deepgram) available.
+    // When self-hosted-whisper lands, add a standard tier entry here.
+    {
+        capability: "transcription",
+        tier: "premium",
+        provider: "deepgram",
+        costPerUnit: 0.0000717, // $0.0043/min = $0.0000717/sec
+        billingUnit: "per-second",
+        margin: 1.3, // 30% — dashboard default; runtime uses getMargin()
+        effectivePrice: 0.00009321, // = costPerUnit * margin ($93.21 per 1M seconds ≈ $5.59 per 1M minutes)
+    },
+    // Embeddings
+    // NOTE: No self-hosted embeddings adapter yet — only premium (openrouter) available.
+    // When self-hosted-embeddings lands, add a standard tier entry here.
+    {
+        capability: "embeddings",
+        tier: "premium",
+        provider: "openrouter",
+        costPerUnit: 0.00000002, // $0.02 per 1M tokens (text-embedding-3-small via OpenRouter)
+        billingUnit: "per-token",
+        margin: 1.3, // 30% — dashboard default; runtime uses getMargin()
+        effectivePrice: 0.000000026, // = costPerUnit * margin ($0.026 per 1M tokens)
+    },
     // Future self-hosted adapters will add more entries here:
-    // - transcription: self-hosted-whisper (standard) vs deepgram (premium)
-    // - embeddings: self-hosted-embeddings (standard) vs openrouter (premium)
+    // - transcription: self-hosted-whisper (standard) — when GPU adapter exists
+    // - embeddings: self-hosted-embeddings (standard) — when GPU adapter exists
     // - image-generation: self-hosted-sdxl (standard) vs replicate (premium)
 ];
 /**

package/dist/monetization/adapters/rate-table.test.js

@@ -104,6 +104,12 @@ describe("getRatesForCapability", () => {
         expect(rates.map((r) => r.tier)).toContain("standard");
         expect(rates.map((r) => r.tier)).toContain("premium");
     });
+    it("returns premium-only for transcription (no standard tier yet)", () => {
+        const rates = getRatesForCapability("transcription");
+        expect(rates).toHaveLength(1);
+        expect(rates[0].tier).toBe("premium");
+        expect(rates[0].provider).toBe("deepgram");
+    });
     it("returns empty array for non-existent capability", () => {
         const rates = getRatesForCapability("image-generation");
         expect(rates).toHaveLength(0);
@@ -136,7 +142,8 @@ describe("calculateSavings", () => {
         expect(savings).toBeCloseTo(2.01, 2);
     });
     it("returns zero when capability has no standard tier", () => {
-        const savings = calculateSavings("image-generation", 1000);
+        // Transcription only has premium (deepgram) — no self-hosted whisper yet
+        const savings = calculateSavings("transcription", 1000);
         expect(savings).toBe(0);
     });
     it("returns zero when capability has no premium tier", () => {

package/dist/monetization/adapters/transcription-factory.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Transcription adapter factory — instantiates all available STT adapters
+ * from environment config and returns them ready to register.
+ *
+ * Only adapters with valid config are created. The factory never touches
+ * the database — it returns plain ProviderAdapter instances that the caller
+ * registers with an ArbitrageRouter or AdapterSocket.
+ *
+ * Priority order (cheapest first, when all adapters available):
+ *   self-hosted-whisper (GPU, cheapest) → Deepgram ($0.0043/min, third-party)
+ *
+ * NOTE: Self-hosted Whisper adapter doesn't exist yet. When it does, it
+ * will slot in as the GPU tier (cheapest) ahead of Deepgram.
+ */
+import { type DeepgramAdapterConfig } from "./deepgram.js";
+import type { ProviderAdapter } from "./types.js";
+/** Top-level factory config. Only providers with an API key are instantiated. */
+export interface TranscriptionFactoryConfig {
+    /** Deepgram API key. Omit or empty string to skip. */
+    deepgramApiKey?: string;
+    /** Per-adapter config overrides */
+    deepgram?: Omit<Partial<DeepgramAdapterConfig>, "apiKey">;
+}
+/** Result of the factory — adapters + metadata for observability. */
+export interface TranscriptionFactoryResult {
+    /** All instantiated adapters, ordered by cost priority (cheapest first). */
+    adapters: ProviderAdapter[];
+    /** Map of adapter name → ProviderAdapter for direct registration. */
+    adapterMap: Map<string, ProviderAdapter>;
+    /** Names of providers that were skipped (no API key). */
+    skipped: string[];
+}
+/**
+ * Create transcription adapters from the provided config.
+ *
+ * Returns only adapters whose API key is present and non-empty.
+ * Order matches arbitrage priority: cheapest first.
+ */
+export declare function createTranscriptionAdapters(config: TranscriptionFactoryConfig): TranscriptionFactoryResult;
+/**
+ * Create transcription adapters from environment variables.
+ *
+ * Reads API keys from:
+ *   - DEEPGRAM_API_KEY
+ *
+ * Accepts optional per-adapter overrides.
+ */
+export declare function createTranscriptionAdaptersFromEnv(overrides?: Omit<TranscriptionFactoryConfig, "deepgramApiKey">): TranscriptionFactoryResult;

package/dist/monetization/adapters/transcription-factory.js

@@ -0,0 +1,52 @@
+/**
+ * Transcription adapter factory — instantiates all available STT adapters
+ * from environment config and returns them ready to register.
+ *
+ * Only adapters with valid config are created. The factory never touches
+ * the database — it returns plain ProviderAdapter instances that the caller
+ * registers with an ArbitrageRouter or AdapterSocket.
+ *
+ * Priority order (cheapest first, when all adapters available):
+ *   self-hosted-whisper (GPU, cheapest) → Deepgram ($0.0043/min, third-party)
+ *
+ * NOTE: Self-hosted Whisper adapter doesn't exist yet. When it does, it
+ * will slot in as the GPU tier (cheapest) ahead of Deepgram.
+ */
+import { createDeepgramAdapter } from "./deepgram.js";
+/**
+ * Create transcription adapters from the provided config.
+ *
+ * Returns only adapters whose API key is present and non-empty.
+ * Order matches arbitrage priority: cheapest first.
+ */
+export function createTranscriptionAdapters(config) {
+    const adapters = [];
+    const skipped = [];
+    // Deepgram — $0.0043/min (Nova-2 wholesale)
+    if (config.deepgramApiKey) {
+        adapters.push(createDeepgramAdapter({ apiKey: config.deepgramApiKey, ...config.deepgram }));
+    }
+    else {
+        skipped.push("deepgram");
+    }
+    // Future: self-hosted-whisper will go BEFORE deepgram (GPU tier, cheapest)
+    const adapterMap = new Map();
+    for (const adapter of adapters) {
+        adapterMap.set(adapter.name, adapter);
+    }
+    return { adapters, adapterMap, skipped };
+}
+/**
+ * Create transcription adapters from environment variables.
+ *
+ * Reads API keys from:
+ *   - DEEPGRAM_API_KEY
+ *
+ * Accepts optional per-adapter overrides.
+ */
+export function createTranscriptionAdaptersFromEnv(overrides) {
+    return createTranscriptionAdapters({
+        deepgramApiKey: process.env.DEEPGRAM_API_KEY,
+        ...overrides,
+    });
+}

package/dist/monetization/adapters/transcription-factory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/monetization/adapters/transcription-factory.test.js

@@ -0,0 +1,84 @@
+import { afterAll, describe, expect, it, vi } from "vitest";
+import { createTranscriptionAdapters, createTranscriptionAdaptersFromEnv } from "./transcription-factory.js";
+describe("createTranscriptionAdapters", () => {
+    it("creates deepgram adapter when API key provided", () => {
+        const result = createTranscriptionAdapters({
+            deepgramApiKey: "sk-dg",
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapterMap.size).toBe(1);
+        expect(result.skipped).toHaveLength(0);
+    });
+    it("returns deepgram as only adapter", () => {
+        const result = createTranscriptionAdapters({
+            deepgramApiKey: "sk-dg",
+        });
+        expect(result.adapters[0].name).toBe("deepgram");
+    });
+    it("skips deepgram when no API key", () => {
+        const result = createTranscriptionAdapters({});
+        expect(result.adapters).toHaveLength(0);
+        expect(result.skipped).toEqual(["deepgram"]);
+    });
+    it("skips deepgram with empty string API key", () => {
+        const result = createTranscriptionAdapters({
+            deepgramApiKey: "",
+        });
+        expect(result.adapters).toHaveLength(0);
+        expect(result.skipped).toContain("deepgram");
+    });
+    it("adapter supports transcription capability", () => {
+        const result = createTranscriptionAdapters({
+            deepgramApiKey: "sk-dg",
+        });
+        expect(result.adapters[0].capabilities).toContain("transcription");
+    });
+    it("adapter implements transcribe", () => {
+        const result = createTranscriptionAdapters({
+            deepgramApiKey: "sk-dg",
+        });
+        expect(typeof result.adapters[0].transcribe).toBe("function");
+    });
+    it("adapterMap keys match adapter names", () => {
+        const result = createTranscriptionAdapters({
+            deepgramApiKey: "sk-dg",
+        });
+        for (const [key, adapter] of result.adapterMap) {
+            expect(key).toBe(adapter.name);
+        }
+    });
+    it("passes per-adapter config overrides", () => {
+        const result = createTranscriptionAdapters({
+            deepgramApiKey: "sk-dg",
+            deepgram: { costPerMinute: 0.005, defaultModel: "nova-2-general" },
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("deepgram");
+    });
+});
+describe("createTranscriptionAdaptersFromEnv", () => {
+    afterAll(() => {
+        vi.unstubAllEnvs();
+    });
+    it("reads API keys from environment variables", () => {
+        vi.stubEnv("DEEPGRAM_API_KEY", "env-dg");
+        const result = createTranscriptionAdaptersFromEnv();
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("deepgram");
+        expect(result.skipped).toHaveLength(0);
+    });
+    it("returns empty when no env vars set", () => {
+        vi.stubEnv("DEEPGRAM_API_KEY", "");
+        const result = createTranscriptionAdaptersFromEnv();
+        expect(result.adapters).toHaveLength(0);
+        expect(result.skipped).toHaveLength(1);
+    });
+    it("accepts per-adapter overrides alongside env keys", () => {
+        vi.stubEnv("DEEPGRAM_API_KEY", "env-dg");
+        const result = createTranscriptionAdaptersFromEnv({
+            deepgram: { marginMultiplier: 1.5 },
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("deepgram");
+    });
+});

package/dist/monetization/adapters/tts-factory.d.ts

@@ -0,0 +1,50 @@
+/**
+ * TTS adapter factory — instantiates all available TTS adapters from
+ * environment config and returns them ready to register.
+ *
+ * Only adapters with valid config are created. The factory never touches
+ * the database — it returns plain ProviderAdapter instances that the caller
+ * registers with an ArbitrageRouter or AdapterSocket.
+ *
+ * Priority order (cheapest first):
+ *   GPU (chatterbox-tts, self-hosted) → ElevenLabs (third-party)
+ */
+import { type ChatterboxTTSAdapterConfig } from "./chatterbox-tts.js";
+import { type ElevenLabsAdapterConfig } from "./elevenlabs.js";
+import type { ProviderAdapter } from "./types.js";
+/** Top-level factory config. Chatterbox needs a base URL; ElevenLabs needs an API key. */
+export interface TTSFactoryConfig {
+    /** Chatterbox GPU container base URL (e.g., "http://chatterbox:8000"). Omit to skip. */
+    chatterboxBaseUrl?: string;
+    /** ElevenLabs API key. Omit or empty string to skip. */
+    elevenlabsApiKey?: string;
+    /** Per-adapter config overrides */
+    chatterbox?: Omit<Partial<ChatterboxTTSAdapterConfig>, "baseUrl">;
+    elevenlabs?: Omit<Partial<ElevenLabsAdapterConfig>, "apiKey">;
+}
+/** Result of the factory — adapters + metadata for observability. */
+export interface TTSFactoryResult {
+    /** All instantiated adapters, ordered by cost priority (cheapest first). */
+    adapters: ProviderAdapter[];
+    /** Map of adapter name → ProviderAdapter for direct registration. */
+    adapterMap: Map<string, ProviderAdapter>;
+    /** Names of providers that were skipped (missing config). */
+    skipped: string[];
+}
+/**
+ * Create TTS adapters from the provided config.
+ *
+ * Returns only adapters whose required config is present.
+ * Order matches arbitrage priority: GPU (cheapest) first.
+ */
+export declare function createTTSAdapters(config: TTSFactoryConfig): TTSFactoryResult;
+/**
+ * Create TTS adapters from environment variables.
+ *
+ * Reads config from:
+ *   - CHATTERBOX_BASE_URL
+ *   - ELEVENLABS_API_KEY
+ *
+ * Accepts optional per-adapter overrides.
+ */
+export declare function createTTSAdaptersFromEnv(overrides?: Omit<TTSFactoryConfig, "chatterboxBaseUrl" | "elevenlabsApiKey">): TTSFactoryResult;

package/dist/monetization/adapters/tts-factory.js

@@ -0,0 +1,62 @@
+/**
+ * TTS adapter factory — instantiates all available TTS adapters from
+ * environment config and returns them ready to register.
+ *
+ * Only adapters with valid config are created. The factory never touches
+ * the database — it returns plain ProviderAdapter instances that the caller
+ * registers with an ArbitrageRouter or AdapterSocket.
+ *
+ * Priority order (cheapest first):
+ *   GPU (chatterbox-tts, self-hosted) → ElevenLabs (third-party)
+ */
+import { createChatterboxTTSAdapter } from "./chatterbox-tts.js";
+import { createElevenLabsAdapter } from "./elevenlabs.js";
+/**
+ * Create TTS adapters from the provided config.
+ *
+ * Returns only adapters whose required config is present.
+ * Order matches arbitrage priority: GPU (cheapest) first.
+ */
+export function createTTSAdapters(config) {
+    const adapters = [];
+    const skipped = [];
+    // Chatterbox — self-hosted GPU, $2.00/1M chars wholesale, $2.40/1M effective (cheapest)
+    if (config.chatterboxBaseUrl) {
+        adapters.push(createChatterboxTTSAdapter({
+            baseUrl: config.chatterboxBaseUrl,
+            costPerUnit: 0.000002,
+            ...config.chatterbox,
+        }));
+    }
+    else {
+        skipped.push("chatterbox-tts");
+    }
+    // ElevenLabs — third-party, ~$15/1M chars (premium)
+    if (config.elevenlabsApiKey) {
+        adapters.push(createElevenLabsAdapter({ apiKey: config.elevenlabsApiKey, ...config.elevenlabs }));
+    }
+    else {
+        skipped.push("elevenlabs");
+    }
+    const adapterMap = new Map();
+    for (const adapter of adapters) {
+        adapterMap.set(adapter.name, adapter);
+    }
+    return { adapters, adapterMap, skipped };
+}
+/**
+ * Create TTS adapters from environment variables.
+ *
+ * Reads config from:
+ *   - CHATTERBOX_BASE_URL
+ *   - ELEVENLABS_API_KEY
+ *
+ * Accepts optional per-adapter overrides.
+ */
+export function createTTSAdaptersFromEnv(overrides) {
+    return createTTSAdapters({
+        chatterboxBaseUrl: process.env.CHATTERBOX_BASE_URL,
+        elevenlabsApiKey: process.env.ELEVENLABS_API_KEY,
+        ...overrides,
+    });
+}

package/dist/monetization/adapters/tts-factory.test.d.ts

@@ -0,0 +1 @@
+export {};