@fudrouter/fsrouter 0.6.72 → 0.6.74

package/open-sse/handlers/chatCore.js

@@ -9,10 +9,11 @@ import { createRequestLogger } from "../utils/requestLogger.js";
 import { getModelTargetFormat, getModelStrip, getModelUpstreamId, getModelType, PROVIDER_ID_TO_ALIAS } from "../config/providerModels.js";
 import { PROVIDERS } from "../config/providers.js";
 import { createErrorResult, parseUpstreamError, formatProviderError } from "../utils/error.js";
-import { HTTP_STATUS } from "../config/runtimeConfig.js";
+import { HTTP_STATUS, TOKEN_SAVER_HEADER } from "../config/runtimeConfig.js";
 import { handleBypassRequest } from "../utils/bypassHandler.js";
 import { trackPendingRequest, appendRequestLog, saveRequestDetail } from '../../dist/lib/usageDb.js';
 import { getExecutor } from "../executors/index.js";
+import { supportsGrokCliReasoningEffort } from "../config/grokCli.js";
 import { buildRequestDetail, extractRequestConfig } from "./chatCore/requestDetail.js";
 import { handleForcedSSEToJson } from "./chatCore/sseToJsonHandler.js";
 import { handleNonStreamingResponse } from "./chatCore/nonStreamingHandler.js";
@@ -21,8 +22,8 @@ import { detectClientTool, isNativePassthrough } from "../utils/clientDetector.j
 import { dedupeTools } from "../utils/toolDeduper.js";
 import { injectCaveman } from "../rtk/caveman.js";
 import { injectPonytail } from "../rtk/ponytail.js";
-import { compressMessages } from "../rtk/index.js";
-import { compressWithHeadroom, formatHeadroomSizeLog, isHeadroomPhantomSavings } from "../rtk/headroom.js";
+import { compressMessages, formatRtkLog } from "../rtk/index.js";
+import { compressWithHeadroom, formatHeadroomLog, formatHeadroomSizeLog, isHeadroomPhantomSavings } from "../rtk/headroom.js";
 import { compressWithPxpipe } from "../rtk/pxpipe.js";
 import { getCapabilitiesForModel } from "../providers/capabilities.js";
 import { stripUnsupportedModalities } from "../translator/concerns/modality.js";
@@ -168,7 +169,8 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
     const msgN = translatedBody.messages?.length || translatedBody.input?.length || translatedBody.contents?.length || body.messages?.length || body.input?.length || 0;
     const toolN = translatedBody.tools?.length || body.tools?.length || 0;
     const fmtStr = passthrough ? `FMT: ${sourceFormat} (passthrough)` : `FMT: ${sourceFormat}→${targetFormat}`;
-    const think = log.fmtThink?.(extractThinking(translatedBody));
+    const showThinking = provider !== "grok-cli" || supportsGrokCliReasoningEffort(model);
+    const think = showThinking ? log.fmtThink?.(extractThinking(translatedBody)) : null;
     const acc = credentials?.connectionName || credentials?.connectionId?.slice(0, 8) || "-";
     const parts = [
       `POST ${clientModel} → ${provider}/${model}`,
@@ -188,40 +190,37 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
     delete translatedBody.tools;
   }
 
-  // Token-saver summary parts, printed as one "⚙" line at the end (only active ones)
-  const xf = [];
+  // Per-request opt-out: client can bypass all token savers via header
+  const tokenSaverEnabled = clientRawRequest?.headers?.[TOKEN_SAVER_HEADER]?.toLowerCase() !== "off";
 
   // RTK: compress tool_result content
