@wopr-network/platform-core 1.8.0 → 1.9.0

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

@@ -85,10 +85,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);
         }
     });
@@ -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", () => {

package/dist/monetization/index.d.ts

@@ -22,6 +22,7 @@ export { createDeepSeekAdapter, type DeepSeekAdapterConfig } from "./adapters/de
 export { createElevenLabsAdapter, type ElevenLabsAdapterConfig } from "./adapters/elevenlabs.js";
 export { createEmbeddingsAdapters, createEmbeddingsAdaptersFromEnv, type EmbeddingsFactoryConfig, type EmbeddingsFactoryResult, } from "./adapters/embeddings-factory.js";
 export { createGeminiAdapter, type GeminiAdapterConfig } from "./adapters/gemini.js";
+export { createImageGenAdapters, createImageGenAdaptersFromEnv, type ImageGenFactoryConfig, type ImageGenFactoryResult, } from "./adapters/image-gen-factory.js";
 export { createKimiAdapter, type KimiAdapterConfig } from "./adapters/kimi.js";
 export { getMargin, loadMarginConfig, type MarginConfig, type MarginRule, withMarginConfig, } from "./adapters/margin-config.js";
 export { createMiniMaxAdapter, type MiniMaxAdapterConfig } from "./adapters/minimax.js";

package/dist/monetization/index.js

@@ -24,6 +24,8 @@ export { createElevenLabsAdapter } from "./adapters/elevenlabs.js";
 // Embeddings adapter factory (WOP-2190)
 export { createEmbeddingsAdapters, createEmbeddingsAdaptersFromEnv, } from "./adapters/embeddings-factory.js";
 export { createGeminiAdapter } from "./adapters/gemini.js";
+// Image-generation adapter factory (WOP-2188)
+export { createImageGenAdapters, createImageGenAdaptersFromEnv, } from "./adapters/image-gen-factory.js";
 export { createKimiAdapter } from "./adapters/kimi.js";
 // Margin config (WOP-364)
 export { getMargin, loadMarginConfig, withMarginConfig, } from "./adapters/margin-config.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/monetization/adapters/image-gen-factory.test.ts

@@ -0,0 +1,158 @@
+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/src/monetization/adapters/image-gen-factory.ts

@@ -0,0 +1,89 @@
+/**
+ * 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, type NanoBananaAdapterConfig } from "./nano-banana.js";
+import { createReplicateAdapter, 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 function createImageGenAdapters(config: ImageGenFactoryConfig): ImageGenFactoryResult {
+  const adapters: ProviderAdapter[] = [];
+  const skipped: string[] = [];
+
+  // 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<string, ProviderAdapter>();
+  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?: Omit<ImageGenFactoryConfig, "geminiApiKey" | "replicateApiToken">,
+): ImageGenFactoryResult {
+  return createImageGenAdapters({
+    geminiApiKey: process.env.GEMINI_API_KEY,
+    replicateApiToken: process.env.REPLICATE_API_TOKEN,
+    ...overrides,
+  });
+}

package/src/monetization/adapters/rate-table.test.ts

@@ -62,7 +62,9 @@ describe("RATE_TABLE", () => {
 
     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);
     }
   });
@@ -146,7 +148,7 @@ describe("getRatesForCapability", () => {
   });
 
   it("returns empty array for non-existent capability", () => {
-    const rates = getRatesForCapability("image-generation" as unknown as AdapterCapability);
+    const rates = getRatesForCapability("video-generation" as unknown as AdapterCapability);
     expect(rates).toHaveLength(0);
   });
 

package/src/monetization/adapters/rate-table.ts

@@ -109,10 +109,34 @@ export const RATE_TABLE: RateEntry[] = [
     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
 ];
 
 /**

package/src/monetization/index.ts

@@ -42,6 +42,13 @@ export {
   type EmbeddingsFactoryResult,
 } from "./adapters/embeddings-factory.js";
 export { createGeminiAdapter, type GeminiAdapterConfig } from "./adapters/gemini.js";
+// Image-generation adapter factory (WOP-2188)
+export {
+  createImageGenAdapters,
+  createImageGenAdaptersFromEnv,
+  type ImageGenFactoryConfig,
+  type ImageGenFactoryResult,
+} from "./adapters/image-gen-factory.js";
 export { createKimiAdapter, type KimiAdapterConfig } from "./adapters/kimi.js";
 // Margin config (WOP-364)
 export {