zevairouter 1.0.0

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

@@ -0,0 +1,66 @@
+import { NextResponse } from "next/server";
+import { getProviderConnectionById } from "@/lib/localDb";
+import { getProviderModels, PROVIDER_ID_TO_ALIAS } from "open-sse/config/providerModels.js";
+import { isOpenAICompatibleProvider, isAnthropicCompatibleProvider } from "@/shared/constants/providers";
+import { UPDATER_CONFIG } from "@/shared/constants/config";
+import { pingModelByKind } from "@/app/api/models/test/ping";
+
+/**
+ * POST /api/providers/[id]/test-models
+ * id = connectionId — used only to resolve provider + model list.
+ * Actual requests go through the internal endpoint that matches each model kind.
+ */
+export async function POST(request, { params }) {
+  try {
+    const { id } = await params;
+    const connection = await getProviderConnectionById(id);
+    if (!connection) {
+      return NextResponse.json({ error: "Connection not found" }, { status: 404 });
+    }
+
+    const providerId = connection.provider;
+    const isCompatible = isOpenAICompatibleProvider(providerId) || isAnthropicCompatibleProvider(providerId);
+    const alias = PROVIDER_ID_TO_ALIAS[providerId] || providerId;
+
+    let models = getProviderModels(alias);
+
+    const baseUrl = `http://127.0.0.1:${process.env.PORT || UPDATER_CONFIG.appPort}`;
+
+    // Compatible providers: fetch live model list
+    if (isCompatible && models.length === 0) {
+      try {
+        const modelsRes = await fetch(`${baseUrl}/api/providers/${id}/models`);
+        if (modelsRes.ok) {
+          const data = await modelsRes.json();
+          models = (data.models || []).map((m) => ({ id: m.id || m.name, name: m.name || m.id }));
+        }
+      } catch { /* fallback to empty */ }
+    }
+
+    if (models.length === 0) {
+      return NextResponse.json({ error: "No models configured for this provider" }, { status: 400 });
+    }
+
+    // Warm up with first model to trigger token refresh (if needed) before parallel calls.
+    // This prevents race condition where multiple requests concurrently refresh the same token.
+    const [first, ...rest] = models;
+    const firstKind = first.type || "llm";
+    const firstResult = await pingModelByKind(`${alias}/${first.id}`, firstKind, baseUrl);
+    const results = [{ modelId: first.id, name: first.name || first.id, ...firstResult }];
+
+    if (rest.length > 0) {
+      const restResults = await Promise.all(
+        rest.map(async (model) => {
+          const result = await pingModelByKind(`${alias}/${model.id}`, model.type || "llm", baseUrl);
+          return { modelId: model.id, name: model.name || model.id, ...result };
+        })
+      );
+      results.push(...restResults);
+    }
+
+    return NextResponse.json({ provider: providerId, connectionId: id, results });
+  } catch (error) {
+    console.log("Error testing models:", error);
+    return NextResponse.json({ error: "Test failed" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,126 @@
+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",
+];
+
+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 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 { searchParams } = new URL(request.url);
+    const provider = searchParams.get("provider") || "all";
+    const accountStatus = searchParams.get("accountStatus") || "all";
+    const sort = searchParams.get("sort") || "priority";
+    const page = parsePositiveInt(searchParams.get("page"), 1);
+    const pageSize = Math.min(parsePositiveInt(searchParams.get("pageSize"), DEFAULT_PAGE_SIZE), MAX_PAGE_SIZE);
+
+    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/app/api/providers/kilo/free-models/route.js

@@ -0,0 +1,55 @@
+import { NextResponse } from "next/server";
+
+const KILO_MODELS_URL = "https://api.kilo.ai/api/gateway/models";
+
+// In-memory cache with TTL
+let cachedModels = null;
+let cacheTimestamp = 0;
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+
+export async function GET() {
+  const now = Date.now();
+
+  // Return cached result if still valid
+  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) {
+    // Return cached data if available, even if expired
+    if (cachedModels) {
+      return NextResponse.json({ models: cachedModels, cached: true, warning: error.message });
+    }
+
+    return NextResponse.json(
+      { models: [], error: `Failed to fetch Kilo models: ${error.message}` },
+      { status: 502 }
+    );
+  }
+}

package/src/app/api/providers/route.js

@@ -0,0 +1,207 @@
+import { NextResponse } from "next/server";
+import {
+  getProviderConnections,
+  createProviderConnection,
+  getProviderNodeById,
+  getProviderNodes,
+  getProxyPoolById,
+} from "@/models";
+import { APIKEY_PROVIDERS } from "@/shared/constants/config";
+import { AI_PROVIDERS, FREE_PROVIDERS, FREE_TIER_PROVIDERS, WEB_COOKIE_PROVIDERS, isOpenAICompatibleProvider, isAnthropicCompatibleProvider, isCustomEmbeddingProvider } from "@/shared/constants/providers";
+import { normalizeProviderId, normalizeProviderSpecificData } from "@/lib/providerNormalization";
+
+export const dynamic = "force-dynamic";
+
+function normalizeProxyConfig(body = {}) {
+  const enabled = body?.connectionProxyEnabled === true;
+  const url = typeof body?.connectionProxyUrl === "string" ? body.connectionProxyUrl.trim() : "";
+  const noProxy = typeof body?.connectionNoProxy === "string" ? body.connectionNoProxy.trim() : "";
+
+  if (enabled && !url) {
+    return { error: "Connection proxy URL is required when connection proxy is enabled" };
+  }
+
+  return {
+    connectionProxyEnabled: enabled,
+    connectionProxyUrl: url,
+    connectionNoProxy: noProxy,
+  };
+}
+
+async function normalizeProxyPoolId(proxyPoolId) {
+  if (proxyPoolId === undefined || proxyPoolId === null || proxyPoolId === "" || proxyPoolId === "__none__") {
+    return { proxyPoolId: null };
+  }
+
+  const normalizedId = String(proxyPoolId).trim();
+  if (!normalizedId) {
+    return { proxyPoolId: null };
+  }
+
+  const proxyPool = await getProxyPoolById(normalizedId);
+  if (!proxyPool) {
+    return { error: "Proxy pool not found" };
+  }
+
+  return { proxyPoolId: normalizedId };
+}
+
+// GET /api/providers - List all connections
+export async function GET() {
+  try {
+    const connections = await getProviderConnections();
+
+    // Build nodeNameMap for compatible providers (id → name)
+    let nodeNameMap = {};
+    try {
+      const nodes = await getProviderNodes();
+      for (const node of nodes) {
+        if (node.id && node.name) nodeNameMap[node.id] = node.name;
+      }
+    } catch { }
+
+    // Hide sensitive fields, enrich name for compatible providers
+    const safeConnections = connections.map(c => {
+      const isCompatible = isOpenAICompatibleProvider(c.provider) || isAnthropicCompatibleProvider(c.provider);
+      const name = isCompatible
+        ? (c.name || nodeNameMap[c.provider] || c.providerSpecificData?.nodeName || c.provider)
+        : c.name;
+      return {
+        ...c,
+        name,
+        apiKey: undefined,
+        accessToken: undefined,
+        refreshToken: undefined,
+        idToken: undefined,
+      };
+    });
+
+    return NextResponse.json({ connections: safeConnections });
+  } catch (error) {
+    console.log("Error fetching providers:", error);
+    return NextResponse.json({ error: "Failed to fetch providers" }, { status: 500 });
+  }
+}
+
+// POST /api/providers - Create new connection (API Key only, OAuth via separate flow)
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const provider = normalizeProviderId(body.provider);
+    const { apiKey, name, displayName, priority, globalPriority, defaultModel, testStatus } = body;
+    const proxyConfig = normalizeProxyConfig(body);
+    if (proxyConfig.error) {
+      return NextResponse.json({ error: proxyConfig.error }, { status: 400 });
+    }
+
+    const proxyPoolResult = await normalizeProxyPoolId(body.proxyPoolId);
+    if (proxyPoolResult.error) {
+      return NextResponse.json({ error: proxyPoolResult.error }, { status: 400 });
+    }
+    const proxyPoolId = proxyPoolResult.proxyPoolId;
+
+    // Validation
+    const isWebCookieProvider = !!WEB_COOKIE_PROVIDERS[provider];
+    const isApiKeyCapableFreeProvider = !!FREE_PROVIDERS[provider]?.authModes?.includes?.("apikey");
+    const isValidProvider = APIKEY_PROVIDERS[provider] ||
+      FREE_TIER_PROVIDERS[provider] ||
+      isApiKeyCapableFreeProvider ||
+      isWebCookieProvider ||
+      isOpenAICompatibleProvider(provider) ||
+      isAnthropicCompatibleProvider(provider) ||
+      isCustomEmbeddingProvider(provider);
+
+    if (!provider || !isValidProvider) {
+      return NextResponse.json({ error: "Invalid provider" }, { status: 400 });
+    }
+    if (!apiKey && provider !== "ollama-local") {
+      return NextResponse.json({ error: `${isWebCookieProvider ? "Cookie value" : "API Key"} is required` }, { status: 400 });
+    }
+    const connectionName = name || displayName || AI_PROVIDERS[provider]?.name;
+    if (!connectionName) {
+      return NextResponse.json({ error: "Name is required" }, { status: 400 });
+    }
+
+    let providerSpecificData = normalizeProviderSpecificData(provider, body, body.providerSpecificData);
+
+    // Compatible/embedding nodes inherit their routing config (prefix/baseUrl) from the node.
+    // OpenAI Compatible and Custom Embedding nodes still allow exactly one connection each
+    // (contract locked in by tests/unit/compatible-provider-connections.test.js #925).
+    // Anthropic Compatible nodes now allow MULTIPLE connections (many API keys) so they can
+    // be load-balanced / rotated like first-party providers (Single + Bulk Add).
+    if (isOpenAICompatibleProvider(provider)) {
+      const node = await getProviderNodeById(provider);
+      if (!node) {
+        return NextResponse.json({ error: "OpenAI Compatible node not found" }, { status: 404 });
+      }
+      const existingConnections = await getProviderConnections({ provider });
+      if (existingConnections.length > 0) {
+        return NextResponse.json({ error: "Only one connection is allowed for this OpenAI Compatible node" }, { status: 400 });
+      }
+      providerSpecificData = {
+        prefix: node.prefix,
+        apiType: node.apiType,
+        baseUrl: node.baseUrl,
+        nodeName: node.name,
+      };
+    } else if (isAnthropicCompatibleProvider(provider)) {
+      const node = await getProviderNodeById(provider);
+      if (!node) {
+        return NextResponse.json({ error: "Anthropic Compatible node not found" }, { status: 404 });
+      }
+      // NOTE: no single-connection guard here on purpose — multiple keys are allowed.
+      providerSpecificData = {
+        prefix: node.prefix,
+        baseUrl: node.baseUrl,
+        nodeName: node.name,
+      };
+    } else if (isCustomEmbeddingProvider(provider)) {
+      const node = await getProviderNodeById(provider);
+      if (!node) {
+        return NextResponse.json({ error: "Custom Embedding node not found" }, { status: 404 });
+      }
+      const existingConnections = await getProviderConnections({ provider });
+      if (existingConnections.length > 0) {
+        return NextResponse.json({ error: "Only one connection is allowed for this Custom Embedding node" }, { status: 400 });
+      }
+      providerSpecificData = {
+        prefix: node.prefix,
+        baseUrl: node.baseUrl,
+        nodeName: node.name,
+      };
+    }
+
+    const mergedProviderSpecificData = {
+      ...(providerSpecificData || {}),
+      connectionProxyEnabled: proxyConfig.connectionProxyEnabled,
+      connectionProxyUrl: proxyConfig.connectionProxyUrl,
+      connectionNoProxy: proxyConfig.connectionNoProxy,
+    };
+
+    if (proxyPoolId !== null) {
+      mergedProviderSpecificData.proxyPoolId = proxyPoolId;
+    }
+
+    const newConnection = await createProviderConnection({
+      provider,
+      authType: isWebCookieProvider ? "cookie" : "apikey",
+      name: connectionName,
+      apiKey: apiKey || "",
+      priority: priority || 1,
+      globalPriority: globalPriority || null,
+      defaultModel: defaultModel || null,
+      providerSpecificData: mergedProviderSpecificData,
+      isActive: true,
+      testStatus: testStatus || "unknown",
+    });
+
+    // Hide sensitive fields
+    const result = { ...newConnection };
+    delete result.apiKey;
+
+    return NextResponse.json({ connection: result }, { status: 201 });
+  } catch (error) {
+    console.log("Error creating provider:", error);
+    return NextResponse.json({ error: "Failed to create provider" }, { status: 500 });
+  }
+}

