n9router 0.4.43 → 0.4.45

package/app/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/app/open-sse/handlers/imageGenerationCore.js

@@ -5,6 +5,12 @@ import { getExecutor } from "../executors/index.js";
 import { getImageAdapter } from "./imageProviders/index.js";
 import { urlToBase64 } from "./imageProviders/_base.js";
 
+function serializeRequestBody(requestBody) {
+  if (typeof FormData !== "undefined" && requestBody instanceof FormData) return requestBody;
+  if (typeof requestBody === "string") return requestBody;
+  return JSON.stringify(requestBody);
+}
+
 /**
  * Core image generation handler — orchestrator only.
  * Provider-specific URL/headers/body/parse/normalize live in `./imageProviders/{id}.js`.
@@ -44,9 +50,58 @@ export async function handleImageGenerationCore({
     );
   }
 
-  const url = adapter.buildUrl(model, credentials);
-  const headers = adapter.buildHeaders(credentials);
-  const requestBody = adapter.buildBody(model, body);
+  // Executor-delegating adapters: skip manual URL/headers/body, use the proven executor flow
+  if (adapter.useExecutor && adapter.executeViaExecutor) {
+    try {
+      log?.debug?.("IMAGE", `${provider.toUpperCase()} | ${model} | prompt="${body.prompt.slice(0, 50)}..." (executor)`);
+      const responseBody = await adapter.executeViaExecutor(model, body, credentials, log);
+      if (onRequestSuccess) await onRequestSuccess();
+      const normalized = adapter.normalize(responseBody, body.prompt);
+      const finalBody = (normalized.created && Array.isArray(normalized.data)) ? normalized : responseBody;
+
+      if (binaryOutput) {
+        const first = finalBody.data?.[0];
+        let b64 = first?.b64_json;
+        if (!b64 && first?.url) {
+          try { b64 = await urlToBase64(first.url); } catch {}
+        }
+        if (b64) {
+          const buf = Buffer.from(b64, "base64");
+          const fmt = (body.output_format || "png").toLowerCase();
+          const mime = fmt === "jpeg" || fmt === "jpg" ? "image/jpeg" : fmt === "webp" ? "image/webp" : "image/png";
+          return {
+            success: true,
+            response: new Response(buf, {
+              headers: { "Content-Type": mime, "Content-Disposition": `inline; filename="image.${fmt === "jpeg" ? "jpg" : fmt}"`, "Access-Control-Allow-Origin": "*" },
+            }),
+          };
+        }
+      }
+
+      return {
+        success: true,
+        response: new Response(JSON.stringify(finalBody), {
+          headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+        }),
+      };
+    } catch (error) {
+      const errMsg = formatProviderError(error, provider, model, HTTP_STATUS.BAD_GATEWAY);
+      log?.debug?.("IMAGE", `Executor error: ${errMsg}`);
+      return createErrorResult(HTTP_STATUS.BAD_GATEWAY, errMsg);
+    }
+  }
+
+  let url;
+  let headers;
+  let requestBody;
+
+  try {
+    url = adapter.buildUrl(model, credentials);
+    requestBody = await adapter.buildBody(model, body);
+    headers = adapter.buildHeaders(credentials, requestBody, model, body);
+  } catch (error) {
+    return createErrorResult(HTTP_STATUS.BAD_REQUEST, error.message || `Invalid ${provider} image request`);
+  }
 
   log?.debug?.("IMAGE", `${provider.toUpperCase()} | ${model} | prompt="${body.prompt.slice(0, 50)}..."`);
 
@@ -55,7 +110,7 @@ export async function handleImageGenerationCore({
     providerResponse = await fetch(url, {
       method: "POST",
       headers,
-      body: JSON.stringify(requestBody),
+      body: serializeRequestBody(requestBody),
     });
   } catch (error) {
     const errMsg = formatProviderError(error, provider, model, HTTP_STATUS.BAD_GATEWAY);
@@ -83,12 +138,13 @@ export async function handleImageGenerationCore({
       if (onCredentialsRefreshed) await onCredentialsRefreshed(newCredentials);
 
       try {
-        const retryHeaders = adapter.buildHeaders(credentials);
+        const retryBody = await adapter.buildBody(model, body);
+        const retryHeaders = adapter.buildHeaders(credentials, retryBody, model, body);
         const retryUrl = adapter.buildUrl(model, credentials);
         providerResponse = await fetch(retryUrl, {
           method: "POST",
           headers: retryHeaders,
-          body: JSON.stringify(requestBody),
+          body: serializeRequestBody(retryBody),
         });
       } catch {
         log?.warn?.("TOKEN", `${provider.toUpperCase()} | retry after refresh failed`);
@@ -114,6 +170,10 @@ export async function handleImageGenerationCore({
         log,
         streamToClient,
         onRequestSuccess,
+        url,
+        requestBody,
+        model,
+        body,
       });
       // Codex streaming case: returns an SSE Response directly
       if (parsed?.sseResponse) {

package/app/open-sse/handlers/imageProviders/antigravity.js

@@ -0,0 +1,73 @@
+// Antigravity image adapter - delegates to the executor for correct request
+// envelope (project, model, requestType, sessionId) and auth headers.
+import { nowSec } from "./_base.js";
+import { getExecutor } from "../../executors/index.js";
+
+// Convert image input (data URI or raw base64) to Gemini inlineData part
+function resolveImageInput(input) {
+  if (!input || typeof input !== "string") return null;
+  // data:image/png;base64,... format
+  const dataUriMatch = input.match(/^data:(image\/[^;]+);base64,(.+)$/);
+  if (dataUriMatch) {
+    return { inlineData: { mimeType: dataUriMatch[1], data: dataUriMatch[2] } };
+  }
+  // Raw base64 string (assume PNG)
+  if (/^[A-Za-z0-9+/]/.test(input) && input.length > 100 && !input.startsWith("http")) {
+    return { inlineData: { mimeType: "image/png", data: input } };
+  }
+  return null;
+}
+
+export default {
+  // Delegate to executor instead of building URL/headers/body manually
+  useExecutor: true,
+
+  // Stubs - required by imageGenerationCore interface but unused with useExecutor
+  buildUrl: () => "",
+  buildHeaders: () => ({}),
+  buildBody: () => ({}),
+
+  async executeViaExecutor(model, body, credentials, log) {
+    const executor = getExecutor("antigravity");
+    if (!executor) throw new Error("Antigravity executor not found");
+
+    // Build parts: text prompt + optional input image for editing
+    const parts = [{ text: body.prompt }];
+    const imageInput = body.image || (Array.isArray(body.images) && body.images[0]);
+    if (imageInput) {
+      const inlineData = resolveImageInput(imageInput);
+      if (inlineData) parts.unshift(inlineData);
+    }
+
+    const chatBody = {
+      contents: [{ role: "user", parts }],
+    };
+
+    const result = await executor.execute({
+      model,
+      body: chatBody,
+      stream: false,
+      credentials,
+      log,
+    });
+
+    if (!result.response.ok) {
+      const text = await result.response.text();
+      throw new Error(text || `HTTP ${result.response.status}`);
+    }
+
+    return result.response.json();
+  },
+
+  normalize: (responseBody, prompt) => {
+    const candidates = responseBody.candidates || responseBody.response?.candidates || [];
+    const parts = candidates[0]?.content?.parts || [];
+    const images = parts.filter((p) => p.inlineData?.data).map((p) => ({
+      b64_json: p.inlineData.data,
+    }));
+    return {
+      created: nowSec(),
+      data: images.length > 0 ? images : [{ b64_json: "", revised_prompt: prompt }],
+    };
+  },
+};

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

@@ -1,7 +1,8 @@
 // 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/app/open-sse/handlers/imageProviders/cloudflareAi.js

@@ -1,6 +1,7 @@
 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/app/open-sse/handlers/imageProviders/codex.js

@@ -1,10 +1,11 @@
 // 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_USER_AGENT = "codex-imagen/0.2.6";
-const CODEX_VERSION = "0.129.0";
+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";
 const CODEX_MODEL_SUFFIX = "-image";
 const CODEX_REF_DETAIL = "high";

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

@@ -1,7 +1,11 @@
 // 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/app/open-sse/handlers/imageProviders/falAi.js

@@ -1,7 +1,8 @@
 // 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/app/open-sse/handlers/imageProviders/gemini.js

@@ -1,7 +1,8 @@
 // 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/app/open-sse/handlers/imageProviders/huggingface.js

@@ -1,7 +1,8 @@
 // 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/app/open-sse/handlers/imageProviders/index.js

@@ -10,12 +10,15 @@ 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 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,
@@ -23,10 +26,12 @@ const ADAPTERS = {
   comfyui,
   huggingface,
   nanobanana,
+  antigravity,
   "fal-ai": falAi,
   "stability-ai": stabilityAi,
   "black-forest-labs": blackForestLabs,
   runwayml,
+  "cloudflare-ai": cloudflareAi,
 };
 
 export function getImageAdapter(provider) {

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

@@ -1,8 +1,10 @@
 // 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/app/open-sse/handlers/imageProviders/openai.js

@@ -1,39 +1,32 @@
 // 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/app/open-sse/handlers/imageProviders/runwayml.js

@@ -1,7 +1,8 @@
 // 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/app/open-sse/handlers/imageProviders/sdwebui.js

@@ -1,9 +1,12 @@
 // 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;

package/app/open-sse/handlers/imageProviders/stabilityAi.js

@@ -1,7 +1,8 @@
 // Stability AI v2 — sync, returns { image: "<b64>" }
 import { nowSec, sizeToAspectRatio } from "./_base.js";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
 
-const BASE_URL = "https://api.stability.ai/v2beta/stable-image/generate";
+const BASE_URL = PROVIDER_MEDIA["stability-ai"]?.imageConfig?.baseUrl;
 
 // Map model id → endpoint segment
 function modelToEndpoint(model) {

package/app/open-sse/handlers/responsesHandler.js

@@ -4,9 +4,10 @@
  */
 
 import { handleChatCore } from "./chatCore.js";
