n9router 0.4.44 → 0.4.46

package/app/open-sse/services/kimchiModels.js

@@ -0,0 +1,176 @@
+import { createHash } from "crypto";
+
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+
+export const KIMCHI_API = "https://llm.kimchi.dev";
+export const KIMCHI_USER_AGENT = "kimchi/0.1.40";
+
+const FETCH_TIMEOUT_MS = 20_000;
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+
+/** @type {Map<string, { expiresAt: number, models: object[], rawModels: object[] }>} */
+const catalogCache = new Map();
+/** @type {Map<string, object>} */
+const metadataByModelId = new Map();
+
+function normalizeKimchiEndpoint(endpoint) {
+  const raw = typeof endpoint === "string" ? endpoint.trim() : "";
+  return (raw || KIMCHI_API).replace(/\/+$/, "");
+}
+
+export function buildKimchiModelsUrl(endpoint) {
+  return `${normalizeKimchiEndpoint(endpoint)}/v1/models/metadata?include_in_cli=true`;
+}
+
+function readToken(credentials) {
+  return (
+    credentials?.accessToken
+    || credentials?.apiKey
+    || credentials?.providerSpecificData?.apiKey
+    || null
+  );
+}
+
+function cacheKey(credentials, endpoint) {
+  const psd = credentials?.providerSpecificData || {};
+  const seed = psd.userId || psd.username || credentials?.refreshToken || readToken(credentials) || "anonymous";
+  return createHash("sha256")
+    .update(`kimchi:${normalizeKimchiEndpoint(endpoint)}:${seed}`)
+    .digest("hex");
+}
+
+function toModelKind(inputModalities) {
+  return Array.isArray(inputModalities) && inputModalities.includes("image")
+    ? "imageToText"
+    : "llm";
+}
+
+export function normalizeKimchiModel(item) {
+  if (!item || typeof item !== "object") return null;
+  const id = item.slug || item.id || item.model || item.name;
+  if (typeof id !== "string" || id.trim() === "") return null;
+
+  const inputModalities = Array.isArray(item.input_modalities)
+    ? item.input_modalities.filter((value) => value === "text" || value === "image")
+    : [];
+  const limits = item.limits && typeof item.limits === "object" ? item.limits : {};
+  const contextLength = Number(limits.context_window || item.contextLength || item.context_length) || undefined;
+  const maxOutputTokens = Number(limits.max_output_tokens || item.maxOutputTokens || item.max_output_tokens) || undefined;
+  const upstreamProvider = typeof item.provider === "string" ? item.provider : "";
+  const reasoning = item.reasoning === true;
+  const kind = toModelKind(inputModalities);
+
+  const model = {
+    ...item,
+    id: id.trim(),
+    name: String(item.display_name || item.displayName || item.name || id).trim(),
+    provider: upstreamProvider,
+    upstreamProvider,
+    reasoning,
+    inputModalities,
+    kind,
+    type: kind,
+    capabilities: {
+      vision: inputModalities.includes("image"),
+      reasoning,
+      ...(contextLength ? { contextWindow: contextLength } : {}),
+      ...(maxOutputTokens ? { maxOutput: maxOutputTokens } : {}),
+      ...(upstreamProvider ? { upstreamProvider } : {}),
+    },
+    ...(contextLength ? { contextLength } : {}),
+    ...(maxOutputTokens ? { maxOutputTokens } : {}),
+  };
+
+  if (upstreamProvider === "anthropic") {
+    model.compat = { supportsReasoningEffort: false, cacheControlFormat: "anthropic" };
+  }
+
+  return model;
+}
+
+function rememberModels(models) {
+  for (const model of models || []) {
+    if (!model?.id) continue;
+    metadataByModelId.set(model.id, model);
+    metadataByModelId.set(model.id.toLowerCase(), model);
+  }
+}
+
+export function getCachedKimchiModelMetadata(modelId) {
+  if (typeof modelId !== "string" || modelId.trim() === "") return null;
+  const raw = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+  return metadataByModelId.get(raw) || metadataByModelId.get(raw.toLowerCase()) || null;
+}
+
+async function fetchKimchiCatalogRaw(token, endpoint, options = {}) {
+  const url = buildKimchiModelsUrl(endpoint);
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(new Error("Kimchi models fetch timeout")), FETCH_TIMEOUT_MS);
+  const signal = options.signal
+    ? AbortSignal.any([options.signal, controller.signal])
+    : controller.signal;
+
+  try {
+    const response = await proxyAwareFetch(url, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json",
+        "Authorization": `Bearer ${token}`,
+        "User-Agent": KIMCHI_USER_AGENT,
+      },
+      cache: "no-store",
+      signal,
+    }, options.proxyOptions || null);
+
+    if (!response.ok) {
+      const error = new Error(`Kimchi models ${response.status}: ${response.statusText}`);
+      error.status = response.status;
+      error.retryable = RETRYABLE_STATUSES.has(response.status);
+      throw error;
+    }
+
+    const data = await response.json();
+    return Array.isArray(data?.models) ? data.models : [];
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function resolveKimchiModels(credentials, options = {}) {
+  const token = readToken(credentials);
+  if (!token) return null;
+
+  const endpoint = credentials?.providerSpecificData?.kimchiEndpoint || options.endpoint || KIMCHI_API;
+  const key = cacheKey(credentials, endpoint);
+  const now = Date.now();
+  if (!options.forceRefresh) {
+    const cached = catalogCache.get(key);
+    if (cached && cached.expiresAt > now) return cached;
+  }
+
+  let rawModels;
+  try {
+    rawModels = await fetchKimchiCatalogRaw(token, endpoint, options);
+  } catch (error) {
+    options.log?.warn?.("KIMCHI_MODELS", error.message);
+    return null;
+  }
+
+  const models = rawModels.map(normalizeKimchiModel).filter(Boolean);
+  if (models.length === 0) return null;
+
+  rememberModels(models);
+  const entry = {
+    expiresAt: Date.now() + CACHE_TTL_MS,
+    models,
+    rawModels,
+  };
+  catalogCache.set(key, entry);
+  return entry;
+}
+
+export function clearKimchiCatalog() {
+  catalogCache.clear();
+  metadataByModelId.clear();
+}

