@fudrouter/fsrouter 0.6.62 → 0.6.63

package/open-sse/config/providerErrorRules.js

@@ -0,0 +1,114 @@
+function buildOpencodeRules() {
+  return [
+    {
+      id: "opencode-monthly-quota-resets-in",
+      match: ({ status, body }) => {
+        if (status !== 429) return null;
+        const text = JSON.stringify(body ?? "").toLowerCase();
+        if (!text.includes("monthly usage limit reached")) return null;
+        const cooldownMs = parseResetCountdownMs(text);
+        if (cooldownMs === null) return null;
+        return {
+          reason: "quota_exhausted",
+          scope: "connection",
+          cooldownMs
+        };
+      }
+    },
+    {
+      id: "opencode-quota-exhausted-headers",
+      match: ({ status, headers }) => {
+        if (status !== 429) return null;
+        const remainingRequests = headers["x-ratelimit-remaining-requests"];
+        if (remainingRequests === "0") {
+          return { reason: "quota_exhausted", scope: "connection" };
+        }
+        const remainingTokens = headers["x-ratelimit-remaining-tokens"];
+        if (remainingTokens === "0") {
+          return { reason: "quota_exhausted", scope: "connection" };
+        }
+        return null;
+      }
+    },
+    {
+      id: "opencode-quota-exhausted-body",
+      match: ({ status, body }) => {
+        if (status !== 429) return null;
+        const text = JSON.stringify(body ?? "").toLowerCase();
+        if (text.includes("organization_quota_exceeded") || text.includes("account_quota_exceeded") || text.includes("plan_limit_reached")) {
+          return { reason: "quota_exhausted", scope: "connection" };
+        }
+        return null;
+      }
+    }
+  ];
+}
+function buildMinimaxRules() {
+  return [
+    {
+      id: "minimax-per-model-quota",
+      match: ({ status, headers }) => {
+        if (status !== 429) return null;
+        const headerVal = headers["x-model-quota-remaining"];
+        if (!headerVal) return null;
+        const exhausted = headerVal.split(",").some((pair) => pair.split("=")[1]?.trim() === "0");
+        if (exhausted) {
+          return { reason: "quota_exhausted", scope: "model" };
+        }
+        return null;
+      }
+    }
+  ];
+}
+const providerRuleRegistry = /* @__PURE__ */ new Map([
+  ["opencode", buildOpencodeRules()],
+  ["opencode-go", buildOpencodeRules()],
+  ["opencode-cli", buildOpencodeRules()],
+  ["minimax", buildMinimaxRules()],
+  ["minimax-passthrough", buildMinimaxRules()]
+]);
+function getProviderErrorRuleMatch(provider, status, headers, body) {
+  if (!provider) return null;
+  const rules = providerRuleRegistry.get(provider.toLowerCase());
+  if (!rules) return null;
+  const safeHeaders = !headers ? {} : typeof headers.get === "function" ? Object.fromEntries(headers.entries()) : Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [
+      key.toLowerCase(),
+      value
+    ])
+  );
+  for (const rule of rules) {
+    const match = rule.match({ status, headers: safeHeaders, body });
+    if (match) return match;
+  }
+  return null;
+}
+function parseResetCountdownMs(text) {
+  if (typeof text !== "string" || text.length === 0) return null;
+  const match = text.match(/resets?\s+in\s+(\d+)\s+(day|days|hour|hours|minute|minutes|second|seconds)\b/);
+  if (!match) return null;
+  const n = Number(match[1]);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = match[2];
+  switch (unit) {
+    case "day":
+    case "days":
+      return n * 864e5;
+    case "hour":
+    case "hours":
+      return n * 36e5;
+    case "minute":
+    case "minutes":
+      return n * 6e4;
+    case "second":
+    case "seconds":
+      return n * 1e3;
+    default:
+      return null;
+  }
+}
+export {
+  getProviderErrorRuleMatch,
+  parseResetCountdownMs,
+  providerRuleRegistry
+};

package/open-sse/config/providerFieldStrips.js

