n9router 0.4.35 → 0.4.37

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

@@ -14,10 +14,14 @@ const ALIAS_TO_PROVIDER_ID = {
   cl: "cline",
   oc: "opencode",
   ocg: "opencode-go",
+  qd: "qoder",
+  qoder: "qoder",
   // TTS providers
   el: "elevenlabs",
   // API Key providers
   openai: "openai",
+  vercel: "vercel-ai-gateway",
+  "vercel-ai-gateway": "vercel-ai-gateway",
   anthropic: "anthropic",
   gemini: "gemini",
   openrouter: "openrouter",
@@ -27,6 +31,8 @@ const ALIAS_TO_PROVIDER_ID = {
   "minimax-cn": "minimax-cn",
   ds: "deepseek",
   deepseek: "deepseek",
+  cmc: "commandcode",
+  commandcode: "commandcode",
   groq: "groq",
   xai: "xai",
   mistral: "mistral",
@@ -65,6 +71,73 @@ const ALIAS_TO_PROVIDER_ID = {
   "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",
 };
 
 /**

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

@@ -0,0 +1,214 @@
+/**
+ * Qoder model catalog fetcher.
+ *
+ * Calls /algo/api/v2/model/list (COSY-signed) on the inference host to get
+ * the live catalog for an authenticated Qoder account, then caches the
+ * per-model `model_config` blocks by key. Chat requests later look up the
+ * exact server-published metadata for the model they want — Qoder's chat
+ * endpoint silently downgrades to a different model when the wrong
+ * model_config is sent.
+ *
+ * On any error the live cache stays empty and chatExecuteCall surfaces the
+ * problem to the user as "model config not yet fetched, retry shortly".
+ */
+
+import { createHash } from "crypto";
+
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { buildCosyHeaders } from "@/lib/qoder/cosy.js";
+import {
+  QODER_MODEL_LIST_URL,
+} from "@/lib/qoder/constants.js";
+
+const FETCH_TIMEOUT_MS = 15_000;
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1h, same as the Kiro catalog
+
+/** @type {Map<string, { expiresAt: number, models: any[], rawConfigs: Map<string, object>, fetched: boolean }>} */
+const catalogCache = new Map();
+
+/**
+ * In-flight fetch promises keyed by cacheKey. Concurrent first-time
+ * callers (parallel chat windows) all observe the same Promise so we
+ * fan-out exactly one upstream request per credential per miss.
+ * @type {Map<string, Promise<{ expiresAt: number, models: any[], rawConfigs: Map<string, object>, fetched: boolean } | null>>}
+ */
+const inflight = new Map();
+
+/**
+ * Stable cache key per credential (so different login sessions for the same
+ * account share an entry).
+ */
+function cacheKey(credentials) {
+  const psd = credentials?.providerSpecificData || {};
+  const seed = psd.userId || credentials?.refreshToken || credentials?.accessToken || "anonymous";
+  return createHash("sha256").update(`qoder:${seed}`).digest("hex");
+}
+
+/**
+ * Strip credential -> COSY creds for buildCosyHeaders.
+ */
+function cosyCredsFromConnection(credentials) {
+  const psd = credentials?.providerSpecificData || {};
+  return {
+    userId: psd.userId,
+    authToken: credentials.accessToken,
+    name: credentials.displayName || "",
+    email: credentials.email || "",
+    machineId: psd.machineId || "",
+  };
+}
+
+/**
+ * Fetch the live model list for this credential. Returns:
+ *   { models: [{ id, name, contextLength, isVL, isReasoning, ... }, ...],
+ *     rawConfigs: Map<modelKey, modelConfigObject> }
+ * or `null` on any error.
+ */
+async function fetchQoderCatalogRaw(credentials, signal, proxyOptions = null) {
+  const creds = cosyCredsFromConnection(credentials);
+  if (!creds.userId || !creds.authToken) return null;
+
+  const headers = {
+    Accept: "application/json",
+    "Accept-Encoding": "identity",
+    ...buildCosyHeaders(Buffer.alloc(0), QODER_MODEL_LIST_URL, creds),
+  };
+
+  const controller = new AbortController();
+  let timer = null;
+  let abortListener = null;
+  let response;
+  try {
+    timer = setTimeout(() => controller.abort("timeout"), FETCH_TIMEOUT_MS);
+    if (signal && typeof signal.addEventListener === "function") {
+      // If the parent signal already aborted before we got here, the
+      // 'abort' event has already fired and addEventListener won't
+      // re-trigger it. Propagate the cancellation immediately.
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+      } else {
+        abortListener = () => controller.abort(signal.reason);
+        signal.addEventListener("abort", abortListener);
+      }
+    }
+    response = await proxyAwareFetch(
+      QODER_MODEL_LIST_URL,
+      {
+        method: "GET",
+        headers,
+        signal: controller.signal,
+      },
+      proxyOptions,
+    );
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+  }
+
+  if (!response.ok) return null;
+
+  const body = await response.json().catch(() => null);
+  if (!body || !Array.isArray(body.chat)) return null;
+
+  const models = [];
+  const rawConfigs = new Map();
+  for (const entry of body.chat) {
+    if (!entry || typeof entry !== "object") continue;
+    const key = entry.key;
+    if (!key) continue;
+
+    // Always cache the config — chat needs model_config even for UI-hidden
+    // models (enable:false). Upstream still accepts chat for these keys.
+    rawConfigs.set(key, entry);
+    if (entry.enable === false) continue;
+
+    const display = entry.display_name || key;
+    const ctx = Number(entry.max_input_tokens) || 131_072;
+    models.push({
+      id: key,
+      name: `${display}`,
+      contextLength: ctx,
+      isVL: !!entry.is_vl,
+      isReasoning: !!entry.is_reasoning,
+      maxOutputTokens: Number(entry.max_output_tokens) || 0,
+      description: entry.description || "",
+    });
+  }
+
+  return { models, rawConfigs };
+}
+
+/**
+ * Get the cached model_config block for a given model key, fetching the
+ * catalog first if needed. Returns null when the catalog can't be fetched
+ * (so callers can fall back to the static registry).
+ */
+export async function getQoderModelConfig(credentials, modelKey, options = {}) {
+  const cached = await resolveQoderModels(credentials, options);
+  if (!cached) return null;
+  const config = cached.rawConfigs.get(modelKey);
+  if (!config) return null;
+  // Defensive copy — chat code may mutate `key` to align with the alias path.
+  return { ...config, key: modelKey };
+}
+
+/**
+ * Resolve the live model catalog + raw configs for a credential. Caches
+ * results for CACHE_TTL_MS so repeated chat requests don't re-fetch, and
+ * deduplicates concurrent misses so parallel chat windows fan-out exactly
+ * one upstream request per credential.
+ */
+export async function resolveQoderModels(credentials, options = {}) {
+  if (!credentials?.accessToken) return null;
+  const psd = credentials.providerSpecificData || {};
+  if (!psd.userId) return null;
+
+  const key = cacheKey(credentials);
+  const now = Date.now();
+  if (!options.forceRefresh) {
+    const cached = catalogCache.get(key);
+    if (cached && cached.expiresAt > now) {
+      return cached;
+    }
+  }
+
+  // Coalesce concurrent misses on the same credential into one upstream call.
+  // forceRefresh callers still get their own fetch (they wanted fresh data).
+  const existing = inflight.get(key);
+  if (existing && !options.forceRefresh) {
+    return existing;
+  }
+
+  const fetchPromise = (async () => {
+    const fetched = await fetchQoderCatalogRaw(credentials, options.signal, options.proxyOptions);
+    if (!fetched) return null;
+    const entry = {
+      expiresAt: Date.now() + CACHE_TTL_MS,
+      models: fetched.models,
+      rawConfigs: fetched.rawConfigs,
+      fetched: true,
+    };
+    catalogCache.set(key, entry);
+    return entry;
+  })();
+
+  inflight.set(key, fetchPromise);
+  try {
+    return await fetchPromise;
+  } finally {
+    // Clear only if this is still the in-flight entry — a forceRefresh
+    // call that started later may have replaced it.
+    if (inflight.get(key) === fetchPromise) {
+      inflight.delete(key);
+    }
+  }
+}
+
+export function invalidateQoderCatalog(credentials) {
+  if (!credentials) return;
+  catalogCache.delete(cacheKey(credentials));
+}
+
+export function clearQoderCatalog() {
+  catalogCache.clear();
+}

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

@@ -2,13 +2,69 @@ import { PROVIDERS } from "../config/providers.js";
 import { OAUTH_ENDPOINTS, GITHUB_COPILOT, REFRESH_LEAD_MS } from "../config/appConstants.js";
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
 
+// xAI refresh — wraps the class method from src/lib/oauth/services/xai.js so
+// the token-refresh switches below can stay flat (one function per provider).
+let _xaiServiceSingleton = null;
+async function refreshXaiToken(refreshToken, log) {
+  if (!refreshToken) return null;
+  return dedupRefresh("xai", refreshToken, async () => {
+    try {
+      if (!_xaiServiceSingleton) {
+        const mod = await import("../../src/lib/oauth/services/xai.js");
+        _xaiServiceSingleton = new mod.XaiService();
+      }
+      const tokens = await _xaiServiceSingleton.refreshAccessToken(refreshToken);
+      return {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token || refreshToken,
+        expiresIn: tokens.expires_in,
+        idToken: tokens.id_token,
+      };
+    } catch (e) {
+      log?.warn?.("TOKEN_REFRESH", `xai refresh failed: ${e?.message || e}`);
+      const msg = String(e?.message || "");
+      if (msg.includes("invalid_grant") || msg.includes("invalid_request")) {
+        return { error: "invalid_grant" };
+      }
+      return null;
+    }
+  }, log);
+}
+
 // Default token expiry buffer (refresh if expires within 5 minutes)
 export const TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1000;
 
-// In-flight refresh dedup: prevents race condition that triggers refresh_token_reused → Auth0 family revoke
-const refreshPromiseCache = new Map();
-function getRefreshCacheKey(provider, refreshToken) {
-  return `${provider}:${refreshToken}`;
+// Dedup: cache in-flight promise + recent result to prevent refresh_token_reused (Auth0 family revoke)
+const REFRESH_RESULT_TTL_MS = 10_000;
+const refreshDedupCache = new Map();
+
+async function dedupRefresh(provider, oldToken, fn, log) {
+  if (!oldToken) return fn();
+  const key = `${provider}:${oldToken}`;
+  const hit = refreshDedupCache.get(key);
+  if (hit) {
+    if (hit.promise) {
+      log?.info?.("TOKEN_REFRESH", `Reusing in-flight refresh for ${provider}`);
+      return hit.promise;
+    }
+    if (hit.expiresAt > Date.now()) {
+      log?.info?.("TOKEN_REFRESH", `Reusing recent refresh result for ${provider}`);
+      return hit.result;
+    }
+    refreshDedupCache.delete(key);
+  }
+  const promise = (async () => {
+    try {
+      const result = await fn();
+      refreshDedupCache.set(key, { result, expiresAt: Date.now() + REFRESH_RESULT_TTL_MS });
+      return result;
+    } catch (err) {
+      refreshDedupCache.delete(key);
+      throw err;
+    }
+  })();
+  refreshDedupCache.set(key, { promise });
+  return promise;
 }
 
 // Check if refresh result indicates unrecoverable error (caller should stop retry, force re-auth)
@@ -44,6 +100,7 @@ export async function refreshAccessToken(provider, refreshToken, credentials, lo
     return null;
   }
 
+  return dedupRefresh(provider, refreshToken, async () => {
   try {
     const response = await fetch(config.refreshUrl, {
       method: "POST",
@@ -87,12 +144,15 @@ export async function refreshAccessToken(provider, refreshToken, credentials, lo
     });
     return null;
   }
+  }, log);
 }
 
 /**
  * Specialized refresh for Claude OAuth tokens
  */
 export async function refreshClaudeOAuthToken(refreshToken, log) {
+  if (!refreshToken) return null;
+  return dedupRefresh("claude", refreshToken, async () => {
   try {
     const response = await fetch(OAUTH_ENDPOINTS.anthropic.token, {
       method: "POST",
@@ -120,12 +180,15 @@ export async function refreshClaudeOAuthToken(refreshToken, log) {
     log?.error?.("TOKEN_REFRESH", `Network error refreshing Claude token: ${error.message}`);
     return null;
   }
+  }, log);
 }
 
 /**
  * Specialized refresh for Google providers (Gemini, Antigravity)
  */
 export async function refreshGoogleToken(refreshToken, clientId, clientSecret, log) {
+  if (!refreshToken) return null;
+  return dedupRefresh(`google:${clientId}`, refreshToken, async () => {
   try {
     const response = await fetch(OAUTH_ENDPOINTS.google.token, {
       method: "POST",
@@ -154,12 +217,15 @@ export async function refreshGoogleToken(refreshToken, clientId, clientSecret, l
     log?.error?.("TOKEN_REFRESH", `Network error refreshing Google token: ${error.message}`);
     return null;
   }
+  }, log);
 }
 
 /**
  * Specialized refresh for Qwen OAuth tokens
  */
 export async function refreshQwenToken(refreshToken, log) {
+  if (!refreshToken) return null;
+  return dedupRefresh("qwen", refreshToken, async () => {
   const endpoint = OAUTH_ENDPOINTS.qwen.token;
 
   try {
@@ -208,6 +274,7 @@ export async function refreshQwenToken(refreshToken, log) {
 
   log?.error?.("TOKEN_REFRESH", "Failed to refresh Qwen token");
   return null;
+  }, log);
 }
 
 /**
@@ -217,6 +284,8 @@ export async function refreshQwenToken(refreshToken, log) {
  * so callers stop retrying and request re-authentication.
  */
 export async function refreshCodexToken(refreshToken, log) {
+  if (!refreshToken) return null;
+  return dedupRefresh("codex", refreshToken, async () => {
   try {
   const response = await fetch(OAUTH_ENDPOINTS.openai.token, {
     method: "POST",
@@ -279,6 +348,7 @@ export async function refreshCodexToken(refreshToken, log) {
     log?.error?.("TOKEN_REFRESH", `Network error refreshing Codex token: ${error.message}`);
     return null;
   }
+  }, log);
 }
 
 /**
@@ -286,6 +356,8 @@ export async function refreshCodexToken(refreshToken, log) {
  * Supports both AWS SSO OIDC (Builder ID/IDC) and Social Auth (Google/GitHub)
  */
 export async function refreshKiroToken(refreshToken, providerSpecificData, log, proxyOptions = null) {
+  if (!refreshToken) return null;
+  return dedupRefresh("kiro", refreshToken, async () => {
   const authMethod = providerSpecificData?.authMethod;
   const clientId = providerSpecificData?.clientId;
   const clientSecret = providerSpecificData?.clientSecret;
@@ -370,12 +442,15 @@ export async function refreshKiroToken(refreshToken, providerSpecificData, log,
     refreshToken: tokens.refreshToken || refreshToken,
     expiresIn: tokens.expiresIn,
   };
+  }, log);
 }
 
 /**
  * Specialized refresh for iFlow OAuth tokens
  */
 export async function refreshIflowToken(refreshToken, log) {
+  if (!refreshToken) return null;
+  return dedupRefresh("iflow", refreshToken, async () => {
   const basicAuth = btoa(`${PROVIDERS.iflow.clientId}:${PROVIDERS.iflow.clientSecret}`);
 
   const response = await fetch(OAUTH_ENDPOINTS.iflow.token, {
@@ -415,12 +490,15 @@ export async function refreshIflowToken(refreshToken, log) {
     refreshToken: tokens.refresh_token || refreshToken,
     expiresIn: tokens.expires_in,
   };
+  }, log);
 }
 
 /**
  * Specialized refresh for GitHub Copilot OAuth tokens
  */
 export async function refreshGitHubToken(refreshToken, log) {
+  if (!refreshToken) return null;
+  return dedupRefresh("github", refreshToken, async () => {
   const params = {
     grant_type: "refresh_token",
     refresh_token: refreshToken,
@@ -461,12 +539,15 @@ export async function refreshGitHubToken(refreshToken, log) {
     refreshToken: tokens.refresh_token || refreshToken,
     expiresIn: tokens.expires_in,
   };
+  }, log);
 }
 
 /**
  * Refresh GitHub Copilot token using GitHub access token
  */
 export async function refreshCopilotToken(githubAccessToken, log) {
+  if (!githubAccessToken) return null;
+  return dedupRefresh("copilot", githubAccessToken, async () => {
   try {
     const response = await fetch("https://api.github.com/copilot_internal/v2/token", {
       headers: {
@@ -505,6 +586,7 @@ export async function refreshCopilotToken(githubAccessToken, log) {
     });
     return null;
   }
+  }, log);
 }
 
 /**
@@ -517,20 +599,8 @@ export async function getAccessToken(provider, credentials, log) {
     log?.warn?.("TOKEN_REFRESH", `No valid refresh token available for provider: ${provider}`);
     return null;
   }
-
-  const cacheKey = getRefreshCacheKey(provider, credentials.refreshToken);
-
-  if (refreshPromiseCache.has(cacheKey)) {
-    log?.info?.("TOKEN_REFRESH", `Reusing in-flight refresh for ${provider}`);
-    return refreshPromiseCache.get(cacheKey);
-  }
-
-  const refreshPromise = _getAccessTokenInternal(provider, credentials, log).finally(() => {
-    refreshPromiseCache.delete(cacheKey);
-  });
-
-  refreshPromiseCache.set(cacheKey, refreshPromise);
-  return refreshPromise;
+  // Dedup is handled inside each refreshXxxToken function
+  return _getAccessTokenInternal(provider, credentials, log);
 }
 
 async function _getAccessTokenInternal(provider, credentials, log) {
@@ -567,6 +637,9 @@ async function _getAccessTokenInternal(provider, credentials, log) {
         log
       );
 
+    case "xai":
+      return await refreshXaiToken(credentials.refreshToken, log);
+
     case "vertex":
     case "vertex-partner": {
       const saJson = parseVertexSaJson(credentials.apiKey);
@@ -611,6 +684,8 @@ export async function refreshTokenByProvider(provider, credentials, log) {
         credentials.providerSpecificData,
         log
       );
+    case "xai":
+      return refreshXaiToken(credentials.refreshToken, log);
     case "vertex":
     case "vertex-partner": {
       const saJson = parseVertexSaJson(credentials.apiKey);
@@ -651,6 +726,7 @@ export function formatProviderCredentials(provider, credentials, log) {
     case "iflow":
     case "openai":
     case "openrouter":
+    case "xai":
       return {
         apiKey: credentials.apiKey,
         accessToken: credentials.accessToken
@@ -798,4 +874,3 @@ export async function refreshWithRetry(refreshFn, maxRetries = 3, log = null) {
   log?.error?.("TOKEN_REFRESH", `All ${maxRetries} retry attempts failed`);
   return null;
 }
-