package/app/open-sse/services/model.js

@@ -1,147 +1,22 @@
-// Provider alias to ID mapping
-const ALIAS_TO_PROVIDER_ID = {
-  cc: "claude",
-  cx: "codex",
-  gc: "gemini-cli",
-  qw: "qwen",
-  if: "iflow",
-  ag: "antigravity",
-  gh: "github",
-  kr: "kiro",
-  cu: "cursor",
-  kc: "kilocode",
-  kmc: "kimi-coding",
-  cl: "cline",
-  oc: "opencode",
-  ocg: "opencode-go",
-  qd: "qoder",
-  qoder: "qoder",
-  // TTS providers
+import REGISTRY from "../providers/registry/index.js";
+
+// Alias→id derived from registry single-source: id→id, alias→id, aliases[]→id.
+// Media-only providers without a registry transport entry keep explicit aliases here.
+const MEDIA_ONLY_ALIASES = {
   el: "elevenlabs",
-  // API Key providers
-  openai: "openai",
-  vercel: "vercel-ai-gateway",
-  "vercel-ai-gateway": "vercel-ai-gateway",
-  anthropic: "anthropic",
-  gemini: "gemini",
-  openrouter: "openrouter",
-  glm: "glm",
-  kimi: "kimi",
-  minimax: "minimax",
-  "minimax-cn": "minimax-cn",
-  hf: "huggingface",
-  huggingface: "huggingface",
-  ds: "deepseek",
-  deepseek: "deepseek",
-  cmc: "commandcode",
-  commandcode: "commandcode",
-  groq: "groq",
-  xai: "xai",
-  mistral: "mistral",
-  pplx: "perplexity",
-  perplexity: "perplexity",
-  together: "together",
-  fireworks: "fireworks",
-  cerebras: "cerebras",
-  cohere: "cohere",
-  nvidia: "nvidia",
-  nebius: "nebius",
-  siliconflow: "siliconflow",
-  hyp: "hyperbolic",
-  hyperbolic: "hyperbolic",
-  dg: "deepgram",
-  deepgram: "deepgram",
-  aai: "assemblyai",
-  assemblyai: "assemblyai",
-  nb: "nanobanana",
-  nanobanana: "nanobanana",
-  ch: "chutes",
-  chutes: "chutes",
-  ark: "volcengine-ark",
-  "volcengine-ark": "volcengine-ark",
-  byteplus: "byteplus",
-  bpm: "byteplus",
-  cursor: "cursor",
-  vx: "vertex",
-  vertex: "vertex",
-  vxp: "vertex-partner",
-  "vertex-partner": "vertex-partner",
-  // Web cookie providers
-  gw: "grok-web",
-  "grok-web": "grok-web",
-  pw: "perplexity-web",
-  "perplexity-web": "perplexity-web",
-  mimo: "xiaomi-mimo",
-  "xiaomi-mimo": "xiaomi-mimo",
-  xmtp: "xiaomi-tokenplan",
-  "xiaomi-tokenplan": "xiaomi-tokenplan",
-  cf: "cloudflare-ai",
-  "cloudflare-ai": "cloudflare-ai",
-  // Image/video providers
-  fal: "fal-ai",
-  "fal-ai": "fal-ai",
-  stability: "stability-ai",
-  "stability-ai": "stability-ai",
-  bfl: "black-forest-labs",
-  "black-forest-labs": "black-forest-labs",
-  recraft: "recraft",
-  topaz: "topaz",
-  runway: "runwayml",
-  runwayml: "runwayml",
-  // Embedding/rerank
   jina: "jina-ai",
   "jina-ai": "jina-ai",
-  // TTS
   polly: "aws-polly",
   "aws-polly": "aws-polly",
-  // Free-tier providers (synced from OmniRoute)
-  agentrouter: "agentrouter",
-  aimlapi: "aimlapi",
-  aiml: "aimlapi",
-  novita: "novita",
-  modal: "modal",
-  mdl: "modal",
-  reka: "reka",
-  nlpcloud: "nlpcloud",
-  nlpc: "nlpcloud",
-  bazaarlink: "bazaarlink",
-  bzl: "bazaarlink",
-  completions: "completions",
-  cpl: "completions",
-  enally: "enally",
-  enly: "enally",
-  freetheai: "freetheai",
-  fta: "freetheai",
-  llm7: "llm7",
-  lepton: "lepton",
-  kluster: "kluster",
-  ai21: "ai21",
-  "inference-net": "inference-net",
-  inet: "inference-net",
-  predibase: "predibase",
-  bytez: "bytez",
-  morph: "morph",
-  longcat: "longcat",
-  lc: "longcat",
-  puter: "puter",
-  pu: "puter",
-  uncloseai: "uncloseai",
-  unc: "uncloseai",
-  scaleway: "scaleway",
-  scw: "scaleway",
-  deepinfra: "deepinfra",
-  sambanova: "sambanova",
-  samba: "sambanova",
-  nscale: "nscale",
-  baseten: "baseten",
-  publicai: "publicai",
-  "nous-research": "nous-research",
-  nous: "nous-research",
-  glhf: "glhf",
-  bb: "blackbox",
-  blackbox: "blackbox",
 };
 
+const ALIAS_TO_PROVIDER_ID = { ...MEDIA_ONLY_ALIASES };
+for (const entry of REGISTRY) {
+  ALIAS_TO_PROVIDER_ID[entry.id] = entry.id;
+  if (entry.alias) ALIAS_TO_PROVIDER_ID[entry.alias] = entry.id;
+  for (const a of entry.aliases || []) ALIAS_TO_PROVIDER_ID[a] = entry.id;
+}
+
 /**
  * Resolve provider alias to provider ID
  */
@@ -241,6 +116,15 @@ export async function getModelInfoCore(modelStr, aliasesOrGetter) {
   };
 }
 
