Update server.js

server.js

@@ -427,6 +427,7 @@ async function makeFalRequestWithRetry(falInput, stream = false) {
             if (isKeyRelatedError(error)) {
                 console.warn(`Marking Fal Key index ${keyInfo.index} as invalid due to caught initiation error.`);
                 invalidKeys.add(keyInfo.key);
+                 console.log(`--> Invalid Keys Set now contains: [${Array.from(invalidKeys).join(', ')}]`); // Log the set content
                 // Continue loop to try the next key
             } else {
                 console.error("Initiation error does not appear to be key-related. Failing request without further key retries.");
@@ -510,9 +511,9 @@ app.post('/v1/chat/completions', async (req, res) => {
                             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 Event Error: ${JSON.stringify(errorInfo)}` } }]
                         };
+                        // Check write status before sending
                         if (!res.writableEnded) { res.write(`data: ${JSON.stringify(errorChunk)}\n\n`); }
                         else { console.warn("Stream ended before writing event error."); }
-                        // Potentially break or add logic based on error type here
                     }
 
                     // Calculate the delta (new content)
@@ -539,6 +540,7 @@ app.post('/v1/chat/completions', async (req, res) => {
                                 finish_reason: isPartial === false ? "stop" : null
                              }]
                         };
+                        // Check write status before sending
                         if (!res.writableEnded) { res.write(`data: ${JSON.stringify(openAIChunk)}\n\n`); }
                         else { console.warn("Stream ended before writing data chunk."); }
                     }
@@ -553,42 +555,65 @@ app.post('/v1/chat/completions', async (req, res) => {
                     console.log("<-- Stream processing finished, but connection was already ended before [DONE].");
                 }
 
+            // ==================================================
+            // START: UPDATED CATCH BLOCK FOR STREAM HANDLING
+            // ==================================================
             } catch (streamError) {
                 // **Catch block for errors during stream processing OR initiation failure**
                 console.error('Error during stream request processing/initiation:', streamError.message || streamError);
+                 // **Log the specific error object for more details**
+                 console.error('Full streamError object:', streamError);
 
                 // **Check if the error is key-related AND if initiation succeeded**
                 // This ensures we only invalidate the key if the error happened *during* processing
                 // using a key that successfully initiated the stream.
                 if (keyUsedForRequest && isKeyRelatedError(streamError)) {
-                    console.warn(`Marking Fal Key index ${indexUsedForRequest} as invalid due to error during stream processing.`);
+                    console.warn(`--> Marking Fal Key index ${indexUsedForRequest} as invalid due to error during stream processing.`);
                     invalidKeys.add(keyUsedForRequest);
+                     console.log(`--> Invalid Keys Set now contains: [${Array.from(invalidKeys).map(k => k.substring(0, 5) + '...').join(', ')}]`); // Log obfuscated keys in set
                 }
-                // else: Error was either non-key-related or happened during initiation (already handled/logged in makeFalRequestWithRetry).
+                // else: Error was non-key-related or happened during initiation (already handled/logged in makeFalRequestWithRetry).
 
-                // --- Report error back to the client ---
+                // --- Safely Report error back to the client ---
                  try {
+                     // **Check headersSent first for initiation errors**
                      if (!res.headersSent) {
-                         // Error likely during initiation (caught from makeFalRequestWithRetry)
+                         console.log("<-- Attempting to send 502 error response (headers not sent).");
                          const errorMessage = (streamError instanceof Error) ? streamError.message : JSON.stringify(streamError);
-                         res.status(502).json({ error: 'Failed to initiate Fal stream', details: errorMessage });
+                         // Avoid sending huge objects if stringify fails or is too large
+                         const detail = String(errorMessage).length < 1000 ? errorMessage : "Error details too large or complex, check server logs.";
+                         res.status(502).json({ error: 'Failed to initiate Fal stream', details: detail });
                          console.log("<-- Stream initiation failed response sent (502).");
-                     } else if (!res.writableEnded) {
-                         // Error during stream processing after headers sent
+                     }
+                     // **Check writableEnded for errors during processing**
+                     else if (!res.writableEnded) {
+                         console.log("<-- Attempting to send error within stream (headers sent, not ended).");
                          const errorDetails = (streamError instanceof Error) ? streamError.message : JSON.stringify(streamError);
-                         res.write(`data: ${JSON.stringify({ error: { message: "Stream processing error after initiation", type: "proxy_error", details: errorDetails } })}\n\n`);
-                         res.write(`data: [DONE]\n\n`); // Still send DONE for robust client handling
-                         res.end();
+                         const detail = String(errorDetails).length < 1000 ? errorDetails : "Error details too large or complex, check server logs.";
+                         // Send an error object in the SSE stream format
+                         res.write(`data: ${JSON.stringify({ error: { message: "Stream processing error after initiation", type: "proxy_error", details: detail } })}\n\n`);
+                         // Still attempt to send [DONE] for robust client handling
+                         res.write(`data: [DONE]\n\n`);
+                         res.end(); // Explicitly end the response
                          console.log("<-- Stream error sent within stream, stream ended.");
                      } else {
-                        console.log("<-- Stream error occurred, but connection was already ended.");
+                        // Stream already ended, just log server-side.
+                        console.log("<-- Stream error occurred, but connection was already ended. Cannot send error to client.");
                      }
                  } catch (finalError) {
-                    console.error('Error sending stream error message to client:', finalError);
-                    if (!res.writableEnded) { res.end(); }
+                    // Error trying to send the error message itself (e.g., network gone)
+                    console.error('!!! Error sending stream error message to client:', finalError);
+                    // Attempt to end the response if it wasn't already
+                    if (!res.writableEnded) {
+                         console.log("<-- Forcefully ending response after error during error reporting.");
+                         res.end();
+                     }
                  }
                  // --- End error reporting ---
             }
+            // ==================================================
+            // END: UPDATED CATCH BLOCK FOR STREAM HANDLING
+            // ==================================================
 
         } else {
             // --- Non-Stream Request ---