-  const rtkStats = compressMessages(translatedBody, rtkEnabled);
-  if (rtkStats?.hits?.length) {
-    const saved = rtkStats.bytesBefore - rtkStats.bytesAfter;
-    const pct = rtkStats.bytesBefore > 0 ? ((saved / rtkStats.bytesBefore) * 100).toFixed(0) : "0";
-    xf.push(`RTK −${saved}B(${pct}%)`);
-  }
+  const rtkStats = compressMessages(translatedBody, tokenSaverEnabled && rtkEnabled);
+  const rtkLine = formatRtkLog(rtkStats);
+  if (rtkLine) console.log(rtkLine);
 
   // Headroom: optional external proxy compression; fail open if proxy is absent.
   const headroomDiagnostics = {};
-  const headroomStats = await compressWithHeadroom(translatedBody, { enabled: headroomEnabled, url: headroomUrl, model: upstreamModel, format: finalFormat, compressUserMessages: headroomCompressUserMessages, diagnostics: headroomDiagnostics });
-  if (headroomStats) {
-    const before = headroomStats.tokens_before || 0;
-    const delta = headroomStats.tokens_saved || 0;
-    const pct = before > 0 ? ((delta / before) * 100).toFixed(1) : "0";
-    xf.push(`HEADROOM −${delta}tok(${pct}%)`);
+  const headroomStats = await compressWithHeadroom(translatedBody, { enabled: tokenSaverEnabled && headroomEnabled, url: headroomUrl, model: upstreamModel, format: finalFormat, compressUserMessages: headroomCompressUserMessages, diagnostics: headroomDiagnostics });
+  const headroomLine = formatHeadroomLog(headroomStats);
+  const headroomSizeLine = formatHeadroomSizeLog(headroomDiagnostics);
+  if (headroomLine) {
+    log?.info?.("HEADROOM", `${headroomLine}${headroomSizeLine ? ` | ${headroomSizeLine}` : ""}`);
     if (isHeadroomPhantomSavings(headroomStats, headroomDiagnostics)) {
       log?.warn?.("HEADROOM", `reported token delta, but outbound JSON shrank <5%; provider may bill near-original payload | ${formatHeadroomSizeLog(headroomDiagnostics)}`);
     }
-  } else if (headroomEnabled) {
-    log?.warn?.("HEADROOM", `skipped: ${headroomDiagnostics.reason || "compression unavailable"}${headroomDiagnostics.endpoint ? ` (${headroomDiagnostics.endpoint})` : ""}`);
-  }
+  } else if (tokenSaverEnabled && headroomEnabled) log?.warn?.("HEADROOM", `skipped: ${headroomDiagnostics.reason || "compression unavailable"}${headroomDiagnostics.endpoint ? ` (${headroomDiagnostics.endpoint})` : ""}`);
+
+  // Token-saver flags accumulator for the single "⚙" log line below.
+  const xf = [];
 
   // Caveman: inject terse-style system prompt
