fix: key rotation - zero delay on 402, 55 retries, handler timeout 55s

api/lib/proxy.js

@@ -1,13 +1,13 @@
 const RETRYABLE_STATUSES = new Set([402, 429, 500, 502, 503, 504, 524]);
-const DEFAULT_MAX_RETRIES = 5;
-const BASE_DELAY_MS = 500;
+const DEFAULT_MAX_RETRIES = 55;
+const BASE_DELAY_MS = 200;
 const MAX_DELAY_MS = 5000;
-const BACKOFF_FACTOR = 2;
-const FETCH_TIMEOUT_MS = 15000;
+const BACKOFF_FACTOR = 1.5;
+const FETCH_TIMEOUT_MS = 10000;
 
 function computeDelay(attempt, random = Math.random) {
   const planned = Math.min(BASE_DELAY_MS * Math.pow(BACKOFF_FACTOR, attempt - 1), MAX_DELAY_MS);
-  return Math.max(planned * random(), 100);
+  return Math.max(planned * random(), 50);
 }
 
 function parseRetryAfterMs(response) {
@@ -37,28 +37,36 @@ async function proxyToKimchi(options) {
     requestHeaders = {},
     requestBody,
     method = "POST",
+    maxRetries: maxRetriesParam,
     retry = {},
     timeoutMs = FETCH_TIMEOUT_MS,
     signal,
   } = options;
 
-  const maxRetries = retry.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const maxRetries = maxRetriesParam ?? retry.maxRetries ?? DEFAULT_MAX_RETRIES;
   const lastError = [];
   let currentKey = null;
   let currentIndex = 0;
 
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    if (signal?.aborted) {
+      throw new Error(`Proxy aborted after ${attempt - 1} attempts`);
+    }
+
     const keyInfo = getNextKey();
     currentKey = keyInfo.key;
     currentIndex = keyInfo.index;
 
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(), timeoutMs);
-    const finalSignal = signal
-      ? typeof AbortSignal.any === "function"
-        ? AbortSignal.any([ctrl.signal, signal])
-        : ctrl.signal
-      : ctrl.signal;
+    let finalSignal = ctrl.signal;
+    if (signal) {
+      if (signal.aborted) {
+        clearTimeout(timer);
+        throw new Error(`Proxy aborted after ${attempt - 1} attempts`);
+      }
+      signal.addEventListener("abort", () => ctrl.abort(), { once: true });
+    }
 
     try {
       const response = await fetch(upstreamUrl, {
@@ -84,26 +92,24 @@ async function proxyToKimchi(options) {
 
       if (isCreditExhausted(response, responseText)) {
         lastError.push(new Error(`HTTP ${response.status}: credits exhausted (key ${currentIndex})`));
-        if (attempt < maxRetries) {
-          await new Promise((resolve) => setTimeout(resolve, 50));
-          continue;
-        }
+        continue;
       }
 
-      lastError.push(new Error(`HTTP ${response.status}`));
+      lastError.push(new Error(`HTTP ${response.status} (key ${currentIndex})`));
 
-      const retryAfterMs = parseRetryAfterMs(response);
-      const delay = retryAfterMs !== null ? Math.max(computeDelay(attempt), retryAfterMs) : computeDelay(attempt);
-      await new Promise((resolve) => setTimeout(resolve, delay));
+      if (response.status === 429) {
+        const retryAfterMs = parseRetryAfterMs(response);
+        const delay = retryAfterMs !== null ? Math.max(computeDelay(attempt), retryAfterMs) : computeDelay(attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
     } catch (error) {
       clearTimeout(timer);
-      if (signal?.aborted) throw error;
 
       lastError.push(error instanceof Error ? error : new Error(String(error)));
 
       if (attempt === maxRetries) {
         throw new Error(
-          `Proxy failed after ${maxRetries} attempts: ${lastError.map((e) => e.message).join("; ")}`,
+          `Proxy failed after ${maxRetries} attempts: ${lastError.slice(-3).map((e) => e.message).join("; ")}`,
         );
       }
 

api/v1/chat/completions.js

@@ -4,6 +4,8 @@ const { proxyToKimchi, streamResponse } = require("../../lib/proxy.js");
 const KIMCHI_UPSTREAM = "https://llm.kimchi.dev/openai/v1/chat/completions";
 
 module.exports = async function handler(req, res) {
+  const keysRaw = process.env.KIMCHI_API_KEYS;
+  const keys = parseKeys(keysRaw);
   let startTime = 0;
   let lastKeyIndex = 0;
 
@@ -12,9 +14,6 @@ module.exports = async function handler(req, res) {
       return res.status(405).json({ error: "Method not allowed" });
     }
 
-    const keysRaw = process.env.KIMCHI_API_KEYS;
-    const keys = parseKeys(keysRaw);
-
     if (keys.length === 0) {
       return res.status(500).json({ error: "No API keys configured. Set KIMCHI_API_KEYS env var." });
     }
@@ -35,10 +34,10 @@ module.exports = async function handler(req, res) {
     let rotateIndex = keySelection.index;
 
     const getNextKey = () => {
-      let attempts = 0;
-      while (isKeyThrottled(keys[rotateIndex]) && attempts < keys.length) {
+      let skipAttempts = 0;
+      while (isKeyThrottled(keys[rotateIndex]) && skipAttempts < keys.length) {
         rotateIndex = (rotateIndex + 1) % keys.length;
-        attempts++;
+        skipAttempts++;
       }
       const key = keys[rotateIndex];
       const idx = rotateIndex;
@@ -61,7 +60,8 @@ module.exports = async function handler(req, res) {
       requestHeaders: {
         "X-Request-Start": String(Date.now()),
       },
-      signal: AbortSignal.timeout(50000),
+      maxRetries: Math.min(keys.length, 55),
+      signal: AbortSignal.timeout(55000),
     });
 
     const elapsed = Date.now() - startTime;
@@ -81,7 +81,7 @@ module.exports = async function handler(req, res) {
       ok: false,
       error: "Failed to reach Kimchi API",
       keyIndex: lastKeyIndex,
-      keyTotal: keys?.length || 0,
+      keyTotal: keys.length,
       attempts: 0,
       elapsedMs: elapsed,
       details: err.message,