-import { convertResponsesApiFormat } from "../translator/helpers/responsesApiHelper.js";
+import { convertResponsesApiFormat } from "../translator/formats/responsesApi.js";
 import { createResponsesApiTransformStream } from "../transformer/responsesTransformer.js";
 import { convertResponsesStreamToJson } from "../transformer/streamToJsonConverter.js";
+import { SSE_HEADERS_CORS } from "../utils/sseConstants.js";
 
 /**
  * Handle /v1/responses request
@@ -88,12 +89,7 @@ export async function handleResponsesCore({ body, modelInfo, credentials, log, o
       success: true,
       response: new Response(transformedBody, {
         status: 200,
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          "Connection": "keep-alive",
-          "Access-Control-Allow-Origin": "*"
-        }
+        headers: { ...SSE_HEADERS_CORS }
       })
     };
   }

package/app/open-sse/handlers/search/chatSearch.js

@@ -2,6 +2,12 @@
  * Wrap chat-completions endpoints (with built-in web search) into the unified
  * /v1/search response format. Supports gemini, openai, xai, kimi, minimax, perplexity.
  */
+import { PROVIDER_MEDIA } from "../../providers/index.js";
+
+// Default search model + endpoint derive from registry searchViaChat (single source)
+const searchModel = (id) => PROVIDER_MEDIA[id]?.searchViaChat?.defaultModel;
+const searchEndpoint = (id, model) =>
+  (PROVIDER_MEDIA[id]?.searchViaChat?.endpoint || "").replace("{model}", model || "");
 
 const REQUEST_TIMEOUT_MS = 15000;
 const DEFAULT_MAX_RESULTS = 10;
