zevairouter 1.0.152 → 1.0.154

package/src/app/(dashboard)/dashboard/usage/components/RequestDetailsTab.js

@@ -1,6 +1,6 @@
 "use client";
 
-import { useState, useEffect, useCallback } from "react";
+import { useState, useEffect, useCallback, useRef } from "react";
 import Card from "@/shared/components/Card";
 import Button from "@/shared/components/Button";
 import Drawer from "@/shared/components/Drawer";
@@ -106,6 +106,7 @@ export default function RequestDetailsTab() {
     startDate: "",
     endDate: ""
   });
+  const detailsRequestRef = useRef({ sequence: 0, controller: null });
 
   const fetchProviders = useCallback(async () => {
     try {
@@ -121,6 +122,10 @@ export default function RequestDetailsTab() {
   }, []);
 
   const fetchDetails = useCallback(async () => {
+    detailsRequestRef.current.controller?.abort();
+    const controller = new AbortController();
+    const sequence = detailsRequestRef.current.sequence + 1;
+    detailsRequestRef.current = { sequence, controller };
     setLoading(true);
     try {
       const params = new URLSearchParams({
@@ -131,15 +136,19 @@ export default function RequestDetailsTab() {
       if (filters.startDate) params.append("startDate", filters.startDate);
       if (filters.endDate) params.append("endDate", filters.endDate);
 
-      const res = await fetch(`/api/usage/request-details?${params}`);
+      const res = await fetch(`/api/usage/request-details?${params}`, {
+        signal: controller.signal,
+      });
       const data = await res.json();
 
+      if (sequence !== detailsRequestRef.current.sequence) return;
       setDetails(data.details || []);
       setPagination(prev => ({ ...prev, ...data.pagination }));
     } catch (error) {
+      if (error?.name === "AbortError") return;
       console.error("Failed to fetch request details:", error);
     } finally {
-      setLoading(false);
+      if (sequence === detailsRequestRef.current.sequence) setLoading(false);
     }
   }, [pagination.page, pagination.pageSize, filters]);
 
@@ -151,6 +160,10 @@ export default function RequestDetailsTab() {
   useEffect(() => {
     // eslint-disable-next-line react-hooks/set-state-in-effect -- data fetch on filter/page change; fetchDetails sets state only after await, which the rule flags conservatively
     fetchDetails();
+    return () => {
+      detailsRequestRef.current.controller?.abort();
+      detailsRequestRef.current.sequence += 1;
+    };
   }, [fetchDetails]);
 
   const handleViewDetail = (detail) => {
@@ -168,6 +181,12 @@ export default function RequestDetailsTab() {
 
   const handleClearFilters = () => {
     setFilters({ provider: "", startDate: "", endDate: "" });
+    setPagination(prev => ({ ...prev, page: 1 }));
+  };
+
+  const handleFilterChange = (field, value) => {
+    setFilters(prev => ({ ...prev, [field]: value }));
+    setPagination(prev => ({ ...prev, page: 1 }));
   };
 
   return (
@@ -179,7 +198,7 @@ export default function RequestDetailsTab() {
             <select
               id="provider-filter"
               value={filters.provider}
-              onChange={(e) => setFilters({ ...filters, provider: e.target.value })}
+              onChange={(e) => handleFilterChange("provider", e.target.value)}
               className={cn(
                 "h-9 px-3 rounded-lg border border-black/10 dark:border-white/10 bg-surface",
                 "text-sm text-text-main focus:outline-none focus:ring-2 focus:ring-primary/20",
@@ -202,7 +221,7 @@ export default function RequestDetailsTab() {
               id="start-date-filter"
               type="datetime-local"
               value={filters.startDate}
-              onChange={(e) => setFilters({ ...filters, startDate: e.target.value })}
+              onChange={(e) => handleFilterChange("startDate", e.target.value)}
               className={cn(
                 "h-9 px-3 rounded-lg border border-black/10 dark:border-white/10 bg-surface",
                 "w-full min-w-0 text-sm text-text-main focus:outline-none focus:ring-2 focus:ring-primary/20"
@@ -216,7 +235,7 @@ export default function RequestDetailsTab() {
               id="end-date-filter"
               type="datetime-local"
               value={filters.endDate}
-              onChange={(e) => setFilters({ ...filters, endDate: e.target.value })}
+              onChange={(e) => handleFilterChange("endDate", e.target.value)}
               className={cn(
                 "h-9 px-3 rounded-lg border border-black/10 dark:border-white/10 bg-surface",
                 "w-full min-w-0 text-sm text-text-main focus:outline-none focus:ring-2 focus:ring-primary/20"

package/src/app/api/dashboard/cli-tools/keys/route.js

@@ -0,0 +1,33 @@
+import { NextResponse } from "next/server";
+import { getApiKeys } from "@/lib/localDb";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+// CLI setup needs the actual key value to write local tool configuration.
+// This narrowly scoped dashboard route is protected by dashboardGuard.
+export async function GET() {
+  try {
+    const keys = await getApiKeys(true);
+    const cliKeys = keys.map(({ id, key, name, createdAt }) => ({
+      id,
+      key,
+      name,
+      createdAt,
+    }));
+
+    return NextResponse.json(
+      { keys: cliKeys },
+      { headers: { "Cache-Control": "private, no-store, max-age=0" } },
+    );
+  } catch (error) {
+    console.log("Error fetching CLI tool keys:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch CLI tool keys" },
+      {
+        status: 500,
+        headers: { "Cache-Control": "private, no-store, max-age=0" },
+      },
+    );
+  }
+}

package/src/app/api/dashboard/media/[operation]/route.js

@@ -0,0 +1,60 @@
+import { getApiKeys, getSettings } from "@/lib/localDb";
+import { handleEmbeddings } from "@/sse/handlers/embeddings.js";
+import { handleFetch } from "@/sse/handlers/fetch.js";
+import { handleImageGeneration } from "@/sse/handlers/imageGeneration.js";
+import { handleSearch } from "@/sse/handlers/search.js";
+import { handleStt } from "@/sse/handlers/stt.js";
+import { handleTts } from "@/sse/handlers/tts.js";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+export const maxDuration = 300;
+
+const OPERATIONS = Object.freeze({
+  embeddings: { pathname: "/api/v1/embeddings", handler: handleEmbeddings },
+  images: { pathname: "/api/v1/images/generations", handler: handleImageGeneration },
+  speech: { pathname: "/api/v1/audio/speech", handler: handleTts },
+  transcriptions: { pathname: "/api/v1/audio/transcriptions", handler: handleStt },
+  search: { pathname: "/api/v1/search", handler: handleSearch },
+  fetch: { pathname: "/api/v1/web/fetch", handler: handleFetch },
+});
+
+async function injectDashboardApiKey(headers) {
+  if (headers.get("authorization") || headers.get("x-api-key")) return;
+
+  try {
+    const settings = await getSettings();
+    if (!settings?.requireApiKey) return;
+
+    const keys = await getApiKeys(true);
+    const activeKey = (keys || []).find((apiKey) => (
+      apiKey?.isActive !== false && typeof apiKey?.key === "string" && apiKey.key
+    ));
+    if (activeKey) headers.set("authorization", `Bearer ${activeKey.key}`);
+  } catch {
+    // The media handler returns the normal auth error when no key can be loaded.
+  }
+}
+
+export async function POST(request, { params }) {
+  const { operation } = await params;
+  const target = OPERATIONS[operation];
+  if (!target) {
+    return Response.json({ error: "Unsupported dashboard media operation" }, { status: 404 });
+  }
+
+  const headers = new Headers(request.headers);
+  await injectDashboardApiKey(headers);
+
+  const url = new URL(request.url);
+  url.pathname = target.pathname;
+  const body = await request.arrayBuffer();
+  const proxiedRequest = new Request(url, {
+    method: "POST",
+    headers,
+    body: body.byteLength > 0 ? body : undefined,
+    signal: request.signal,
+  });
+
+  return target.handler(proxiedRequest);
+}

package/src/app/api/keys/[id]/route.js

@@ -1,6 +1,19 @@
 import { NextResponse } from "next/server";
 import { deleteApiKey, getApiKeyById, updateApiKey } from "@/lib/localDb";
 
+function validateNonNegativeNumber(body, field, { integer = false } = {}) {
+  if (body[field] === undefined) return {};
+
+  const value = body[field];
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return { error: `${field} must be a non-negative number` };
+  }
+  if (integer && !Number.isInteger(value)) {
+    return { error: `${field} must be a non-negative integer` };
+  }
+  return { value };
+}
+
 // GET /api/keys/[id] - Get single key
 // ?reveal=1 returns the full secret (dashboard auth only — used by eye toggle)
 export async function GET(request, { params }) {
@@ -11,7 +24,11 @@ export async function GET(request, { params }) {
     if (!key) {
       return NextResponse.json({ error: "Key not found" }, { status: 404 });
     }
-    return NextResponse.json({ key });
+    if (reveal) return NextResponse.json({ key });
+
+    const safeKey = { ...key };
+    delete safeKey.key;
+    return NextResponse.json({ key: safeKey });
   } catch (error) {
     console.log("Error fetching key:", error);
     return NextResponse.json({ error: "Failed to fetch key" }, { status: 500 });
@@ -20,11 +37,44 @@ export async function GET(request, { params }) {
 
 // PUT /api/keys/[id] - Update key
 export async function PUT(request, { params }) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return NextResponse.json({ error: "JSON body must be an object" }, { status: 400 });
+  }
+
   try {
     const { id } = await params;
-    const body = await request.json();
     const { isActive, budgetDaily, budgetMonthly, requestsPerMinute, allowedModels } = body;
 
+    if (isActive !== undefined && typeof isActive !== "boolean") {
+      return NextResponse.json({ error: "isActive must be a boolean" }, { status: 400 });
+    }
+
+    const dailyResult = validateNonNegativeNumber(body, "budgetDaily");
+    if (dailyResult.error) {
+      return NextResponse.json({ error: dailyResult.error }, { status: 400 });
+    }
+    const monthlyResult = validateNonNegativeNumber(body, "budgetMonthly");
+    if (monthlyResult.error) {
+      return NextResponse.json({ error: monthlyResult.error }, { status: 400 });
+    }
+    const rpmResult = validateNonNegativeNumber(body, "requestsPerMinute", { integer: true });
+    if (rpmResult.error) {
+      return NextResponse.json({ error: rpmResult.error }, { status: 400 });
+    }
+    if (
+      allowedModels !== undefined
+      && (!Array.isArray(allowedModels) || allowedModels.some((model) => typeof model !== "string"))
+    ) {
+      return NextResponse.json({ error: "allowedModels must be an array of strings" }, { status: 400 });
+    }
+
     const existing = await getApiKeyById(id);
     if (!existing) {
       return NextResponse.json({ error: "Key not found" }, { status: 404 });
@@ -32,19 +82,19 @@ export async function PUT(request, { params }) {
 
     const updateData = {};
     if (isActive !== undefined) updateData.isActive = isActive;
-    if (budgetDaily !== undefined) updateData.budgetDaily = Math.max(0, Number(budgetDaily) || 0);
-    if (budgetMonthly !== undefined) updateData.budgetMonthly = Math.max(0, Number(budgetMonthly) || 0);
-    if (requestsPerMinute !== undefined) updateData.requestsPerMinute = Math.max(0, Math.floor(Number(requestsPerMinute) || 0));
-    if (allowedModels !== undefined) {
-      if (!Array.isArray(allowedModels) || allowedModels.some((model) => typeof model !== "string")) {
-        return NextResponse.json({ error: "allowedModels must be an array of strings" }, { status: 400 });
-      }
-      updateData.allowedModels = allowedModels;
-    }
+    if (dailyResult.value !== undefined) updateData.budgetDaily = dailyResult.value;
+    if (monthlyResult.value !== undefined) updateData.budgetMonthly = monthlyResult.value;
+    if (rpmResult.value !== undefined) updateData.requestsPerMinute = rpmResult.value;
+    if (allowedModels !== undefined) updateData.allowedModels = allowedModels;
 
     const updated = await updateApiKey(id, updateData);
+    if (!updated) {
+      return NextResponse.json({ error: "Key not found" }, { status: 404 });
+    }
+    const safeUpdated = { ...updated };
+    delete safeUpdated.key;
 
-    return NextResponse.json({ key: updated });
+    return NextResponse.json({ key: safeUpdated });
   } catch (error) {
     console.log("Error updating key:", error);
     return NextResponse.json({ error: "Failed to update key" }, { status: 500 });

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

@@ -8,7 +8,12 @@ export const dynamic = "force-dynamic";
 export async function GET() {
   try {
     const keys = await getApiKeys();
-    return NextResponse.json({ keys });
+    const safeKeys = keys.map((apiKey) => {
+      const safeKey = { ...apiKey };
+      delete safeKey.key;
+      return safeKey;
+    });
+    return NextResponse.json({ keys: safeKeys });
   } catch (error) {
     console.log("Error fetching keys:", error);
     return NextResponse.json({ error: "Failed to fetch keys" }, { status: 500 });
@@ -17,14 +22,23 @@ export async function GET() {
 
 // POST /api/keys - Create new API key
 export async function POST(request) {
+  let body;
   try {
-    const body = await request.json();
-    const { name } = body;
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
 
-    if (!name) {
-      return NextResponse.json({ error: "Name is required" }, { status: 400 });
-    }
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return NextResponse.json({ error: "JSON body must be an object" }, { status: 400 });
+  }
 
+  const name = typeof body.name === "string" ? body.name.trim() : "";
+  if (!name) {
+    return NextResponse.json({ error: "Name is required" }, { status: 400 });
+  }
+
+  try {
     // Always get machineId from server
     const machineId = await getConsistentMachineId();
     const apiKey = await createApiKey(name, machineId);

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

@@ -6,13 +6,14 @@ function metric(name, help, type, value) {
 }
 
 export async function GET() {
-  const [stats, activeRequests, connections] = await Promise.all([
+  const [stats, requestActivity, connections] = await Promise.all([
     getUsageStats("all"),
     getActiveRequests(),
     getProviderConnections({ isActive: true }),
   ]);
   const cache = responseCache.getStats();
-  const active = activeRequests.reduce((sum, request) => sum + (request.count || 0), 0);
+  const active = (requestActivity.activeRequests || [])
+    .reduce((sum, request) => sum + (request.count || 0), 0);
 
   const body = [
     metric("zevai_requests_total", "Completed routed requests.", "counter", stats.totalRequests),

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

@@ -5,6 +5,68 @@ import {
   updateProviderConnection,
   deleteProviderConnection,
 } from "@/models";
+import { sanitizeProviderConnection } from "@/lib/providerConnectionSanitizer";
+
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function validateProviderUpdateBody(body) {
+  if (!isJsonObject(body)) return "JSON body must be an object";
+
+  if (body.name !== undefined) {
+    if (typeof body.name !== "string" || !body.name.trim()) {
+      return "name must be a non-empty string";
+    }
+  }
+  for (const field of ["apiKey", "connectionProxyUrl", "connectionNoProxy"]) {
+    if (body[field] !== undefined && typeof body[field] !== "string") {
+      return `${field} must be a string`;
+    }
+  }
+  for (const field of ["defaultModel", "testStatus", "lastError", "lastErrorAt"]) {
+    if (body[field] !== undefined && body[field] !== null && typeof body[field] !== "string") {
+      return `${field} must be a string or null`;
+    }
+  }
+  if (body.isActive !== undefined && typeof body.isActive !== "boolean") {
+    return "isActive must be a boolean";
+  }
+  if (
+    body.connectionProxyEnabled !== undefined
+    && typeof body.connectionProxyEnabled !== "boolean"
+  ) {
+    return "connectionProxyEnabled must be a boolean";
+  }
+  if (
+    body.priority !== undefined
+    && (typeof body.priority !== "number" || !Number.isFinite(body.priority) || body.priority <= 0)
+  ) {
+    return "priority must be a positive number";
+  }
+  if (
+    body.globalPriority !== undefined
+    && body.globalPriority !== null
+    && (typeof body.globalPriority !== "number" || !Number.isFinite(body.globalPriority) || body.globalPriority < 0)
+  ) {
+    return "globalPriority must be null or a non-negative number";
+  }
+  if (
+    body.proxyPoolId !== undefined
+    && body.proxyPoolId !== null
+    && typeof body.proxyPoolId !== "string"
+  ) {
+    return "proxyPoolId must be a string or null";
+  }
+  if (
+    body.providerSpecificData !== undefined
+    && body.providerSpecificData !== null
+    && !isJsonObject(body.providerSpecificData)
+  ) {
+    return "providerSpecificData must be an object or null";
+  }
+  return null;
+}
 
 function normalizeProxyConfig(body = {}) {
   const hasAnyProxyField =
@@ -69,14 +131,7 @@ export async function GET(request, { params }) {
       return NextResponse.json({ error: "Connection not found" }, { status: 404 });
     }
 
-    // Hide sensitive fields
-    const result = { ...connection };
-    delete result.apiKey;
-    delete result.accessToken;
-    delete result.refreshToken;
-    delete result.idToken;
-
-    return NextResponse.json({ connection: result });
+    return NextResponse.json({ connection: sanitizeProviderConnection(connection) });
   } catch (error) {
     console.log("Error fetching connection:", error);
     return NextResponse.json({ error: "Failed to fetch connection" }, { status: 500 });
@@ -85,9 +140,20 @@ export async function GET(request, { params }) {
 
 // PUT /api/providers/[id] - Update connection
 export async function PUT(request, { params }) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  const validationError = validateProviderUpdateBody(body);
+  if (validationError) {
+    return NextResponse.json({ error: validationError }, { status: 400 });
+  }
+
   try {
     const { id } = await params;
-    const body = await request.json();
     const {
       name,
       priority,
@@ -156,15 +222,11 @@ export async function PUT(request, { params }) {
     }
 
     const updated = await updateProviderConnection(id, updateData);
+    if (!updated) {
+      return NextResponse.json({ error: "Connection not found" }, { status: 404 });
+    }
 
-    // Hide sensitive fields
-    const result = { ...updated };
-    delete result.apiKey;
-    delete result.accessToken;
-    delete result.refreshToken;
-    delete result.idToken;
-
-    return NextResponse.json({ connection: result });
+    return NextResponse.json({ connection: sanitizeProviderConnection(updated) });
   } catch (error) {
     console.log("Error updating connection:", error);
     return NextResponse.json({ error: "Failed to update connection" }, { status: 500 });

package/src/app/api/providers/[id]/test/testUtils.js

@@ -5,6 +5,7 @@ import { isOpenAICompatibleProvider, isAnthropicCompatibleProvider } from "@/sha
 import { PROVIDER_ENDPOINTS } from "@/shared/constants/config";
 import { getDefaultModel } from "open-sse/config/providerModels.js";
 import { resolveOllamaLocalHost } from "open-sse/config/providers.js";
+import { getEarliestModelLockUntil } from "open-sse/services/accountFallback.js";
 import {
   refreshProviderCredentials,
   shouldRefreshCredentials,
@@ -769,12 +770,20 @@ export async function testSingleConnection(id) {
 
   const latencyMs = Date.now() - start;
 
+  // A successful auth/health test does not prove that a model-specific quota
+  // lock recovered. Preserve its error timestamp so a newer quota snapshot can
+  // safely authorize one bounded recovery probe.
+  const preserveModelLockError = result.valid && !!getEarliestModelLockUntil(connection);
   const updateData = result.inconclusive
     ? {}
     : {
         testStatus: result.valid ? "active" : "error",
-        lastError: result.valid ? null : result.error,
-        lastErrorAt: result.valid ? null : new Date().toISOString(),
+        lastError: result.valid
+          ? (preserveModelLockError ? connection.lastError : null)
+          : result.error,
+        lastErrorAt: result.valid
+          ? (preserveModelLockError ? connection.lastErrorAt : null)
+          : new Date().toISOString(),
       };
 
   if (result.refreshed && result.newTokens) {

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

@@ -2,22 +2,7 @@ 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",
-];
+import { sanitizeProviderConnection } from "@/lib/providerConnectionSanitizer";
 
 const DEFAULT_PAGE_SIZE = 20;
 const MAX_PAGE_SIZE = 500;
@@ -29,16 +14,8 @@ function maskName(name) {
 }
 
 function sanitize(c) {
-  const safe = {};
-  for (const f of SAFE_FIELDS) if (c[f] !== undefined) safe[f] = c[f];
+  const safe = sanitizeProviderConnection(c);
   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;
 }
 
@@ -57,8 +34,17 @@ function isUsageEligible(connection) {
 }
 
 function parsePositiveInt(value, fallback) {
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+  if (value === null || value === undefined || value === "") {
+    return { value: fallback };
+  }
+  if (!/^[1-9]\d*$/.test(value)) {
+    return { error: "must be a positive integer" };
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) {
+    return { error: "must be a safe positive integer" };
+  }
+  return { value: parsed };
 }
 
 function sortConnections(connections, sort) {
@@ -83,14 +69,30 @@ function sortConnections(connections, sort) {
 
 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 pageResult = parsePositiveInt(searchParams.get("page"), 1);
+    const pageSizeResult = parsePositiveInt(searchParams.get("pageSize"), DEFAULT_PAGE_SIZE);
+
+    if (!new Set(["all", "active", "inactive"]).has(accountStatus)) {
+      return NextResponse.json({ error: "accountStatus must be all, active, or inactive" }, { status: 400 });
+    }
+    if (!new Set(["priority", "provider"]).has(sort)) {
+      return NextResponse.json({ error: "sort must be priority or provider" }, { status: 400 });
+    }
+    if (pageResult.error) {
+      return NextResponse.json({ error: `page ${pageResult.error}` }, { status: 400 });
+    }
+    if (pageSizeResult.error || pageSizeResult.value > MAX_PAGE_SIZE) {
+      const error = pageSizeResult.error || `must be at most ${MAX_PAGE_SIZE}`;
+      return NextResponse.json({ error: `pageSize ${error}` }, { status: 400 });
+    }
+
+    const page = pageResult.value;
+    const pageSize = pageSizeResult.value;
+    await backfillCodexEmails();
 
     const allConnections = await getProviderConnections();
     const eligibleConnections = allConnections.filter(isUsageEligible);