-  if (cavemanEnabled && cavemanLevel) {
+  if (tokenSaverEnabled && cavemanEnabled && cavemanLevel) {
     injectCaveman(translatedBody, finalFormat, cavemanLevel);
     xf.push(`CAVEMAN:${cavemanLevel}`);
   }
 
   // Ponytail: inject lazy-senior-dev system prompt
-  if (ponytailEnabled && ponytailLevel) {
+  if (tokenSaverEnabled && ponytailEnabled && ponytailLevel) {
     injectPonytail(translatedBody, finalFormat, ponytailLevel);
     xf.push(`PONYTAIL:${ponytailLevel}`);
   }
@@ -243,20 +242,19 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
 
   const executor = getExecutor(provider);
   trackPendingRequest(model, provider, connectionId, true);
-  try {
-    appendRequestLog({ model, provider, connectionId, status: "PENDING" }).catch(() => { });
-
-    const msgCount = translatedBody.messages?.length || translatedBody.input?.length || translatedBody.contents?.length || translatedBody.request?.contents?.length || 0;
-    log?.debug?.("REQUEST", `${provider.toUpperCase()} | ${model} | ${msgCount} msgs`);
-
-    const streamController = createStreamController({
-      onDisconnect: (reason) => {
-        trackPendingRequest(model, provider, connectionId, false);
-        if (onDisconnect) onDisconnect(reason);
-      },
-      onError: () => trackPendingRequest(model, provider, connectionId, false),
-      log, provider, model, reqTag
-    });
+  appendRequestLog({ model, provider, connectionId, status: "PENDING" }).catch(() => { });
+
+  const msgCount = translatedBody.messages?.length || translatedBody.input?.length || translatedBody.contents?.length || translatedBody.request?.contents?.length || 0;
+  log?.debug?.("REQUEST", `${provider.toUpperCase()} | ${model} | ${msgCount} msgs`);
+
+  const streamController = createStreamController({
+    onDisconnect: (reason) => {
+      trackPendingRequest(model, provider, connectionId, false);
+      if (onDisconnect) onDisconnect(reason);
+    },
+    onError: () => trackPendingRequest(model, provider, connectionId, false),
+    log, provider, model, reqTag
+  });
 
   const proxyOptions = {
     connectionProxyEnabled: credentials?.providerSpecificData?.connectionProxyEnabled === true,
@@ -392,10 +390,6 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
   // Streaming response
   const { onStreamComplete, streamDetailId } = buildOnStreamComplete({ ...sharedCtx });
   return handleStreamingResponse({ ...sharedCtx, providerResponse, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, streamController, onStreamComplete, streamDetailId });
-  } catch (error) {
-    trackPendingRequest(model, provider, connectionId, false);
-    throw error;
-  }
 }
 
 export function isTokenExpiringSoon(expiresAt, bufferMs = 5 * 60 * 1000) {

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

@@ -6,6 +6,7 @@ import openaiCompatNode from "./openaiCompatNode.js";
 const OPENAI_COMPAT_PROVIDERS = [
   "openai", "openrouter", "mistral", "voyage-ai", "fireworks",
   "together", "nebius", "github", "nvidia", "jina-ai",
+  "vercel-ai-gateway",
 ];
 
 const ADAPTERS = {

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

@@ -1,29 +1,21 @@
 // OpenAI-compatible embeddings adapter (most providers)
 import { bearerAuth } from "./_base.js";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
 
+// media-only providers without a registry file keep URL here; rest derive from registry media.embeddingConfig.baseUrl
 const ENDPOINTS = {
-  openai: "https://api.openai.com/v1/embeddings",
-  openrouter: "https://openrouter.ai/api/v1/embeddings",
-  mistral: "https://api.mistral.ai/v1/embeddings",
-  "voyage-ai": "https://api.voyageai.com/v1/embeddings",
-  fireworks: "https://api.fireworks.ai/inference/v1/embeddings",
-  together: "https://api.together.xyz/v1/embeddings",
-  nebius: "https://api.tokenfactory.nebius.com/v1/embeddings",
-  github: "https://models.github.ai/inference/embeddings",
-  nvidia: "https://integrate.api.nvidia.com/v1/embeddings",
   "jina-ai": "https://api.jina.ai/v1/embeddings",
 };
 
+const embedCfg = (id) => PROVIDER_MEDIA[id]?.embeddingConfig || {};
+const embedUrl = (id) => embedCfg(id).baseUrl || ENDPOINTS[id];
+
 export default function createOpenAIEmbeddingAdapter(providerId) {
+  const cfg = embedCfg(providerId);
   return {
-    buildUrl: () => ENDPOINTS[providerId],
+    buildUrl: () => embedUrl(providerId),
     buildHeaders: (creds) => {
-      const headers = { "Content-Type": "application/json", ...bearerAuth(creds) };
-      if (providerId === "openrouter") {
-        headers["HTTP-Referer"] = "https://endpoint-proxy.local";
-        headers["X-Title"] = "Endpoint Proxy";
-      }
-      return headers;
+      return { "Content-Type": "application/json", ...bearerAuth(creds), ...(cfg.headers || {}) };
     },
     buildBody: (model, { input, encoding_format, dimensions }) => {
       const body = { model, input };

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

@@ -1,27 +1,8 @@
-/**
- * Black Forest Labs FLUX API adapter.
- *
- * Providers: black-forest-labs
- * Auth: x-key header (not Authorization Bearer) — uses apiKey or accessToken
- * Format: JSON body → async polling via task result URL
- * Polling: Yes — polls until status == "Ready"
- *
- * Supported request params:
- * @param {string}  prompt                  - (required) Image description
- * @param {string}  [model]                 - Model ID (e.g. "flux-pro-1.1", "flux-kontext-pro")
- * @param {string}  [size]                  - Dimensions → parsed to width/height integers
- * @param {number}  [seed]                  - Fixed seed
- * @param {number}  [guidance]              - Guidance scale
- * @param {number}  [num_steps]             - Diffusion steps
- * @param {string}  [output_format="jpeg"]  - "jpeg"|"png"|"webp"
- * @param {string}  [image_url]             - Reference image (Kontext edit models only)
- *
- * Response normalize: result.sample → { created, data: [{ url }] }.
- */
 // Black Forest Labs (FLUX) — async submit + polling_url
 import { sleep, nowSec, POLL_INTERVAL_MS, POLL_TIMEOUT_MS } from "./_base.js";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
 
-const BASE_URL = "https://api.bfl.ai/v1";
+const BASE_URL = PROVIDER_MEDIA["black-forest-labs"]?.imageConfig?.baseUrl;
 
 export default {
   async: true,

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

@@ -1,35 +1,7 @@
-/**
- * Cloudflare AI Workers image generation adapter.
- *
- * Providers: cloudflare-ai
- * Auth: Bearer token via Authorization header
- *       Requires providerSpecificData.accountId for endpoint construction.
- * Format: JSON body OR FormData (model-dependent) → sync base64 response
- * Polling: None (synchronous)
- *
- * Endpoint: https://api.cloudflare.com/client/v4/accounts/{accountId}/ai/run/{model}
- *
- * Supported request params:
- * @param {string}  prompt               - (required) Image description
- * @param {string}  [size]               - Parsed to width/height integers (e.g. "1024x1024")
- * @param {number}  [seed]               - Fixed seed
- * @param {number}  [num_steps]          - Diffusion steps
- * @param {number}  [guidance]           - CFG guidance scale
- * @param {string}  [negative_prompt]    - Elements to exclude
- * @param {string}  [image_url]          - Reference image for img2img (SD v1.5-img2img)
- * @param {string}  [mask_image]         - Mask image for inpainting (SD v1.5-inpainting)
- *
- * Body format:
- * - FLUX.2 Dev and similar multipart-only models → FormData
- * - All other models → JSON { prompt, width, height, ... }
- *
- * Response normalize:
- * - string → { data: [{ b64_json: result }] }
- * - { image: b64 } → { data: [{ b64_json: image }] }
- */
 import { nowSec, urlToBase64 } from "./_base.js";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
 
-const BASE_URL = "https://api.cloudflare.com/client/v4/accounts";
+const BASE_URL = PROVIDER_MEDIA["cloudflare-ai"]?.imageConfig?.baseUrl;
 
 const MULTIPART_MODELS = new Set([
   "@cf/black-forest-labs/flux-2-dev",

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

@@ -1,27 +1,9 @@
-/**
- * OpenAI Codex (Responses API) image generation adapter.
- *
- * Providers: codex (ChatGPT Plus/Pro accounts via OAuth session)
- * Auth: Bearer session token + chatgpt-account-id header
- * Format: JSON body → SSE stream (parses image_generation_call delta events)
- * Polling: None (streaming SSE)
- *
- * Supported request params:
- * @param {string}  prompt                        - (required) Image description
- * @param {string}  [model="gpt-4o"]              - Model ID ("-image" suffix is stripped automatically)
- * @param {string}  [size="1024x1024"]            - Dimensions: "1024x1024"|"1792x1024"|"1024x1792"|"1536x1024"|"1024x1536"
- * @param {string}  [quality="auto"]              - "low"|"medium"|"high"|"auto"
- * @param {string}  [output_format="png"]         - "png"|"jpeg"|"webp"
- * @param {string}  [background="auto"]           - "auto"|"transparent"|"opaque"
- * @param {string}  [image_detail="high"]         - "low"|"high"|"auto"
- * @param {string}  [image]                       - Reference image URL or base64 data URI
- * @param {string[]} [images]                     - Multiple reference images
- */
 // Codex (ChatGPT Plus/Pro) image generation via Responses API + SSE
 import { randomUUID } from "node:crypto";
 import { nowSec } from "./_base.js";
+import { PROVIDERS } from "../../config/providers.js";
 
-const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+const CODEX_RESPONSES_URL = PROVIDERS["codex"].baseUrl;
 const CODEX_USER_AGENT = "codex_cli_rs/0.136.0";
 const CODEX_VERSION = "0.136.0";
 const CODEX_ORIGINATOR = "codex_cli_rs";

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

@@ -1,24 +1,11 @@
-/**
- * ComfyUI local node-graph image generation adapter.
- *
- * Providers: comfyui (self-hosted instance)
- * Auth: None (unauthenticated local endpoint)
- * Format: JSON workflow prompt → async polling via /history endpoint
- * Polling: Yes — submits prompt then polls /history/{prompt_id}
- *
- * Supported request params:
- * @param {string}  prompt      - (required) Positive prompt text
- * @param {number}  [n=1]       - Number of images
- * @param {string}  [size]      - Dimensions → width/height in workflow
- * @param {number}  [seed]      - Fixed seed
- * @param {number}  [num_steps] - Sampling steps
- *
- * Response normalize: downloads generated images and converts to base64.
- */
 // ComfyUI — local, noAuth (placeholder; full graph workflow not implemented)
+import { PROVIDER_MEDIA } from "../../providers/index.js";
+
+const BASE_URL = PROVIDER_MEDIA["comfyui"]?.imageConfig?.baseUrl;
+
 export default {
   noAuth: true,
-  buildUrl: () => "http://localhost:8188",
+  buildUrl: () => BASE_URL,
   buildHeaders: () => ({ "Content-Type": "application/json" }),
   buildBody: (_model, body) => ({ prompt: body.prompt }),
   normalize: (responseBody) => responseBody,

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

@@ -1,28 +1,8 @@
-/**
- * Fal.ai asynchronous image generation adapter.
- *
- * Providers: fal-ai
- * Auth: Key {apiKey} via Authorization header (uses "Key" prefix, not "Bearer")
- * Format: JSON body → async queue submission + polling
- * Polling: Yes — submits to /runs, polls /requests/{id}/status, fetches /requests/{id}
- *
- * Supported request params:
- * @param {string}  prompt               - (required) Image description
- * @param {string}  [model]              - Model path (e.g. "fal-ai/flux/schnell")
- * @param {number}  [n=1]                - Number of images (num_images)
- * @param {string}  [size="1024x1024"]   - Maps to image_size aspect ratio: "1:1"|"16:9"|"9:16" etc.
- * @param {number}  [seed]               - Fixed seed for reproducibility
- * @param {number}  [guidance]           - Guidance scale (model-dependent)
- * @param {number}  [num_steps]          - Diffusion sampling steps
- * @param {string}  [style]              - Style preset (Recraft/Ideogram only)
- * @param {string}  [image]              - Reference image URL (img2img conditioning)
- *
- * Response normalize: maps images[] or image{} to { created, data: [{ url }] }.
- */
 // Fal.ai — async submit + queue polling
 import { sleep, nowSec, sizeToAspectRatio, POLL_INTERVAL_MS, POLL_TIMEOUT_MS } from "./_base.js";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
 
-const BASE_URL = "https://queue.fal.run";
+const BASE_URL = PROVIDER_MEDIA["fal-ai"]?.imageConfig?.baseUrl;
 
 export default {
   async: true,

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

@@ -1,22 +1,8 @@
-/**
- * Google Gemini multimodal image generation adapter.
- *
- * Providers: gemini (via NanoBanana tier routing)
- * Auth: API key appended as ?key= query param
- * Format: JSON body → sync JSON response (generateContent / generateImage)
- * Polling: None (synchronous)
- *
- * Supported request params:
- * @param {string} prompt  - (required) Image description text
- *
- * Notes:
- * - No size, quality, or style params are supported by the Gemini image endpoint.
- * - Response is normalized to { created, data: [{ b64_json, revised_prompt }] }.
- */
 // Google Gemini adapter (Nano Banana models)
 import { nowSec } from "./_base.js";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
 
-const BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models";
+const BASE_URL = PROVIDER_MEDIA["gemini"]?.imageConfig?.baseUrl;
 
 export default {
   buildUrl: (model, creds) => {

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

@@ -1,23 +1,8 @@
-/**
- * HuggingFace Inference API image generation adapter.
- *
- * Providers: huggingface
- * Auth: Bearer token via Authorization header (apiKey or accessToken)
- * Format: JSON body { inputs: prompt } → binary image response (PNG/JPEG)
- * Polling: None (synchronous, may queue on HF side)
- *
- * Supported request params:
- * @param {string} prompt  - (required) Image description text
- *
- * Notes:
- * - Only "inputs" (prompt) is accepted by the HF Inference endpoint.
- * - No size, quality, style, or other params are passed through.
- * - Response normalize: converts raw binary image to base64 data URI.
- */
 // HuggingFace Inference API — returns binary image
 import { nowSec } from "./_base.js";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
 
-const BASE_URL = "https://api-inference.huggingface.co/models";
+const BASE_URL = PROVIDER_MEDIA["huggingface"]?.imageConfig?.baseUrl;
 
 export default {
   buildUrl: (model) => `${BASE_URL}/${model}`,

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

@@ -11,14 +11,14 @@ 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";
+import antigravity from "./antigravity.js";
 
 const ADAPTERS = {
   openai: createOpenAIAdapter("openai"),
   minimax: createOpenAIAdapter("minimax"),
   openrouter: createOpenAIAdapter("openrouter"),
   recraft: createOpenAIAdapter("recraft"),
+  "vercel-ai-gateway": createOpenAIAdapter("vercel-ai-gateway"),
   xai: createOpenAIAdapter("xai"),
   gemini,
   codex,
@@ -26,13 +26,12 @@ const ADAPTERS = {
   comfyui,
   huggingface,
   nanobanana,
+  antigravity,
   "fal-ai": falAi,
   "stability-ai": stabilityAi,
   "black-forest-labs": blackForestLabs,
   runwayml,
   "cloudflare-ai": cloudflareAi,
-  leonardo,
-  weavy,
 };
 
 export function getImageAdapter(provider) {

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

@@ -34,7 +34,7 @@ import { randomBytes } from "crypto";
 // 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 { 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;

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

@@ -1,29 +1,10 @@
-/**
- * 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";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
 
-const SUBMIT_URL = "https://api.nanobananaapi.ai/api/v1/nanobanana/generate";
-const POLL_BASE = "https://api.nanobananaapi.ai/api/v1/nanobanana/record-info";
+const IMG_CFG = PROVIDER_MEDIA["nanobanana"]?.imageConfig || {};
+const SUBMIT_URL = IMG_CFG.baseUrl;
+const POLL_BASE = IMG_CFG.pollUrl;
 
 export default {
   async: true,

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

@@ -1,60 +1,32 @@
-/**
- * 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)
+import { PROVIDER_MEDIA } from "../../providers/index.js";
 
-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",
-};
+const imageCfg = (id) => PROVIDER_MEDIA[id]?.imageConfig || {};
+const imageUrl = (id) => imageCfg(id).baseUrl;
 
 export default function createOpenAIAdapter(providerId) {
+  const cfg = imageCfg(providerId);
   return {
-    buildUrl: () => ENDPOINTS[providerId],
+    buildUrl: () => imageUrl(providerId),
     buildHeaders: (creds) => {
-      const headers = { "Content-Type": "application/json" };
+      const headers = { "Content-Type": "application/json", ...(cfg.headers || {}) };
       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;
+      const full = { model, prompt, n, size };
+      if (quality) full.quality = quality;
+      if (style) full.style = style;
+      if (response_format) full.response_format = response_format;
+      // bodyFields whitelist (e.g. xAI accepts only model/prompt/n/response_format)
+      if (Array.isArray(cfg.bodyFields)) {
+        const req = {};
+        for (const f of cfg.bodyFields) if (full[f] !== undefined) req[f] = full[f];
         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;
+      return full;
     },
     normalize: (responseBody) => responseBody,
   };

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

@@ -1,32 +1,8 @@
-/**
- * RunwayML image and video generation adapter.
- *
- * Providers: runwayml
- * Auth: Bearer token + X-Runway-Version header
- * Format: JSON body → async polling
- * Polling: Yes — polls task ID until status == "SUCCEEDED"
- *
- * Model routing:
- * - "*_image*" model IDs → POST /text_to_image (image generation)
- * - all others           → POST /image_to_video (video generation)
- *
- * Image model params:
- * @param {string}  prompt         - (required) Image description (sent as promptText)
- * @param {string}  [size]         - Maps to ratio: "1:1"|"16:9"|"9:16" etc.
- * @param {string}  [image]        - Reference image URL (referenceImages[])
- *
- * Video model params:
- * @param {string}  prompt         - (required) Video description (promptText)
- * @param {string}  [image]        - Start frame URL (promptImage)
- * @param {number}  [duration=5]   - Video duration in seconds
- * @param {string}  [resolution]   - "720p"|"1080p"
- *
- * Response normalize: output[] → { created, data: [{ url }] }.
- */
 // Runway ML — async submit + /tasks/{id} polling
 import { sleep, nowSec, sizeToAspectRatio, POLL_INTERVAL_MS, POLL_TIMEOUT_MS } from "./_base.js";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
 
-const BASE_URL = "https://api.dev.runwayml.com/v1";
+const BASE_URL = PROVIDER_MEDIA["runwayml"]?.imageConfig?.baseUrl;
 
 export default {
   async: true,

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

@@ -1,28 +1,12 @@
-/**
- * Stable Diffusion WebUI (Automatic1111) local adapter.
- *
- * Providers: sdwebui (self-hosted instance)
- * Auth: Optional HTTP Basic auth (username/password)
- * Format: JSON body → sync JSON response
- * Polling: None (synchronous, but can be slow)
- *
- * Supported request params:
- * @param {string}  prompt              - (required) Positive prompt
- * @param {number}  [n=1]               - Number of images (batch_size)
- * @param {string}  [size="512x512"]    - Dimensions e.g. "512x512", "768x768" → width/height
- * @param {string}  [negative_prompt]   - Tokens to exclude
- * @param {number}  [seed]              - Fixed seed (-1 = random)
- * @param {number}  [guidance=7]        - CFG scale
- * @param {number}  [num_steps=20]      - Sampling steps
- *
- * Response normalize: extracts images[0] → { created, data: [{ b64_json }] }.
- */
 // SD WebUI (AUTOMATIC1111) — local, noAuth
 import { nowSec } from "./_base.js";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
+
+const BASE_URL = PROVIDER_MEDIA["sdwebui"]?.imageConfig?.baseUrl;
 
 export default {
   noAuth: true,
-  buildUrl: () => "http://localhost:7860/sdapi/v1/txt2img",
+  buildUrl: () => BASE_URL,
   buildHeaders: () => ({ "Content-Type": "application/json" }),
   buildBody: (_model, body) => {
     const { prompt, n = 1, size = "1024x1024" } = body;