package/src/app/api/providers/suggested-models/filters.js

@@ -0,0 +1,20 @@
+// Free OpenCode models that don't use the "-free" id suffix
+const KNOWN_FREE_OPENCODE_MODELS = ["big-pickle"];
+
+export const FILTERS = {
+  "openrouter-free": (models) =>
+    models
+      .filter(
+        (m) =>
+          m.pricing?.prompt === "0" &&
+          m.pricing?.completion === "0" &&
+          m.context_length >= 200000
+      )
+      .map((m) => ({ id: m.id, name: m.name, contextLength: m.context_length }))
+      .sort((a, b) => b.contextLength - a.contextLength),
+
+  "opencode-free": (models) =>
+    models
+      .filter((m) => m.id?.endsWith("-free") || KNOWN_FREE_OPENCODE_MODELS.includes(m.id))
+      .map((m) => ({ id: m.id, name: m.id })),
+};

package/src/app/api/providers/suggested-models/route.js

@@ -0,0 +1,32 @@
+import { NextResponse } from "next/server";
+import { FILTERS } from "./filters.js";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request) {
+  const { searchParams } = new URL(request.url);
+  const url = searchParams.get("url");
+  const type = searchParams.get("type");
+
+  if (!url || !type) {
+    return NextResponse.json({ error: "Missing url or type" }, { status: 400 });
+  }
+
+  const filter = FILTERS[type];
+  if (!filter) {
+    return NextResponse.json({ error: "Unknown filter type" }, { status: 400 });
+  }
+
+  try {
+    const res = await fetch(url);
+    if (!res.ok) {
+      return NextResponse.json({ data: [] });
+    }
+    const json = await res.json();
+    const raw = json.data ?? json.models ?? json;
+    const data = filter(Array.isArray(raw) ? raw : []);
+    return NextResponse.json({ data });
+  } catch {
+    return NextResponse.json({ data: [] });
+  }
+}

