@wopr-network/platform-core 1.8.0 → 1.10.0

package/dist/monetization/adapters/bootstrap.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Unified adapter bootstrap — instantiates ALL capability-specific adapter
+ * factories from a single config and returns every adapter ready to register.
+ *
+ * This is the top-level entry point for standing up the full arbitrage stack.
+ * Call `bootstrapAdapters(config)` (or `bootstrapAdaptersFromEnv()`) once at
+ * startup, then register the returned adapters with an ArbitrageRouter or
+ * AdapterSocket.
+ *
+ * Capabilities wired:
+ *   - text-generation (DeepSeek, Gemini, MiniMax, Kimi, OpenRouter)
+ *   - tts (Chatterbox GPU, ElevenLabs)
+ *   - transcription (Deepgram)
+ *   - embeddings (OpenRouter)
+ *
+ * Image-generation (Nano Banana, Replicate) will be wired once the
+ * image-gen-factory PR merges.
+ */
+import { type EmbeddingsFactoryConfig } from "./embeddings-factory.js";
+import { type TextGenFactoryConfig } from "./text-gen-factory.js";
+import { type TranscriptionFactoryConfig } from "./transcription-factory.js";
+import { type TTSFactoryConfig } from "./tts-factory.js";
+import type { ProviderAdapter } from "./types.js";
+/** Combined config for all adapter factories. */
+export interface BootstrapConfig {
+    /** Text-generation adapter config */
+    textGen?: TextGenFactoryConfig;
+    /** TTS adapter config */
+    tts?: TTSFactoryConfig;
+    /** Transcription adapter config */
+    transcription?: TranscriptionFactoryConfig;
+    /** Embeddings adapter config */
+    embeddings?: EmbeddingsFactoryConfig;
+}
+/** Result of bootstrapping all adapters. */
+export interface BootstrapResult {
+    /**
+     * All instantiated adapters across all capabilities, ordered by capability then cost.
+     * Register these with an ArbitrageRouter or AdapterSocket.
+     *
+     * NOTE: The same provider may appear multiple times if it serves multiple
+     * capabilities (e.g. OpenRouter for both text-gen and embeddings). Each
+     * instance is independently configured. Use the per-capability factory
+     * results if you need a name→adapter map within a single capability.
+     */
+    adapters: ProviderAdapter[];
+    /** Names of providers that were skipped (missing config), grouped by capability. */
+    skipped: Record<string, string[]>;
+    /** Summary counts for observability. */
+    summary: {
+        total: number;
+        skipped: number;
+        byCapability: Record<string, number>;
+    };
+}
+/**
+ * Bootstrap all adapter factories from the provided config.
+ *
+ * Instantiates every capability factory and merges the results into a
+ * single unified result. Only adapters with valid config are created.
+ */
+export declare function bootstrapAdapters(config: BootstrapConfig): BootstrapResult;
+/**
+ * Bootstrap all adapter factories from environment variables.
+ *
+ * Reads API keys from:
+ *   - DEEPSEEK_API_KEY, GEMINI_API_KEY, MINIMAX_API_KEY, KIMI_API_KEY, OPENROUTER_API_KEY (text-gen)
+ *   - CHATTERBOX_BASE_URL, ELEVENLABS_API_KEY (TTS)
+ *   - DEEPGRAM_API_KEY (transcription)
+ *   - OPENROUTER_API_KEY (embeddings)
+ *
+ * Accepts optional per-capability config overrides.
+ */
+export declare function bootstrapAdaptersFromEnv(overrides?: Partial<BootstrapConfig>): BootstrapResult;

package/dist/monetization/adapters/bootstrap.js

