Update server.js

server.js

@@ -2,11 +2,13 @@ import express from 'express';
 import { fal } from '@fal-ai/client';
 
 // --- Multi-Key Configuration ---
-const rawFalKeys = process.env.FAL_KEYS; // Expect comma-separated keys: key1,key2,key3
+// *** 使用 FAL_KEY 环境变量读取逗号分隔的密钥 ***
+const rawFalKeys = process.env.FAL_KEY; // Expect comma-separated keys: key1,key2,key3 in FAL_KEY
 const API_KEY = process.env.API_KEY; // Custom API Key for proxy auth remains the same
 
 if (!rawFalKeys) {
-    console.error("Error: FAL_KEYS environment variable is not set (should be comma-separated).");
+    // *** 更新错误信息以引用 FAL_KEY ***
+    console.error("Error: FAL_KEY environment variable is not set (should be comma-separated).");
     process.exit(1);
 }
 
@@ -26,18 +28,19 @@ let falKeys = rawFalKeys.split(',')
     }));
 
 if (falKeys.length === 0) {
-    console.error("Error: No valid FAL_KEYS found after processing the environment variable.");
+    // *** 更新错误信息以引用 FAL_KEY ***
+    console.error("Error: No valid keys found in FAL_KEY after processing the environment variable.");
     process.exit(1);
 }
 
 let currentKeyIndex = 0;
 const failedKeyCooldown = 60 * 1000; // Cooldown period in milliseconds (e.g., 60 seconds) before retrying a failed key
 
-console.log(`Loaded ${falKeys.length} FAL API Key(s).`);
+// *** 更新日志信息以引用 FAL_KEY ***
+console.log(`Loaded ${falKeys.length} FAL API Key(s) from FAL_KEY environment variable.`);
 console.log(`Failed key cooldown period: ${failedKeyCooldown / 1000} seconds.`);
 
 // NOTE: We will configure fal client per request now, so initial global config is removed.
-// fal.config({ ... }); // Removed
 
 // --- Key Management Functions ---
 