@@ -0,0 +1,35 @@
+const KNOWN_OFFENDING_FIELDS = [
+  "reasoning_budget",
+  "chat_template",
+  "reasoning_content",
+  "context_management"
+];
+function findOffendingField(bodyText) {
+  if (typeof bodyText !== "string" || !bodyText) return null;
+  for (const field of KNOWN_OFFENDING_FIELDS) {
+    if (bodyText.includes(field)) return field;
+  }
+  return null;
+}
+function stripGroqUnsupportedFields(body) {
+  if (!body || typeof body !== "object") return body;
+  const next = { ...body };
+  delete next.logprobs;
+  delete next.logit_bias;
+  delete next.top_logprobs;
+  if (Array.isArray(next.messages)) {
+    next.messages = next.messages.map((m) => {
+      if (m && typeof m === "object" && "name" in m) {
+        const { name: _name, ...rest } = m;
+        return rest;
+      }
+      return m;
+    });
+  }
+  return next;
+}
+export {
+  KNOWN_OFFENDING_FIELDS,
+  findOffendingField,
+  stripGroqUnsupportedFields
+};

package/open-sse/config/providerHeaderProfiles.js

@@ -0,0 +1,191 @@
+import { antigravityUserAgent } from "../services/antigravityHeaders.ts";
+const GITHUB_COPILOT_API_VERSION = "2026-06-01";
+const GITHUB_COPILOT_EDITOR_VERSION = "vscode/1.126.0";
+const GITHUB_COPILOT_CHAT_PLUGIN_VERSION = "copilot-chat/0.54.0";
+const GITHUB_COPILOT_CHAT_USER_AGENT = "GitHubCopilotChat/0.54.0";
+const GITHUB_COPILOT_REFRESH_PLUGIN_VERSION = "copilot/1.388.0";
+const GITHUB_COPILOT_REFRESH_USER_AGENT = "GithubCopilot/1.0";
+const GITHUB_COPILOT_INTEGRATION_ID = "vscode-chat";
+const GITHUB_COPILOT_OPENAI_INTENT = "conversation-panel";
+const GITHUB_COPILOT_DEFAULT_INITIATOR = "user";
+const GITHUB_COPILOT_USER_AGENT_LIBRARY = "electron-fetch";
+const QWEN_CLI_VERSION = "0.19.3";
+const QWEN_STAINLESS_LANG = "js";
+const QWEN_STAINLESS_PACKAGE_VERSION = "5.11.0";
+const QWEN_STAINLESS_RETRY_COUNT = "1";
+const QWEN_STAINLESS_RUNTIME = "node";
+const QWEN_ACCEPT_LANGUAGE = "*";
+const QWEN_SEC_FETCH_MODE = "cors";
+const QODER_DEFAULT_USER_AGENT = "Qoder-Cli";
+const KIRO_SDK_USER_AGENT = "AWS-SDK-JS/3.0.0 kiro-ide/1.0.0";
+const KIRO_AMZ_USER_AGENT = "aws-sdk-js/3.0.0 kiro-ide/1.0.0";
+const KIRO_STREAMING_TARGET = "AmazonCodeWhispererStreamingService.GenerateAssistantResponse";
+const CURSOR_REGISTRY_VERSION = "3.9";
+function getGitHubCopilotChatHeaders(accept = "application/json", initiator = GITHUB_COPILOT_DEFAULT_INITIATOR) {
+  return {
+    "copilot-integration-id": GITHUB_COPILOT_INTEGRATION_ID,
+    "editor-version": GITHUB_COPILOT_EDITOR_VERSION,
+    "editor-plugin-version": GITHUB_COPILOT_CHAT_PLUGIN_VERSION,
+    "user-agent": GITHUB_COPILOT_CHAT_USER_AGENT,
+    "openai-intent": GITHUB_COPILOT_OPENAI_INTENT,
+    "x-github-api-version": GITHUB_COPILOT_API_VERSION,
+    "x-vscode-user-agent-library-version": GITHUB_COPILOT_USER_AGENT_LIBRARY,
+    "X-Initiator": initiator,
+    Accept: accept,
+    "Content-Type": "application/json"
+  };
+}
+function getRuntimePlatform() {
+  return typeof process !== "undefined" && typeof process.platform === "string" ? process.platform : "unknown";
+}
+function getRuntimeArch() {
+  return typeof process !== "undefined" && typeof process.arch === "string" ? process.arch : "unknown";
+}
+function getRuntimeVersion() {
+  return typeof process !== "undefined" && typeof process.version === "string" ? process.version : "unknown";
+}
+function normalizeStainlessPlatform(platform = getRuntimePlatform()) {
+  const normalized = platform.toLowerCase();
+  if (normalized.includes("ios")) return "iOS";
+  if (normalized === "android") return "Android";
+  if (normalized === "darwin") return "MacOS";
+  if (normalized === "win32") return "Windows";
+  if (normalized === "freebsd") return "FreeBSD";
+  if (normalized === "openbsd") return "OpenBSD";
+  if (normalized === "linux") return "Linux";
+  return normalized ? `Other:${normalized}` : "Unknown";
+}
+function normalizeStainlessArch(arch = getRuntimeArch()) {
+  if (arch === "x32") return "x32";
+  if (arch === "x86_64" || arch === "x64") return "x64";
+  if (arch === "arm") return "arm";
+  if (arch === "aarch64" || arch === "arm64") return "arm64";
+  return arch ? `other:${arch}` : "unknown";
+}
+function getQwenCliUserAgent(version = QWEN_CLI_VERSION) {
+  return `QwenCode/${version} (${getRuntimePlatform()}; ${getRuntimeArch()})`;
+}
+function getGitHubCopilotInternalUserHeaders(authorization) {
+  return {
+    Authorization: authorization,
+    Accept: "application/json",
+    "X-GitHub-Api-Version": GITHUB_COPILOT_API_VERSION,
+    "User-Agent": GITHUB_COPILOT_CHAT_USER_AGENT,
+    "Editor-Version": GITHUB_COPILOT_EDITOR_VERSION,
+    "Editor-Plugin-Version": GITHUB_COPILOT_CHAT_PLUGIN_VERSION
+  };
+}
+function getGitHubCopilotRefreshHeaders(authorization) {
+  return {
+    Authorization: authorization,
+    Accept: "application/json",
+    "User-Agent": GITHUB_COPILOT_REFRESH_USER_AGENT,
+    "Editor-Version": GITHUB_COPILOT_EDITOR_VERSION,
+    "Editor-Plugin-Version": GITHUB_COPILOT_REFRESH_PLUGIN_VERSION
+  };
+}
+function getQwenOauthHeaders() {
+  const userAgent = getQwenCliUserAgent();
+  return {
+    "User-Agent": userAgent,
+    "X-Dashscope-AuthType": "qwen-oauth",
+    "X-Dashscope-CacheControl": "enable",
+    "X-Dashscope-UserAgent": userAgent,
+    "X-Stainless-Arch": normalizeStainlessArch(),
+    "X-Stainless-Lang": QWEN_STAINLESS_LANG,
+    "X-Stainless-Os": normalizeStainlessPlatform(),
+    "X-Stainless-Package-Version": QWEN_STAINLESS_PACKAGE_VERSION,
+    "X-Stainless-Retry-Count": QWEN_STAINLESS_RETRY_COUNT,
+    "X-Stainless-Runtime": QWEN_STAINLESS_RUNTIME,
+    "X-Stainless-Runtime-Version": getRuntimeVersion(),
+    Connection: "keep-alive",
+    "Accept-Language": QWEN_ACCEPT_LANGUAGE,
+    "Sec-Fetch-Mode": QWEN_SEC_FETCH_MODE
+  };
+}
+function getQoderDefaultHeaders() {
+  return {
+    "User-Agent": QODER_DEFAULT_USER_AGENT
+  };
+}
+function getQoderDashscopeCompatHeaders() {
+  const userAgent = getQwenCliUserAgent();
+  return {
+    "x-dashscope-authtype": "qwen-oauth",
+    "x-dashscope-cachecontrol": "enable",
+    "user-agent": userAgent,
+    "x-dashscope-useragent": userAgent,
+    "x-stainless-arch": normalizeStainlessArch(),
+    "x-stainless-lang": QWEN_STAINLESS_LANG,
+    "x-stainless-os": normalizeStainlessPlatform()
+  };
+}
+function getAntigravityUserAgent() {
+  return antigravityUserAgent();
+}
+function getAntigravityProviderHeaders() {
+  return {
+    "User-Agent": getAntigravityUserAgent()
+  };
+}
+function getKiroServiceHeaders(accept = "application/vnd.amazon.eventstream") {
+  return {
+    "Content-Type": "application/json",
+    Accept: accept,
+    "X-Amz-Target": KIRO_STREAMING_TARGET,
+    "User-Agent": KIRO_SDK_USER_AGENT,
+    "X-Amz-User-Agent": KIRO_AMZ_USER_AGENT
+  };
+}
+function getCursorUserAgent(version) {
+  return `Cursor/${version}`;
+}
+function getCursorRegistryHeaders(version = CURSOR_REGISTRY_VERSION) {
+  return {
+    "connect-accept-encoding": "gzip",
+    "connect-protocol-version": "1",
+    "Content-Type": "application/connect+proto",
+    "User-Agent": getCursorUserAgent(version)
+  };
+}
+export {
+  CURSOR_REGISTRY_VERSION,
+  GITHUB_COPILOT_API_VERSION,
+  GITHUB_COPILOT_CHAT_PLUGIN_VERSION,
+  GITHUB_COPILOT_CHAT_USER_AGENT,
+  GITHUB_COPILOT_DEFAULT_INITIATOR,
+  GITHUB_COPILOT_EDITOR_VERSION,
+  GITHUB_COPILOT_INTEGRATION_ID,
+  GITHUB_COPILOT_OPENAI_INTENT,
+  GITHUB_COPILOT_REFRESH_PLUGIN_VERSION,
+  GITHUB_COPILOT_REFRESH_USER_AGENT,
+  GITHUB_COPILOT_USER_AGENT_LIBRARY,
+  KIRO_AMZ_USER_AGENT,
+  KIRO_SDK_USER_AGENT,
+  KIRO_STREAMING_TARGET,
+  QODER_DEFAULT_USER_AGENT,
+  QWEN_ACCEPT_LANGUAGE,
+  QWEN_CLI_VERSION,
+  QWEN_SEC_FETCH_MODE,
+  QWEN_STAINLESS_LANG,
+  QWEN_STAINLESS_PACKAGE_VERSION,
+  QWEN_STAINLESS_RETRY_COUNT,
+  QWEN_STAINLESS_RUNTIME,
+  getAntigravityProviderHeaders,
+  getAntigravityUserAgent,
+  getCursorRegistryHeaders,
+  getCursorUserAgent,
+  getGitHubCopilotChatHeaders,
+  getGitHubCopilotInternalUserHeaders,
+  getGitHubCopilotRefreshHeaders,
+  getKiroServiceHeaders,
+  getQoderDashscopeCompatHeaders,
+  getQoderDefaultHeaders,
+  getQwenCliUserAgent,
+  getQwenOauthHeaders,
+  getRuntimeArch,
+  getRuntimePlatform,
+  getRuntimeVersion,
+  normalizeStainlessArch,
+  normalizeStainlessPlatform
+};

