Update server.js

server.js

@@ -20,9 +20,10 @@ if (falKeys.length === 0) {
     process.exit(1);
 }
 
-console.log(`Loaded ${falKeys.length} Fal AI Keys.`);
+console.log(`Loaded ${falKeys.length} Fal AI Keys initially.`);
 
-let currentFalKeyIndex = 0; // Index of the *next* key to try for a *new* request
+// 不再需要 currentFalKeyIndex
+// let currentFalKeyIndex = 0;
 
 // --- End Key Management ---
 
@@ -232,12 +233,12 @@ function convertMessagesToFalPrompt(messages) {
 // === convertMessagesToFalPrompt 函数结束 ===
 
 
-// POST /v1/chat/completions endpoint (带 Key 重试逻辑 - Stream 修正版)
+// POST /v1/chat/completions endpoint (随机 Key + 失败排除)
 app.post('/v1/chat/completions', async (req, res) => {
     const { model, messages, stream = false, reasoning = false, ...restOpenAIParams } = req.body;
-    const requestId = `req-${Date.now()}`; // Unique ID for this incoming request
+    const requestId = `req-${Date.now()}`;
 
-    console.log(`[${requestId}] Received chat completion request for model: ${model}, stream: ${stream}`);
+    console.log(`[${requestId}] Received chat completion request for model: ${model}, stream: ${stream}. Strategy: Random key with exclusion.`);
 
     if (!FAL_SUPPORTED_MODELS.includes(model)) {
         console.warn(`[${requestId}] Warning: Requested model '${model}' is not in the explicitly supported list.`);
@@ -247,8 +248,13 @@ app.post('/v1/chat/completions', async (req, res) => {
         return res.status(400).json({ error: 'Missing or invalid parameters: model and messages array are required.' });
     }
 
-    let lastError = null; // Store the last error encountered during key rotation
-    let success = false; // Flag to indicate if any key succeeded
+    let lastError = null;
+    let success = false;
+    let attempt = 0;
+    const maxAttempts = falKeys.length; // Safety limit
+
+    // *** 為此請求創建可用的 Key 列表副本 ***
+    let availableKeysForRequest = [...falKeys];
 
     // 准备 Fal Input (只需要准备一次)
     const { prompt, system_prompt } = convertMessagesToFalPrompt(messages);
@@ -258,82 +264,69 @@ app.post('/v1/chat/completions', async (req, res) => {
         ...(system_prompt && { system_prompt: system_prompt }),
         reasoning: !!reasoning,
     };
+    console.log(`[${requestId}] Fal Input prepared. System Prompt Length: ${system_prompt?.length || 0}, Prompt Length: ${prompt?.length || 0}`);
 
-    // 打印一次 Fal Input 和 Prompt 信息
-    console.log(`[${requestId}] Fal Input (prepared once):`, JSON.stringify(falInput, null, 2));
-    console.log(`[${requestId}] System Prompt Length:`, system_prompt?.length || 0);
-    console.log(`[${requestId}] Prompt Length:`, prompt?.length || 0);
 
-    // *** 重试循环：尝试最多 falKeys.length 次 ***
-    for (let attempt = 0; attempt < falKeys.length; attempt++) {
-        const keyIndexToTry = (currentFalKeyIndex + attempt) % falKeys.length;
-        const selectedFalKey = falKeys[keyIndexToTry];
-        console.log(`[${requestId}] Attempt ${attempt + 1}/${falKeys.length}: Trying Fal Key at index ${keyIndexToTry}`);
+    // *** 重试循环：只要还有可用的 Key 且未达最大尝试次数 ***
+    while (availableKeysForRequest.length > 0 && attempt < maxAttempts) {
+        attempt++;
+        // *** 隨機選擇一個 Key ***
+        const randomIndex = Math.floor(Math.random() * availableKeysForRequest.length);
+        const selectedFalKey = availableKeysForRequest[randomIndex];
+        // Mask key in logs for security
+        const maskedKey = selectedFalKey.length > 8 ? `${selectedFalKey.substring(0, 4)}...${selectedFalKey.substring(selectedFalKey.length - 4)}` : selectedFalKey;
+        console.log(`[${requestId}] Attempt ${attempt}/${maxAttempts}: Trying random key (masked: ${maskedKey}). ${availableKeysForRequest.length} keys available.`);
 
         try {
-            // 配置 fal 客户端 (每次尝试都重新配置)
-            fal.config({
-                credentials: selectedFalKey,
-            });
+            fal.config({ credentials: selectedFalKey });
 
-            // --- 执行 Fal AI 调用 ---
             if (stream) {
                 // --- 流式处理 ---
                 res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
                 res.setHeader('Cache-Control', 'no-cache');
                 res.setHeader('Connection', 'keep-alive');
                 res.setHeader('Access-Control-Allow-Origin', '*');
-                // !! 不要在这里 flushHeaders !!
 
                 let previousOutput = '';
                 let firstEventProcessed = false;
-                let streamFailedMidway = false; // Flag for errors after successful start
-                let keyConfirmedWorking = false; // Flag if key actually produced data
+                let streamFailedMidway = false;
+                let keyConfirmedWorking = false;
 
                 const falStream = await fal.stream("fal-ai/any-llm", { input: falInput });
 
-                // 处理流
                 try {
                     for await (const event of falStream) {
                         const currentOutput = (event && typeof event.output === 'string') ? event.output : '';
                         const isPartial = (event && typeof event.partial === 'boolean') ? event.partial : true;
                         const errorInfo = (event && event.error) ? event.error : null;
-                        const eventStatus = errorInfo?.status; // Check status within error object if present
+                        const eventStatus = errorInfo?.status;
 
-                        // --- 检查事件错误 ---
                         if (errorInfo) {
-                            console.warn(`[${requestId}] Error received in fal stream event (Key Index ${keyIndexToTry}):`, errorInfo);
-                            lastError = errorInfo; // Store the error
+                            console.warn(`[${requestId}] Error in stream event (Key: ${maskedKey}):`, errorInfo);
+                            lastError = errorInfo;
 
-                            // 如果是第一次事件且是 Key 相关错误 (401/403/429)，则中断此 key 的尝试
                             if (!firstEventProcessed && (eventStatus === 401 || eventStatus === 403 || eventStatus === 429)) {
-                                console.warn(`[${requestId}] Key-related error (${eventStatus}) on first stream event for key index ${keyIndexToTry}. Aborting this attempt.`);
-                                // 不需要发送响应，直接跳出内部循环，让外部循环尝试下一个 key
-                                break; // Exit the inner `for await...of` loop
+                                console.warn(`[${requestId}] Key ${maskedKey} failed (${eventStatus}) on first event. Excluding it for this request.`);
+                                availableKeysForRequest.splice(randomIndex, 1); // 从可用列表移除
+                                console.log(`[${requestId}] ${availableKeysForRequest.length} keys remaining for this request.`);
+                                break; // 中断内部循环，外部循环将尝试下一个随机 key
                             } else {
-                                // 如果是其他错误，或者非第一次事件的错误，则认为是流处理失败
-                                console.error(`[${requestId}] Unrecoverable stream error or error after stream start.`);
-                                streamFailedMidway = true; // Mark stream as failed after start
+                                console.error(`[${requestId}] Unrecoverable stream error or error after stream start (Key: ${maskedKey}).`);
+                                streamFailedMidway = true;
                                 if (!res.headersSent) {
-                                     // 如果还没发header，说明key可能一开始就返回错误，直接发送500
                                      res.status(500).json({ object: "error", message: `Fal Stream Error: ${JSON.stringify(errorInfo)}`, type:"fal_stream_error"});
-                                     console.error(`[${requestId}] Headers not sent, responding with 500 JSON error.`);
                                 } else if (!res.writableEnded) {
-                                     // 如果已发header，发送错误chunk
                                     const errorChunk = { id: `chatcmpl-${Date.now()}-error`, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model: model, choices: [{ index: 0, delta: {}, finish_reason: "error", message: { role: 'assistant', content: `Fal Stream Error: ${JSON.stringify(errorInfo)}` } }] };
                                     res.write(`data: ${JSON.stringify(errorChunk)}\n\n`);
-                                    console.error(`[${requestId}] Headers sent, sending error chunk.`);
                                 }
-                                break; // Exit the inner `for await...of` loop
+                                break; // 中断内部循环
                             }
                         }
 
-                        // --- 成功接收到第一个非错误事件 ---
                         if (!keyConfirmedWorking && !errorInfo) {
-                             success = true; // Mark overall success *for this request*
-                             keyConfirmedWorking = true; // Mark this specific key as working
-                             currentFalKeyIndex = (keyIndexToTry + 1) % falKeys.length; // Update global index for next request
-                             console.log(`[${requestId}] Key at index ${keyIndexToTry} confirmed working. Next request starts at index ${currentFalKeyIndex}.`);
+                             success = true;
+                             keyConfirmedWorking = true;
+                             console.log(`[${requestId}] Key ${maskedKey} confirmed working (stream).`);
                              if (!res.headersSent) {
                                  res.flushHeaders();
                                  console.log(`[${requestId}] Stream headers flushed.`);
@@ -341,15 +334,12 @@ app.post('/v1/chat/completions', async (req, res) => {
                              firstEventProcessed = true;
                         }
 
-                        // --- 处理有效数据 ---
                         if (!errorInfo) {
                             let deltaContent = '';
                             if (currentOutput.startsWith(previousOutput)) {
                                 deltaContent = currentOutput.substring(previousOutput.length);
                             } else if (currentOutput.length > 0) {
-                                console.warn(`[${requestId}] Fal stream output mismatch detected. Sending full current output as delta.`, { previousLength: previousOutput.length, currentLength: currentOutput.length });
-                                deltaContent = currentOutput;
-                                previousOutput = ''; // Reset previous if mismatch
+                                deltaContent = currentOutput; previousOutput = '';
                             }
                             previousOutput = currentOutput;
 
@@ -360,78 +350,56 @@ app.post('/v1/chat/completions', async (req, res) => {
                                  }
                             }
                         }
-
                     } // End `for await...of` loop
 
-                    // --- 循环后处理 ---
                     if (streamFailedMidway) {
-                         // 如果是因为流中途错误跳出的，确保响应结束
                          if (!res.writableEnded) {
-                              res.write(`data: [DONE]\n\n`); // Send DONE even after error as per OpenAI spec
-                              res.end();
-                              console.log(`[${requestId}] Stream ended with [DONE] after mid-stream error.`);
+                              res.write(`data: [DONE]\n\n`); res.end();
                          }
-                         break; // Exit the outer key retry loop because the stream failed *after* starting
+                         break; // 中断外部循环，因为流在中途失败
                     } else if (keyConfirmedWorking) {
-                         // 如果 Key 正常工作且循环正常结束 (没有 break)
                          if (!res.writableEnded) {
-                            res.write(`data: [DONE]\n\n`);
-                            res.end();
-                            console.log(`[${requestId}] Stream finished normally and [DONE] sent.`);
+                            res.write(`data: [DONE]\n\n`); res.end();
                          }
-                         break; // Exit the outer key retry loop because we succeeded
+                         break; // 中断外部循环，因为成功
                     }
-                    // If loop finished without confirming the key worked and without mid-stream error (e.g., first event was key error)
-                    // let the outer loop continue to the next key.
+                    // 如果内部循环因为首个事件是 key 错误而中断，外部循环会继续
 
                 } catch (streamProcessingError) {
-                    // This catches errors in the stream processing *logic* itself, less likely
-                    console.error(`[${requestId}] Error during fal stream processing loop logic:`, streamProcessingError);
+                    console.error(`[${requestId}] Error during fal stream processing loop logic (Key: ${maskedKey}):`, streamProcessingError);
                     lastError = streamProcessingError;
                     if (!res.headersSent) {
                         res.status(500).json({ object: "error", message: `Proxy Stream Processing Error: ${streamProcessingError.message}`, type:"proxy_internal_error"});
-                        console.error(`[${requestId}] Headers not sent, responding with 500 JSON error for stream logic failure.`);
                     } else if (!res.writableEnded) {
                         try {
                              res.write(`data: ${JSON.stringify({ error: { message: "Proxy Stream processing error", type: "proxy_internal_error", details: streamProcessingError.message } })}\n\n`);
-                             res.write(`data: [DONE]\n\n`);
-                             res.end();
-                             console.error(`[${requestId}] Headers sent, sending error chunk for stream logic failure.`);
-                        } catch (finalError) {
-                             console.error(`[${requestId}] Error sending final error message to client:`, finalError);
-                             if (!res.writableEnded) { res.end(); }
-                        }
+                             res.write(`data: [DONE]\n\n`); res.end();
+                        } catch (finalError) { if (!res.writableEnded) { res.end(); } }
                     }
-                    break; // Exit the outer key retry loop
+                    break; // 中断外部循环
                 }
 
-                // If we reached here and `success` is true, it means the stream finished successfully.
-                if (success) {
-                    break; // Exit the outer key retry loop
-                }
-                // Otherwise, the stream ended because the first event was a key error, continue the outer loop.
+                 // 如果流成功或中途失败，外部循环会 break；如果因首个 key 错误而中断内部循环，则外部循环继续
+                 if (success || streamFailedMidway) {
+                    break;
+                 }
 
 
             } else {
-                // --- 非流式处理 (基本不变) ---
-                console.log(`[${requestId}] Executing non-stream request with key index ${keyIndexToTry}...`);
+                // --- 非流式处理 ---
+                console.log(`[${requestId}] Executing non-stream request (Key: ${maskedKey})...`);
                 const result = await fal.subscribe("fal-ai/any-llm", { input: falInput, logs: true });
 
                 if (result && result.error) {
-                     console.error(`[${requestId}] Fal-ai returned a business error with key index ${keyIndexToTry}:`, result.error);
+                     console.error(`[${requestId}] Fal-ai returned a business error (Key: ${maskedKey}):`, result.error);
                      lastError = new Error(`Fal-ai error: ${JSON.stringify(result.error)}`);
-                     lastError.status = result.status || 500; // Use status from error if available
+                     lastError.status = result.status || 500;
                      lastError.type = "fal_ai_error";
-                     // Business errors (e.g., bad input) usually shouldn't be retried with other keys
-                     break; // Exit retry loop
+                     break; // 业务错误，中断重试
                 }
 
-                console.log(`[${requestId}] Received non-stream result from fal-ai with key index ${keyIndexToTry}`);
-
-                success = true; // Mark overall success
-                currentFalKeyIndex = (keyIndexToTry + 1) % falKeys.length; // Update global index
-                console.log(`[${requestId}] Key at index ${keyIndexToTry} successful (non-stream). Next request starts at index ${currentFalKeyIndex}.`);
-
+                console.log(`[${requestId}] Received non-stream result (Key: ${maskedKey}).`);
+                success = true; // 标记成功
                 const openAIResponse = {
                     id: `chatcmpl-${result.requestId || Date.now()}`, object: "chat.completion", created: Math.floor(Date.now() / 1000), model: model,
                     choices: [{ index: 0, message: { role: "assistant", content: result.output || "" }, finish_reason: "stop" }],
@@ -440,72 +408,63 @@ app.post('/v1/chat/completions', async (req, res) => {
                     ...(result.reasoning && { fal_reasoning: result.reasoning }),
                 };
                 res.json(openAIResponse);
-                break; // 成功，跳出重试循环
+                break; // 成功，中断外部循环
             }
 
         } catch (error) {
-            // This outer catch handles errors from fal.config, fal.stream setup (before first event), fal.subscribe setup
+            // Catch errors from fal.config, fal.stream/subscribe setup
             lastError = error;
             const status = error?.status;
             const errorMessage = error?.body?.detail || error?.message || 'Unknown setup error';
+            console.warn(`[${requestId}] Attempt ${attempt} with key ${maskedKey} failed during setup. Status: ${status || 'N/A'}, Message: ${errorMessage}`);
+            // console.error("Setup Error details:", error); // Log full error for debug if needed
 
-            console.warn(`[${requestId}] Attempt ${attempt + 1} with key index ${keyIndexToTry} failed during setup. Status: ${status || 'N/A'}, Message: ${errorMessage}`);
-            console.error("Setup Error details:", error); // Log full error
-
-            // Check for key-related errors during setup
             if (status === 401 || status === 403 || status === 429) {
-                console.log(`[${requestId}] Key-related setup error (${status}). Trying next key...`);
-                // Continue the outer loop
+                console.warn(`[${requestId}] Key ${maskedKey} failed (${status}) during setup. Excluding it for this request.`);
+                availableKeysForRequest.splice(randomIndex, 1); // 从可用列表移除
+                console.log(`[${requestId}] ${availableKeysForRequest.length} keys remaining for this request.`);
+                // 继续外部循环
             } else {
-                 // Unrecoverable setup error (e.g., network, internal fal error)
-                 console.error(`[${requestId}] Unrecoverable setup error encountered. Status: ${status || 'N/A'}. Stopping key rotation.`);
-                 break; // Exit the outer key retry loop
+                 console.error(`[${requestId}] Unrecoverable setup error encountered (Key: ${maskedKey}). Status: ${status || 'N/A'}. Stopping retries.`);
+                 break; // 中断外部循环
             }
         }
     } // --- ��束重试循环 ---
 
-    // 如果循环结束了还没有成功 (所有 Key 都失败了或遇到不可恢复错误)
+    // 如果循环结束了还没有成功
     if (!success) {
-        console.error(`[${requestId}] All Fal Key attempts failed or an unrecoverable error occurred.`);
+        console.error(`[${requestId}] All attempts failed or an unrecoverable error occurred. No available keys left or max attempts reached.`);
         if (!res.headersSent) {
-            const statusCode = lastError?.status || 503; // Use status from last error (could be from setup or first stream event), default 503
+            const statusCode = lastError?.status || 503;
             const errorMessage = (lastError instanceof Error) ? lastError.message : JSON.stringify(lastError);
-            const detailMessage = lastError?.body?.detail || errorMessage; // Prefer detailed message
+            const detailMessage = lastError?.body?.detail || errorMessage;
             const errorType = lastError?.type || (statusCode === 401 || statusCode === 403 || statusCode === 429 ? "key_error" : "proxy_error");
-
              console.error(`[${requestId}] Sending final error response. Status: ${statusCode}, Type: ${errorType}, Message: ${detailMessage}`);
-
              res.status(statusCode).json({
                  object: "error",
-                 message: `All Fal Key attempts failed or an unrecoverable error occurred. Last error: ${detailMessage}`,
+                 message: `All attempts failed. Last error: ${detailMessage}`,
                  type: errorType,
                  param: null,
                  code: statusCode === 429 ? "rate_limit_exceeded" : (statusCode === 401 || statusCode === 403 ? "invalid_api_key" : "service_unavailable")
              });
         } else if (!res.writableEnded) {
-            // This case should be less likely now as stream errors are handled inside the loop
-            console.error(`[${requestId}] Headers potentially sent, but request failed. Attempting to end stream.`);
+            console.error(`[${requestId}] Headers potentially sent, but request failed. Ending stream.`);
              try {
-                 // Don't send another error chunk if one might have been sent already
-                 res.write(`data: [DONE]\n\n`);
-                 res.end();
-             } catch (e) {
-                 console.error(`[${requestId}] Failed to write final [DONE] to stream:`, e);
-                 if (!res.writableEnded) res.end();
-             }
+                 res.write(`data: [DONE]\n\n`); res.end();
+             } catch (e) { if (!res.writableEnded) res.end(); }
         } else {
-            console.error(`[${requestId}] Request failed, but response stream was already fully ended. Cannot send error.`);
+            console.error(`[${requestId}] Request failed, but response stream was already fully ended.`);
         }
     }
 
 });
 
-// 启动服务器 (更新启动信息)
+// 启动服务器
 app.listen(PORT, () => {
     console.log(`===================================================`);
-    console.log(` Fal OpenAI Proxy Server (Key Rotation with Retry v2 + System Top + Separator + Recency)`); // 更新描述
+    console.log(` Fal OpenAI Proxy Server (Random Key + Exclusion Strategy)`); // 更新描述
     console.log(` Listening on port: ${PORT}`);
-    console.log(` Loaded ${falKeys.length} Fal AI Keys for rotation.`);
+    console.log(` Loaded ${falKeys.length} Fal AI Keys initially.`);
     console.log(` Using Limits: System Prompt=${SYSTEM_PROMPT_LIMIT}, Prompt=${PROMPT_LIMIT}`);
     console.log(` API Key Auth Enabled: ${API_KEY ? 'Yes' : 'No'}`);
     console.log(` Chat Completions Endpoint: POST http://localhost:${PORT}/v1/chat/completions`);
@@ -513,7 +472,7 @@ app.listen(PORT, () => {
     console.log(`===================================================`);
 });
 
-// 根路径响应 (更新信息)
+// 根路径响应
 app.get('/', (req, res) => {
-    res.send('Fal OpenAI Proxy (Key Rotation with Retry v2 + System Top + Separator + Recency Strategy) is running.'); // 更新描述
+    res.send('Fal OpenAI Proxy (Random Key + Exclusion Strategy) is running.'); // 更新描述
 });