@@ -126,7 +129,6 @@ const PORT = process.env.PORT || 3000;
 
 // API Key 鉴权中间件 (Remains the same, checks custom API_KEY)
 const apiKeyAuth = (req, res, next) => {
-    // ... (Keep existing apiKeyAuth middleware code) ...
     const authHeader = req.headers['authorization'];
 
     if (!authHeader) {
@@ -157,7 +159,7 @@ const SYSTEM_PROMPT_LIMIT = 4800;
 // === 限制定义结束 ===
 
 // 定义 fal-ai/any-llm 支持的模型列表 (Remains the same)
-const FAL_SUPPORTED_MODELS = [ /* ... model list ... */
+const FAL_SUPPORTED_MODELS = [
     "anthropic/claude-3.7-sonnet",
     "anthropic/claude-3.5-sonnet",
     "anthropic/claude-3-5-haiku",
@@ -178,7 +180,7 @@ const FAL_SUPPORTED_MODELS = [ /* ... model list ... */
 ];
 
 // Helper function to get owner from model ID (Remains the same)
-const getOwner = (modelId) => { /* ... */
+const getOwner = (modelId) => {
     if (modelId && modelId.includes('/')) {
         return modelId.split('/')[0];
     }
@@ -186,7 +188,7 @@ const getOwner = (modelId) => { /* ... */
 };
 
 // GET /v1/models endpoint (Remains the same)
-app.get('/v1/models', (req, res) => { /* ... */
+app.get('/v1/models', (req, res) => {
     console.log("Received request for GET /v1/models");
     try {
         const modelsData = FAL_SUPPORTED_MODELS.map(modelId => ({
@@ -201,7 +203,7 @@ app.get('/v1/models', (req, res) => { /* ... */
 });
 
 // === convertMessagesToFalPrompt 函数 (Remains the same) ===
-function convertMessagesToFalPrompt(messages) { /* ... */
+function convertMessagesToFalPrompt(messages) {
     let fixed_system_prompt_content = "";
     const conversation_message_blocks = [];
     // console.log(`Original messages count: ${messages.length}`); // Less verbose logging
@@ -347,48 +349,35 @@ async function tryFalCallWithFailover(operation, functionId, params) {
             // --- Configure fal client with the selected key for this attempt ---
             // WARNING: This global config change might have concurrency issues in high-load scenarios
             // if the fal client library doesn't isolate requests properly.
-            // A better approach would be per-request credentials if the library supported it.
             fal.config({ credentials: currentFalKey });
 
             if (operation === 'stream') {
-                // For streams, the retry logic primarily applies to *initiating* the stream.
-                // If the stream starts but fails later, this loop won't restart it.
                 const streamResult = await fal.stream(functionId, params);
                 console.log(`Successfully initiated stream with key ending in ...${currentFalKey.slice(-4)}`);
-                // If successful, return the stream iterator
                 return streamResult;
             } else { // 'subscribe' (non-stream)
                 const result = await fal.subscribe(functionId, params);
                 console.log(`Successfully completed subscribe request with key ending in ...${currentFalKey.slice(-4)}`);
 
-                // Check for application-level errors *returned* by fal within the result object
-                // These are usually model errors, not key errors. Let them propagate.
                 if (result && result.error) {
                      console.warn(`Fal-ai returned an application error (non-stream) with key ...${currentFalKey.slice(-4)}: ${JSON.stringify(result.error)}`);
-                     // Don't mark key as failed for application errors unless specifically known.
                 }
-                // Return the result object (which might contain an error)
                 return result;
             }
         } catch (error) {
             console.error(`Error using key ending in ...${currentFalKey.slice(-4)}:`, error.message || error);
-            lastError = error; // Store the error
+            lastError = error;
 
-            // Check if the error is likely related to the key itself
             if (isKeyRelatedError(error)) {
                 markKeyFailed(keyInfo);
                 console.log(`Key marked as failed. Trying next key if available...`);
-                // Continue the loop to try the next key
             } else {
-                // If the error is not key-related (e.g., network issue, fal internal error),
-                // stop retrying and propagate the error immediately.
                 console.error("Non-key related error occurred. Aborting retries.");
-                throw error; // Re-throw the error
+                throw error;
             }
         }
     }
 
-    // If the loop finishes, all keys were tried and failed with key-related errors.
     console.error("All FAL keys failed after attempting each one.");
     throw new Error(lastError ? `All FAL keys failed. Last error: ${lastError.message}` : "All FAL API keys failed.");
 }
@@ -402,7 +391,6 @@ app.post('/v1/chat/completions', async (req, res) => {
 
     if (!FAL_SUPPORTED_MODELS.includes(model)) {
          console.warn(`Warning: Requested model '${model}' is not in the explicitly supported list.`);
-         // Allow proceeding, maybe fal-ai/any-llm supports it dynamically
     }
     if (!model || !messages || !Array.isArray(messages) || messages.length === 0) {
         console.error("Invalid request parameters:", { model, messages: Array.isArray(messages) ? messages.length : typeof messages });
@@ -416,31 +404,24 @@ app.post('/v1/chat/completions', async (req, res) => {
             model: model,
             prompt: prompt,
             ...(system_prompt && { system_prompt: system_prompt }),
-            reasoning: !!reasoning, // Ensure boolean
-            // Spread any other OpenAI compatible params if needed, though fal might ignore them
-            // ...restOpenAIParams // Be careful with spreading unknown params
+            reasoning: !!reasoning,
         };
 
         console.log("Prepared Fal Input (lengths):", { system_prompt: system_prompt?.length, prompt: prompt?.length });
-        // Optional: Log full input for debugging (can be verbose)
-        // console.log("Full Fal Input:", JSON.stringify(falInput, null, 2));
 
-        // --- Use the failover wrapper for the Fal API call ---
         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', '*'); // Keep CORS header if needed
+            res.setHeader('Access-Control-Allow-Origin', '*');
             res.flushHeaders();
 
             let previousOutput = '';
             let falStream;
 
             try {
-                 // --- Initiate stream using failover ---
                  falStream = await tryFalCallWithFailover('stream', "fal-ai/any-llm", { input: falInput });
 
-                 // --- Process the stream (existing logic) ---
                  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;
@@ -448,11 +429,9 @@ app.post('/v1/chat/completions', async (req, res) => {
 
                     if (errorInfo) {
                         console.error("Error received *during* fal stream:", errorInfo);
-                        // Note: This error happened *after* successful stream initiation.
-                        // We send an error chunk, but don't mark the key failed here as the connection worked initially.
                         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`);
-                        break; // Stop processing this stream
+                        break;
                     }
 
                     let deltaContent = '';
@@ -461,11 +440,11 @@ app.post('/v1/chat/completions', async (req, res) => {
                     } else if (currentOutput.length > 0) {
                         console.warn("Fal stream output mismatch detected. Sending full current output as delta.", { previousLength: previousOutput.length, currentLength: currentOutput.length });
                         deltaContent = currentOutput;
-                        previousOutput = ''; // Reset previous since we sent full
+                        previousOutput = '';
                     }
-                    previousOutput = currentOutput; // Update previousOutput for next iteration
+                    previousOutput = currentOutput;
 
-                    if (deltaContent || !isPartial) { // Send delta or final chunk
+                    if (deltaContent || !isPartial) {
                         const openAIChunk = { id: `chatcmpl-${Date.now()}`, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model: model, choices: [{ index: 0, delta: { content: deltaContent }, finish_reason: isPartial === false ? "stop" : null }] };
                         res.write(`data: ${JSON.stringify(openAIChunk)}\n\n`);
                     }
@@ -475,12 +454,9 @@ app.post('/v1/chat/completions', async (req, res) => {
                  console.log("Stream finished successfully.");
 
             } catch (streamError) {
-                // This catch handles errors from tryFalCallWithFailover OR the stream processing loop
                 console.error('Error during stream processing:', streamError);
-                // Don't try to write to response if headers already sent and stream failed mid-way uncleanly
                 if (!res.writableEnded) {
                      try {
-                         // Send a final error chunk if possible
                          const errorDetails = (streamError instanceof Error) ? streamError.message : JSON.stringify(streamError);
                          const finalErrorChunk = { error: { message: "Stream failed", type: "proxy_error", details: errorDetails } };
                          res.write(`data: ${JSON.stringify(finalErrorChunk)}\n\n`);
@@ -488,65 +464,57 @@ app.post('/v1/chat/completions', async (req, res) => {
                          res.end();
                      } catch (finalError) {
                          console.error('Error sending final stream error message to client:', finalError);
-                         if (!res.writableEnded) { res.end(); } // Ensure response ends
+                         if (!res.writableEnded) { res.end(); }
                      }
                  }
             }
 
         } else { // Non-stream
              console.log("Executing non-stream request with failover...");
-             // --- Call subscribe using failover ---
              const result = await tryFalCallWithFailover('subscribe', "fal-ai/any-llm", { input: falInput, logs: true });
 
              console.log("Received non-stream result from fal-ai via failover wrapper.");
-             // Optional: Log full result for debugging
-             // console.log("Full non-stream result:", JSON.stringify(result, null, 2));
 
-             // Check for application-level errors *within* the successful response
              if (result && result.error) {
                  console.error("Fal-ai returned an application error in non-stream mode (after successful API call):", result.error);
-                 // Return a 500 status but format it like OpenAI error if possible
                  return res.status(500).json({
                       object: "error",
                       message: `Fal-ai application error: ${JSON.stringify(result.error)}`,
                       type: "fal_ai_error",
                       param: null,
-                      code: result.error.code || null // Include code if available
+                      code: result.error.code || null
                  });
              }
 
-             // --- Format successful non-stream response (existing logic) ---
              const openAIResponse = {
-                 id: `chatcmpl-${result?.requestId || Date.now()}`, // Use requestId if available
+                 id: `chatcmpl-${result?.requestId || Date.now()}`,
                  object: "chat.completion",
                  created: Math.floor(Date.now() / 1000),
-                 model: model, // Use the requested model ID
+                 model: model,
                  choices: [{
                      index: 0,
                      message: {
                          role: "assistant",
-                         content: result?.output || "" // Safely access output
+                         content: result?.output || ""
                      },
-                     finish_reason: "stop" // Assume stop for non-stream
+                     finish_reason: "stop"
                  }],
-                 usage: { // Fal doesn't provide token usage
+                 usage: {
                      prompt_tokens: null,
                      completion_tokens: null,
                      total_tokens: null
                  },
-                 system_fingerprint: null, // Not provided by fal
-                 ...(result?.reasoning && { fal_reasoning: result.reasoning }), // Include reasoning if present
+                 system_fingerprint: null,
+                 ...(result?.reasoning && { fal_reasoning: result.reasoning }),
              };
              res.json(openAIResponse);
              console.log("Returned non-stream response successfully.");
         }
 
     } catch (error) {
-        // This catches errors from setup, convertMessagesToFalPrompt, or tryFalCallWithFailover (if all keys failed or non-key error occurred)
         console.error('Unhandled error in /v1/chat/completions:', error);
         if (!res.headersSent) {
             const errorMessage = (error instanceof Error) ? error.message : JSON.stringify(error);
-            // Provide a more informative error message
             const errorType = error.message?.includes("All FAL keys failed") ? "api_key_error" : "proxy_internal_error";
             res.status(500).json({
                  error: {
@@ -557,7 +525,7 @@ app.post('/v1/chat/completions', async (req, res) => {
             });
         } else if (!res.writableEnded) {
              console.error("Headers already sent, attempting to end response after error.");
-             res.end(); // Try to end the response if possible
+             res.end();
         }
     }
 });
@@ -567,7 +535,8 @@ app.listen(PORT, () => {
     console.log(`===========================================================`);
     console.log(` Fal OpenAI Proxy Server (Multi-Key Failover)`);
     console.log(` Listening on port: ${PORT}`);
-    console.log(` Loaded ${falKeys.length} FAL API Key(s).`);
+    // *** 更新日志信息以引用 FAL_KEY ***
+    console.log(` Loaded ${falKeys.length} FAL API Key(s) from FAL_KEY.`);
     console.log(` API Key Auth Enabled: ${API_KEY ? 'Yes' : 'No'}`);
     console.log(` Limits: System Prompt=${SYSTEM_PROMPT_LIMIT}, Prompt=${PROMPT_LIMIT}`);
     console.log(` Chat Completions: POST http://localhost:${PORT}/v1/chat/completions`);
@@ -575,7 +544,7 @@ app.listen(PORT, () => {
     console.log(`===========================================================`);
 });
 
-// Root path response (Remains the same)
+// Root path response
 app.get('/', (req, res) => {
     res.send('Fal OpenAI Proxy (Multi-Key Failover) is running.');
 });