package/open-sse/config/providerModels.js

@@ -0,0 +1,106 @@
+import { PROVIDERS } from "./providers.js";
+import REGISTRY from "../providers/registry/index.js";
+// PROVIDER_MODELS now built from providers/registry (transport + models co-located)
+import { PROVIDER_MODELS } from "../providers/index.js";
+import { modelQuotaFamily, modelStrip, modelTargetFormat, normalizeModelId } from "../providers/models/schema.js";
+import { CODEX_REVIEW_SUFFIX } from "../providers/models/helpers.js";
+
+export { PROVIDER_MODELS };
+
+
+// Helper functions
+export function getProviderModels(aliasOrId) {
+  return PROVIDER_MODELS[aliasOrId] || [];
+}
+
+export function getDefaultModel(aliasOrId) {
+  const models = PROVIDER_MODELS[aliasOrId];
+  return models?.[0]?.id || null;
+}
+
+// Providers whose registry uses dots in version numbers (e.g. "claude-sonnet-4.5").
+// For these, we tolerate clients sending dashes ("claude-sonnet-4-5") by normalizing
+// digit-hyphen-digit to digit-dot-digit before lookup. Other providers are left untouched.
+const DOT_VERSION_PROVIDERS = new Set(["kr", "kiro"]);
+
+// Find a registry entry by id. For Kiro models, tolerates dash/dot version separators
+// ("claude-sonnet-4-5" ~= "claude-sonnet-4.5"). Other providers use exact match only.
+function findModel(models, modelId, aliasOrId) {
+  if (!models) return undefined;
+  const found = models.find(m => m.id === modelId);
+  if (found) return found;
+  if (!DOT_VERSION_PROVIDERS.has(aliasOrId)) return undefined;
+  const normalized = normalizeModelId(modelId);
+  if (normalized === modelId) return undefined;
+  return models.find(m => m.id === normalized);
+}
+
+export function isValidModel(aliasOrId, modelId, passthroughProviders = new Set()) {
+  if (passthroughProviders.has(aliasOrId)) return true;
+  const models = PROVIDER_MODELS[aliasOrId];
+  if (!models) return false;
+  return !!findModel(models, modelId, aliasOrId);
+}
+
+export function findModelName(aliasOrId, modelId) {
+  const models = PROVIDER_MODELS[aliasOrId];
+  if (!models) return modelId;
+  const found = findModel(models, modelId, aliasOrId);
+  return found?.name || modelId;
+}
+
+export function getModelTargetFormat(aliasOrId, modelId) {
+  const models = PROVIDER_MODELS[aliasOrId];
+  if (!models) return null;
+  return modelTargetFormat(findModel(models, modelId, aliasOrId));
+}
+
+export function getModelType(aliasOrId, modelId) {
+  const models = PROVIDER_MODELS[aliasOrId];
+  if (!models) return null;
+  const found = findModel(models, modelId, aliasOrId);
+  return found?.kind || found?.type || null;
+}
+
+export function getModelUpstreamId(aliasOrId, modelId) {
+  // Split off thinking suffix "(level)" so lookup hits the base id; re-append it to
+  // the result so downstream applyThinking still sees the suffix (body.model is stripped separately).
+  const sufMatch = typeof modelId === "string" ? modelId.match(/\([^()]+\)\s*$/) : null;
+  const suffix = sufMatch ? sufMatch[0] : "";
+  const baseId = suffix ? modelId.slice(0, sufMatch.index).trim() : modelId;
+  const models = PROVIDER_MODELS[aliasOrId];
+  const found = findModel(models, baseId, aliasOrId);
+  if (found?.upstreamModelId) return found.upstreamModelId + suffix;
+  if (found?.id) return found.id + suffix;
+  if (aliasOrId === "cx" && typeof baseId === "string" && baseId.endsWith(CODEX_REVIEW_SUFFIX)) {
+    return baseId.slice(0, -CODEX_REVIEW_SUFFIX.length) + suffix;
+  }
+  return baseId + suffix;
+}
+
+export function getModelQuotaFamily(aliasOrId, modelId) {
+  const models = PROVIDER_MODELS[aliasOrId];
+  return modelQuotaFamily(findModel(models, modelId, aliasOrId));
+}
+
+// OAuth short aliases — derived from registry `alias` (single source). everything else: alias = id.
+// vertex/vertex-partner keep alias=id (kept via the `|| id` fallback in consumers).
+export const OAUTH_ALIASES = Object.fromEntries(
+  REGISTRY.filter(r => r.alias && r.alias !== r.id).map(r => [r.id, r.alias])
+);
+
+// Derived from PROVIDERS — no need to maintain manually
+export const PROVIDER_ID_TO_ALIAS = Object.fromEntries(
+  Object.keys(PROVIDERS).map(id => [id, OAUTH_ALIASES[id] || id])
+);
+
+export function getModelsByProviderId(providerId) {
+  const alias = PROVIDER_ID_TO_ALIAS[providerId] || providerId;
+  return PROVIDER_MODELS[alias] || [];
+}
+
+// Get strip list for a model entry (explicit opt-in only)
+// Returns array of content types to strip, e.g. ["image", "audio"]
+export function getModelStrip(alias, modelId) {
+  return modelStrip(findModel(PROVIDER_MODELS[alias], modelId, alias));
+}

