@wopr-network/platform-core 1.6.0 → 1.8.0

package/src/monetization/adapters/tts-factory.test.ts

@@ -0,0 +1,163 @@
+import { afterAll, describe, expect, it, vi } from "vitest";
+import { createTTSAdapters, createTTSAdaptersFromEnv } from "./tts-factory.js";
+
+describe("createTTSAdapters", () => {
+  it("creates both adapters when all config provided", () => {
+    const result = createTTSAdapters({
+      chatterboxBaseUrl: "http://chatterbox:8000",
+      elevenlabsApiKey: "sk-el",
+    });
+
+    expect(result.adapters).toHaveLength(2);
+    expect(result.adapterMap.size).toBe(2);
+    expect(result.skipped).toHaveLength(0);
+  });
+
+  it("returns adapters in cost-priority order (GPU first)", () => {
+    const result = createTTSAdapters({
+      chatterboxBaseUrl: "http://chatterbox:8000",
+      elevenlabsApiKey: "sk-el",
+    });
+
+    const names = result.adapters.map((a) => a.name);
+    expect(names).toEqual(["chatterbox-tts", "elevenlabs"]);
+  });
+
+  it("skips chatterbox when no base URL", () => {
+    const result = createTTSAdapters({
+      elevenlabsApiKey: "sk-el",
+    });
+
+    expect(result.adapters).toHaveLength(1);
+    expect(result.adapters[0].name).toBe("elevenlabs");
+    expect(result.skipped).toEqual(["chatterbox-tts"]);
+  });
+
+  it("skips elevenlabs when no API key", () => {
+    const result = createTTSAdapters({
+      chatterboxBaseUrl: "http://chatterbox:8000",
+    });
+
+    expect(result.adapters).toHaveLength(1);
+    expect(result.adapters[0].name).toBe("chatterbox-tts");
+    expect(result.skipped).toEqual(["elevenlabs"]);
+  });
+
+  it("skips elevenlabs with empty string API key", () => {
+    const result = createTTSAdapters({
+      chatterboxBaseUrl: "http://chatterbox:8000",
+      elevenlabsApiKey: "",
+    });
+
+    expect(result.adapters).toHaveLength(1);
+    expect(result.skipped).toContain("elevenlabs");
+  });
+
+  it("returns empty result when no config provided", () => {
+    const result = createTTSAdapters({});
+
+    expect(result.adapters).toHaveLength(0);
+    expect(result.adapterMap.size).toBe(0);
+    expect(result.skipped).toEqual(["chatterbox-tts", "elevenlabs"]);
+  });
+
+  it("all adapters support tts capability", () => {
+    const result = createTTSAdapters({
+      chatterboxBaseUrl: "http://chatterbox:8000",
+      elevenlabsApiKey: "sk-el",
+    });
+
+    for (const adapter of result.adapters) {
+      expect(adapter.capabilities).toContain("tts");
+    }
+  });
+
+  it("all adapters implement synthesizeSpeech", () => {
+    const result = createTTSAdapters({
+      chatterboxBaseUrl: "http://chatterbox:8000",
+      elevenlabsApiKey: "sk-el",
+    });
+
+    for (const adapter of result.adapters) {
+      expect(typeof adapter.synthesizeSpeech).toBe("function");
+    }
+  });
+
+  it("adapterMap keys match adapter names", () => {
+    const result = createTTSAdapters({
+      chatterboxBaseUrl: "http://chatterbox:8000",
+      elevenlabsApiKey: "sk-el",
+    });
+
+    for (const [key, adapter] of result.adapterMap) {
+      expect(key).toBe(adapter.name);
+    }
+  });
+
+  it("chatterbox adapter is marked self-hosted", () => {
+    const result = createTTSAdapters({
+      chatterboxBaseUrl: "http://chatterbox:8000",
+    });
+
+    expect(result.adapters[0].selfHosted).toBe(true);
+  });
+
+  it("elevenlabs adapter is not marked self-hosted", () => {
+    const result = createTTSAdapters({
+      elevenlabsApiKey: "sk-el",
+    });
+
+    expect(result.adapters[0].selfHosted).toBeUndefined();
+  });
+
+  it("passes per-adapter config overrides", () => {
+    const result = createTTSAdapters({
+      chatterboxBaseUrl: "http://chatterbox:8000",
+      chatterbox: { costPerChar: 0.000001 },
+      elevenlabsApiKey: "sk-el",
+      elevenlabs: { defaultVoice: "custom-voice" },
+    });
+
+    expect(result.adapters).toHaveLength(2);
+  });
+});
+
+describe("createTTSAdaptersFromEnv", () => {
+  afterAll(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("reads config from environment variables", () => {
+    vi.stubEnv("CHATTERBOX_BASE_URL", "http://chatterbox:8000");
+    vi.stubEnv("ELEVENLABS_API_KEY", "env-el");
+
+    const result = createTTSAdaptersFromEnv();
+
+    expect(result.adapters).toHaveLength(2);
+    const names = result.adapters.map((a) => a.name);
+    expect(names).toEqual(["chatterbox-tts", "elevenlabs"]);
+    expect(result.skipped).toHaveLength(0);
+  });
+
+  it("returns empty when no env vars set", () => {
+    vi.stubEnv("CHATTERBOX_BASE_URL", "");
+    vi.stubEnv("ELEVENLABS_API_KEY", "");
+
+    const result = createTTSAdaptersFromEnv();
+
+    expect(result.adapters).toHaveLength(0);
+    expect(result.skipped).toHaveLength(2);
+  });
+
+  it("accepts per-adapter overrides alongside env config", () => {
+    vi.stubEnv("CHATTERBOX_BASE_URL", "http://chatterbox:8000");
+    vi.stubEnv("ELEVENLABS_API_KEY", "");
+
+    const result = createTTSAdaptersFromEnv({
+      chatterbox: { costPerChar: 0.000001 },
+    });
+
+    expect(result.adapters).toHaveLength(1);
+    expect(result.adapters[0].name).toBe("chatterbox-tts");
+  });
+});

package/src/monetization/adapters/tts-factory.ts

@@ -0,0 +1,93 @@
+/**
+ * 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, createChatterboxTTSAdapter } from "./chatterbox-tts.js";
+import { createElevenLabsAdapter, 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 function createTTSAdapters(config: TTSFactoryConfig): TTSFactoryResult {
+  const adapters: ProviderAdapter[] = [];
+  const skipped: string[] = [];
+
+  // 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<string, ProviderAdapter>();
+  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?: Omit<TTSFactoryConfig, "chatterboxBaseUrl" | "elevenlabsApiKey">,
+): TTSFactoryResult {
+  return createTTSAdapters({
+    chatterboxBaseUrl: process.env.CHATTERBOX_BASE_URL,
+    elevenlabsApiKey: process.env.ELEVENLABS_API_KEY,
+    ...overrides,
+  });
+}

package/src/monetization/index.ts

@@ -34,6 +34,13 @@ export { type ChatterboxTTSAdapterConfig, createChatterboxTTSAdapter } from "./a
 export { createDeepgramAdapter, type DeepgramAdapterConfig } from "./adapters/deepgram.js";
 export { createDeepSeekAdapter, type DeepSeekAdapterConfig } from "./adapters/deepseek.js";
 export { createElevenLabsAdapter, type ElevenLabsAdapterConfig } from "./adapters/elevenlabs.js";
+// Embeddings adapter factory (WOP-2190)
+export {
+  createEmbeddingsAdapters,
+  createEmbeddingsAdaptersFromEnv,
+  type EmbeddingsFactoryConfig,
+  type EmbeddingsFactoryResult,
+} from "./adapters/embeddings-factory.js";
 export { createGeminiAdapter, type GeminiAdapterConfig } from "./adapters/gemini.js";
 export { createKimiAdapter, type KimiAdapterConfig } from "./adapters/kimi.js";
 // Margin config (WOP-364)
@@ -65,6 +72,20 @@ export {
   type TextGenFactoryConfig,
   type TextGenFactoryResult,
 } from "./adapters/text-gen-factory.js";
+// Transcription adapter factory
+export {
+  createTranscriptionAdapters,
+  createTranscriptionAdaptersFromEnv,
+  type TranscriptionFactoryConfig,
+  type TranscriptionFactoryResult,
+} from "./adapters/transcription-factory.js";
+// TTS adapter factory
+export {
+  createTTSAdapters,
+  createTTSAdaptersFromEnv,
+  type TTSFactoryConfig,
+  type TTSFactoryResult,
+} from "./adapters/tts-factory.js";
 export {
   type AdapterCapability,
   type AdapterResult,