fix(openai-bridge): avoid duplicate error headers

Author: awsl233777

cli/openai-bridge.js

@@ -514,8 +514,20 @@ function createOpenaiBridgeHttpHandler(options = {}) {
             res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
             res.end(JSON.stringify(ensureResponseMetadata(responsesPayload)));
             } catch (e) {
+                if (res.writableEnded || res.destroyed) {
+                    return;
+                }
+                const message = e && e.message ? e.message : 'Internal Error';
+                if (res.headersSent) {
+                    try {
+                        res.end();
+                    } catch (_) {
+                        // Headers are already committed; avoid surfacing a secondary write failure.
+                    }
+                    return;
+                }
                 res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
-                res.end(JSON.stringify({ error: e && e.message ? e.message : 'Internal Error' }));
+                res.end(JSON.stringify({ error: message }));
             }
         })();
 

tests/unit/openai-bridge-upstream-responses.test.mjs

@@ -1609,3 +1609,77 @@ test('openai-bridge maps reasoning effort when converting to upstream chat compl
     await upstream.close();
     await rm(tmpDir, { recursive: true, force: true });
 });
+
+test('openai-bridge does not write 500 headers after response headers were already sent', async () => {
+    const upstream = http.createServer((req, res) => {
+        if (req.url === '/v1/chat/completions' && req.method === 'POST') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                id: 'chatcmpl_headers_sent_regression',
+                model: 'gpt-test',
+                choices: [{ message: { role: 'assistant', content: 'ok' } }]
+            }));
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'not found' }));
+    });
+    const { port: upstreamPort } = await listen(upstream);
+
+    const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'codexmate-bridge-test-'));
+    const settingsFile = path.join(tmpDir, 'bridge.json');
+    await writeFile(settingsFile, JSON.stringify({
+        version: 1,
+        providers: {
+            test: { baseUrl: `http://127.0.0.1:${upstreamPort}/v1`, apiKey: 'sk-upstream' }
+        }
+    }), 'utf-8');
+
+    let uncaught = null;
+    const onUncaught = (err) => { uncaught = err; };
+    process.once('uncaughtException', onUncaught);
+
+    const handler = createOpenaiBridgeHttpHandler({ settingsFile, expectedToken: 'codexmate' });
+    const bridge = http.createServer((req, res) => {
+        const originalWriteHead = res.writeHead.bind(res);
+        let wroteSuccessHeader = false;
+        res.writeHead = function patchedWriteHead(statusCode, headers) {
+            if (statusCode === 200) wroteSuccessHeader = true;
+            if (wroteSuccessHeader && statusCode === 500) {
+                throw new Error('regression: attempted second writeHead after headers sent');
+            }
+            return originalWriteHead(statusCode, headers);
+        };
+        const originalEnd = res.end.bind(res);
+        res.end = function patchedEnd(chunk, encoding, cb) {
+            if (wroteSuccessHeader && !res.writableEnded) {
+                originalEnd(chunk, encoding, cb);
+                throw new Error('simulated post-header write failure');
+            }
+            return originalEnd(chunk, encoding, cb);
+        };
+        if (!handler(req, res)) {
+            res.statusCode = 404;
+            res.end('not handled');
+        }
+    });
+    const { port: bridgePort } = await listen(bridge);
+
+    const resp = await requestText(`http://127.0.0.1:${bridgePort}/bridge/openai/test/v1/responses`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'Authorization': 'Bearer codexmate'
+        },
+        body: { model: 'gpt-test', input: 'ping' }
+    });
+
+    assert.equal(resp.status, 200);
+    assert.equal(uncaught, null);
+
+    process.removeListener('uncaughtException', onUncaught);
+    await bridge.close();
+    await upstream.close();
+    await rm(tmpDir, { recursive: true, force: true });
+});