@nexus-cortex/core 4.124.59 → 4.124.61

package/dist/orchestrator/APIClient.js

@@ -2122,118 +2122,16 @@ export class APIClient {
         // Capture this context before entering generator
         const self = this;
         // Create async generator that both yields chunks AND accumulates final message
-        const chunks = async function* () {
-            if (process.env.DEBUG === 'true' || process.env.DEBUG_THINKING === 'true') {
-                console.log(`[DEBUG APIClient] OpenAI request:`, JSON.stringify(openaiRequest, null, 2));
-            }
-            const stream = await client.chat.completions.create(openaiRequest);
-            let chunkCount = 0;
-            for await (const chunk of stream) {
-                if (!firstChunk)
-                    firstChunk = chunk;
-                chunkCount++;
-                if (captureStreamUsage && chunk?.usage)
-                    streamUsage = chunk.usage;
-                const delta = chunk.choices?.[0]?.delta;
-                // Debug: Log first few chunks to see what fields are present
-                if ((process.env.DEBUG === 'true' || process.env.DEBUG_THINKING === 'true') && chunkCount <= 3) {
-                    console.log(`[DEBUG APIClient] Chunk ${chunkCount} delta keys:`, delta ? Object.keys(delta) : 'null');
-                    if (delta?.reasoning_content) {
-                        console.log(`[DEBUG APIClient] Found reasoning_content in chunk ${chunkCount}`);
-                    }
-                }
-                // Extract reasoning content (for models with native interleaved thinking)
-                // XAI: chunk.choices[0].delta.reasoning_content
-                // DeepSeek: chunk.choices[0].delta.reasoning_content
-                // GPT-5: chunk.choices[0].delta.reasoning_content (when reasoning_effort != 'none')
-                if (delta?.reasoning_content) {
-                    fullReasoningContent += delta.reasoning_content;
-                    yield {
-                        type: 'content_block_delta',
-                        delta: delta.reasoning_content,
-                        data: { ...chunk, reasoning: true }
-                    };
-                }
-                // Extract regular text content
-                if (delta?.content) {
-                    fullContent += delta.content;
-                    yield {
-                        type: 'text_delta',
-                        delta: delta.content,
-                        data: chunk
-                    };
-                }
-                // Phase 2.8: Handle streaming tool_calls
-                if (delta?.tool_calls && Array.isArray(delta.tool_calls)) {
-                    for (const toolCallDelta of delta.tool_calls) {
-                        const index = toolCallDelta.index;
-                        // Initialize tool call accumulator if needed
-                        if (!accumulatedToolCalls.has(index)) {
-                            accumulatedToolCalls.set(index, { arguments: '' });
-                        }
-                        const accumulated = accumulatedToolCalls.get(index);
-                        // Accumulate tool call properties
-                        if (toolCallDelta.id) {
-                            accumulated.id = toolCallDelta.id;
-                        }
-                        if (toolCallDelta.function?.name) {
-                            accumulated.name = toolCallDelta.function.name;
-                        }
-                        if (toolCallDelta.function?.arguments) {
-                            accumulated.arguments += toolCallDelta.function.arguments;
-                        }
-                    }
-                }
-                // Check if finish_reason indicates tool_calls completion (or length-truncated tool call)
-                const finishReason = chunk.choices?.[0]?.finish_reason;
-                if (finishReason)
-                    lastFinishReason = String(finishReason);
-                if ((finishReason === 'tool_calls' || finishReason === 'length') && accumulatedToolCalls.size > 0) {
-                    // Emit tool_use_complete events for each accumulated tool call
-                    for (const [_, toolCall] of accumulatedToolCalls) {
-                        if (toolCall.id && toolCall.name) {
-                            try {
-                                let input;
-                                try {
-                                    input = JSON.parse(toolCall.arguments);
-                                }
-                                catch {
-                                    input = self.repairTruncatedJSON(toolCall.arguments);
-                                }
-                                const decodedInput = self.decodeHtmlEntitiesInObject(input);
-                                yield {
-                                    type: 'tool_use_complete',
-                                    toolUse: {
-                                        id: toolCall.id,
-                                        name: toolCall.name,
-                                        input: decodedInput
-                                    },
-                                    data: chunk
-                                };
-                            }
-                            catch (error) {
-                                console.error(`[APIClient] Failed to parse tool arguments (${toolCall.arguments.length} chars): ${toolCall.arguments.slice(0, 200)}...`);
-                            }
-                        }
-                    }
-                }
-            }
-            // Stream complete - log summary
-            if (process.env.DEBUG === 'true' || process.env.DEBUG_THINKING === 'true') {
-                console.log(`[DEBUG APIClient] Stream complete - total chunks: ${chunkCount}, reasoning content length: ${fullReasoningContent.length}, content length: ${fullContent.length}`);
-            }
-            // Stream complete - resolve final message in OpenAI Chat Completions format
-            // Include accumulated tool_calls in the final message
-            const finalToolCalls = Array.from(accumulatedToolCalls.values())
-                .filter(tc => tc.id && tc.name)
-                .map(tc => ({
-                id: tc.id,
-                type: 'function',
-                function: {
-                    name: tc.name,
-                    arguments: tc.arguments
-                }
-            }));
+        // R238 (2026-10-06): `finalMessage` used to resolve ONLY at the natural end of the stream — a consumer that broke out of `chunks`
+        // (abort, tail-loop guard, ESC) or a stream that threw left the promise pending forever. Any early exit now settles it with the
+        // PARTIAL message (finish_reason 'aborted', content/reasoning/tool_calls accumulated so far, x_partial: true, an estimated output-token
+        // count for accounting since the provider's usage chunk never arrives). The natural-end path is byte-identical.
+        let streamCompletedNaturally = false;
+        let streamError = undefined;
+        const resolvePartial = () => {
+            const partialToolCalls = Array.from(accumulatedToolCalls.values())
+                .filter((tc) => tc.id && tc.name)
+                .map((tc) => ({ id: tc.id, type: 'function', function: { name: tc.name, arguments: tc.arguments } }));
             finalMessageResolve({
                 id: firstChunk?.id || 'chatcmpl-' + Date.now(),
                 object: 'chat.completion',
@@ -2245,14 +2143,158 @@ export class APIClient {
                             role: 'assistant',
                             content: fullContent || null,
                             ...(fullReasoningContent && { reasoning_content: fullReasoningContent }),
-                            ...(finalToolCalls.length > 0 && { tool_calls: finalToolCalls })
+                            ...(partialToolCalls.length > 0 && { tool_calls: partialToolCalls })
                         },
-                        // R153: tool calls keep 'tool_calls' (downstream contract); otherwise report what the provider said
-                        // ('length' = output cap hit) instead of a synthetic 'stop'.
-                        finish_reason: finalToolCalls.length > 0 ? 'tool_calls' : (lastFinishReason ?? 'stop')
+                        finish_reason: 'aborted'
                     }],
-                usage: streamFinalUsage(streamUsage)
+                usage: streamFinalUsage(streamUsage),
+                x_partial: true,
+                x_estimated_output_tokens: Math.round((fullContent.length + fullReasoningContent.length) / 4),
+                ...(streamError !== undefined ? { x_error: String(streamError?.message ?? streamError).slice(0, 300) } : {}),
             });
+        };
+        const chunks = async function* () {
+            try {
+                if (process.env.DEBUG === 'true' || process.env.DEBUG_THINKING === 'true') {
+                    console.log(`[DEBUG APIClient] OpenAI request:`, JSON.stringify(openaiRequest, null, 2));
+                }
+                const stream = await client.chat.completions.create(openaiRequest);
+                let chunkCount = 0;
+                for await (const chunk of stream) {
+                    if (!firstChunk)
+                        firstChunk = chunk;
+                    chunkCount++;
+                    if (captureStreamUsage && chunk?.usage)
+                        streamUsage = chunk.usage;
+                    const delta = chunk.choices?.[0]?.delta;
+                    // Debug: Log first few chunks to see what fields are present
+                    if ((process.env.DEBUG === 'true' || process.env.DEBUG_THINKING === 'true') && chunkCount <= 3) {
+                        console.log(`[DEBUG APIClient] Chunk ${chunkCount} delta keys:`, delta ? Object.keys(delta) : 'null');
+                        if (delta?.reasoning_content) {
+                            console.log(`[DEBUG APIClient] Found reasoning_content in chunk ${chunkCount}`);
+                        }
+                    }
+                    // Extract reasoning content (for models with native interleaved thinking)
+                    // XAI: chunk.choices[0].delta.reasoning_content
+                    // DeepSeek: chunk.choices[0].delta.reasoning_content
+                    // GPT-5: chunk.choices[0].delta.reasoning_content (when reasoning_effort != 'none')
+                    if (delta?.reasoning_content) {
+                        fullReasoningContent += delta.reasoning_content;
+                        yield {
+                            type: 'content_block_delta',
+                            delta: delta.reasoning_content,
+                            data: { ...chunk, reasoning: true }
+                        };
+                    }
+                    // Extract regular text content
+                    if (delta?.content) {
+                        fullContent += delta.content;
+                        yield {
+                            type: 'text_delta',
+                            delta: delta.content,
+                            data: chunk
+                        };
+                    }
+                    // Phase 2.8: Handle streaming tool_calls
+                    if (delta?.tool_calls && Array.isArray(delta.tool_calls)) {
+                        for (const toolCallDelta of delta.tool_calls) {
+                            const index = toolCallDelta.index;
+                            // Initialize tool call accumulator if needed
+                            if (!accumulatedToolCalls.has(index)) {
+                                accumulatedToolCalls.set(index, { arguments: '' });
+                            }
+                            const accumulated = accumulatedToolCalls.get(index);
+                            // Accumulate tool call properties
+                            if (toolCallDelta.id) {
+                                accumulated.id = toolCallDelta.id;
+                            }
+                            if (toolCallDelta.function?.name) {
+                                accumulated.name = toolCallDelta.function.name;
+                            }
+                            if (toolCallDelta.function?.arguments) {
+                                accumulated.arguments += toolCallDelta.function.arguments;
+                            }
+                        }
+                    }
+                    // Check if finish_reason indicates tool_calls completion (or length-truncated tool call)
+                    const finishReason = chunk.choices?.[0]?.finish_reason;
+                    if (finishReason)
+                        lastFinishReason = String(finishReason);
+                    if ((finishReason === 'tool_calls' || finishReason === 'length') && accumulatedToolCalls.size > 0) {
+                        // Emit tool_use_complete events for each accumulated tool call
+                        for (const [_, toolCall] of accumulatedToolCalls) {
+                            if (toolCall.id && toolCall.name) {
+                                try {
+                                    let input;
+                                    try {
+                                        input = JSON.parse(toolCall.arguments);
+                                    }
+                                    catch {
+                                        input = self.repairTruncatedJSON(toolCall.arguments);
+                                    }
+                                    const decodedInput = self.decodeHtmlEntitiesInObject(input);
+                                    yield {
+                                        type: 'tool_use_complete',
+                                        toolUse: {
+                                            id: toolCall.id,
+                                            name: toolCall.name,
+                                            input: decodedInput
+                                        },
+                                        data: chunk
+                                    };
+                                }
+                                catch (error) {
+                                    console.error(`[APIClient] Failed to parse tool arguments (${toolCall.arguments.length} chars): ${toolCall.arguments.slice(0, 200)}...`);
+                                }
+                            }
+                        }
+                    }
+                }
+                // Stream complete - log summary
+                if (process.env.DEBUG === 'true' || process.env.DEBUG_THINKING === 'true') {
+                    console.log(`[DEBUG APIClient] Stream complete - total chunks: ${chunkCount}, reasoning content length: ${fullReasoningContent.length}, content length: ${fullContent.length}`);
+                }
+                // Stream complete - resolve final message in OpenAI Chat Completions format
+                // Include accumulated tool_calls in the final message
+                const finalToolCalls = Array.from(accumulatedToolCalls.values())
+                    .filter(tc => tc.id && tc.name)
+                    .map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: {
+                        name: tc.name,
+                        arguments: tc.arguments
+                    }
+                }));
+                finalMessageResolve({
+                    id: firstChunk?.id || 'chatcmpl-' + Date.now(),
+                    object: 'chat.completion',
+                    created: firstChunk?.created || Math.floor(Date.now() / 1000),
+                    model: firstChunk?.model || request.modelId,
+                    choices: [{
+                            index: 0,
+                            message: {
+                                role: 'assistant',
+                                content: fullContent || null,
+                                ...(fullReasoningContent && { reasoning_content: fullReasoningContent }),
+                                ...(finalToolCalls.length > 0 && { tool_calls: finalToolCalls })
+                            },
+                            // R153: tool calls keep 'tool_calls' (downstream contract); otherwise report what the provider said
+                            // ('length' = output cap hit) instead of a synthetic 'stop'.
+                            finish_reason: finalToolCalls.length > 0 ? 'tool_calls' : (lastFinishReason ?? 'stop')
+                        }],
+                    usage: streamFinalUsage(streamUsage)
+                });
+                streamCompletedNaturally = true;
+            }
+            catch (err) {
+                streamError = err;
+                throw err; // the chunk consumer still sees the error, as before
+            }
+            finally {
+                if (!streamCompletedNaturally)
+                    resolvePartial(); // R238: abort / early return / throw → settle with the partial message
+            }
         }();
         return {
             chunks,