codexmate 0.0.53 → 0.0.55

package/cli/openai-bridge.js

@@ -300,9 +300,28 @@ function cloneJsonValue(value) {
 }
 
 function normalizeResponsesToolOutput(value) {
-    if (typeof value === 'string') return value;
-    if (value == null) return '';
-    return stringifyJsonValue(value, '');
+    if (typeof value === 'string') return value || '(empty)';
+    if (value == null) return '(empty)';
+    return stringifyJsonValue(value, '(empty)') || '(empty)';
+}
+
+function chatContentToPlainText(content) {
+    if (typeof content === 'string') return content;
+    if (!Array.isArray(content)) return '';
+    return content
+        .map((item) => {
+            if (typeof item === 'string') return item;
+            if (!isRecord(item)) return '';
+            if (typeof item.text === 'string') return item.text;
+            if (typeof item.content === 'string') return item.content;
+            return '';
+        })
+        .join('');
+}
+
+function wrapReasoningContentForChat(content) {
+    const text = chatContentToPlainText(content).trim();
+    return text ? `<thinking>${text}</thinking>` : '';
 }
 
 function normalizeOpenAiToolArguments(value) {
@@ -530,7 +549,7 @@ function normalizeResponsesInputToChatMessages(input) {
 
         if (itemType === 'reasoning') {
             flushPendingToolCalls();
-            const reasoningContent = toOpenAiMessageContent(item.summary != null ? item.summary : (item.content != null ? item.content : item));
+            const reasoningContent = wrapReasoningContentForChat(toOpenAiMessageContent(item.summary != null ? item.summary : (item.content != null ? item.content : item)));
             const reasoningSignature = asTrimmedString(item.encrypted_content || item.reasoning_signature);
             if (!hasOpenAiMessageContent(reasoningContent) && !reasoningSignature) return;
             const message = { role: 'assistant', content: reasoningContent };
@@ -889,6 +908,12 @@ function convertResponsesRequestToChatCompletions(payload) {
         top_p: Number.isFinite(body.top_p) ? Number(body.top_p) : undefined,
         max_tokens: Number.isFinite(maxOutputTokens) && maxOutputTokens > 0 ? maxOutputTokens : undefined
     };
+    if (isRecord(body.reasoning)) {
+        const effort = asTrimmedString(body.reasoning.effort);
+        if (effort) chat.reasoning_effort = effort;
+    } else if (asTrimmedString(body.reasoning_effort)) {
+        chat.reasoning_effort = asTrimmedString(body.reasoning_effort);
+    }
     if (Array.isArray(body.stop) && body.stop.length) {
         chat.stop = body.stop.filter((item) => typeof item === 'string' && item.trim());
     }
@@ -940,12 +965,22 @@ function buildResponsesPayloadFromChatResult(model, text, toolCalls, upstreamPay
         }
     }
 
+    const choice = upstreamPayload && typeof upstreamPayload === 'object' && Array.isArray(upstreamPayload.choices)
+        ? upstreamPayload.choices[0]
+        : null;
+    const finishReason = choice && typeof choice.finish_reason === 'string' ? choice.finish_reason : '';
+    const statusPatch = finishReason === 'length'
+        ? { status: 'incomplete', incomplete_details: { reason: 'max_output_tokens' } }
+        : (finishReason === 'content_filter'
+            ? { status: 'incomplete', incomplete_details: { reason: 'content_filter' } }
+            : { status: 'completed' });
+
     const payload = {
         id: responseId,
         object: 'response',
         model,
         created_at: createdAt,
-        status: 'completed',
+        ...statusPatch,
         output,
         output_text: trimmedText
     };
@@ -1017,12 +1052,14 @@ function sendResponsesSse(res, responsePayload) {
         const itemId = typeof item.id === 'string' && item.id.trim()
             ? item.id.trim()
             : (typeof item.call_id === 'string' && item.call_id.trim() ? item.call_id.trim() : `item_${crypto.randomBytes(8).toString('hex')}`);
+        const wireItem = buildResponsesSseItem(item, itemId);
 
         // Emit item added so Codex can anchor subsequent deltas by output_index/content_index/item_id.
         writeSse(res, 'response.output_item.added', {
             type: 'response.output_item.added',
             output_index: outputIndex,
-            item: { ...item, id: itemId }
+            item: wireItem,
+            sequence_number: nextSeq()
         });
 
         if (itemType === 'message') {
@@ -1032,6 +1069,7 @@ function sendResponsesSse(res, responsePayload) {
                 if (!block || typeof block !== 'object') continue;
                 if (block.type !== 'output_text') continue;
                 const text = typeof block.text === 'string' ? block.text : '';
+                emitResponsesTextPartAdded(res, itemId, outputIndex, contentIndex, nextSeq);
                 if (text) {
                     writeSse(res, 'response.output_text.delta', {
                         type: 'response.output_text.delta',
@@ -1050,6 +1088,33 @@ function sendResponsesSse(res, responsePayload) {
                     text,
                     sequence_number: nextSeq()
                 });
+                emitResponsesTextPartDone(res, itemId, outputIndex, contentIndex, text, nextSeq);
+            }
+        } else if (itemType === 'function_call' || itemType === 'custom_tool_call') {
+            emitResponsesToolArgumentEvents(res, wireItem, outputIndex, nextSeq);
+        } else if (itemType === 'reasoning') {
+            const summary = Array.isArray(item.summary) ? item.summary : [];
+            for (let summaryIndex = 0; summaryIndex < summary.length; summaryIndex += 1) {
+                const block = summary[summaryIndex];
+                const text = block && typeof block.text === 'string' ? block.text : '';
+                if (text) {
+                    writeSse(res, 'response.reasoning_summary_text.delta', {
+                        type: 'response.reasoning_summary_text.delta',
+                        item_id: itemId,
+                        output_index: outputIndex,
+                        summary_index: summaryIndex,
+                        delta: text,
+                        sequence_number: nextSeq()
+                    });
+                }
+                writeSse(res, 'response.reasoning_summary_text.done', {
+                    type: 'response.reasoning_summary_text.done',
+                    item_id: itemId,
+                    output_index: outputIndex,
+                    summary_index: summaryIndex,
+                    text,
+                    sequence_number: nextSeq()
+                });
             }
         }
 
@@ -1057,7 +1122,7 @@ function sendResponsesSse(res, responsePayload) {
         writeSse(res, 'response.output_item.done', {
             type: 'response.output_item.done',
             output_index: outputIndex,
-            item: { ...item, id: itemId },
+            item: wireItem,
             sequence_number: nextSeq()
         });
     }
@@ -1083,15 +1148,25 @@ function extractResponsesOutputText(payload) {
     return '';
 }
 
-function toUpstreamNonStreamingResponsesPayload(payload) {
+function normalizeResponsesPayloadForUpstream(payload, stream) {
     const body = payload && typeof payload === 'object' ? payload : {};
-    const normalized = { ...body, stream: false };
+    const normalized = { ...body, stream };
     if (Array.isArray(body.tools)) {
         normalized.tools = normalizeResponsesToolsForResponsesApi(body.tools);
     }
+    if (isRecord(body.reasoning)) {
+        const include = Array.isArray(body.include) ? body.include.filter((item) => typeof item === 'string') : [];
+        if (!include.includes('reasoning.encrypted_content')) {
+            normalized.include = [...include, 'reasoning.encrypted_content'];
+        }
+    }
     return normalized;
 }
 
+function toUpstreamNonStreamingResponsesPayload(payload) {
+    return normalizeResponsesPayloadForUpstream(payload, false);
+}
+
 function shouldFallbackFromUpstreamResponses(status, bodyText) {
     if (!Number.isFinite(status)) return false;
     // Common "unsupported" status codes for a route.
@@ -1202,6 +1277,101 @@ function writeSse(res, eventName, dataObj) {
     res.write(`data: ${JSON.stringify(dataObj)}\n\n`);
 }
 
+function buildResponsesSseItem(item, fallbackId) {
+    const source = isRecord(item) ? item : {};
+    const itemId = asTrimmedString(source.id || source.call_id) || fallbackId || `item_${crypto.randomBytes(8).toString('hex')}`;
+    if (source.type === 'message') {
+        return {
+            ...source,
+            id: itemId,
+            role: source.role || 'assistant',
+            content: Array.isArray(source.content) ? source.content : []
+        };
+    }
+    if (source.type === 'reasoning') {
+        return {
+            ...source,
+            id: itemId,
+            summary: Array.isArray(source.summary) ? source.summary : []
+        };
+    }
+    if (source.type === 'function_call') {
+        return {
+            ...source,
+            id: itemId,
+            call_id: asTrimmedString(source.call_id) || itemId,
+            name: asTrimmedString(source.name),
+            arguments: typeof source.arguments === 'string' ? source.arguments : ''
+        };
+    }
+    if (source.type === 'custom_tool_call') {
+        return {
+            ...source,
+            id: itemId,
+            call_id: asTrimmedString(source.call_id) || itemId,
+            name: asTrimmedString(source.name),
+            input: typeof source.input === 'string' ? source.input : ''
+        };
+    }
+    return { ...source, id: itemId };
+}
+
+function emitResponsesTextPartAdded(res, itemId, outputIndex, contentIndex, nextSeq) {
+    writeSse(res, 'response.content_part.added', {
+        type: 'response.content_part.added',
+        item_id: itemId,
+        output_index: outputIndex,
+        content_index: contentIndex,
+        part: { type: 'output_text', text: '', annotations: [], logprobs: [] },
+        sequence_number: nextSeq()
+    });
+}
+
+function emitResponsesTextPartDone(res, itemId, outputIndex, contentIndex, text, nextSeq) {
+    writeSse(res, 'response.content_part.done', {
+        type: 'response.content_part.done',
+        item_id: itemId,
+        output_index: outputIndex,
+        content_index: contentIndex,
+        part: { type: 'output_text', text: typeof text === 'string' ? text : '', annotations: [], logprobs: [] },
+        sequence_number: nextSeq()
+    });
+}
+
+function emitResponsesToolArgumentEvents(res, item, outputIndex, nextSeq) {
+    const eventType = item.type === 'custom_tool_call'
+        ? 'response.custom_tool_call_input.delta'
+        : 'response.function_call_arguments.delta';
+    const doneType = item.type === 'custom_tool_call'
+        ? ''
+        : 'response.function_call_arguments.done';
+    const value = item.type === 'custom_tool_call'
+        ? (typeof item.input === 'string' ? item.input : '')
+        : (typeof item.arguments === 'string' ? item.arguments : '');
+    if (value) {
+        writeSse(res, eventType, {
+            type: eventType,
+            item_id: item.id,
+            output_index: outputIndex,
+            call_id: item.call_id,
+            name: item.name,
+            delta: value,
+            sequence_number: nextSeq()
+        });
+    }
+    if (doneType) {
+        writeSse(res, doneType, {
+            type: doneType,
+            item_id: item.id,
+            output_index: outputIndex,
+            call_id: item.call_id,
+            name: item.name,
+            arguments: value,
+            sequence_number: nextSeq()
+        });
+    }
+}
+
 function appendChatStreamToolCall(target, toolCall) {
     if (!toolCall || typeof toolCall !== 'object') return;
     const index = Number.isFinite(toolCall.index) ? toolCall.index : target.length;
@@ -1232,6 +1402,37 @@ function writeChatCompletionChunkAsResponsesSse(state, chunk) {
         const delta = choice && choice.delta && typeof choice.delta === 'object' ? choice.delta : null;
         if (!delta) continue;
 
+        const reasoningSegment = typeof delta.reasoning_content === 'string'
+            ? delta.reasoning_content
+            : (typeof delta.reasoning === 'string'
+                ? delta.reasoning
+                : (typeof delta.reasoning_text === 'string' ? delta.reasoning_text : ''));
+        if (reasoningSegment) {
+            if (!state.reasoningItem) {
+                state.reasoningItem = {
+                    id: `rs_${crypto.randomBytes(8).toString('hex')}`,
+                    type: 'reasoning',
+                    summary: [{ type: 'summary_text', text: '' }]
+                };
+                state.output.push(state.reasoningItem);
+                writeSse(state.res, 'response.output_item.added', {
+                    type: 'response.output_item.added',
+                    output_index: state.output.length - 1,
+                    item: buildResponsesSseItem(state.reasoningItem, state.reasoningItem.id)
+                });
+            }
+            state.reasoningText += reasoningSegment;
+            state.reasoningItem.summary[0].text = state.reasoningText;
+            writeSse(state.res, 'response.reasoning_summary_text.delta', {
+                type: 'response.reasoning_summary_text.delta',
+                item_id: state.reasoningItem.id,
+                output_index: state.output.indexOf(state.reasoningItem),
+                summary_index: 0,
+                delta: reasoningSegment,
+                sequence_number: state.nextSeq()
+            });
+        }
+
         const segments = [];
         // DeepSeek-style OpenAI-compatible streams may emit private reasoning in
         // `reasoning_content` before the final answer. Responses `output_text`
@@ -1252,8 +1453,9 @@ function writeChatCompletionChunkAsResponsesSse(state, chunk) {
                 writeSse(state.res, 'response.output_item.added', {
                     type: 'response.output_item.added',
                     output_index: state.output.length - 1,
-                    item: state.messageItem
+                    item: buildResponsesSseItem(state.messageItem, state.messageItem.id)
                 });
+                emitResponsesTextPartAdded(state.res, state.messageItem.id, state.output.length - 1, 0, state.nextSeq);
             }
             state.messageText += seg;
             state.messageItem.content[0].text = state.messageText;
@@ -1283,6 +1485,24 @@ function finishChatStreamResponsesSse(state) {
     if (!state || state.finished) return;
     state.finished = true;
 
+    if (state.reasoningItem) {
+        const outputIndex = state.output.indexOf(state.reasoningItem);
+        writeSse(state.res, 'response.reasoning_summary_text.done', {
+            type: 'response.reasoning_summary_text.done',
+            item_id: state.reasoningItem.id,
+            output_index: outputIndex,
+            summary_index: 0,
+            text: state.reasoningText,
+            sequence_number: state.nextSeq()
+        });
+        writeSse(state.res, 'response.output_item.done', {
+            type: 'response.output_item.done',
+            output_index: outputIndex,
+            item: buildResponsesSseItem(state.reasoningItem, state.reasoningItem.id),
+            sequence_number: state.nextSeq()
+        });
+    }
+
     if (state.messageItem) {
         const outputIndex = state.output.indexOf(state.messageItem);
         writeSse(state.res, 'response.output_text.done', {
@@ -1293,10 +1513,11 @@ function finishChatStreamResponsesSse(state) {
             text: state.messageText,
             sequence_number: state.nextSeq()
         });
+        emitResponsesTextPartDone(state.res, state.messageItem.id, outputIndex, 0, state.messageText, state.nextSeq);
         writeSse(state.res, 'response.output_item.done', {
             type: 'response.output_item.done',
             output_index: outputIndex,
-            item: state.messageItem,
+            item: buildResponsesSseItem(state.messageItem, state.messageItem.id),
             sequence_number: state.nextSeq()
         });
     }
@@ -1310,12 +1531,13 @@ function finishChatStreamResponsesSse(state) {
         writeSse(state.res, 'response.output_item.added', {
             type: 'response.output_item.added',
             output_index: outputIndex,
-            item
+            item: buildResponsesSseItem(item, item.call_id)
         });
+        emitResponsesToolArgumentEvents(state.res, buildResponsesSseItem(item, item.call_id), outputIndex, state.nextSeq);
         writeSse(state.res, 'response.output_item.done', {
             type: 'response.output_item.done',
             output_index: outputIndex,
-            item,
+            item: buildResponsesSseItem(item, item.call_id),
             sequence_number: state.nextSeq()
         });
     }
@@ -1485,6 +1707,8 @@ function streamChatCompletionsAsResponsesSse(targetUrl, options = {}) {
                 output: [],
                 messageItem: null,
                 messageText: '',
+                reasoningItem: null,
+                reasoningText: '',
                 toolCalls: [],
                 toolTypesByName: options.toolTypesByName || {},
                 finished: false,
@@ -2012,7 +2236,7 @@ function createOpenaiBridgeHttpHandler(options = {}) {
                     ? { ok: false, status: 404, bodyText: '' }
                     : await retryTransientRequest(() => streamResponsesSse(upstreamResponsesUrl, {
                         method: 'POST',
-                        body: responsesRequest,
+                        body: normalizeResponsesPayloadForUpstream(responsesRequest, true),
                         headers: codexHeaders,
                         timeoutMs: streamTimeoutMs,
                         maxBytes: maxUpstreamBytes,