swayrouter 1.0.0

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

@@ -0,0 +1,211 @@
+import { NextResponse } from "next/server";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const MODEL_TEST_ERROR = publicError("provider", "Provider model test failed");
+import { getCustomModels, getProviderConnectionById } from "@/lib/localDb";
+import { getProviderModels, PROVIDER_ID_TO_ALIAS } from "open-sse/config/providerModels.js";
+import { isOpenAICompatibleProvider, isAnthropicCompatibleProvider } from "@/shared/constants/providers";
+import { RUNTIME_CONFIG } from "@/shared/constants/config";
+import { pingModelByKind } from "@/routes/api/models/test/ping";
+
+function normalizedProviderAlias(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function normalizeCustomModelId(value, alias, acceptedAliases) {
+  const rawId = String(value || "").trim();
+  if (!rawId) return "";
+
+  const rawLower = rawId.toLowerCase();
+  const prefix = [...acceptedAliases]
+    .filter(Boolean)
+    .sort((left, right) => right.length - left.length)
+    .find((candidate) => rawLower.startsWith(`${candidate}/`));
+  if (!prefix) return rawId;
+  return `${alias}/${rawId.slice(prefix.length + 1)}`;
+}
+
+export function mergeCustomModels(models, customModels, acceptedAliases, alias, routeModel) {
+  const merged = [...models];
+  const seen = new Set(
+    merged
+      .map((model) => normalizedProviderAlias(routeModel(model?.id)))
+      .filter(Boolean),
+  );
+
+  for (const customModel of Array.isArray(customModels) ? customModels : []) {
+    const providerAlias = normalizedProviderAlias(customModel?.providerAlias);
+    const type = normalizedProviderAlias(customModel?.type || "llm");
+    if (!acceptedAliases.has(providerAlias) || type !== "llm") continue;
+
+    const id = normalizeCustomModelId(customModel?.id, alias, acceptedAliases);
+    const routedId = normalizedProviderAlias(routeModel(id));
+    if (!id || !routedId || seen.has(routedId)) continue;
+
+    seen.add(routedId);
+    merged.push({
+      ...customModel,
+      id,
+      name: customModel.name || id,
+      type: "llm",
+    });
+  }
+
+  return merged;
+}
+
+export async function POST(request, { params }) {
+  try {
+    const { id } = await params;
+    let requestBody = {};
+    try {
+      requestBody = await request.json();
+    } catch {
+
+    }
+    const requestedModel = String(
+      requestBody?.model || new URL(request.url).searchParams.get("model") || ""
+    ).trim();
+    const connection = await getProviderConnectionById(id);
+    if (!connection) {
+      return NextResponse.json({ error: "Connection not found" }, { status: 404 });
+    }
+    if (connection.isActive === false) {
+      return NextResponse.json({
+        error: "Connection is inactive",
+        message: "Enable this connection before testing its models.",
+      }, { status: 409 });
+    }
+
+    const providerId = connection.provider;
+    const isCompatible = providerId === "agentrouter"
+      || isOpenAICompatibleProvider(providerId)
+      || isAnthropicCompatibleProvider(providerId);
+    const isCodeBuddy = providerId === "codebuddy-cn" || providerId === "codebuddy-intl";
+    const isCodeBuddyIntl = providerId === "codebuddy-intl";
+    const usesDynamicCatalog = isCompatible || isCodeBuddy;
+    const alias = PROVIDER_ID_TO_ALIAS[providerId] || providerId;
+    const acceptedAliases = new Set(
+      [
+        providerId,
+        alias,
+        connection.providerAlias,
+        connection.providerSpecificData?.providerAlias,
+        connection.providerSpecificData?.prefix,
+      ]
+        .map(normalizedProviderAlias)
+        .filter(Boolean),
+    );
+
+    let models = getProviderModels(alias);
+
+    const baseUrl = `http://127.0.0.1:${process.env.PORT || RUNTIME_CONFIG.appPort}`;
+
+    if (usesDynamicCatalog && models.length === 0) {
+      try {
+        const modelsRes = await fetch(`${baseUrl}/api/providers/${id}/models?refresh=1`);
+        if (modelsRes.ok) {
+          const data = await modelsRes.json();
+          models = (data.models || []).map((m) => ({ id: m.id || m.name, name: m.name || m.id }));
+        }
+      } catch {                         }
+    }
+
+    if (models.length === 0 && usesDynamicCatalog && requestedModel) {
+      models = [{ id: requestedModel, name: requestedModel, kind: "llm" }];
+    }
+
+    const routeModel = (modelId) => {
+      const value = String(modelId || "");
+
+      if (providerId === "clinepass" || providerId === "cline-pass") {
+        const slug = value.replace(/^cline-pass\//, "").replace(/^clinepass\//, "");
+        return `${alias}/${slug}`;
+      }
+      return value.startsWith(`${alias}/`) ? value : `${alias}/${value}`;
+    };
+
+    let customModels = [];
+    try {
+      customModels = await getCustomModels();
+    } catch {
+      customModels = [];
+    }
+    models = mergeCustomModels(models, customModels, acceptedAliases, alias, routeModel);
+
+    if (models.length === 0) {
+      return NextResponse.json({ error: "No models configured for this provider" }, { status: 400 });
+    }
+
+    const isClinePass = providerId === "clinepass" || providerId === "cline-pass";
+    const pingOptions = {
+      connectionId: id,
+      providerId,
+      stream: isClinePass || isCodeBuddyIntl,
+      probeFormat: isCodeBuddyIntl ? "codebuddy-intl" : undefined,
+      timeoutMs: isClinePass || isCodeBuddyIntl ? 60_000 : undefined,
+      signal: request.signal,
+    };
+    const selected = requestedModel
+      ? models.filter((model) => {
+        const candidate = String(model.id || "");
+        return candidate === requestedModel
+          || routeModel(candidate) === requestedModel
+          || requestedModel.endsWith(`/${candidate}`)
+          || candidate.endsWith(`/${requestedModel.split("/").pop()}`);
+      })
+      : models;
+
+    if (requestedModel && selected.length === 0) {
+      return NextResponse.json({
+        provider: providerId,
+        connectionId: id,
+        results: [{ modelId: requestedModel, name: requestedModel, ok: false, error: "Model not found" }],
+      }, { status: 404 });
+    }
+
+    const results = new Array(selected.length);
+    let nextIndex = 0;
+    const concurrency = requestedModel ? 1 : Math.min(4, selected.length);
+    const worker = async () => {
+      while (true) {
+        const index = nextIndex++;
+        if (index >= selected.length) return;
+        if (request.signal.aborted) return;
+        const model = selected[index];
+        try {
+          const result = await pingModelByKind(
+            routeModel(model.id),
+            model.kind || model.type || "llm",
+            baseUrl,
+            pingOptions
+          );
+          results[index] = { modelId: model.id, name: model.name || model.id, ...result };
+        } catch (error) {
+          if (request.signal.aborted) return;
+          logRouteError("ProviderModelTest", error);
+          results[index] = {
+            modelId: model.id,
+            name: model.name || model.id,
+            ok: false,
+            latencyMs: 0,
+            status: 502,
+            error: MODEL_TEST_ERROR,
+          };
+        }
+      }
+    };
+    await Promise.all(Array.from({ length: concurrency }, () => worker()));
+    if (request.signal.aborted) return new Response(null, { status: 499 });
+
+    return NextResponse.json({
+      provider: providerId,
+      connectionId: id,
+      requestedModel: requestedModel || null,
+      results,
+    });
+  } catch (error) {
+    logRouteError("ProviderModelsTest", error);
+    return NextResponse.json({ error: MODEL_TEST_ERROR }, { status: 500 });
+  }
+}

package/src/routes/api/providers/catalog/route.js

@@ -0,0 +1,58 @@
+import { NextResponse } from "next/server";
+import REGISTRY from "open-sse/providers/registry/index.js";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  try {
+    const providers = REGISTRY.filter((r) => !r.hidden)
+      .map((r) => {
+        const display = r.display || {};
+        const staticModels = ["codebuddy-cn", "codebuddy-intl"].includes(r.id)
+          && Array.isArray(r.models)
+          ? r.models.map((model) => ({
+            id: model.id,
+            name: model.name || model.id,
+          }))
+          : [];
+
+        const authType =
+          r.authType ||
+          (Array.isArray(r.authModes) && r.authModes.length
+            ? r.authModes[0]
+            : null) ||
+          (r.hasOAuth || r.category === "oauth"
+            ? "oauth"
+            : null) ||
+          (r.noAuth ? "none" : null) ||
+          (r.category === "webCookie" ? "cookie" : "apikey");
+        return {
+          id: r.id,
+          name: display.name || r.name || r.id,
+          alias: r.uiAlias || r.alias || r.id,
+          category: r.category,
+          authType,
+          ...(Array.isArray(r.authModes) && r.authModes.length
+            ? { authModes: r.authModes }
+            : {}),
+          ...(r.noAuth ? { noAuth: true } : {}),
+          ...(r.hasOAuth ? { hasOAuth: true } : {}),
+          ...(r.passthroughModels ? { passthroughModels: true } : {}),
+          ...(r.thinkingConfig ? { thinkingConfig: r.thinkingConfig } : {}),
+          ...(staticModels.length ? { models: staticModels } : {}),
+          ...(display.color ? { color: display.color } : {}),
+          ...(display.icon ? { icon: display.icon } : {}),
+          ...(display.textIcon ? { textIcon: display.textIcon } : {}),
+        };
+      })
+      .sort((a, b) => a.id.localeCompare(b.id));
+
+    return NextResponse.json({ providers });
+  } catch (error) {
+    console.error("[providers/catalog]", error);
+    return NextResponse.json(
+      { error: "Failed to build provider catalog" },
+      { status: 500 }
+    );
+  }
+}

package/src/routes/api/providers/client/route.js

@@ -0,0 +1,133 @@
+import { NextResponse } from "next/server";
+import { getProviderConnections } from "@/lib/localDb";
+import { backfillCodexEmails } from "@/lib/oauth/providers";
+import { USAGE_APIKEY_PROVIDERS, USAGE_SUPPORTED_PROVIDERS } from "@/shared/constants/providers";
+
+const SAFE_FIELDS = [
+  "id", "provider", "authType", "name", "email", "displayName",
+  "priority", "globalPriority", "isActive", "defaultModel",
+  "testStatus", "lastError", "lastErrorAt", "errorCode",
+  "expiresAt", "lastUsedAt", "consecutiveUseCount",
+  "createdAt", "updatedAt",
+];
+
+const SAFE_PSD_FIELDS = [
+  "baseUrl", "azureEndpoint", "deployment", "apiVersion", "accountId",
+  "region", "projectId", "resourceUrl", "proxyPoolId",
+  "connectionProxyEnabled", "connectionProxyUrl", "connectionNoProxy",
+  "githubLogin", "githubName", "githubEmail", "githubUserId",
+  "username", "firstName", "lastName", "authMethod", "authKind",
+  "profileArn",
+];
+
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 500;
+
+function maskName(name) {
+  if (typeof name !== "string" || name.length <= 16) return name;
+  if (/[a-zA-Z0-9_-]{32,}/.test(name)) return `${name.slice(0, 8)}***`;
+  return name;
+}
+
+function sanitize(c) {
+  const safe = {};
+  for (const f of SAFE_FIELDS) if (c[f] !== undefined) safe[f] = c[f];
+  if (safe.name) safe.name = maskName(safe.name);
+  if (c.providerSpecificData) {
+    const psd = {};
+    for (const f of SAFE_PSD_FIELDS) {
+      if (c.providerSpecificData[f] !== undefined) psd[f] = c.providerSpecificData[f];
+    }
+    safe.providerSpecificData = psd;
+  }
+  return safe;
+}
+
+function isUsageEligible(connection) {
+  return USAGE_SUPPORTED_PROVIDERS.includes(connection.provider) && (
+    connection.authType === "oauth" || USAGE_APIKEY_PROVIDERS.includes(connection.provider)
+  );
+}
+
+function parsePositiveInt(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function readListOptions(request) {
+  const { searchParams } = new URL(request.url);
+  return {
+    provider: searchParams.get("provider") || "all",
+    accountStatus: searchParams.get("accountStatus") || "all",
+    sort: searchParams.get("sort") || "priority",
+    page: parsePositiveInt(searchParams.get("page"), 1),
+    pageSize: Math.min(parsePositiveInt(searchParams.get("pageSize"), DEFAULT_PAGE_SIZE), MAX_PAGE_SIZE),
+  };
+}
+
+function sortConnections(connections, sort) {
+  const list = [...connections];
+
+  if (sort === "provider") {
+    return list.sort((a, b) => {
+      const orderA = USAGE_SUPPORTED_PROVIDERS.indexOf(a.provider);
+      const orderB = USAGE_SUPPORTED_PROVIDERS.indexOf(b.provider);
+      if (orderA !== orderB) return orderA - orderB;
+      return a.provider.localeCompare(b.provider);
+    });
+  }
+
+  return list.sort((a, b) => {
+    const priorityA = a.priority ?? Number.MAX_SAFE_INTEGER;
+    const priorityB = b.priority ?? Number.MAX_SAFE_INTEGER;
+    if (priorityA !== priorityB) return priorityA - priorityB;
+    return (a.provider || "").localeCompare(b.provider || "");
+  });
+}
+
+export async function GET(request) {
+  try {
+    await backfillCodexEmails();
+
+    const { provider, accountStatus, sort, page, pageSize } = readListOptions(request);
+
+    const allConnections = await getProviderConnections();
+    const eligibleConnections = allConnections.filter(isUsageEligible);
+    const providerOptions = Array.from(new Set(eligibleConnections.map((conn) => conn.provider))).sort();
+
+    const providerFilteredConnections = eligibleConnections.filter((conn) => (
+      provider === "all" || conn.provider === provider
+    ));
+
+    const accountFilteredConnections = providerFilteredConnections.filter((conn) => {
+      if (accountStatus === "active") return conn.isActive ?? true;
+      if (accountStatus === "inactive") return !(conn.isActive ?? true);
+      return true;
+    });
+
+    const sortedConnections = sortConnections(accountFilteredConnections, sort);
+    const total = sortedConnections.length;
+    const totalPages = Math.max(1, Math.ceil(total / pageSize));
+    const currentPage = Math.min(page, totalPages);
+    const offset = (currentPage - 1) * pageSize;
+    const pageConnections = sortedConnections.slice(offset, offset + pageSize).map(sanitize);
+
+    return NextResponse.json({
+      connections: pageConnections,
+      providerOptions,
+      pagination: {
+        page: currentPage,
+        pageSize,
+        total,
+        totalPages,
+      },
+      totals: {
+        eligibleConnections: eligibleConnections.length,
+        providerFilteredConnections: providerFilteredConnections.length,
+      },
+    });
+  } catch (error) {
+    console.log("Error fetching providers for client:", error);
+    return NextResponse.json({ error: "Failed to fetch providers" }, { status: 500 });
+  }
+}

package/src/routes/api/providers/counts/route.js

@@ -0,0 +1,43 @@
+import { NextResponse } from "next/server";
+import { countProviderConnections } from "@/models";
+import { normalizeProviderId } from "@/lib/providerNormalization";
+
+function normalizeCountRow(row) {
+  const provider = normalizeProviderId(row.provider);
+  return {
+    provider,
+    total: Number(row.total) || 0,
+    active: Number(row.active) || 0,
+    inactive: Number(row.inactive) || 0,
+  };
+}
+
+function mergeProviderCounts(rows) {
+  const merged = new Map();
+  for (const row of rows) {
+    const normalized = normalizeCountRow(row);
+    const key = String(normalized.provider || "").trim().toLowerCase();
+    if (!key) continue;
+    const existing = merged.get(key);
+    if (existing) {
+      existing.total += normalized.total;
+      existing.active += normalized.active;
+      existing.inactive += normalized.inactive;
+    } else {
+      merged.set(key, normalized);
+    }
+  }
+  return [...merged.values()];
+}
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  try {
+    const counts = mergeProviderCounts(await countProviderConnections());
+    return NextResponse.json({ counts });
+  } catch (error) {
+    console.log("Error fetching provider counts:", error);
+    return NextResponse.json({ error: "Failed to fetch provider counts" }, { status: 500 });
+  }
+}

package/src/routes/api/providers/kilo/free-models/route.js

@@ -0,0 +1,58 @@
+import { NextResponse } from "next/server";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const KILO_MODELS_ERROR = publicError("provider", "Unable to load Kilo models");
+const KILO_MODELS_WARNING = "Kilo model refresh failed; showing cached models.";
+
+const KILO_MODELS_URL = "https://api.kilo.ai/api/gateway/models";
+
+let cachedModels = null;
+let cacheTimestamp = 0;
+const CACHE_TTL_MS = 60 * 60 * 1000;
+
+export async function GET() {
+  const now = Date.now();
+
+  if (cachedModels && now - cacheTimestamp < CACHE_TTL_MS) {
+    return NextResponse.json({ models: cachedModels, cached: true });
+  }
+
+  try {
+    const res = await fetch(KILO_MODELS_URL, {
+      headers: { "Accept": "application/json" },
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (!res.ok) {
+      throw new Error(`Kilo API returned ${res.status}`);
+    }
+
+    const json = await res.json();
+    const allModels = json.data || [];
+
+    const freeModels = allModels
+      .filter((m) => m.isFree === true)
+      .map((m) => ({
+        id: m.id,
+        name: m.name,
+        isFree: true,
+        context_length: m.context_length || 0,
+      }));
+
+    cachedModels = freeModels;
+    cacheTimestamp = now;
+
+    return NextResponse.json({ models: freeModels, cached: false });
+  } catch (error) {
+    logRouteError("KiloModels", error);
+
+    if (cachedModels) {
+      return NextResponse.json({ models: cachedModels, cached: true, warning: KILO_MODELS_WARNING });
+    }
+
+    return NextResponse.json(
+      { models: [], error: KILO_MODELS_ERROR },
+      { status: 502 }
+    );
+  }
+}