package/open-sse/config/providerRegistry.js

@@ -0,0 +1,16 @@
+/**
+ * Stub: providerRegistry — provider category + registry lookups.
+ * TODO: Wire to actual provider registry when available.
+ */
+
+export function getProviderCategory(provider) {
+  const p = (provider || '').toLowerCase();
+  // OAuth providers
+  if (['codex', 'cursor', 'kiro', 'qoder', 'cline', 'opencode', 'grok'].includes(p)) return 'oauth';
+  // Default to apikey
+  return 'apikey';
+}
+
+export function getRegistryEntry(provider) {
+  return null;
+}

package/open-sse/config/providers.js

@@ -0,0 +1,19 @@
+// Barrel: PROVIDERS now built from providers/registry (transport co-located with models)
+import { PROVIDERS } from "../providers/index.js";
+export { PROVIDERS, PROVIDER_OAUTH } from "../providers/index.js";
+
+export const OLLAMA_LOCAL_DEFAULT_HOST = "http://localhost:11434";
+
+export function resolveOllamaLocalHost(credentials) {
+  const raw = credentials?.providerSpecificData?.baseUrl?.trim();
+  return (raw || OLLAMA_LOCAL_DEFAULT_HOST).replace(/\/$/, "");
+}
+
+// Region URLs single-source from registry xiaomi-tokenplan.transport
+export const XIAOMI_TOKENPLAN_REGIONS = PROVIDERS["xiaomi-tokenplan"]?.regions || {};
+export const XIAOMI_TOKENPLAN_DEFAULT_REGION = PROVIDERS["xiaomi-tokenplan"]?.defaultRegion;
+
+export function resolveXiaomiTokenplanBaseUrl(credentials) {
+  const region = credentials?.providerSpecificData?.region;
+  return XIAOMI_TOKENPLAN_REGIONS[region] || XIAOMI_TOKENPLAN_REGIONS[XIAOMI_TOKENPLAN_DEFAULT_REGION];
+}

