@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/handlers/imageProviders/index.js

@@ -1,44 +0,0 @@
-// Image provider adapter registry
-import createOpenAIAdapter from "./openai.js";
-import gemini from "./gemini.js";
-import codex from "./codex.js";
-import sdwebui from "./sdwebui.js";
-import comfyui from "./comfyui.js";
-import huggingface from "./huggingface.js";
-import nanobanana from "./nanobanana.js";
-import falAi from "./falAi.js";
-import stabilityAi from "./stabilityAi.js";
-import blackForestLabs from "./blackForestLabs.js";
-import runwayml from "./runwayml.js";
-import cloudflareAi from "./cloudflareAi.js";
-import leonardo from "./leonardo.js";
-import weavy from "./weavy.js";
-
-const ADAPTERS = {
-  openai: createOpenAIAdapter("openai"),
-  minimax: createOpenAIAdapter("minimax"),
-  openrouter: createOpenAIAdapter("openrouter"),
-  recraft: createOpenAIAdapter("recraft"),
-  xai: createOpenAIAdapter("xai"),
-  gemini,
-  codex,
-  sdwebui,
-  comfyui,
-  huggingface,
-  nanobanana,
-  "fal-ai": falAi,
-  "stability-ai": stabilityAi,
-  "black-forest-labs": blackForestLabs,
-  runwayml,
-  "cloudflare-ai": cloudflareAi,
-  leonardo,
-  weavy,
-};
-
-export function getImageAdapter(provider) {
-  return ADAPTERS[provider] || null;
-}
-
-export function isImageProvider(provider) {
-  return provider in ADAPTERS;
-}

package/open-sse/handlers/imageProviders/leonardo.js