+// Config-driven prefix → provider inference (first match wins, fallback "openai").
+const MODEL_PREFIX_PROVIDERS = [
+  [/^claude-/, "anthropic"],
+  [/^gemini-/, "gemini"],
+  [/^gpt-/, "openai"],
+  [/^o[134]/, "openai"],
+  [/^deepseek-/, "openrouter"],
+];
+
 /**
  * Infer provider from model name prefix
  * Used as fallback when no provider prefix or alias is given
@@ -248,12 +132,5 @@ export async function getModelInfoCore(modelStr, aliasesOrGetter) {
 function inferProviderFromModelName(modelName) {
   if (!modelName) return "openai";
   const m = modelName.toLowerCase();
-  if (m.startsWith("claude-")) return "anthropic";
-  if (m.startsWith("gemini-")) return "gemini";
-  if (m.startsWith("gpt-")) return "openai";
-  if (m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4"))
-    return "openai";
-  if (m.startsWith("deepseek-")) return "openrouter";
-  // Default fallback
-  return "openai";
+  return MODEL_PREFIX_PROVIDERS.find(([re]) => re.test(m))?.[1] || "openai";
 }

package/app/open-sse/services/oauthCredentialManager.js

@@ -3,8 +3,10 @@ import {
   isUnrecoverableRefreshError,
   refreshTokenByProvider,
 } from "./tokenRefresh.js";
+import { PROVIDER_OAUTH } from "../providers/index.js";
 
-export const CODEX_MAX_REFRESH_AGE_MS = 8 * 24 * 60 * 60 * 1000;
+// Single source: codex.oauth.maxRefreshAgeMs (8 days) — proactive refresh window
+export const CODEX_MAX_REFRESH_AGE_MS = PROVIDER_OAUTH["codex"]?.maxRefreshAgeMs;
 
 const refreshLocks = new Map();
 
@@ -35,9 +37,9 @@ export function getCredentialLastRefreshMs(credentials) {
   );
 }
 
-export function isCodexRefreshStale(credentials, nowMs = Date.now()) {
+export function isCodexRefreshStale(credentials, nowMs = Date.now(), maxAgeMs = CODEX_MAX_REFRESH_AGE_MS) {
   const lastRefreshMs = getCredentialLastRefreshMs(credentials);
-  return !lastRefreshMs || nowMs - lastRefreshMs >= CODEX_MAX_REFRESH_AGE_MS;
+  return !lastRefreshMs || nowMs - lastRefreshMs >= maxAgeMs;
 }
 
 export function shouldRefreshCredentials(provider, credentials, nowMs = Date.now()) {
@@ -48,7 +50,9 @@ export function shouldRefreshCredentials(provider, credentials, nowMs = Date.now
     return true;
   }
 
-  if (provider === "codex" && credentials.refreshToken && isCodexRefreshStale(credentials, nowMs)) {
+  // Proactive stale refresh for providers declaring oauth.maxRefreshAgeMs (e.g. codex)
+  const maxAgeMs = PROVIDER_OAUTH[provider]?.maxRefreshAgeMs;
+  if (maxAgeMs && credentials.refreshToken && isCodexRefreshStale(credentials, nowMs, maxAgeMs)) {
     return true;
   }
 
@@ -101,8 +105,9 @@ export function mergeRefreshedCredentials(provider, currentCredentials, refreshe
     next.copilotTokenExpiresAt = refreshedCredentials.copilotTokenExpiresAt;
   }
 
+  // trackRefreshAt providers (e.g. codex) always stamp lastRefreshAt for staleness tracking
   if (
-    provider === "codex" ||
+    PROVIDER_OAUTH[provider]?.trackRefreshAt ||
     next.accessToken ||
     next.apiKey ||
     next.token ||

package/app/open-sse/services/provider.js

@@ -1,14 +1,14 @@
 import { PROVIDERS } from "../config/providers.js";
-import { buildClineHeaders } from "../../src/shared/utils/clineAuth.js";
+import { OPENAI_COMPAT_BASE, ANTHROPIC_COMPAT_BASE } from "../providers/shared.js";
 
 const OPENAI_COMPATIBLE_PREFIX = "openai-compatible-";
 const OPENAI_COMPATIBLE_DEFAULTS = {
-  baseUrl: "https://api.openai.com/v1",
+  baseUrl: OPENAI_COMPAT_BASE,
 };
 
 const ANTHROPIC_COMPATIBLE_PREFIX = "anthropic-compatible-";
 const ANTHROPIC_COMPATIBLE_DEFAULTS = {
-  baseUrl: "https://api.anthropic.com/v1",
+  baseUrl: ANTHROPIC_COMPAT_BASE,
 };
 
 function isOpenAICompatible(provider) {
@@ -24,27 +24,6 @@ function getOpenAICompatibleType(provider) {
   return provider.includes("responses") ? "responses" : "chat";
 }
 
-function buildOpenAICompatibleUrl(baseUrl, apiType) {
-  const normalized = baseUrl.replace(/\/$/, "");
-  const path = apiType === "responses" ? "/responses" : "/chat/completions";
-  return `${normalized}${path}`;
-}
-
-function buildAnthropicCompatibleUrl(baseUrl) {
-  const normalized = baseUrl.replace(/\/$/, "");
-  return `${normalized}/messages`;
-}
-
-function buildQwenBaseUrl(resourceUrl, fallbackBaseUrl) {
-  const fallback = (fallbackBaseUrl || "").replace(/\/chat\/completions$/, "");
-  const raw = typeof resourceUrl === "string" ? resourceUrl.trim() : "";
-  if (!raw) return fallback;
-  if (raw.startsWith("http://") || raw.startsWith("https://")) {
-    return raw.replace(/\/$/, "");
-  }
-  return `https://${raw.replace(/\/$/, "")}/v1`;
-}
-
 // Detect request format from body structure
 export function detectFormat(body) {
   // OpenAI Responses API: has input (array or string) instead of messages[]
@@ -125,8 +104,8 @@ export function detectFormat(body) {
   return "openai";
 }
 
-// Get provider config
-export function getProviderConfig(provider) {
+// Get provider config (internal — no external runtime consumer)
+function getProviderConfig(provider) {
   if (isOpenAICompatible(provider)) {
     const apiType = getOpenAICompatibleType(provider);
     return {
@@ -145,180 +124,6 @@ export function getProviderConfig(provider) {
   return PROVIDERS[provider] || PROVIDERS.openai;
 }
 
-// Get number of fallback URLs for provider (for retry logic)
-export function getProviderFallbackCount(provider) {
-  const config = getProviderConfig(provider);
-  return config.baseUrls?.length || 1;
-}
-
-// Build provider URL
-export function buildProviderUrl(provider, model, stream = true, options = {}) {
-  if (isOpenAICompatible(provider)) {
-    const apiType = getOpenAICompatibleType(provider);
-    const baseUrl = options?.baseUrl || OPENAI_COMPATIBLE_DEFAULTS.baseUrl;
-    return buildOpenAICompatibleUrl(baseUrl, apiType);
-  }
-  if (isAnthropicCompatible(provider)) {
-    const baseUrl = options?.baseUrl || ANTHROPIC_COMPATIBLE_DEFAULTS.baseUrl;
-    return buildAnthropicCompatibleUrl(baseUrl);
-  }
-  const config = getProviderConfig(provider);
-
-  switch (provider) {
-    case "claude":
-      return `${config.baseUrl}?beta=true`;
-
-    case "gemini": {
-      const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
-      return `${config.baseUrl}/${model}:${action}`;
-    }
-
-    case "gemini-cli": {
-      const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
-      return `${config.baseUrl}:${action}`;
-    }
-
-    case "antigravity": {
-      // Use baseUrlIndex from options or default to 0
-      const urlIndex = options?.baseUrlIndex || 0;
-      const baseUrl = config.baseUrls[urlIndex] || config.baseUrls[0];
-      const path = stream ? "/v1internal:streamGenerateContent?alt=sse" : "/v1internal:generateContent";
-      return `${baseUrl}${path}`;
-    }
-
-    case "codex":
-      return config.baseUrl;
-
-    case "qwen": {
-      const baseUrl = buildQwenBaseUrl(options?.qwenResourceUrl, config.baseUrl);
-      return `${baseUrl}/chat/completions`;
-    }
-
-    case "github":
-      return config.baseUrl;
-
-    case "glm":
-    case "kimi":
-    case "minimax":
-      // Claude-compatible providers
-      return `${config.baseUrl}?beta=true`;
-
-    default:
-      return config.baseUrl;
-  }
-}
-
-// Build provider headers
-export function buildProviderHeaders(provider, credentials, stream = true, body = null) {
-  const config = getProviderConfig(provider);
-  const headers = {
-    "Content-Type": "application/json",
-    ...config.headers
-  };
-
-  // Add auth header
-  // Specific override for Anthropic Compatible
-  if (isAnthropicCompatible(provider)) {
-    if (credentials.apiKey) {
-      headers["x-api-key"] = credentials.apiKey;
-      // Do NOT send Authorization header when apiKey is present for Anthropic Compatible
-      // as it causes issues with some providers (e.g. opencode.ai)
-    } else if (credentials.accessToken) {
-      headers["Authorization"] = `Bearer ${credentials.accessToken}`;
-    }
-    // Add default Anthropic version if not present (some proxies require it)
-    if (!headers["anthropic-version"]) {
-      headers["anthropic-version"] = "2023-06-01";
-    }
-  } else {
-    switch (provider) {
-      case "gemini":
-        if (credentials.apiKey) {
-          headers["x-goog-api-key"] = credentials.apiKey;
-        } else if (credentials.accessToken) {
-          headers["Authorization"] = `Bearer ${credentials.accessToken}`;
-        }
-        break;
-  
-      case "antigravity":
-      case "gemini-cli":
-        // Antigravity and Gemini CLI use OAuth access token
-        headers["Authorization"] = `Bearer ${credentials.accessToken}`;
-        break;
-  
-      case "claude":
-        // Claude uses x-api-key header for API key, or Authorization for OAuth
-        if (credentials.apiKey) {
-          headers["x-api-key"] = credentials.apiKey;
-        } else if (credentials.accessToken) {
-          headers["Authorization"] = `Bearer ${credentials.accessToken}`;
-        }
-        break;
-  
-      case "github": {
-        // GitHub Copilot requires special headers to mimic VSCode
-        // Prioritize copilotToken from providerSpecificData, fallback to accessToken
-        const githubToken = credentials.copilotToken || credentials.accessToken;
-        // Add headers in exact same order as test endpoint
-        headers["Authorization"] = `Bearer ${githubToken}`;
-        headers["Content-Type"] = "application/json";
-        headers["copilot-integration-id"] = "vscode-chat";
-        headers["editor-version"] = "vscode/1.107.1";
-        headers["editor-plugin-version"] = "copilot-chat/0.26.7";
-        headers["user-agent"] = "GitHubCopilotChat/0.26.7";
-        headers["openai-intent"] = "conversation-panel";
-        headers["x-github-api-version"] = "2025-04-01";
-        // Generate a UUID for x-request-id (Cloudflare Workers compatible)
-        headers["x-request-id"] = crypto.randomUUID ? crypto.randomUUID() : 
-          'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
-            const r = Math.random() * 16 | 0;
-            const v = c == 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-          });
-        headers["x-vscode-user-agent-library-version"] = "electron-fetch";
-        headers["X-Initiator"] = "user";
-        headers["Accept"] = "application/json";
-        break;
-      }
-  
-      case "codex":
-      case "qwen":
-      case "openai":
-      case "openrouter":
-        headers["Authorization"] = `Bearer ${credentials.apiKey || credentials.accessToken}`;
-        break;
-
-      case "cline":
-        Object.assign(headers, buildClineHeaders(credentials.apiKey || credentials.accessToken));
-        break;
-  
-      case "glm":
-      case "kimi":
-      case "minimax":
-        // Claude-compatible API providers use x-api-key
-        headers["x-api-key"] = credentials.apiKey;
-        break;
-
-      case "vertex":
-      case "vertex-partner":
-        // Vertex uses async token minting — headers are set by VertexExecutor._buildHeadersAsync()
-        // Do NOT set Authorization here; it would leak the raw SA JSON as Bearer token
-        break;
-  
-      default:
-        headers["Authorization"] = `Bearer ${credentials.apiKey || credentials.accessToken}`;
-        break;
-    }
-  }
-
-  // Stream accept header
-  if (stream) {
-    headers["Accept"] = "text/event-stream";
-  }
-
-  return headers;
-}
-
 // Get target format for provider
 export function getTargetFormat(provider) {
   if (isOpenAICompatible(provider)) {
@@ -331,6 +136,16 @@ export function getTargetFormat(provider) {
   return config.format || "openai";
 }
 
+// Resolve which transport to use for a provider given the client sourceFormat.
+// Multi-endpoint providers (transport.transports[]) pick the entry matching sourceFormat
+// to avoid lossy translation; falls back to the default transport when no match.
+export function resolveTransport(provider, sourceFormat) {
+  const config = PROVIDERS[provider];
+  const transports = config?.transports;
+  if (!Array.isArray(transports) || !transports.length) return null;
+  return transports.find(t => t.format === sourceFormat) || null;
+}
+
 // Check if last message is from user
 export function isLastMessageFromUser(body) {
   const messages = body.messages || body.contents;
@@ -344,12 +159,10 @@ export function hasThinkingConfig(body) {
   return !!(body.reasoning_effort || body.thinking?.type === "enabled");
 }
 
-// Normalize thinking config based on last message role
-// - If lastMessage is not user → remove thinking config
-// - If lastMessage is user AND has thinking config → keep it (force enable)
+// Normalize provider-native thinking config based on last message role.
+// OpenAI reasoning_effort is request-level and must survive tool-result turns.
 export function normalizeThinkingConfig(body) {
   if (!isLastMessageFromUser(body)) {
-    delete body.reasoning_effort;
     delete body.thinking;
   }
   return body;

package/app/open-sse/services/qoderModels.js

@@ -15,10 +15,10 @@
 import { createHash } from "crypto";
 
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
-import { buildCosyHeaders } from "@/lib/qoder/cosy.js";
+import { buildCosyHeaders } from "../shared/qoder/cosy.js";
 import {
   QODER_MODEL_LIST_URL,
-} from "@/lib/qoder/constants.js";
+} from "../shared/qoder/constants.js";
 
 const FETCH_TIMEOUT_MS = 15_000;
 const CACHE_TTL_MS = 60 * 60 * 1000; // 1h, same as the Kiro catalog