package/open-sse/config/registryUtils.js

@@ -0,0 +1,106 @@
+/**
+ * Shared Registry Utilities
+ *
+ * Common interfaces and helpers used by all provider registries
+ * (audio, image, video, music). Extracts duplicated patterns into
+ * reusable functions.
+ */
+
+/**
+ * Per-registry ``modelId → providerId`` index for the bare-model lookup below.
+ * The media registries (image/video/audio/music) are static module-level objects, so the
+ * index is built once per registry and reused. First-wins insertion preserves the original
+ * Object.entries() iteration order (the same provider the linear scan would have returned).
+ */
+const registryModelIndexCache = new WeakMap();
+function getRegistryModelIndex(registry) {
+  let index = registryModelIndexCache.get(registry);
+  if (!index) {
+    index = new Map();
+    for (const [providerId, config] of Object.entries(registry)) {
+      for (const model of config.models) {
+        if (!index.has(model.id)) index.set(model.id, providerId);
+      }
+    }
+    registryModelIndexCache.set(registry, index);
+  }
+  return index;
+}
+
+/**
+ * Parse a "provider/model" string against a registry.
+ * Supports both "provider/model" prefix and bare "model" lookup.
+ */
+export function parseModelFromRegistry(modelStr, registry) {
+  if (!modelStr) return { provider: null, model: null };
+
+  // Try each provider prefix
+  for (const [providerId, config] of Object.entries(registry)) {
+    if (modelStr.startsWith(providerId + "/")) {
+      return { provider: providerId, model: modelStr.slice(providerId.length + 1) };
+    }
+    if (config.alias && modelStr.startsWith(config.alias + "/")) {
+      return { provider: providerId, model: modelStr.slice(config.alias.length + 1) };
+    }
+  }
+
+  // No provider prefix — find the model via the precomputed index (was an O(providers × models)
+  // scan on every call).
+  const providerId = getRegistryModelIndex(registry).get(modelStr);
+  if (providerId) {
+    return { provider: providerId, model: modelStr };
+  }
+
+  return { provider: null, model: modelStr };
+}
+
+/**
+ * Flatten all models from a registry into a list with provider info.
+ * Optionally merge extra fields per provider via the `extra` callback.
+ */
+export function getAllModelsFromRegistry(registry, extra) {
+  const models = [];
+
+  for (const [providerId, config] of Object.entries(registry)) {
+    const extraFields = extra ? extra(providerId, config) : {};
+    for (const model of config.models) {
+      const entries = [providerId, config.alias].filter(
+        (prefix) => typeof prefix === "string" && prefix.length > 0
+      );
+      for (const prefix of entries) {
+        models.push({
+          id: `${prefix}/${model.id}`,
+          name: model.name,
+          provider: providerId,
+          ...extraFields,
+        });
+      }
+    }
+  }
+
+  return models;
+}
+
+/**
+ * Build auth headers for a provider.
+ * Handles bearer, key, token, xi-api-key, x-api-key, and none.
+ */
+export function buildAuthHeaders(provider, token) {
+  if (provider.authType === "none" || provider.authHeader === "none" || !token) {
+    return {};
+  }
+
+  switch (provider.authHeader) {
+    case "key":
+      return { Authorization: `Key ${token}` };
+    case "token":
+      return { Authorization: `Token ${token}` };
+    case "xi-api-key":
+      return { "xi-api-key": token };
+    case "x-api-key":
+      return { "x-api-key": token };
+    case "bearer":
+    default:
+      return { Authorization: `Bearer ${token}` };
+  }
+}