@@ -1,435 +0,0 @@
-/**
- * Leonardo AI image and video generation adapter.
- *
- * Providers: leonardo
- * Auth: JWT Bearer token + Sentry trace headers (randomized per request)
- * Format: GraphQL mutation (Generate) → async polling via generationId
- * Polling: Yes — polls /generations/{id} until status == "COMPLETE"
- *
- * Generation paths:
- * - v1 (SDXL-based): phoenix, flux-dev, lucid-origin — uses modelId UUID + contrast/guidance
- * - v2 (native):     seedream, flux-2-pro, gpt-image, sora, veo, kling, etc. — no modelId param
- * - ideogram:        v4/v3 — uses aspectRatio instead of width/height
- *
- * IMPORTANT — params actually forwarded by this adapter:
- * @param {string}  prompt              - (required) Image/video description (max 1400 chars)
- * @param {string}  [model]             - Model alias (e.g. "leo-seedream", "leo-kling-3")
- * @param {number}  [n=1]               - Number of images/clips, capped at 4
- * @param {string}  [size="1024x1024"]  - Output dimensions, used to derive width/height/aspect ratio
- * @param {string}  [negative_prompt]   - Elements to exclude (forwarded directly to Leonardo API)
- *
- * NOTE: For video models (kling, veo, sora, seedance, etc.), the Leonardo GraphQL
- * API itself handles model routing — this adapter sends the same params as for images.
- * duration, resolution, aspect_ratio, image_url, video_url, end_image_url, and
- * motion_strength are NOT currently forwarded by this adapter. They are listed in
- * providerModels.js for future adapter support and UI documentation purposes only.
- */
-// Leonardo AI — GraphQL-based image generation adapter
-// Uses cookie → JWT auth and Leonardo's native GraphQL API.
-// Reference: kliperspro/backend/services/leonardo-service.js
-import { sleep, nowSec, POLL_INTERVAL_MS } from "./_base.js";
-import { randomBytes } from "crypto";
-
-// Read Leonardo admin config (promptEnhance, capabilities etc.) from KV store.
-// Falls back to empty object if DB not available (e.g., first boot).
-async function getLeonardoAdminConfig() {
-  try {
-    const { getAdapter } = await import('../../../dist/lib/db/driver.js');
-    const db = await getAdapter();
-    const row = db.get(`SELECT value FROM kv WHERE scope = 'leonardo' AND key = 'admin_config'`);
-    if (!row?.value) return null;
-    return typeof row.value === "string" ? JSON.parse(row.value) : row.value;
-  } catch {
-    return null;
-  }
-}
-
-let _adminConfigCache = null;
-let _adminConfigAt = 0;
-const ADMIN_CONFIG_TTL = 30_000; // 30 seconds
-
-async function getModelConfig(modelId) {
-  const now = Date.now();
-  if (!_adminConfigCache || now - _adminConfigAt > ADMIN_CONFIG_TTL) {
-    _adminConfigCache = await getLeonardoAdminConfig();
-    _adminConfigAt = now;
-  }
-  if (!_adminConfigCache?.models) return null;
-  const slug = (modelId || "").replace(/^leo-/, "").toLowerCase();
-  return _adminConfigCache.models.find(m =>
-    (m.id || "").replace(/^leo-/, "").toLowerCase() === slug ||
-    (m.apiModelName || "").toLowerCase() === slug
-  ) || null;
-}
-
-const GRAPHQL_URL = "https://api.leonardo.ai/v1/graphql";
-const SENTRY_REL = "6a0bd1b5b7ef23a4f22608a2ed90c5e753cbc669";
-
-const POLL_TIMEOUT_MS = 120_000; // 2 minutes
-const POLL_INTERVAL_LEONARDO = 3000; // 3 seconds
-
-// ============================================
-// MODEL UUID REGISTRY — mirrors leoapi-main model_id.txt
-// ============================================
-const MODEL_REGISTRY = {
-  // Nano Banana
-  "nano-banana-2":    "7418e71f-4133-4e1b-9895-bee19f48f2ce",
-  "nano-banana-pro":  "7c02ef35-3a6b-4df6-b78d-873e5032c3b4",
-  "nano-banana":      "4a008a65-8d97-44f5-97a0-66c431612614",
-  // Seedream
-  "seedream-4.5":     "f1c295ea-1575-445f-89ae-9b4013a6a37c",
-  "seedream-4":       "94515e81-e589-4a5b-aeae-10ced50142c2",
-  "seedream":         "f1c295ea-1575-445f-89ae-9b4013a6a37c",
-  // GPT Image
-  "gpt-image-2":      "99ecc726-3404-412c-9dc1-24d4cdef2299",
-  "gpt-image-1.5":    "99ecc726-3404-412c-9dc1-24d4cdef2299",
-  "gpt-image-1":      "f75b1998-e5cb-4fdf-9eef-98e8186c2c2f",
-  "gpt-image":        "99ecc726-3404-412c-9dc1-24d4cdef2299",
-  // Flux
-  "flux-2-pro":       "5478273a-68e1-4efe-a0c4-3fe84e4c16a8",
-  "flux-2-dev":       "c19631a4-21b4-4dbd-b015-b446b7a4e0e0",
-  "flux-dev":         "b2614463-296c-462a-9586-aafdb8f00e36",
-  "flux-schnell":     "1dd50843-d653-4516-a8e3-f0238ee453ff",
-  "flux-kontext-max": "02dff998-e678-416c-a8a7-ce93188f2e68",
-  "flux-kontext":     "28aeddf8-bd19-4803-80fc-79602d1a9989",
-  // Lucid
-  "lucid-origin":     "7b592283-e8a7-4c5a-9ba6-d18c31f258b9",
-  "lucid-realism":    "05ce0082-2d80-4a2d-8653-4d1c85e2418e",
-  // Ideogram (uuid only for v3; v4 = null → native v2)
-  "ideogram-3":       "f9672904-3313-4867-b883-407ef6a0edec",
-  // Phoenix
-  phoenix:            "de7d3faf-762f-48e0-b3b7-9d0ac3a3fcf3",
-  "phoenix-1.0":      "de7d3faf-762f-48e0-b3b7-9d0ac3a3fcf3",
-  // XL models
-  "kino-xl":          "aa77f04e-3eec-4034-9c07-d0f619684628",
-  "anime-xl":         "e71a1c2f-4f80-4800-934f-2c68979d8cc8",
-  "lightning-xl":     "b24e16ff-06e3-43eb-8d33-4416c2d75876",
-  "vision-xl":        "5c232a9e-9061-4777-980a-ddc8e65647c6",
-  "diffusion-xl":     "1e60896f-3c26-4296-8ecc-53e2afecc132",
-  // LTX video UUIDs (needed for video adapter if passed as image model by mistake)
-  "ltxv-2.3-pro":     "938ebb92-045c-48b5-a02b-9489b4933f60",
-  "ltxv-2.3-fast":    "0eba7ca6-57b0-4b9f-9ff3-fd78af067109",
-  // Kling video UUIDs
-  "kling":            "6c904469-5291-4043-b610-f53b50dfd6ff",
-  "kling-omni":       "0d5109cf-d256-4720-86d3-d8e5ff5a3ce2",
-  // Note: gemini-image-2, recraft-v4, recraft-v4-pro, ideogram-v4, sora-2,
-  // veo-*, hailuo-*, seedance-*, happy-horse all have uuid=null in DEFAULT_CONFIG
-  // → they are treated as native v2 models (no modelId in generation params)
-};
-
-// ============================================
-// DIMENSION TABLES
-// ============================================
-const STANDARD_SIZES  = { "16:9": [1920, 1080], "9:16": [1080, 1920], "1:1": [1024, 1024], "4:3": [1440, 1080], "3:4": [1080, 1440], "3:2": [1620, 1080], "2:3": [1080, 1620] };
-const SEEDREAM_SIZES  = { "16:9": [2752, 1536], "9:16": [1536, 2752], "1:1": [1536, 1536], "4:3": [2048, 1536], "3:4": [1536, 2048], "3:2": [2048, 1360], "2:3": [1360, 2048] };
-const PHOENIX_SIZES   = { "16:9": [2752, 1536], "9:16": [1536, 2752], "1:1": [1536, 1536], "4:3": [2048, 1536], "3:2": [2048, 1360] };
-const GPT_IMAGE_SIZES = { "16:9": [1376,  768], "9:16": [ 768, 1376], "1:1": [1024, 1024], "4:3": [1184,  888], "3:4": [ 888, 1184], "3:2": [1248,  832], "2:3": [ 832, 1248] };
-
-// ============================================
-// HELPERS
-// ============================================
-
-function makeHex(n) { return randomBytes(n).toString("hex"); }
-
-/** Build Sentry trace headers (required by Leonardo API gateway) */
-function sentryHeaders(token) {
-  const tid = makeHex(8) + makeHex(8);
-  return {
-    authorization: `Bearer ${token}`,
-    "sentry-trace": `${tid}-${makeHex(8).slice(0, 16)}-0`,
-    baggage: `sentry-environment=vercel-production,sentry-release=${SENTRY_REL},sentry-public_key=a851bd902378477eae99cf74c62e142a,sentry-trace_id=${tid},sentry-org_id=4504767521292288,sentry-sampled=false`,
-  };
-}
-
-/** Execute a GraphQL request against Leonardo's API */
-async function gql(token, payload) {
-  const res = await fetch(GRAPHQL_URL, {
-    method: "POST",
-    headers: {
-      accept: "*/*",
-      "accept-language": "en-US,en;q=0.9",
-      "content-type": "application/json",
-      origin: "https://app.leonardo.ai",
-      referer: "https://app.leonardo.ai/",
-      "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
-      "x-leo-schema-version": "latest",
-      "sec-fetch-dest": "empty",
-      "sec-fetch-mode": "cors",
-      "sec-fetch-site": "same-site",
-      ...sentryHeaders(token),
-    },
-    body: JSON.stringify(payload),
-  });
-  if (!res.ok) throw new Error(`Leonardo GraphQL HTTP ${res.status}`);
-  return res.json();
-}
-
-/** Resolve model UUID from name/id pattern */
-function resolveModelUuid(modelId) {
-  if (!modelId) return null;
-  const input = modelId.trim();
-
-  // Pass-through raw UUIDs
-  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(input)) {
-    return input;
-  }
-
-  // Strip 'leo-' prefix
-  const name = input.replace(/^leo-/, "").toLowerCase();
-  if (MODEL_REGISTRY[name]) return MODEL_REGISTRY[name];
-  const normalized = name.replace(/[_.]/g, "-");
-  if (MODEL_REGISTRY[normalized]) return MODEL_REGISTRY[normalized];
-  for (const [key, uuid] of Object.entries(MODEL_REGISTRY)) {
-    if (key.includes(name) || name.includes(key)) return uuid;
-  }
-  return null;
-}
-
-/** Convert OpenAI size string (e.g. "1024x1024") → Leonardo aspect ratio → [width, height] */
-function sizeToLeonardoDimensions(size, modelId = "") {
-  const sizeMap = {
-    "1024x1024": "1:1",
-    "1024x1792": "9:16",
-    "1792x1024": "16:9",
-    "1024x1536": "2:3",
-    "1536x1024": "3:2",
-  };
-  const ar = sizeMap[size] || "1:1";
-
-  const lower = (modelId || "").toLowerCase();
-  const isSeedream = lower.includes("seedream");
-  const isPhoenix  = lower.includes("phoenix") || lower.includes("nano-banana");
-  const isGpt      = lower.includes("gpt-image");
-
-  if (isSeedream  && SEEDREAM_SIZES[ar])  return { ar, dims: SEEDREAM_SIZES[ar] };
-  if (isPhoenix   && PHOENIX_SIZES[ar])   return { ar, dims: PHOENIX_SIZES[ar] };
-  if (isGpt       && GPT_IMAGE_SIZES[ar]) return { ar, dims: GPT_IMAGE_SIZES[ar] };
-  return { ar, dims: STANDARD_SIZES[ar] || [1024, 1024] };
-}
-
-/** Derive the API model name sent in the mutation (strip leading 'leo-') */
-function resolveApiModelName(modelId) {
-  const clean = (modelId || "").replace(/^leo-/, "").toLowerCase();
-  const maps = {
-    "phoenix": "phoenix-v1.0",
-    "seedream": "seedream-4.5",
-    "gpt-image": "gpt-image-1.5",
-    "ideogram-v4": "ideogram-v4.0",
-    "recraft-v4-pro": "recraft-v4",
-    "happy-horse": "happy-horse",
-    "kling": "kling-2.6",
-    "kling-3": "kling-3.0",
-    "kling-3-turbo": "kling-3.0-turbo",
-    "kling-o1": "kling-video-o-1",
-    "kling-o3": "kling-video-o-3",
-    "ltx-pro": "ltxv-2.3-pro",
-    "ltx-fast": "ltxv-2.3-fast",
-    "ltx-2-pro": "ltxv-2.3-pro",
-    "ltx-2-fast": "ltxv-2.3-fast",
-  };
-  return maps[clean] || clean;
-}
-
-/**
- * Returns the generation API version for a model:
- *  - "v1" → legacy SDXL path: num_images + modelId UUID + contrast (Phoenix, Flux Dev, Lucid Origin)
- *  - "v2" → native path: quantity, no modelId (Seedream, GPT Image, Flux 2 Pro, etc.)
- */
-function getModelApiVersion(modelId) {
-  const name = (modelId || "").toLowerCase();
-  const isV1 = (
-    name === "leo-flux-dev" || name === "flux-dev" ||
-    name.includes("lucid-origin")
-  );
-  return isV1 ? "v1" : "v2";
-}
-
-// ============================================
-// POLLING
-// ============================================
-
-async function pollGenerationStatus(token, genId) {
-  const query = {
-    operationName: "GetAIGenerationFeedStatuses",
-    variables: { where: { id: { _eq: genId } } },
-    query: `query GetAIGenerationFeedStatuses($where: generations_bool_exp = {}) {
-  generations(where: $where) { id status __typename }
-}`,
-  };
-  const rj = await gql(token, query);
-  const gen = (rj?.data?.generations || [])[0];
-  return gen?.status || "PENDING";
-}
-
-async function fetchGeneratedImageUrls(token, genId) {
-  const query = {
-    operationName: "GetAIGenerationFeed",
-    variables: { where: { id: { _eq: genId } }, limit: 4 },
-    query: `query GetAIGenerationFeed($where: generations_bool_exp = {}, $limit: Int) {
-  generations(where: $where, limit: $limit) {
-    generated_images(order_by: [{url: desc}]) { url id __typename }
-    __typename
-  }
-}`,
-  };
-  const rj = await gql(token, query);
-  const gen = (rj?.data?.generations || [])[0];
-  return (gen?.generated_images || []).map((img) => img.url).filter(Boolean);
-}
-
-async function waitForImages(token, genId, timeoutMs = POLL_TIMEOUT_MS) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    await sleep(POLL_INTERVAL_LEONARDO);
-    const status = await pollGenerationStatus(token, genId);
-    if (status === "COMPLETE" || status === "COMPLETED") {
-      return await fetchGeneratedImageUrls(token, genId);
-    }
-    if (status === "FAILED" || status === "ERROR") {
-      throw new Error(`Leonardo generation failed (status=${status})`);
-    }
-  }
-  // Timeout — try one last fetch
-  try {
-    const urls = await fetchGeneratedImageUrls(token, genId);
-    if (urls.length) return urls;
-  } catch {}
-  throw new Error("Leonardo generation timed out");
-}
-
-// ============================================
-// ADAPTER
-// ============================================
-
-export default {
-  /** Credentials stored as cookie (apiKey) + resolved JWT (accessToken) */
-  buildUrl: (_model, _creds) => GRAPHQL_URL,
-
-  buildHeaders: (creds) => {
-    const token = creds?.accessToken || creds?.apiKey || "";
-    return {
-      accept: "*/*",
-      "accept-language": "en-US,en;q=0.9",
-      "content-type": "application/json",
-      origin: "https://app.leonardo.ai",
-      referer: "https://app.leonardo.ai/",
-      "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
-      "x-leo-schema-version": "latest",
-      "sec-fetch-dest": "empty",
-      "sec-fetch-mode": "cors",
-      "sec-fetch-site": "same-site",
-      ...sentryHeaders(token),
-    };
-  },
-
-  buildBody: async (modelId, body) => {
-    const n = Math.min(body.n || 1, 4);
-    const { ar, dims } = sizeToLeonardoDimensions(body.size, modelId);
-    const [width, height] = dims;
-    const prompt = (body.prompt || "").slice(0, 1400);
-    const modelCfg = await getModelConfig(modelId);
-    const apiModelName = modelCfg?.apiModelName || resolveApiModelName(modelId);
-    const modelUuid = resolveModelUuid(modelId);
-    const apiVersion = getModelApiVersion(modelId);
-    const promptEnhance = body.prompt_enhance ?? (modelCfg?.promptEnhance || "OFF");
-
-    let params;
-
-    if (apiVersion === "v1") {
-      // ── v1 legacy path (Phoenix, Flux Dev, Lucid Origin) ──
-      // Requires: num_images, modelId UUID, contrast
-      params = {
-        width,
-        height,
-        prompt,
-        num_images: n,
-        modelId: modelUuid,
-        prompt_enhance: promptEnhance,
-        contrast: body.contrast ?? 3.5,  // required for Phoenix/Lucid
-      };
-      if (body.guidance_scale != null) params.guidance_scale = body.guidance_scale;
-      if (body.num_inference_steps != null) params.num_inference_steps = body.num_inference_steps;
-    } else {
-      // ── v2 native path (Seedream, GPT Image, Flux 2 Pro, etc.) ──
-      params = {
-        prompt,
-        quantity: n,
-        prompt_enhance: promptEnhance,
-      };
-      if (apiModelName.toLowerCase().includes("ideogram")) {
-        params.aspectRatio = ar;
-      } else {
-        params.width = width;
-        params.height = height;
-      }
-      if (modelCfg?.quality) params.quality = modelCfg.quality;
-    }
-
-    if (body.negative_prompt) params.negative_prompt = body.negative_prompt;
-
-    return {
-      operationName: "Generate",
-      variables: {
-        request: {
-          model: apiModelName,
-          public: body.is_public ?? false,
-          parameters: params,
-        },
-      },
-      query: `mutation Generate($request: CreateGenerationRequest!) {
-  generate(request: $request) {
-    apiCreditCost generationId __typename
-  }
-}`,
-    };
-  },
-
-  /**
-   * Overrides standard parse flow — after submitting the mutation we need to
-   * poll until the generation completes, then return OpenAI-format image URLs.
-   *
-   * The imageGenerationCore passes:
-   *   { headers, log, streamToClient, onRequestSuccess, url, requestBody, model, body }
-   * `headers` is the request headers object (plain dict) containing `authorization`.
-   */
-  async parseResponse(response, { headers, log }) {
-    const rj = await response.json();
-
-    // Propagate GraphQL errors
-    if (rj?.errors?.length) {
-      const msg = rj.errors.map((e) => e.message).join(" | ");
-      throw new Error(`Leonardo generate error: ${msg}`);
-    }
-
-    const genId = rj?.data?.generate?.generationId;
-    if (!genId) {
-      throw new Error(`Leonardo: no generationId in response: ${JSON.stringify(rj).slice(0, 300)}`);
-    }
-
-    log?.debug?.("LEONARDO", `Generation submitted genId=${genId}`);
-
-    // Extract the Bearer JWT from the request Authorization header
-    const authHeader = (headers?.authorization || headers?.Authorization || "");
-    const token = authHeader.replace(/^Bearer\s+/i, "").trim();
-
-    if (!token) {
-      throw new Error("Leonardo: no JWT token found in request headers");
-    }
-
-    const urls = await waitForImages(token, genId);
-    log?.debug?.("LEONARDO", `Generation complete — ${urls.length} image(s) fetched`);
-
-    // Return in OpenAI image-response format
-    return {
-      created: nowSec(),
-      data: urls.map((url) => ({ url })),
-    };
-  },
-
-  normalize: (parsed) => {
-    // Already normalized by parseResponse above
-    if (parsed?.created && Array.isArray(parsed?.data)) return parsed;
-    const urls = Array.isArray(parsed?.data) ? parsed.data : [];
-    return { created: nowSec(), data: urls };
-  },
-};