@@ -43,9 +49,7 @@ function normalizeCitation(c) {
  */
 const CHAT_SEARCH_CONFIG = {
   gemini: {
-    endpoint: (model) =>
-      `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
-    defaultModel: "gemini-2.5-flash",
+    endpoint: (model) => searchEndpoint("gemini", model),
     buildBody: (query) => ({
       contents: [{ role: "user", parts: [{ text: query }] }],
       tools: [{ google_search: {} }]
@@ -70,8 +74,7 @@ const CHAT_SEARCH_CONFIG = {
   },
 
   openai: {
-    endpoint: () => "https://api.openai.com/v1/chat/completions",
-    defaultModel: "gpt-4o-mini",
+    endpoint: () => searchEndpoint("openai"),
     buildBody: (query, model) => {
       const body = {
         model,
@@ -105,8 +108,7 @@ const CHAT_SEARCH_CONFIG = {
   },
 
   xai: {
-    endpoint: () => "https://api.x.ai/v1/responses",
-    defaultModel: "grok-4.20-reasoning",
+    endpoint: () => searchEndpoint("xai"),
     buildBody: (query, model) => ({
       model,
       input: [{ role: "user", content: query }],
@@ -145,8 +147,7 @@ const CHAT_SEARCH_CONFIG = {
   },
 
   kimi: {
-    endpoint: () => "https://api.moonshot.cn/v1/chat/completions",
-    defaultModel: "kimi-k2.5",
+    endpoint: () => searchEndpoint("kimi"),
     buildBody: (query, model) => ({
       model,
       messages: [{ role: "user", content: query }],
@@ -195,8 +196,7 @@ const CHAT_SEARCH_CONFIG = {
   },
 
   minimax: {
-    endpoint: () => "https://api.minimaxi.com/v1/text/chatcompletion_v2",
-    defaultModel: "MiniMax-M2.7",
+    endpoint: () => searchEndpoint("minimax"),
     buildBody: (query, model) => ({
       model,
       messages: [{ role: "user", content: query }],
@@ -254,8 +254,7 @@ const CHAT_SEARCH_CONFIG = {
   },
 
   perplexity: {
-    endpoint: () => "https://api.perplexity.ai/chat/completions",
-    defaultModel: "sonar",
+    endpoint: () => searchEndpoint("perplexity"),
     buildBody: (query, model) => ({
       model,
       messages: [{ role: "user", content: query }]
@@ -324,7 +323,7 @@ export async function handleChatSearch({
     Number.isFinite(maxResults) && maxResults > 0
       ? Math.floor(maxResults)
       : DEFAULT_MAX_RESULTS;
-  const useModel = model || cfg.defaultModel;
+  const useModel = model || searchModel(provider);
   const url = cfg.endpoint(useModel);
   const body = cfg.buildBody(query, useModel);
   const headers = cfg.buildHeaders(token);

package/app/open-sse/handlers/sttCore.js

@@ -1,7 +1,6 @@
 import { Buffer } from "node:buffer";
 import { createErrorResult } from "../utils/error.js";
 import { HTTP_STATUS } from "../config/runtimeConfig.js";
-import { AI_PROVIDERS } from "../../src/shared/constants/providers.js";
 
 // Build auth headers from sttConfig + token
 function buildAuthHeaders(cfg, token) {
@@ -167,11 +166,11 @@ function jsonResponse(obj) {
  * STT core handler — dispatch by sttConfig.format.
  * @returns {Promise<{success, response, status?, error?}>}
  */
-export async function handleSttCore({ provider, model, formData, credentials }) {
+export async function handleSttCore({ provider, model, formData, credentials, sttConfig }) {
   const file = formData.get("file");
   if (!file) return createErrorResult(HTTP_STATUS.BAD_REQUEST, "Missing required field: file");
 
-  const cfg = AI_PROVIDERS[provider]?.sttConfig;
+  const cfg = sttConfig;
   if (!cfg) return createErrorResult(HTTP_STATUS.BAD_REQUEST, `Provider '${provider}' does not support STT`);
 
   const token = cfg.authType === "none" ? null : (credentials?.apiKey || credentials?.accessToken);

package/app/open-sse/handlers/ttsProviders/gemini.js

@@ -1,9 +1,20 @@
 // Gemini TTS — generateContent with AUDIO modality returns PCM L16, wrap as WAV
 import { Buffer } from "node:buffer";
+import { PROVIDER_MEDIA, PROVIDER_MODELS } from "../../providers/index.js";
 
-const DEFAULT_MODEL = "gemini-2.5-flash-preview-tts";
+const TTS_CFG = PROVIDER_MEDIA["gemini"]?.ttsConfig || {};
+const TTS_BASE = TTS_CFG.baseUrl;
+const FALLBACK_MODEL = "gemini-3.1-flash-tts-preview";
+const KNOWN_MODELS = [
+  ...(TTS_CFG.models || []),
+  ...(PROVIDER_MODELS["gemini-tts-models"] || []),
+  ...(PROVIDER_MODELS.gemini || []).filter((m) => (m.kind || m.type) === "tts"),
+]
+  .map((m) => m?.id)
+  .filter(Boolean)
+  .filter((id, index, list) => list.indexOf(id) === index);
+const DEFAULT_MODEL = KNOWN_MODELS[0] || FALLBACK_MODEL;
 const DEFAULT_VOICE = "Kore";
-const KNOWN_MODELS = ["gemini-2.5-flash-preview-tts", "gemini-2.5-pro-preview-tts"];
 
 // Parse "model/voice" — if input doesn't match a known TTS model, treat it as voice with default model
 function parseGeminiModelVoice(input) {
@@ -51,7 +62,7 @@ export default {
   async synthesize(text, model, credentials, _responseFormat, opts = {}) {
     if (!credentials?.apiKey) throw new Error("No Gemini API key configured");
     const { modelId, voiceId } = parseGeminiModelVoice(model);
-    const url = `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:generateContent?key=${credentials.apiKey}`;
+    const url = `${TTS_BASE}/${modelId}:generateContent?key=${credentials.apiKey}`;
     const res = await fetch(url, {
       method: "POST",
       headers: { "Content-Type": "application/json" },

package/app/open-sse/handlers/ttsProviders/index.js

@@ -33,8 +33,10 @@ export async function synthesizeViaConfig(provider, text, model, credentials) {
   if (!handler) return null;
   const apiKey = credentials?.apiKey;
   if (cfg.authType !== "none" && !apiKey) throw new Error(`${provider} API key required`);
-  const defaultModel = cfg.models?.[0]?.id || "";
-  const { modelId, voiceId } = parseModelVoice(model, defaultModel, "", cfg.models || []);
+  const { PROVIDER_MODELS } = await import("open-sse/config/providerModels.js");
+  const ttsModels = (PROVIDER_MODELS[provider] || []).filter(m => (m.kind || m.type) === "tts");
+  const defaultModel = ttsModels[0]?.id || "";
+  const { modelId, voiceId } = parseModelVoice(model, defaultModel, "", ttsModels);
   return handler({ baseUrl: cfg.baseUrl, apiKey, text, modelId, voiceId });
 }
 

package/app/open-sse/handlers/ttsProviders/openai.js

@@ -1,11 +1,14 @@
 // OpenAI TTS — model format: "tts-model/voice"
 import { Buffer } from "node:buffer";
+import { PROVIDER_MEDIA } from "../../providers/index.js";
+
+const DEFAULT_TTS_MODEL = PROVIDER_MEDIA["openai"]?.ttsConfig?.defaultModel;
 
 export default {
   async synthesize(text, model, credentials) {
     if (!credentials?.apiKey) throw new Error("No OpenAI API key configured");
 
-    let ttsModel = "gpt-4o-mini-tts";
+    let ttsModel = DEFAULT_TTS_MODEL;
     let voice = "alloy";
     if (model && model.includes("/")) {
       const parts = model.split("/");