swayrouter 1.0.0

package/src/routes/api/providers/[id]/models/route.js

@@ -0,0 +1,716 @@
+import { NextResponse } from "next/server";
+import { getProviderConnectionById } from "@/models";
+import { isOpenAICompatibleProvider, isAnthropicCompatibleProvider, resolveProviderId } from "@/shared/constants/providers";
+import { GEMINI_CONFIG } from "@/lib/oauth/constants/oauth";
+import { refreshGoogleToken, refreshCodexToken, updateProviderCredentials } from "@/sse/services/tokenRefresh";
+import { PROVIDERS, resolveOllamaLocalHost } from "open-sse/config/providers.js";
+import { getModelsByProviderId } from "open-sse/config/providerModels.js";
+import { resolveKiroModels } from "open-sse/services/kiroModels.js";
+import { resolveKimchiModels } from "open-sse/services/kimchiModels.js";
+import { resolveQoderModels } from "open-sse/services/qoderModels.js";
+import { resolveGrokCliModels } from "open-sse/services/grokCliModels.js";
+import { resolveCursorModels } from "open-sse/services/cursorModels.js";
+import { resolveCodeBuddyModels } from "open-sse/services/codebuddyModels.js";
+import { getCapabilitiesForModel } from "open-sse/providers/capabilities.js";
+import { getThinkingLevels } from "open-sse/providers/thinkingLevels.js";
+import { AGENTROUTER_MODELS_URL, AGENTROUTER_OPENAI_HEADERS } from "open-sse/providers/shared.js";
+import { resolveConnectionProxyConfig } from "@/lib/network/connectionProxy.js";
+import { logRouteError } from "@/lib/errors/publicError";
+
+const MODEL_CACHE_TTL_MS = 10 * 60 * 1000;
+const LIVE_MODELS_WARNING = "Live model catalog unavailable; using static catalog.";
+const modelCacheStore = new Map();
+
+function cachedModelsKey(provider, connectionId) {
+  return `${provider}:${connectionId}`;
+}
+
+function getCachedModels(payload, provider, connectionId) {
+  const key = cachedModelsKey(provider, connectionId);
+  const entry = modelCacheStore.get(key);
+  if (entry && Date.now() - entry.at < MODEL_CACHE_TTL_MS) {
+    return { payload: { ...payload, ...entry.payload, cached: true } };
+  }
+  return null;
+}
+
+function setCachedModels(payload, provider, connectionId) {
+  modelCacheStore.set(cachedModelsKey(provider, connectionId), {
+    at: Date.now(),
+    payload: { provider, connectionId, models: payload.models },
+  });
+}
+
+function withCapabilities(provider, models) {
+  const providerId = resolveProviderId(provider);
+  return (Array.isArray(models) ? models : []).map((model) => {
+    if (!model || typeof model !== "object") return model;
+    const id = typeof model.id === "string" ? model.id : typeof model.model === "string" ? model.model : "";
+    if (!id) return model;
+    const next = { ...model };
+    const suppliedCapabilities = next.capabilities ?? next.caps ?? null;
+    next.capabilities = getCapabilitiesForModel(providerId, id, suppliedCapabilities);
+    if (!Array.isArray(next.thinkingLevels)) {
+      const thinkingLevels = getThinkingLevels(providerId, id, suppliedCapabilities);
+      if (thinkingLevels) next.thinkingLevels = thinkingLevels;
+    }
+    return next;
+  });
+}
+
+function serveModels(provider, connectionId, models, extra = {}, options = {}) {
+  const freshPayload = { provider, connectionId, models: withCapabilities(provider, models), ...extra };
+  const cached = options.forceRefresh ? null : getCachedModels(freshPayload, provider, connectionId);
+  if (cached) return cached.payload;
+  setCachedModels(freshPayload, provider, connectionId);
+  return freshPayload;
+}
+
+const GEMINI_CLI_MODELS_URL = "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels";
+
+const CODEX_CLIENT_VERSION = "0.144.6";
+const CODEX_MODELS_URL = `https://chatgpt.com/backend-api/codex/models?client_version=${CODEX_CLIENT_VERSION}`;
+
+const parseOpenAIStyleModels = (data) => {
+  if (Array.isArray(data)) return data;
+  return data?.data || data?.models || data?.results || [];
+};
+
+const parseGeminiCliModels = (data) => {
+  if (Array.isArray(data?.models)) {
+    return data.models
+      .map((item) => {
+        const id = item?.id || item?.model || item?.name;
+        if (!id) return null;
+        return { id, name: item?.displayName || item?.name || id };
+      })
+      .filter(Boolean);
+  }
+
+  if (data?.models && typeof data.models === "object") {
+    return Object.entries(data.models)
+      .filter(([, info]) => !info?.isInternal)
+      .map(([id, info]) => ({
+        id,
+        name: info?.displayName || info?.name || id,
+      }));
+  }
+
+  return [];
+};
+
+const appendCodexReviewModels = (models) => models.flatMap((model) => {
+  const id = model?.id || model?.slug || model?.model || model?.name;
+  if (!id) return [];
+  const name = model?.display_name || model?.displayName || model?.name || id;
+  const normalized = { ...model, id, name };
+  const isChatModel = (model?.type || "llm") !== "image" && !id.toLowerCase().includes("embed");
+  if (!isChatModel || id.endsWith("-review")) return [normalized];
+  return [
+    normalized,
+    {
+      ...normalized,
+      id: `${id}-review`,
+      name: `${name} Review`,
+      upstreamModelId: id,
+      quotaFamily: "review",
+    },
+  ];
+});
+
+const parseCodexModels = (data) => appendCodexReviewModels(parseOpenAIStyleModels(data));
+
+const createOpenAIModelsConfig = (url) => ({
+  url,
+  method: "GET",
+  headers: { "Content-Type": "application/json" },
+  authHeader: "Authorization",
+  authPrefix: "Bearer ",
+  parseResponse: parseOpenAIStyleModels
+});
+
+const getStaticProviderModels = (providerId) =>
+  getModelsByProviderId(providerId).map((model) => ({
+    ...model,
+    id: model.id,
+    name: model.name || model.id,
+  }));
+
+const buildOAuthResolver = ({ refreshFn, fetchFn, parseFn, errorLabel }) => async (connection) => {
+  const { accessToken, refreshToken } = connection;
+  if (!accessToken) {
+    return { error: "No valid token found", status: 401 };
+  }
+  let warning;
+  try {
+    let response = await fetchFn(accessToken, connection);
+    if (!response.ok && (response.status === 401 || response.status === 403) && refreshToken) {
+      const refreshed = await refreshFn(connection);
+      if (refreshed?.accessToken) {
+        await updateProviderCredentials(connection.id, {
+          accessToken: refreshed.accessToken,
+          refreshToken: refreshed.refreshToken || refreshToken,
+          expiresIn: refreshed.expiresIn,
+        });
+        connection.accessToken = refreshed.accessToken;
+        if (refreshed.refreshToken) connection.refreshToken = refreshed.refreshToken;
+        response = await fetchFn(refreshed.accessToken, connection);
+      }
+    }
+    if (response.ok) {
+      const data = await response.json();
+      const models = parseFn(data);
+      if (models.length > 0) return { models };
+    } else {
+      const errorText = await response.text();
+      warning = LIVE_MODELS_WARNING;
+      logRouteError(errorLabel, {
+        status: response.status,
+        response: errorText.slice(0, 500),
+      });
+    }
+  } catch (error) {
+    warning = LIVE_MODELS_WARNING;
+    logRouteError(errorLabel, error);
+  }
+  return { models: [], warning };
+};
+
+const PROVIDER_MODELS_CONFIG = {
+  claude: {
+    url: "https://api.anthropic.com/v1/models",
+    method: "GET",
+    headers: {
+      "Anthropic-Version": "2023-06-01",
+      "Content-Type": "application/json"
+    },
+    authHeader: "x-api-key",
+    parseResponse: (data) => data.data || []
+  },
+  gemini: {
+    url: "https://generativelanguage.googleapis.com/v1beta/models",
+    method: "GET",
+    headers: { "Content-Type": "application/json" },
+    authQuery: "key",
+    parseResponse: (data) => data.models || []
+  },
+  codex: {
+    customResolver: buildOAuthResolver({
+      refreshFn: (conn) => refreshCodexToken(conn.refreshToken),
+      fetchFn: (token) => fetch(CODEX_MODELS_URL, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "application/json",
+          "Authorization": `Bearer ${token}`,
+          "originator": "codex_cli_rs"
+        }
+      }),
+      parseFn: parseCodexModels,
+      errorLabel: "Failed to fetch Codex models"
+    })
+  },
+  "codebuddy-cn": {
+    customResolver: async (connection, options = {}) => {
+      if (!options.forceRefresh) {
+        return { models: getStaticProviderModels("codebuddy-cn") };
+      }
+      const result = await resolveCodeBuddyModels({
+        provider: "codebuddy-cn",
+        accessToken: connection.accessToken,
+        refreshToken: connection.refreshToken,
+      }, {
+        log: console,
+        onCredentialsRefreshed: async (refreshed) => {
+          await updateProviderCredentials(connection.id, {
+            accessToken: refreshed.accessToken,
+            refreshToken: refreshed.refreshToken || connection.refreshToken,
+            expiresIn: refreshed.expiresIn,
+          });
+          connection.accessToken = refreshed.accessToken;
+          if (refreshed.refreshToken) connection.refreshToken = refreshed.refreshToken;
+        },
+      });
+      if (result?.error) return result;
+      if (result?.models?.length) {
+        return result;
+      }
+      return {
+        models: getStaticProviderModels("codebuddy-cn"),
+        warning: result?.warning || "CodeBuddy returned no live models; falling back to static catalog.",
+      };
+    },
+  },
+  "codebuddy-intl": {
+    customResolver: async () => ({ models: getStaticProviderModels("codebuddy-intl") }),
+  },
+  antigravity: {
+    customResolver: buildOAuthResolver({
+      refreshFn: (conn) => refreshGoogleToken(conn.refreshToken, GEMINI_CONFIG.clientId, GEMINI_CONFIG.clientSecret),
+      fetchFn: (token) => fetch("https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal:models", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${token}`,
+        },
+        body: JSON.stringify({}),
+      }),
+      parseFn: (data) => data?.models || [],
+      errorLabel: "Failed to fetch Antigravity models",
+    }),
+  },
+  github: {
+    url: "https://api.githubcopilot.com/models",
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "Copilot-Integration-Id": "vscode-chat",
+      "editor-version": "vscode/1.107.1",
+      "editor-plugin-version": "copilot-chat/0.26.7",
+      "user-agent": "GitHubCopilotChat/0.26.7"
+    },
+    authHeader: "Authorization",
+    authPrefix: "Bearer ",
+    parseResponse: (data) => {
+      if (!data?.data) return [];
+
+      return data.data
+        .filter(m => m.capabilities?.type === "chat")
+        .filter(m => m.policy?.state !== "disabled")
+        .map(m => ({
+          id: m.id,
+          name: m.name || m.id,
+          version: m.version,
+          capabilities: m.capabilities,
+          isDefault: m.model_picker_enabled === true
+        }));
+    }
+  },
+  openai: createOpenAIModelsConfig("https://api.openai.com/v1/models"),
+  agentrouter: {
+    ...createOpenAIModelsConfig(AGENTROUTER_MODELS_URL),
+    headers: {
+      "Content-Type": "application/json",
+      ...AGENTROUTER_OPENAI_HEADERS,
+    },
+  },
+  openrouter: createOpenAIModelsConfig("https://openrouter.ai/api/v1/models"),
+  anthropic: {
+    url: "https://api.anthropic.com/v1/models",
+    method: "GET",
+    headers: {
+      "Anthropic-Version": "2023-06-01",
+      "Content-Type": "application/json"
+    },
+    authHeader: "x-api-key",
+    parseResponse: (data) => data.data || []
+  },
+
+  alicode: {
+    url: "https://coding.dashscope.aliyuncs.com/v1/models",
+    method: "GET",
+    headers: { "Content-Type": "application/json" },
+    authHeader: "Authorization",
+    authPrefix: "Bearer ",
+    parseResponse: (data) => data.data || []
+  },
+  "alicode-intl": {
+    url: "https://coding-intl.dashscope.aliyuncs.com/v1/models",
+    method: "GET",
+    headers: { "Content-Type": "application/json" },
+    authHeader: "Authorization",
+    authPrefix: "Bearer ",
+    parseResponse: (data) => data.data || []
+  },
+  "alims-intl": {
+    url: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1/models",
+    method: "GET",
+    headers: { "Content-Type": "application/json" },
+    authHeader: "Authorization",
+    authPrefix: "Bearer ",
+    parseResponse: (data) => data.data || []
+  },
+  byteplus: createOpenAIModelsConfig("https://ark.ap-southeast.bytepluses.com/api/coding/v3/models"),
+
+  deepseek: createOpenAIModelsConfig("https://api.deepseek.com/models"),
+  groq: createOpenAIModelsConfig("https://api.groq.com/openai/v1/models"),
+  xai: createOpenAIModelsConfig("https://api.x.ai/v1/models"),
+  mistral: createOpenAIModelsConfig("https://api.mistral.ai/v1/models"),
+  perplexity: createOpenAIModelsConfig("https://api.perplexity.ai/router/v1/models"),
+  together: createOpenAIModelsConfig("https://api.together.xyz/v1/models"),
+  fireworks: createOpenAIModelsConfig("https://api.fireworks.ai/inference/v1/models"),
+  cerebras: createOpenAIModelsConfig("https://api.cerebras.ai/v1/models"),
+  nebius: createOpenAIModelsConfig("https://api.studio.nebius.ai/v1/models"),
+  ollama: createOpenAIModelsConfig("https://ollama.com/api/tags"),
+
+  nanobanana: createOpenAIModelsConfig("https://api.nanobananaapi.ai/v1/models"),
+  chutes: createOpenAIModelsConfig("https://llm.chutes.ai/v1/models"),
+  nvidia: createOpenAIModelsConfig("https://integrate.api.nvidia.com/v1/models"),
+  assemblyai: createOpenAIModelsConfig("https://api.assemblyai.com/v1/models"),
+  "vercel-ai-gateway": createOpenAIModelsConfig("https://ai-gateway.vercel.sh/v1/models"),
+  kimchi: {
+    customResolver: async (connection) => {
+      const result = await resolveKimchiModels({
+        accessToken: connection.accessToken,
+        apiKey: connection.apiKey,
+        providerSpecificData: connection.providerSpecificData || {},
+      }, { forceRefresh: true, log: console });
+      if (result?.models?.length) {
+        return { models: result.models };
+      }
+      return {
+        models: getStaticProviderModels("kimchi"),
+        warning: "Kimchi returned no live models; falling back to static catalog.",
+      };
+    }
+  },
+  cursor: {
+    customResolver: async (connection, options = {}) => {
+      const result = await resolveCursorModels({
+        accessToken: connection.accessToken,
+        providerSpecificData: connection.providerSpecificData || {},
+      }, {
+        forceRefresh: options.forceRefresh === true,
+        log: console,
+        onAuthFailure: async ({ status }) => {
+          await updateProviderCredentials(connection.id, {
+            testStatus: "stale",
+            lastError: `Cursor credentials rejected (${status}); re-authenticate Cursor.`,
+            lastErrorAt: new Date().toISOString(),
+            errorCode: status,
+          });
+        },
+      });
+      if (result?.models?.length) return { models: result.models };
+      return {
+        models: getStaticProviderModels("cursor"),
+        warning: result?.warning || "Cursor returned no live models; falling back to static catalog.",
+      };
+    },
+  },
+
+  kiro: {
+    customResolver: async (connection) => {
+      const credentials = {
+        accessToken: connection.accessToken,
+        refreshToken: connection.refreshToken,
+        providerSpecificData: connection.providerSpecificData || {}
+      };
+      let warning;
+      try {
+        const result = await resolveKiroModels(credentials, {
+          log: console,
+          onCredentialsRefreshed: async (refreshed) => {
+            if (refreshed?.accessToken) {
+              await updateProviderCredentials(connection.id, {
+                accessToken: refreshed.accessToken,
+                refreshToken: refreshed.refreshToken || connection.refreshToken,
+                expiresIn: refreshed.expiresIn,
+              });
+              connection.accessToken = refreshed.accessToken;
+              if (refreshed.refreshToken) connection.refreshToken = refreshed.refreshToken;
+            }
+          }
+        });
+        if (result?.models?.length) {
+          return {
+            models: result.models.map((m) => ({
+              id: m.id,
+              name: m.name,
+              upstreamModelId: m.upstreamModelId,
+              contextLength: m.contextLength,
+              rateMultiplier: m.rateMultiplier,
+              capabilities: m.capabilities,
+              description: m.description
+            }))
+          };
+        }
+        warning = "Kiro returned no models; falling back to static catalog.";
+      } catch (error) {
+        warning = LIVE_MODELS_WARNING;
+        logRouteError("KiroModels", error);
+      }
+      return { models: [], warning };
+    }
+  },
+  qoder: {
+    customResolver: async (connection) => {
+      const credentials = {
+        accessToken: connection.accessToken,
+        apiKey: connection.apiKey,
+        refreshToken: connection.refreshToken,
+        email: connection.email,
+        displayName: connection.displayName,
+        providerSpecificData: connection.providerSpecificData || {},
+      };
+      let warning;
+      try {
+        const result = await resolveQoderModels(credentials, { forceRefresh: true });
+        if (result?.models?.length) {
+          return {
+            models: result.models.map((m) => ({
+
+              id: `qoder/${m.id}`,
+              name: m.name,
+              contextLength: m.contextLength,
+              isVL: m.isVL,
+              isReasoning: m.isReasoning,
+              maxOutputTokens: m.maxOutputTokens,
+              description: m.description,
+            })),
+          };
+        }
+        warning = "Qoder returned no models; falling back to static catalog.";
+      } catch (error) {
+        warning = LIVE_MODELS_WARNING;
+        logRouteError("QoderModels", error);
+      }
+      return { models: [], warning };
+    },
+  },
+  "gemini-cli": {
+    customResolver: buildOAuthResolver({
+      refreshFn: (conn) => refreshGoogleToken(conn.refreshToken, GEMINI_CONFIG.clientId, GEMINI_CONFIG.clientSecret),
+      fetchFn: (token, conn) => {
+        const projectId = conn.projectId || conn.providerSpecificData?.projectId;
+        const body = projectId ? { project: projectId } : {};
+        return fetch(GEMINI_CLI_MODELS_URL, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${token}`,
+            "User-Agent": "google-api-nodejs-client/9.15.1",
+            "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1"
+          },
+          body: JSON.stringify(body)
+        });
+      },
+      parseFn: parseGeminiCliModels,
+      errorLabel: "Failed to fetch Gemini CLI models"
+    })
+  },
+  "grok-cli": {
+    customResolver: async (connection) => {
+      const proxy = await resolveConnectionProxyConfig(connection.providerSpecificData || {});
+      const result = await resolveGrokCliModels({
+        ...connection,
+        connectionId: connection.id,
+      }, {
+        log: console,
+        proxyOptions: {
+          connectionProxyEnabled: proxy.connectionProxyEnabled === true,
+          connectionProxyUrl: proxy.connectionProxyUrl || "",
+          connectionNoProxy: proxy.connectionNoProxy || "",
+          relayUrl: proxy.relayUrl || "",
+          relayToken: proxy.relayToken || "",
+          vercelRelayUrl: proxy.vercelRelayUrl || "",
+          strictProxy: proxy.strictProxy === true,
+          proxyPoolUnavailable: proxy.proxyPoolUnavailable === true,
+          proxyPoolError: proxy.proxyPoolError || "",
+        },
+        onCredentialsRefreshed: async (refreshed) => {
+          await updateProviderCredentials(connection.id, {
+            ...refreshed,
+            existingProviderSpecificData: connection.providerSpecificData || {},
+          });
+        },
+      });
+      if (result.models.length) return result;
+      return {
+        models: getStaticProviderModels("grok-cli"),
+        warning: result.warning || "Grok CLI returned no live models; using static catalog.",
+      };
+    },
+  },
+  "ollama-local": {
+    customResolver: async (connection) => {
+      const url = `${resolveOllamaLocalHost(connection)}/api/tags`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" }
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        logRouteError("OllamaLocalModels", {
+          status: response.status,
+          response: errorText.slice(0, 500),
+        });
+        return { error: "Unable to load models from provider", status: response.status };
+      }
+      const data = await response.json();
+      return { models: parseOpenAIStyleModels(data) };
+    }
+  }
+};
+
+export async function GET(request, { params }) {
+  try {
+    const { id } = await params;
+    const forceRefresh = new URL(request.url).searchParams.get("refresh") === "1";
+    const connection = await getProviderConnectionById(id);
+
+    if (!connection) {
+      return NextResponse.json({ error: "Connection not found" }, { status: 404 });
+    }
+
+    if (isOpenAICompatibleProvider(connection.provider)) {
+      const baseUrl = connection.providerSpecificData?.baseUrl
+        || PROVIDERS[connection.provider]?.baseUrl?.replace(/\/chat\/completions\/?$/i, "");
+      if (!baseUrl) {
+        return NextResponse.json({ error: "No base URL configured for OpenAI compatible provider" }, { status: 400 });
+      }
+      const url = `${baseUrl.replace(/\/$/, "")}/models`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${connection.apiKey}`,
+        },
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        logRouteError("CompatibleProviderModels", {
+          provider: connection.provider,
+          status: response.status,
+          response: errorText.slice(0, 500),
+        });
+        return NextResponse.json(
+          { error: "Unable to load models from provider" },
+          { status: response.status }
+        );
+      }
+
+      const data = await response.json();
+      const models = data.data || data.models || [];
+
+      return NextResponse.json(serveModels(connection.provider, connection.id, models, {}, { forceRefresh }));
+    }
+
+    if (isAnthropicCompatibleProvider(connection.provider)) {
+      let baseUrl = connection.providerSpecificData?.baseUrl;
+      if (!baseUrl) {
+        return NextResponse.json({ error: "No base URL configured for Anthropic compatible provider" }, { status: 400 });
+      }
+
+      baseUrl = baseUrl.replace(/\/$/, "");
+      if (baseUrl.endsWith("/messages")) {
+        baseUrl = baseUrl.slice(0, -9);
+      }
+
+      const url = `${baseUrl}/models`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": connection.apiKey,
+          "anthropic-version": "2023-06-01",
+          "Authorization": `Bearer ${connection.apiKey}`
+        },
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        logRouteError("CompatibleProviderModels", {
+          provider: connection.provider,
+          status: response.status,
+          response: errorText.slice(0, 500),
+        });
+        return NextResponse.json(
+          { error: "Unable to load models from provider" },
+          { status: response.status }
+        );
+      }
+
+      const data = await response.json();
+      const models = data.data || data.models || [];
+
+      return NextResponse.json(serveModels(connection.provider, connection.id, models, {}, { forceRefresh }));
+    }
+
+    if (connection.provider === "clinepass" || connection.provider === "cline-pass") {
+      const result = await resolveClinepassModels({
+        apiKey: connection.apiKey,
+        accessToken: connection.accessToken,
+      });
+      if (result?.models?.length) {
+        return NextResponse.json(serveModels(connection.provider, connection.id, result.models, {}, { forceRefresh }));
+      }
+      const staticModels = getModelsByProviderId("clinepass")
+        .map((m) => ({ id: m.id, name: m.name || m.id }));
+      if (staticModels.length) {
+        return NextResponse.json(serveModels(connection.provider, connection.id, staticModels, { warning: "live catalog unavailable — serving static registry entries" }, { forceRefresh }));
+      }
+      return NextResponse.json({ provider: connection.provider, connectionId: connection.id, models: [] });
+    }
+
+    const config = PROVIDER_MODELS_CONFIG[connection.provider];
+    if (!config) {
+      return NextResponse.json(
+        { error: `Provider ${connection.provider} does not support models listing` },
+        { status: 400 }
+      );
+    }
+
+    if (typeof config.customResolver === "function") {
+      const result = await config.customResolver(connection, { forceRefresh });
+      if (result.error) {
+        const status = Number.isInteger(result.status) ? result.status : 500;
+        const error = status === 401 ? "No valid token found" : "Unable to load models from provider";
+        return NextResponse.json({ error }, { status });
+      }
+      return NextResponse.json(
+        serveModels(connection.provider, connection.id, result.models, {
+          ...(result.warning ? { warning: result.warning } : {}),
+        }, { forceRefresh })
+      );
+    }
+
+    const token = connection.providerSpecificData?.copilotToken || connection.accessToken || connection.apiKey;
+    if (!token) {
+      return NextResponse.json({ error: "No valid token found" }, { status: 401 });
+    }
+
+    let url = config.url;
+    if (config.authQuery) {
+      url += `?${config.authQuery}=${token}`;
+    }
+
+    const headers = { ...config.headers };
+    if (config.authHeader && !config.authQuery) {
+      headers[config.authHeader] = (config.authPrefix || "") + token;
+    }
+
+    const fetchOptions = {
+      method: config.method,
+      headers
+    };
+
+    if (config.body && config.method === "POST") {
+      fetchOptions.body = JSON.stringify(config.body);
+    }
+
+    const response = await fetch(url, fetchOptions);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      logRouteError("ProviderModels", {
+        provider: connection.provider,
+        status: response.status,
+        response: errorText.slice(0, 500),
+      });
+      return NextResponse.json(
+        { error: "Unable to load models from provider" },
+        { status: response.status }
+      );
+    }
+
+    const data = await response.json();
+    const models = config.parseResponse(data);
+
+    return NextResponse.json(serveModels(connection.provider, connection.id, models, {}, { forceRefresh }));
+  } catch (error) {
+    logRouteError("ProviderModels", error);
+    return NextResponse.json({ error: "Failed to fetch models" }, { status: 500 });
+  }
+}