codexmate 0.0.28 → 0.0.30

package/cli/openai-bridge.js

@@ -1,11 +1,16 @@
 const http = require('http');
 const https = require('https');
 const crypto = require('crypto');
+const { StringDecoder } = require('string_decoder');
 const { readJsonFile, writeJsonAtomic } = require('../lib/cli-file-utils');
 const { isValidHttpUrl, normalizeBaseUrl, joinApiUrl } = require('../lib/cli-utils');
 
 const DEFAULT_BRIDGE_TOKEN = 'codexmate';
 const SETTINGS_VERSION = 1;
+// 推理模型 reasoning 阶段可能长时间无字节输出，需匹配 codex 的 stream_idle_timeout_ms=300000。
+const STREAM_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+const REQUEST_TIMEOUT_MS = 5 * 60 * 1000;
+const RESPONSES_UNSUPPORTED_TTL_MS = 30 * 60 * 1000;
 
 function normalizeText(value) {
     return typeof value === 'string' ? value.trim() : '';
@@ -281,7 +286,10 @@ function normalizeResponsesInputToChatMessages(input) {
 
     const toRole = (value) => {
         const roleRaw = typeof value === 'string' ? value.trim().toLowerCase() : '';
-        return roleRaw === 'assistant' ? 'assistant' : (roleRaw === 'system' ? 'system' : 'user');
+        if (roleRaw === 'assistant') return 'assistant';
+        // codex 把 AGENTS.md 注入 developer 角色；Responses 的 developer 在 chat 侧等价于 system。
+        if (roleRaw === 'system' || roleRaw === 'developer') return 'system';
+        return 'user';
     };
 
     if (input && typeof input === 'object' && !Array.isArray(input)) {
@@ -439,6 +447,43 @@ function normalizeResponsesToolsForResponsesApi(tools) {
         .filter(Boolean);
 }
 
+function mergeLeadingSystemMessages(messages, leadingInstructions) {
+    const segments = [];
+    const seen = new Set();
+    const pushSegment = (text) => {
+        const trimmed = typeof text === 'string' ? text.trim() : '';
+        if (!trimmed || seen.has(trimmed)) return;
+        seen.add(trimmed);
+        segments.push(trimmed);
+    };
+    if (typeof leadingInstructions === 'string') {
+        pushSegment(leadingInstructions);
+    }
+    const rest = [];
+    for (const msg of messages) {
+        if (msg && msg.role === 'system') {
+            const content = msg.content;
+            if (typeof content === 'string') {
+                pushSegment(content);
+            } else if (Array.isArray(content)) {
+                for (const part of content) {
+                    if (part && typeof part === 'object' && typeof part.text === 'string') {
+                        pushSegment(part.text);
+                    }
+                }
+            }
+            continue;
+        }
+        rest.push(msg);
+    }
+    const out = [];
+    if (segments.length) {
+        out.push({ role: 'system', content: segments.join('\n\n---\n\n') });
+    }
+    for (const msg of rest) out.push(msg);
+    return out;
+}
+
 function convertResponsesRequestToChatCompletions(payload) {
     const body = payload && typeof payload === 'object' ? payload : {};
     const model = typeof body.model === 'string' ? body.model.trim() : '';
@@ -446,12 +491,10 @@ function convertResponsesRequestToChatCompletions(payload) {
         return { error: 'responses 请求缺少 model' };
     }
 
-    const messages = [];
-    // Align with Maxx/CLIProxyAPI style: map "instructions" to a leading system message.
-    if (typeof body.instructions === 'string' && body.instructions.trim()) {
-        messages.push({ role: 'system', content: body.instructions.trim() });
-    }
-    messages.push(...normalizeResponsesInputToChatMessages(body.input));
+    const rawMessages = normalizeResponsesInputToChatMessages(body.input);
+    // codex 同时下发 body.instructions（内置 prompt）与 input 内 developer/system 消息（AGENTS.md）。
+    // 合流为一条领头 system，避免某些上游"只认第一条 system"导致 AGENTS.md 失效。
+    const messages = mergeLeadingSystemMessages(rawMessages, body.instructions);
     if (!messages.length) {
         // codex sometimes sends empty input for probes; tolerate.
         messages.push({ role: 'user', content: '' });
@@ -710,12 +753,72 @@ function shouldFallbackFromUpstreamResponses(status, bodyText) {
     return false;
 }
 
+// 仅识别"端点级别不支持"——可缓存，与 per-request 的 tool 格式错误区分。
+function isResponsesEndpointUnsupported(status, bodyText) {
+    if (!Number.isFinite(status)) return false;
+    if (status === 404 || status === 405 || status === 501) return true;
+    const text = String(bodyText || '');
+    if (!text) return false;
+    if (/not implemented/i.test(text)) return true;
+    if (/convert_request_failed/i.test(text)) return true;
+    if (/unknown (endpoint|route)/i.test(text)) return true;
+    if (/unsupported.*\/?v1\/responses/i.test(text)) return true;
+    if (/does not support.*responses/i.test(text)) return true;
+    try {
+        const parsed = JSON.parse(text);
+        const code = parsed && parsed.error && typeof parsed.error.code === 'string' ? parsed.error.code : '';
+        const msg = parsed && parsed.error && typeof parsed.error.message === 'string' ? parsed.error.message : '';
+        if (code === 'convert_request_failed') return true;
+        if (/not implemented/i.test(msg)) return true;
+        if (/unknown (endpoint|route)/i.test(msg)) return true;
+        if (/unsupported.*\/?v1\/responses/i.test(msg)) return true;
+        if (/does not support.*responses/i.test(msg)) return true;
+    } catch (_) {}
+    return false;
+}
+
 function isLoopbackAddress(address) {
     if (!address) return false;
     const value = String(address);
     return value === '127.0.0.1' || value === '::1' || value === '::ffff:127.0.0.1';
 }
 
+function isTransientNetworkError(error) {
+    const text = String(error || '').trim();
+    if (!text) return false;
+    if (/socket hang up/i.test(text)) return true;
+    if (/ECONNRESET|ECONNREFUSED|EPIPE|EPROTO|ETIMEDOUT/i.test(text)) return true;
+    if (/EAI_AGAIN/i.test(text)) return true;
+    if (/UND_ERR_SOCKET/i.test(text)) return true;
+    if (/disconnected before|secure tls|tls handshake/i.test(text)) return true;
+    return false;
+}
+
+const TRANSIENT_RETRY_DELAYS_MS = [200, 600];
+
+async function retryTransientRequest(executor) {
+    let lastResult = null;
+    for (let attempt = 0; attempt <= TRANSIENT_RETRY_DELAYS_MS.length; attempt += 1) {
+        if (attempt > 0) {
+            const delay = TRANSIENT_RETRY_DELAYS_MS[attempt - 1];
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((r) => {
+                const t = setTimeout(r, delay);
+                if (typeof t.unref === 'function') t.unref();
+            });
+        }
+        // eslint-disable-next-line no-await-in-loop
+        const result = await executor(attempt);
+        lastResult = result;
+        if (!result) return result;
+        if (result.ok) return result;
+        if (result.retry) return result;
+        if (result.status && result.status > 0) return result;
+        if (!isTransientNetworkError(result.error)) return result;
+    }
+    return lastResult;
+}
+
 function writeSse(res, eventName, dataObj) {
     if (!res || res.writableEnded || res.destroyed) return;
     if (eventName) {
@@ -758,7 +861,15 @@ function writeChatCompletionChunkAsResponsesSse(state, chunk) {
         const delta = choice && choice.delta && typeof choice.delta === 'object' ? choice.delta : null;
         if (!delta) continue;
 
+        const segments = [];
+        // DeepSeek-style OpenAI-compatible streams may emit private reasoning in
+        // `reasoning_content` before the final answer. Responses `output_text`
+        // must stay user-visible answer text only; forwarding reasoning here
+        // pollutes Codex output and breaks exact-answer prompts.
         if (typeof delta.content === 'string' && delta.content) {
+            segments.push(delta.content);
+        }
+        for (const seg of segments) {
             if (!state.messageItem) {
                 state.messageItem = {
                     id: `msg_${crypto.randomBytes(8).toString('hex')}`,
@@ -773,14 +884,14 @@ function writeChatCompletionChunkAsResponsesSse(state, chunk) {
                     item: state.messageItem
                 });
             }
-            state.messageText += delta.content;
+            state.messageText += seg;
             state.messageItem.content[0].text = state.messageText;
             writeSse(state.res, 'response.output_text.delta', {
                 type: 'response.output_text.delta',
                 item_id: state.messageItem.id,
                 output_index: state.output.length - 1,
                 content_index: 0,
-                delta: delta.content,
+                delta: seg,
                 sequence_number: state.nextSeq()
             });
         }
@@ -790,6 +901,10 @@ function writeChatCompletionChunkAsResponsesSse(state, chunk) {
                 appendChatStreamToolCall(state.toolCalls, toolCall);
             }
         }
+
+        if (typeof choice.finish_reason === 'string' && choice.finish_reason) {
+            state.sawFinishReason = true;
+        }
     }
 }
 
@@ -903,7 +1018,7 @@ function streamChatCompletionsAsResponsesSse(targetUrl, options = {}) {
     }
     const timeoutMs = Number.isFinite(options.timeoutMs)
         ? Math.max(1000, Number(options.timeoutMs))
-        : 30000;
+        : STREAM_IDLE_TIMEOUT_MS;
     const res = options.res;
     const fallbackModel = typeof options.model === 'string' ? options.model : '';
 
@@ -1006,6 +1121,7 @@ function streamChatCompletionsAsResponsesSse(targetUrl, options = {}) {
                 toolCalls: [],
                 finished: false,
                 sawDone: false,
+                sawFinishReason: false,
                 nextSeq: () => {
                     sequence += 1;
                     return sequence;
@@ -1021,6 +1137,7 @@ function streamChatCompletionsAsResponsesSse(targetUrl, options = {}) {
             });
 
             let buffer = '';
+            const utf8Decoder = new StringDecoder('utf8');
             const handleEventBlock = (block) => {
                 const dataLines = String(block || '')
                     .split(/\r?\n/)
@@ -1048,7 +1165,7 @@ function streamChatCompletionsAsResponsesSse(targetUrl, options = {}) {
 
             upstreamRes.on('data', (chunk) => {
                 if (!chunk) return;
-                buffer += chunk.toString('utf-8');
+                buffer += utf8Decoder.write(chunk);
                 let boundary = buffer.search(/\r?\n\r?\n/);
                 while (boundary >= 0) {
                     const block = buffer.slice(0, boundary);
@@ -1059,8 +1176,9 @@ function streamChatCompletionsAsResponsesSse(targetUrl, options = {}) {
                 }
             });
             upstreamRes.on('end', () => {
+                buffer += utf8Decoder.end();
                 if (buffer.trim()) handleEventBlock(buffer);
-                if (!state.finished && !state.sawDone) {
+                if (!state.finished && !state.sawDone && !state.sawFinishReason) {
                     failChatStreamResponsesSse(state, 'upstream stream ended before [DONE]');
                     finish({ ok: true });
                     return;
@@ -1105,7 +1223,7 @@ async function proxyRequestJson(targetUrl, options = {}) {
 
     const timeoutMs = Number.isFinite(options.timeoutMs)
         ? Math.max(1000, Number(options.timeoutMs))
-        : 30000;
+        : REQUEST_TIMEOUT_MS;
     return new Promise((resolve) => {
         let settled = false;
         const finish = (value) => {
@@ -1177,6 +1295,27 @@ function createOpenaiBridgeHttpHandler(options = {}) {
         throw new Error('createOpenaiBridgeHttpHandler 缺少 settingsFile');
     }
 
+    // 端点不支持的缓存（per-baseUrl, TTL 30 分钟）：避免每次非流式请求重复探测 /v1/responses。
+    const unsupportedResponses = new Map();
+    const isResponsesKnownUnsupported = (baseUrl) => {
+        if (!baseUrl) return false;
+        const entry = unsupportedResponses.get(baseUrl);
+        if (!entry) return false;
+        if (entry.expiresAt <= Date.now()) {
+            unsupportedResponses.delete(baseUrl);
+            return false;
+        }
+        return true;
+    };
+    const markResponsesUnsupported = (baseUrl) => {
+        if (!baseUrl) return;
+        unsupportedResponses.set(baseUrl, { expiresAt: Date.now() + RESPONSES_UNSUPPORTED_TTL_MS });
+    };
+    const clearResponsesUnsupported = (baseUrl) => {
+        if (!baseUrl) return;
+        unsupportedResponses.delete(baseUrl);
+    };
+
     const matchPath = (requestPath) => {
         const normalized = String(requestPath || '');
         const prefix = '/bridge/openai/';
@@ -1266,7 +1405,7 @@ function createOpenaiBridgeHttpHandler(options = {}) {
                 }
 
                 const url = joinApiUrl(upstream.baseUrl, 'models');
-                const result = await proxyRequestJson(url, {
+                const result = await retryTransientRequest(() => proxyRequestJson(url, {
                     method: 'GET',
                     headers: {
                         ...(authHeader ? { Authorization: authHeader } : {}),
@@ -1275,7 +1414,7 @@ function createOpenaiBridgeHttpHandler(options = {}) {
                     maxBytes: maxUpstreamBytes,
                     httpAgent,
                     httpsAgent
-                });
+                }));
                 if (!result.ok) {
                     res.writeHead(502, { 'Content-Type': 'application/json; charset=utf-8' });
                     res.end(JSON.stringify({ error: `Upstream request failed: ${result.error}` }));
@@ -1325,7 +1464,7 @@ function createOpenaiBridgeHttpHandler(options = {}) {
                 }
                 const upstreamUrl = joinApiUrl(upstream.baseUrl, 'chat/completions');
                 const chatBody = { ...converted.chat, stream: true };
-                const streamed = await streamChatCompletionsAsResponsesSse(upstreamUrl, {
+                const streamed = await retryTransientRequest(() => streamChatCompletionsAsResponsesSse(upstreamUrl, {
                     method: 'POST',
                     body: chatBody,
                     headers: {
@@ -1337,7 +1476,7 @@ function createOpenaiBridgeHttpHandler(options = {}) {
                     httpsAgent,
                     res,
                     model: typeof chatBody.model === 'string' ? chatBody.model : ''
-                });
+                }));
                 if (!streamed.ok) {
                     if (res.writableEnded || res.destroyed) {
                         return;
@@ -1356,20 +1495,25 @@ function createOpenaiBridgeHttpHandler(options = {}) {
 
             // Maxx-style behavior: prefer upstream /responses if supported.
             // Fallback to /chat/completions conversion when upstream does not implement /responses (404/405).
+            // 已知不支持的上游：直接跳过探测，节省一次 round-trip。
+            const skipResponsesProbe = isResponsesKnownUnsupported(upstream.baseUrl);
             const upstreamResponsesUrl = joinApiUrl(upstream.baseUrl, 'responses');
-            const upstreamResponsesResult = await proxyRequestJson(upstreamResponsesUrl, {
-                method: 'POST',
-                body: toUpstreamNonStreamingResponsesPayload(responsesRequest),
-                headers: {
-                    ...(authHeader ? { Authorization: authHeader } : {}),
-                    ...upstreamHeaders
-                },
-                maxBytes: maxUpstreamBytes,
-                httpAgent,
-                httpsAgent
-            });
+            const upstreamResponsesResult = skipResponsesProbe
+                ? { ok: true, status: 404, bodyText: '' }
+                : await retryTransientRequest(() => proxyRequestJson(upstreamResponsesUrl, {
+                    method: 'POST',
+                    body: toUpstreamNonStreamingResponsesPayload(responsesRequest),
+                    headers: {
+                        ...(authHeader ? { Authorization: authHeader } : {}),
+                        ...upstreamHeaders
+                    },
+                    maxBytes: maxUpstreamBytes,
+                    httpAgent,
+                    httpsAgent
+                }));
 
             if (upstreamResponsesResult.ok && upstreamResponsesResult.status >= 200 && upstreamResponsesResult.status < 300) {
+                clearResponsesUnsupported(upstream.baseUrl);
                 const upstreamJson = parseJsonOrError(upstreamResponsesResult.bodyText);
                 if (upstreamJson.error) {
                     res.writeHead(502, { 'Content-Type': 'application/json; charset=utf-8' });
@@ -1401,6 +1545,9 @@ function createOpenaiBridgeHttpHandler(options = {}) {
                     res.end(upstreamResponsesResult.bodyText || JSON.stringify({ error: 'Upstream error' }));
                     return;
                 }
+                if (!skipResponsesProbe && isResponsesEndpointUnsupported(upstreamResponsesResult.status, upstreamResponsesResult.bodyText)) {
+                    markResponsesUnsupported(upstream.baseUrl);
+                }
                 // fallthrough to chat/completions conversion
             }
 
@@ -1418,7 +1565,7 @@ function createOpenaiBridgeHttpHandler(options = {}) {
             }
 
             const upstreamUrl = joinApiUrl(upstream.baseUrl, 'chat/completions');
-            const upstreamResult = await proxyRequestJson(upstreamUrl, {
+            const upstreamResult = await retryTransientRequest(() => proxyRequestJson(upstreamUrl, {
                 method: 'POST',
                 body: converted.chat,
                 headers: {
@@ -1428,7 +1575,7 @@ function createOpenaiBridgeHttpHandler(options = {}) {
                 maxBytes: maxUpstreamBytes,
                 httpAgent,
                 httpsAgent
-            });
+            }));
             if (!upstreamResult.ok) {
                 res.writeHead(502, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.end(JSON.stringify({ error: `Upstream request failed: ${upstreamResult.error}` }));
@@ -1485,5 +1632,22 @@ module.exports = {
     readOpenaiBridgeSettings,
     upsertOpenaiBridgeProvider,
     resolveOpenaiBridgeUpstream,
-    createOpenaiBridgeHttpHandler
+    createOpenaiBridgeHttpHandler,
+    // exported for local-bridge reuse
+    convertResponsesRequestToChatCompletions,
+    streamChatCompletionsAsResponsesSse,
+    proxyRequestJson,
+    ensureResponseMetadata,
+    sendResponsesSse,
+    extractAuthorizationToken,
+    readRequestBody,
+    parseJsonOrError,
+    extractChatCompletionResult,
+    buildResponsesPayloadFromChatResult,
+    retryTransientRequest,
+    normalizeOpenaiUpstreamBaseUrl,
+    extractResponsesOutputText,
+    shouldFallbackFromUpstreamResponses,
+    isTransientNetworkError,
+    isLoopbackAddress
 };