package/open-sse/handlers/imageProviders/nanobanana.js

@@ -1,79 +0,0 @@
-/**
- * NanoBanana image generation adapter.
- *
- * Providers: nanobanana
- * Auth: Bearer token (apiKey or accessToken)
- * Format: JSON body → async polling via task status endpoint
- * Polling: Yes — polls until resultImageUrl is available
- *
- * Supported request params:
- * @param {string}  prompt               - (required) Image description
- * @param {number}  [n=1]                - Number of images (numImages)
- * @param {string}  [size="1024x1024"]   - Maps to aspect ratio: "1:1"|"9:16"|"16:9"|"4:3"|"3:2"|"2:3"
- * @param {string}  [image]              - Reference image URL → enables IMAGETOIAMGE mode
- * @param {string[]} [images]            - Multiple reference image URLs
- *
- * Request type:
- * - No image → type: "TEXTTOIAMGE"
- * - image/images provided → type: "IMAGETOIAMGE"
- *
- * Response normalize: extracts resultImageUrl (falls back to originImageUrl).
- */
-// NanoBanana API — async submit + poll record-info
-import { sleep, nowSec, sizeToAspectRatio, POLL_INTERVAL_MS, POLL_TIMEOUT_MS } from "./_base.js";
-
-const SUBMIT_URL = "https://api.nanobananaapi.ai/api/v1/nanobanana/generate";
-const POLL_BASE = "https://api.nanobananaapi.ai/api/v1/nanobanana/record-info";
-
-export default {
-  async: true,
-  buildUrl: () => SUBMIT_URL,
-  buildHeaders: (creds) => {
-    const headers = { "Content-Type": "application/json" };
-    const key = creds?.apiKey || creds?.accessToken;
-    if (key) headers["Authorization"] = `Bearer ${key}`;
-    return headers;
-  },
-  buildBody: (_model, body) => {
-    const ratio = sizeToAspectRatio(body.size);
-    const isEdit = !!(body.image || (Array.isArray(body.images) && body.images.length));
-    const req = {
-      prompt: body.prompt,
-      type: isEdit ? "IMAGETOIAMGE" : "TEXTTOIAMGE",
-      numImages: body.n || 1,
-      image_size: ratio,
-      // API requires callBackUrl; we poll instead so a dummy URL is fine.
-      callBackUrl: "https://localhost/callback",
-    };
-    if (isEdit) {
-      const urls = Array.isArray(body.images) ? body.images.filter(Boolean) : [];
-      if (body.image) urls.push(body.image);
-      req.imageUrls = urls;
-    }
-    return req;
-  },
-  // Async: parse submit → poll until SUCCESS, return raw poll data
-  async parseResponse(response, { headers }) {
-    const submitData = await response.json();
-    if (submitData.code !== 200) throw new Error(submitData.msg || "NanoBanana submit failed");
-    const taskId = submitData.data?.taskId;
-    if (!taskId) throw new Error("NanoBanana: no taskId returned");
-    const pollUrl = `${POLL_BASE}?taskId=${encodeURIComponent(taskId)}`;
-    const deadline = Date.now() + POLL_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-      await sleep(POLL_INTERVAL_MS);
-      const r = await fetch(pollUrl, { headers });
-      if (!r.ok) throw new Error(`NanoBanana status ${r.status}`);
-      const s = await r.json();
-      const flag = s.data?.successFlag;
-      if (flag === 1) return s.data;
-      if (flag === 2 || flag === 3) throw new Error(s.data?.errorMessage || "NanoBanana generation failed");
-    }
-    throw new Error("NanoBanana polling timeout");
-  },
-  normalize: (responseBody, prompt) => {
-    const url = responseBody.response?.resultImageUrl || responseBody.response?.originImageUrl;
-    if (url) return { created: nowSec(), data: [{ url, revised_prompt: prompt }] };
-    return { created: nowSec(), data: [] };
-  },
-};