@@ -0,0 +1,103 @@
+/**
+ * Unified adapter bootstrap — instantiates ALL capability-specific adapter
+ * factories from a single config and returns every adapter ready to register.
+ *
+ * This is the top-level entry point for standing up the full arbitrage stack.
+ * Call `bootstrapAdapters(config)` (or `bootstrapAdaptersFromEnv()`) once at
+ * startup, then register the returned adapters with an ArbitrageRouter or
+ * AdapterSocket.
+ *
+ * Capabilities wired:
+ *   - text-generation (DeepSeek, Gemini, MiniMax, Kimi, OpenRouter)
+ *   - tts (Chatterbox GPU, ElevenLabs)
+ *   - transcription (Deepgram)
+ *   - embeddings (OpenRouter)
+ *
+ * Image-generation (Nano Banana, Replicate) will be wired once the
+ * image-gen-factory PR merges.
+ */
+import { createEmbeddingsAdapters } from "./embeddings-factory.js";
+import { createTextGenAdapters } from "./text-gen-factory.js";
+import { createTranscriptionAdapters } from "./transcription-factory.js";
+import { createTTSAdapters } from "./tts-factory.js";
+/**
+ * Bootstrap all adapter factories from the provided config.
+ *
+ * Instantiates every capability factory and merges the results into a
+ * single unified result. Only adapters with valid config are created.
+ */
+export function bootstrapAdapters(config) {
+    const textGen = createTextGenAdapters(config.textGen ?? {});
+    const tts = createTTSAdapters(config.tts ?? {});
+    const transcription = createTranscriptionAdapters(config.transcription ?? {});
+    const embeddings = createEmbeddingsAdapters(config.embeddings ?? {});
+    const adapters = [
+        ...textGen.adapters,
+        ...tts.adapters,
+        ...transcription.adapters,
+        ...embeddings.adapters,
+    ];
+    const skipped = {};
+    if (textGen.skipped.length > 0)
+        skipped["text-generation"] = textGen.skipped;
+    if (tts.skipped.length > 0)
+        skipped.tts = tts.skipped;
+    if (transcription.skipped.length > 0)
+        skipped.transcription = transcription.skipped;
+    if (embeddings.skipped.length > 0)
+        skipped.embeddings = embeddings.skipped;
+    let totalSkipped = 0;
+    for (const list of Object.values(skipped)) {
+        totalSkipped += list.length;
+    }
+    return {
+        adapters,
+        skipped,
+        summary: {
+            total: adapters.length,
+            skipped: totalSkipped,
+            byCapability: {
+                "text-generation": textGen.adapters.length,
+                tts: tts.adapters.length,
+                transcription: transcription.adapters.length,
+                embeddings: embeddings.adapters.length,
+            },
+        },
+    };
+}
+/**
+ * Bootstrap all adapter factories from environment variables.
+ *
+ * Reads API keys from:
+ *   - DEEPSEEK_API_KEY, GEMINI_API_KEY, MINIMAX_API_KEY, KIMI_API_KEY, OPENROUTER_API_KEY (text-gen)
+ *   - CHATTERBOX_BASE_URL, ELEVENLABS_API_KEY (TTS)
+ *   - DEEPGRAM_API_KEY (transcription)
+ *   - OPENROUTER_API_KEY (embeddings)
+ *
+ * Accepts optional per-capability config overrides.
+ */
+export function bootstrapAdaptersFromEnv(overrides) {
+    return bootstrapAdapters({
+        textGen: {
+            deepseekApiKey: process.env.DEEPSEEK_API_KEY,
+            geminiApiKey: process.env.GEMINI_API_KEY,
+            minimaxApiKey: process.env.MINIMAX_API_KEY,
+            kimiApiKey: process.env.KIMI_API_KEY,
+            openrouterApiKey: process.env.OPENROUTER_API_KEY,
+            ...overrides?.textGen,
+        },
+        tts: {
+            chatterboxBaseUrl: process.env.CHATTERBOX_BASE_URL,
+            elevenlabsApiKey: process.env.ELEVENLABS_API_KEY,
+            ...overrides?.tts,
+        },
+        transcription: {
+            deepgramApiKey: process.env.DEEPGRAM_API_KEY,
+            ...overrides?.transcription,
+        },
+        embeddings: {
+            openrouterApiKey: process.env.OPENROUTER_API_KEY,
+            ...overrides?.embeddings,
+        },
+    });
+}

package/dist/monetization/adapters/bootstrap.test.d.ts

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

package/dist/monetization/adapters/bootstrap.test.js