package/src/app/api/providers/test-batch/route.js

@@ -0,0 +1,131 @@
+import { NextResponse } from "next/server";
+import { getProviderConnections } from "@/models";
+import {
+  FREE_PROVIDERS,
+  OAUTH_PROVIDERS,
+  APIKEY_PROVIDERS,
+  OPENAI_COMPATIBLE_PREFIX,
+  ANTHROPIC_COMPATIBLE_PREFIX,
+} from "@/shared/constants/providers";
+import { testSingleConnection } from "../[id]/test/testUtils.js";
+
+function getAuthGroup(providerId, connection = null) {
+  // Prioritize authType from connection if available
+  if (connection?.authType) {
+    if (connection.authType === "oauth") {
+      // Check if it's a free provider
+      if (FREE_PROVIDERS[providerId]) return "free";
+      return "oauth";
+    }
+    return connection.authType;
+  }
+  
+  // Fallback to constants
+  if (FREE_PROVIDERS[providerId]) return "free";
+  if (OAUTH_PROVIDERS[providerId]) return "oauth";
+  if (APIKEY_PROVIDERS[providerId]) return "apikey";
+  if (
+    typeof providerId === "string" &&
+    (providerId.startsWith(OPENAI_COMPATIBLE_PREFIX) || providerId.startsWith(ANTHROPIC_COMPATIBLE_PREFIX))
+  )
+    return "compatible";
+  return "apikey";
+}
+
+function isCompatibleProvider(providerId) {
+  return (
+    typeof providerId === "string" &&
+    (providerId.startsWith(OPENAI_COMPATIBLE_PREFIX) || providerId.startsWith(ANTHROPIC_COMPATIBLE_PREFIX))
+  );
+}
+
+// POST /api/providers/test-batch - Test multiple connections by group
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const { mode, providerId } = body;
+
+    if (!mode) {
+      return NextResponse.json({ error: "mode is required" }, { status: 400 });
+    }
+
+    const allConnections = await getProviderConnections({ isActive: true });
+
+    let connectionsToTest = [];
+    if (mode === "provider" && providerId) {
+      connectionsToTest = allConnections.filter((c) => c.provider === providerId);
+    } else if (mode === "oauth") {
+      connectionsToTest = allConnections.filter((c) => getAuthGroup(c.provider, c) === "oauth");
+    } else if (mode === "free") {
+      connectionsToTest = allConnections.filter((c) => getAuthGroup(c.provider, c) === "free");
+    } else if (mode === "apikey") {
+      connectionsToTest = allConnections.filter((c) => getAuthGroup(c.provider, c) === "apikey");
+    } else if (mode === "compatible") {
+      connectionsToTest = allConnections.filter((c) => isCompatibleProvider(c.provider));
+    } else if (mode === "all") {
+      connectionsToTest = allConnections;
+    } else {
+      return NextResponse.json(
+        { error: "Invalid mode. Use: provider, oauth, free, apikey, compatible, all" },
+        { status: 400 }
+      );
+    }
+
+    if (connectionsToTest.length === 0) {
+      return NextResponse.json({
+        mode,
+        providerId: providerId || null,
+        results: [],
+        summary: { total: 0, passed: 0, failed: 0 },
+        testedAt: new Date().toISOString(),
+      });
+    }
+
+    const results = [];
+    for (const conn of connectionsToTest) {
+      try {
+        const data = await testSingleConnection(conn.id);
+        results.push({
+          provider: conn.provider,
+          connectionId: conn.id,
+          connectionName: conn.name || conn.email || conn.provider,
+          authType: conn.authType || getAuthGroup(conn.provider, conn),
+          valid: data.valid,
+          latencyMs: data.latencyMs || 0,
+          error: data.error || null,
+          diagnosis: data.diagnosis || null,
+          statusCode: data.statusCode || null,
+          testedAt: data.testedAt || new Date().toISOString(),
+        });
+      } catch (error) {
+        results.push({
+          provider: conn.provider,
+          connectionId: conn.id,
+          connectionName: conn.name || conn.email || conn.provider,
+          authType: conn.authType || getAuthGroup(conn.provider, conn),
+          valid: false,
+          latencyMs: 0,
+          error: error.message,
+          diagnosis: { type: "network_error", source: "local", code: null, message: error.message },
+          statusCode: null,
+          testedAt: new Date().toISOString(),
+        });
+      }
+    }
+
+    return NextResponse.json({
+      mode,
+      providerId: providerId || null,
+      results,
+      testedAt: new Date().toISOString(),
+      summary: {
+        total: results.length,
+        passed: results.filter((r) => r.valid).length,
+        failed: results.filter((r) => !r.valid).length,
+      },
+    });
+  } catch (error) {
+    console.log("Error in batch test:", error);
+    return NextResponse.json({ error: "Batch test failed" }, { status: 500 });
+  }
+}