package/open-sse/handlers/imageProviders/openai.js

@@ -1,61 +0,0 @@
-/**
- * OpenAI-compatible image generation adapter.
- *
- * Providers: openai | minimax | openrouter | recraft | xai
- * Auth: Bearer token via Authorization header (apiKey or accessToken)
- * Format: JSON body → sync JSON response
- * Polling: None (synchronous)
- *
- * Supported request params:
- * @param {string}  prompt                    - (required) Image description
- * @param {string}  [model]                   - Model ID (set by caller)
- * @param {number}  [n=1]                     - Number of images (1–10 for DALL-E 2; 1 for DALL-E 3/GPT Image 1)
- * @param {string}  [size="1024x1024"]        - Dimensions: "256x256"|"512x512"|"1024x1024"|"1792x1024"|"1024x1792"
- * @param {string}  [quality="standard"]      - "standard"|"hd"|"low"|"medium"|"high"|"auto"
- * @param {string}  [style]                   - DALL-E 3 only: "vivid"|"natural"
- * @param {string}  [response_format="url"]   - "url"|"b64_json"
- * @param {string}  [output_format]           - GPT Image 1 only: "png"|"jpeg"|"webp"
- * @param {string}  [background]              - GPT Image 1 only: "auto"|"transparent"|"opaque"
- *
- * xAI note: only prompt, model, n, response_format are forwarded.
- */
-// OpenAI-compatible adapter (used by openai, minimax, openrouter, recraft)
-
-const ENDPOINTS = {
-  openai: "https://api.openai.com/v1/images/generations",
-  minimax: "https://api.minimaxi.com/v1/images/generations",
-  openrouter: "https://openrouter.ai/api/v1/images/generations",
-  recraft: "https://external.api.recraft.ai/v1/images/generations",
-  xai: "https://api.x.ai/v1/images/generations",
-};
-
-export default function createOpenAIAdapter(providerId) {
-  return {
-    buildUrl: () => ENDPOINTS[providerId],
-    buildHeaders: (creds) => {
-      const headers = { "Content-Type": "application/json" };
-      const key = creds?.apiKey || creds?.accessToken;
-      if (key) headers["Authorization"] = `Bearer ${key}`;
-      if (providerId === "openrouter") {
-        headers["HTTP-Referer"] = "https://endpoint-proxy.local";
-        headers["X-Title"] = "Endpoint Proxy";
-      }
-      return headers;
-    },
-    buildBody: (model, body) => {
-      const { prompt, n = 1, size = "1024x1024", quality, style, response_format } = body;
-      // xAI only accepts prompt, model, n, response_format
-      if (providerId === "xai") {
-        const req = { model, prompt, n };
-        if (response_format) req.response_format = response_format;
-        return req;
-      }
-      const req = { model, prompt, n, size };
-      if (quality) req.quality = quality;
-      if (style) req.style = style;
-      if (response_format) req.response_format = response_format;
-      return req;
-    },
-    normalize: (responseBody) => responseBody,
-  };
-}