@@ -0,0 +1,146 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { bootstrapAdapters, bootstrapAdaptersFromEnv } from "./bootstrap.js";
+describe("bootstrapAdapters", () => {
+    it("creates all adapters when all keys provided", () => {
+        const result = bootstrapAdapters({
+            textGen: {
+                deepseekApiKey: "sk-ds",
+                geminiApiKey: "sk-gem",
+                minimaxApiKey: "sk-mm",
+                kimiApiKey: "sk-kimi",
+                openrouterApiKey: "sk-or",
+            },
+            tts: {
+                chatterboxBaseUrl: "http://chatterbox:8000",
+                elevenlabsApiKey: "sk-el",
+            },
+            transcription: {
+                deepgramApiKey: "sk-dg",
+            },
+            embeddings: {
+                openrouterApiKey: "sk-or",
+            },
+        });
+        // 5 text-gen + 2 TTS + 1 transcription + 1 embeddings = 9
+        expect(result.adapters).toHaveLength(9);
+        expect(result.summary.total).toBe(9);
+        expect(result.summary.skipped).toBe(0);
+    });
+    it("allows duplicate provider names across capabilities", () => {
+        const result = bootstrapAdapters({
+            textGen: { openrouterApiKey: "sk-or" },
+            embeddings: { openrouterApiKey: "sk-or" },
+        });
+        // OpenRouter appears twice — once for text-gen, once for embeddings
+        const openrouters = result.adapters.filter((a) => a.name === "openrouter");
+        expect(openrouters).toHaveLength(2);
+        expect(result.summary.total).toBe(2);
+    });
+    it("returns correct per-capability counts", () => {
+        const result = bootstrapAdapters({
+            textGen: { deepseekApiKey: "sk-ds" },
+            tts: { chatterboxBaseUrl: "http://chatterbox:8000" },
+            transcription: { deepgramApiKey: "sk-dg" },
+            embeddings: { openrouterApiKey: "sk-or" },
+        });
+        expect(result.summary.byCapability).toEqual({
+            "text-generation": 1,
+            tts: 1,
+            transcription: 1,
+            embeddings: 1,
+        });
+    });
+    it("tracks skipped providers by capability", () => {
+        const result = bootstrapAdapters({
+            textGen: { deepseekApiKey: "sk-ds" },
+            tts: {},
+            transcription: {},
+            embeddings: {},
+        });
+        expect(result.skipped.tts).toEqual(["chatterbox-tts", "elevenlabs"]);
+        expect(result.skipped.transcription).toEqual(["deepgram"]);
+        expect(result.skipped.embeddings).toEqual(["openrouter"]);
+        expect(result.skipped["text-generation"]).toEqual(["gemini", "minimax", "kimi", "openrouter"]);
+    });
+    it("returns empty result when no config provided", () => {
+        const result = bootstrapAdapters({});
+        expect(result.adapters).toHaveLength(0);
+        expect(result.summary.total).toBe(0);
+        expect(result.summary.skipped).toBeGreaterThan(0);
+    });
+    it("omits capability from skipped when all providers created", () => {
+        const result = bootstrapAdapters({
+            transcription: { deepgramApiKey: "sk-dg" },
+        });
+        expect(result.skipped.transcription).toBeUndefined();
+    });
+    it("handles partial config — only text-gen", () => {
+        const result = bootstrapAdapters({
+            textGen: { openrouterApiKey: "sk-or" },
+        });
+        expect(result.summary.byCapability["text-generation"]).toBe(1);
+        expect(result.summary.byCapability.tts).toBe(0);
+        expect(result.summary.byCapability.transcription).toBe(0);
+        expect(result.summary.byCapability.embeddings).toBe(0);
+    });
+    it("passes per-adapter overrides through", () => {
+        const result = bootstrapAdapters({
+            textGen: {
+                deepseekApiKey: "sk-ds",
+                deepseek: { marginMultiplier: 1.5 },
+            },
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("deepseek");
+    });
+});
+describe("bootstrapAdaptersFromEnv", () => {
+    beforeEach(() => {
+        vi.unstubAllEnvs();
+    });
+    afterAll(() => {
+        vi.unstubAllEnvs();
+    });
+    it("reads all keys from environment variables", () => {
+        vi.stubEnv("DEEPSEEK_API_KEY", "env-ds");
+        vi.stubEnv("GEMINI_API_KEY", "env-gem");
+        vi.stubEnv("MINIMAX_API_KEY", "env-mm");
+        vi.stubEnv("KIMI_API_KEY", "env-kimi");
+        vi.stubEnv("OPENROUTER_API_KEY", "env-or");
+        vi.stubEnv("CHATTERBOX_BASE_URL", "http://chatterbox:8000");
+        vi.stubEnv("ELEVENLABS_API_KEY", "env-el");
+        vi.stubEnv("DEEPGRAM_API_KEY", "env-dg");
+        const result = bootstrapAdaptersFromEnv();
+        // 5 text-gen + 2 TTS + 1 transcription + 1 embeddings = 9
+        expect(result.adapters).toHaveLength(9);
+        expect(result.summary.total).toBe(9);
+    });
+    it("returns empty when no env vars set", () => {
+        vi.stubEnv("DEEPSEEK_API_KEY", "");
+        vi.stubEnv("GEMINI_API_KEY", "");
+        vi.stubEnv("MINIMAX_API_KEY", "");
+        vi.stubEnv("KIMI_API_KEY", "");
+        vi.stubEnv("OPENROUTER_API_KEY", "");
+        vi.stubEnv("CHATTERBOX_BASE_URL", "");
+        vi.stubEnv("ELEVENLABS_API_KEY", "");
+        vi.stubEnv("DEEPGRAM_API_KEY", "");
+        const result = bootstrapAdaptersFromEnv();
+        expect(result.adapters).toHaveLength(0);
+        expect(result.summary.skipped).toBeGreaterThan(0);
+    });
+    it("accepts per-capability overrides", () => {
+        vi.stubEnv("DEEPSEEK_API_KEY", "env-ds");
+        vi.stubEnv("GEMINI_API_KEY", "");
+        vi.stubEnv("MINIMAX_API_KEY", "");
+        vi.stubEnv("KIMI_API_KEY", "");
+        vi.stubEnv("OPENROUTER_API_KEY", "");
+        vi.stubEnv("CHATTERBOX_BASE_URL", "");
+        vi.stubEnv("ELEVENLABS_API_KEY", "");
+        vi.stubEnv("DEEPGRAM_API_KEY", "");
+        const result = bootstrapAdaptersFromEnv({
+            textGen: { deepseek: { marginMultiplier: 2.0 } },
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("deepseek");
+    });
+});

package/dist/monetization/adapters/image-gen-factory.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Image generation adapter factory — instantiates all available image-gen
+ * 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-sdxl (GPU, cheapest — not yet implemented)
+ *   → Replicate (~$0.019/image, SDXL on A40)
+ *   → Nano Banana / Gemini ($0.02/image)
+ */
+import { type NanoBananaAdapterConfig } from "./nano-banana.js";
+import { type ReplicateAdapterConfig } from "./replicate.js";
+import type { ProviderAdapter } from "./types.js";
+/** Top-level factory config. Only providers with an API key/token are instantiated. */
+export interface ImageGenFactoryConfig {
+    /** Gemini API key (for Nano Banana image generation). Omit or empty string to skip. */
+    geminiApiKey?: string;
+    /** Replicate API token. Omit or empty string to skip. */
+    replicateApiToken?: string;
+    /** Per-adapter config overrides */
+    nanoBanana?: Omit<Partial<NanoBananaAdapterConfig>, "apiKey">;
+    replicate?: Omit<Partial<ReplicateAdapterConfig>, "apiToken">;
+}
+/** Result of the factory — adapters + metadata for observability. */
+export interface ImageGenFactoryResult {
+    /** 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 image generation adapters from the provided config.
+ *
+ * Returns only adapters whose API key/token is present and non-empty.
+ * Order matches arbitrage priority: cheapest first.
+ */
+export declare function createImageGenAdapters(config: ImageGenFactoryConfig): ImageGenFactoryResult;
+/**
+ * Create image generation adapters from environment variables.
+ *
+ * Reads config from:
+ *   - GEMINI_API_KEY (for Nano Banana)
+ *   - REPLICATE_API_TOKEN
+ *
+ * Accepts optional per-adapter overrides.
+ */
+export declare function createImageGenAdaptersFromEnv(overrides?: Omit<ImageGenFactoryConfig, "geminiApiKey" | "replicateApiToken">): ImageGenFactoryResult;

package/dist/monetization/adapters/image-gen-factory.js

@@ -0,0 +1,60 @@
+/**
+ * Image generation adapter factory — instantiates all available image-gen
+ * 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-sdxl (GPU, cheapest — not yet implemented)
+ *   → Replicate (~$0.019/image, SDXL on A40)
+ *   → Nano Banana / Gemini ($0.02/image)
+ */
+import { createNanoBananaAdapter } from "./nano-banana.js";
+import { createReplicateAdapter } from "./replicate.js";
+/**
+ * Create image generation adapters from the provided config.
+ *
+ * Returns only adapters whose API key/token is present and non-empty.
+ * Order matches arbitrage priority: cheapest first.
+ */
+export function createImageGenAdapters(config) {
+    const adapters = [];
+    const skipped = [];
+    // Replicate — ~$0.019/image SDXL (cheapest)
+    if (config.replicateApiToken) {
+        adapters.push(createReplicateAdapter({ apiToken: config.replicateApiToken, ...config.replicate }));
+    }
+    else {
+        skipped.push("replicate");
+    }
+    // Nano Banana (Gemini) — $0.02/image (slightly more expensive fallback)
+    if (config.geminiApiKey) {
+        adapters.push(createNanoBananaAdapter({ apiKey: config.geminiApiKey, ...config.nanoBanana }));
+    }
+    else {
+        skipped.push("nano-banana");
+    }
+    const adapterMap = new Map();
+    for (const adapter of adapters) {
+        adapterMap.set(adapter.name, adapter);
+    }
+    return { adapters, adapterMap, skipped };
+}
+/**
+ * Create image generation adapters from environment variables.
+ *
+ * Reads config from:
+ *   - GEMINI_API_KEY (for Nano Banana)
+ *   - REPLICATE_API_TOKEN
+ *
+ * Accepts optional per-adapter overrides.
+ */
+export function createImageGenAdaptersFromEnv(overrides) {
+    return createImageGenAdapters({
+        geminiApiKey: process.env.GEMINI_API_KEY,
+        replicateApiToken: process.env.REPLICATE_API_TOKEN,
+        ...overrides,
+    });
+}

package/dist/monetization/adapters/image-gen-factory.test.d.ts

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

package/dist/monetization/adapters/image-gen-factory.test.js

@@ -0,0 +1,126 @@
+import { afterAll, describe, expect, it, vi } from "vitest";
+import { createImageGenAdapters, createImageGenAdaptersFromEnv } from "./image-gen-factory.js";
+describe("createImageGenAdapters", () => {
+    it("creates both adapters when all keys provided", () => {
+        const result = createImageGenAdapters({
+            geminiApiKey: "sk-gem",
+            replicateApiToken: "r8-rep",
+        });
+        expect(result.adapters).toHaveLength(2);
+        expect(result.adapterMap.size).toBe(2);
+        expect(result.skipped).toHaveLength(0);
+    });
+    it("returns adapters in cost-priority order (cheapest first)", () => {
+        const result = createImageGenAdapters({
+            geminiApiKey: "sk-gem",
+            replicateApiToken: "r8-rep",
+        });
+        const names = result.adapters.map((a) => a.name);
+        expect(names).toEqual(["replicate", "nano-banana"]);
+    });
+    it("skips nano-banana when no Gemini API key", () => {
+        const result = createImageGenAdapters({
+            replicateApiToken: "r8-rep",
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("replicate");
+        expect(result.skipped).toEqual(["nano-banana"]);
+    });
+    it("skips replicate when no API token", () => {
+        const result = createImageGenAdapters({
+            geminiApiKey: "sk-gem",
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("nano-banana");
+        expect(result.skipped).toEqual(["replicate"]);
+    });
+    it("skips adapters with empty string keys", () => {
+        const result = createImageGenAdapters({
+            geminiApiKey: "",
+            replicateApiToken: "r8-rep",
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("replicate");
+        expect(result.skipped).toContain("nano-banana");
+    });
+    it("returns empty result when no keys provided", () => {
+        const result = createImageGenAdapters({});
+        expect(result.adapters).toHaveLength(0);
+        expect(result.adapterMap.size).toBe(0);
+        expect(result.skipped).toEqual(["replicate", "nano-banana"]);
+    });
+    it("all adapters support image-generation capability", () => {
+        const result = createImageGenAdapters({
+            geminiApiKey: "sk-gem",
+            replicateApiToken: "r8-rep",
+        });
+        for (const adapter of result.adapters) {
+            expect(adapter.capabilities).toContain("image-generation");
+        }
+    });
+    it("all adapters implement generateImage", () => {
+        const result = createImageGenAdapters({
+            geminiApiKey: "sk-gem",
+            replicateApiToken: "r8-rep",
+        });
+        for (const adapter of result.adapters) {
+            expect(typeof adapter.generateImage).toBe("function");
+        }
+    });
+    it("adapterMap keys match adapter names", () => {
+        const result = createImageGenAdapters({
+            geminiApiKey: "sk-gem",
+            replicateApiToken: "r8-rep",
+        });
+        for (const [key, adapter] of result.adapterMap) {
+            expect(key).toBe(adapter.name);
+        }
+    });
+    it("passes per-adapter config overrides", () => {
+        const result = createImageGenAdapters({
+            geminiApiKey: "sk-gem",
+            nanoBanana: { costPerImage: 0.01 },
+            replicateApiToken: "r8-rep",
+            replicate: { marginMultiplier: 1.5 },
+        });
+        expect(result.adapters).toHaveLength(2);
+    });
+    it("creates only one adapter for single-provider config", () => {
+        const result = createImageGenAdapters({
+            geminiApiKey: "sk-gem",
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("nano-banana");
+        expect(result.skipped).toEqual(["replicate"]);
+    });
+});
+describe("createImageGenAdaptersFromEnv", () => {
+    afterAll(() => {
+        vi.unstubAllEnvs();
+    });
+    it("reads keys from environment variables", () => {
+        vi.stubEnv("GEMINI_API_KEY", "env-gem");
+        vi.stubEnv("REPLICATE_API_TOKEN", "env-rep");
+        const result = createImageGenAdaptersFromEnv();
+        expect(result.adapters).toHaveLength(2);
+        const names = result.adapters.map((a) => a.name);
+        expect(names).toEqual(["replicate", "nano-banana"]);
+        expect(result.skipped).toHaveLength(0);
+    });
+    it("returns empty when no env vars set", () => {
+        vi.stubEnv("GEMINI_API_KEY", "");
+        vi.stubEnv("REPLICATE_API_TOKEN", "");
+        const result = createImageGenAdaptersFromEnv();
+        expect(result.adapters).toHaveLength(0);
+        expect(result.skipped).toHaveLength(2);
+    });
+    it("accepts per-adapter overrides alongside env keys", () => {
+        vi.stubEnv("GEMINI_API_KEY", "env-gem");
+        vi.stubEnv("REPLICATE_API_TOKEN", "");
+        const result = createImageGenAdaptersFromEnv({
+            nanoBanana: { costPerImage: 0.01 },
+        });
+        expect(result.adapters).toHaveLength(1);
+        expect(result.adapters[0].name).toBe("nano-banana");
+    });
+});

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

@@ -73,6 +73,27 @@ export const RATE_TABLE = [
         margin: 1.3, // 30% — dashboard default; runtime uses getMargin()
         effectivePrice: 0.00009321, // = costPerUnit * margin ($93.21 per 1M seconds ≈ $5.59 per 1M minutes)
     },
+    // Image Generation
+    // NOTE: No self-hosted SDXL adapter yet — only premium tiers available.
+    // When self-hosted-sdxl lands, add a standard tier entry here.
+    {
+        capability: "image-generation",
+        tier: "premium",
+        provider: "nano-banana",
+        costPerUnit: 0.02, // $0.02 per image (Gemini Imagen via Nano Banana)
+        billingUnit: "per-image",
+        margin: 1.3, // 30% — dashboard default; runtime uses getMargin()
+        effectivePrice: 0.026, // = costPerUnit * margin ($26.00 per 1K images)
+    },
+    {
+        capability: "image-generation",
+        tier: "premium",
+        provider: "replicate",
+        costPerUnit: 0.019, // ~$0.019 per image (SDXL on A40, ~8s avg at $0.0023/s)
+        billingUnit: "per-image",
+        margin: 1.3, // 30% — dashboard default; runtime uses getMargin()
+        effectivePrice: 0.0247, // = costPerUnit * margin ($24.70 per 1K images)
+    },
     // Embeddings
     // NOTE: No self-hosted embeddings adapter yet — only premium (openrouter) available.
     // When self-hosted-embeddings lands, add a standard tier entry here.
@@ -85,10 +106,33 @@ export const RATE_TABLE = [
         margin: 1.3, // 30% — dashboard default; runtime uses getMargin()
         effectivePrice: 0.000000026, // = costPerUnit * margin ($0.026 per 1M tokens)
     },
+    // Image Generation
+    // NOTE: No self-hosted SDXL adapter yet — only premium tiers available.
+    // When self-hosted-sdxl lands, add a standard tier entry here.
+    // Multiple premium providers exist — cheapest first so lookupRate() returns
+    // the best rate. Use getRatesForCapability() for per-provider breakdowns.
+    {
+        capability: "image-generation",
+        tier: "premium",
+        provider: "replicate",
+        costPerUnit: 0.019, // ~$0.019 per image (SDXL on A40, ~8s avg at $0.0023/s)
+        billingUnit: "per-image",
+        margin: 1.3, // 30% — dashboard default; runtime uses getMargin()
+        effectivePrice: 0.0247, // = costPerUnit * margin ($24.70 per 1K images)
+    },
+    {
+        capability: "image-generation",
+        tier: "premium",
+        provider: "nano-banana",
+        costPerUnit: 0.02, // $0.02 per image (Gemini Imagen via Nano Banana)
+        billingUnit: "per-image",
+        margin: 1.3, // 30% — dashboard default; runtime uses getMargin()
+        effectivePrice: 0.026, // = costPerUnit * margin ($26.00 per 1K images)
+    },
     // Future self-hosted adapters will add more entries here:
     // - 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)
+    // - image-generation: self-hosted-sdxl (standard) — when GPU adapter exists
 ];
 /**
  * Look up a rate entry by capability and tier.

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

@@ -44,7 +44,7 @@ describe("RATE_TABLE", () => {
         const premiumEntries = RATE_TABLE.filter((e) => e.tier === "premium");
         for (const entry of premiumEntries) {
             // Third-party providers are well-known brand names
-            const isThirdParty = ["elevenlabs", "deepgram", "openrouter", "replicate", "gemini"].includes(entry.provider);
+            const isThirdParty = ["elevenlabs", "deepgram", "openrouter", "replicate", "nano-banana"].includes(entry.provider);
             expect(isThirdParty).toBe(true);
         }
     });
@@ -83,7 +83,7 @@ describe("lookupRate", () => {
         expect(premium?.provider).toBe("openrouter");
     });
     it("returns undefined for non-existent capability", () => {
-        const rate = lookupRate("image-generation", "standard");
+        const rate = lookupRate("video-generation", "standard");
         expect(rate).toBeUndefined();
     });
     it("returns undefined for non-existent tier", () => {
@@ -111,7 +111,7 @@ describe("getRatesForCapability", () => {
         expect(rates[0].provider).toBe("deepgram");
     });
     it("returns empty array for non-existent capability", () => {
-        const rates = getRatesForCapability("image-generation");
+        const rates = getRatesForCapability("video-generation");
         expect(rates).toHaveLength(0);
     });
     it("all returned rates have the requested capability", () => {
@@ -148,7 +148,7 @@ describe("calculateSavings", () => {
     });
     it("returns zero when capability has no premium tier", () => {
         // This would happen if a capability only has self-hosted, no third-party
-        const savings = calculateSavings("embeddings", 1000);
+        const savings = calculateSavings("voice-cloning", 1000);
         expect(savings).toBe(0);
     });
     it("savings scale linearly with units", () => {