@ouro.bot/cli 0.1.0-alpha.723 → 0.1.0-alpha.725

package/dist/heart/streaming.js

@@ -1,80 +1,285 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESPONSES_FUNCTION_CALL_OUTPUT_CAP = exports.SettleStreamer = exports.SettleParser = void 0;
+exports.RESPONSES_FUNCTION_CALL_OUTPUT_CAP = exports.ProviderTextOutput = exports.SettleStreamer = exports.SettleParser = exports.SettleFinalizationCallbackError = void 0;
+exports.finalizeSettleStream = finalizeSettleStream;
 exports.truncateResponsesFunctionCallOutput = truncateResponsesFunctionCallOutput;
 exports.toResponsesInput = toResponsesInput;
 exports.toResponsesTools = toResponsesTools;
 exports.streamChatCompletion = streamChatCompletion;
 exports.streamResponsesApi = streamResponsesApi;
 const runtime_1 = require("../nerves/runtime");
-// Character-level state machine that extracts the answer value from
-// `settle` tool call JSON arguments as they stream in.
-// Scans for prefix `"answer":"` or `"answer": "` in the character stream,
-// then emits text handling JSON escapes, stopping at unescaped closing `"`.
+class SettleFinalizationCallbackError extends Error {
+    retryable = false;
+    cause;
+    constructor(cause) {
+        const normalized = cause instanceof Error ? cause : new Error(String(cause));
+        super(`settle finalization callback failed: ${normalized.message}`);
+        this.name = "SettleFinalizationCallbackError";
+        this.cause = normalized;
+    }
+}
+exports.SettleFinalizationCallbackError = SettleFinalizationCallbackError;
+function isJsonWhitespace(character) {
+    return character === " " || character === "\t" || character === "\n" || character === "\r";
+}
+function isHighSurrogate(character) {
+    const code = character.charCodeAt(0);
+    return code >= 0xD800 && code <= 0xDBFF;
+}
+function isLowSurrogate(character) {
+    const code = character.charCodeAt(0);
+    return code >= 0xDC00 && code <= 0xDFFF;
+}
+// Incremental JSON string decoder for the top-level `answer` property in
+// streamed settle arguments. JSON.parse remains the terminal authority; this
+// state machine exists only to emit validated string units before EOF.
 class SettleParser {
-    // Possible prefixes to match (with and without space after colon)
-    static PREFIXES = ['"answer":"', '"answer": "'];
-    // Buffer of characters seen so far (pre-activation only)
-    buf = "";
+    rawArguments = "";
     _active = false;
     _complete = false;
-    inEscape = false;
+    invalid = false;
+    terminalResult;
+    containers = [];
+    rootLastSignificant = "";
+    scanInString = false;
+    scanEscape = false;
+    scanStringRaw = "";
+    scanStringIsRootKey = false;
+    answerKeyState = "none";
+    decodeState = "normal";
+    unicodeDigits = "";
+    pendingHighSurrogate = "";
+    decodedAnswer = "";
     get active() { return this._active; }
     get complete() { return this._complete; }
     process(delta) {
-        if (this._complete)
+        if (this.terminalResult)
+            return "";
+        this.rawArguments += delta;
+        if (this._complete || this.invalid)
             return "";
         let out = "";
         for (let i = 0; i < delta.length; i++) {
             const ch = delta[i];
-            if (!this._active) {
-                this.buf += ch;
-                // Check if any prefix has been fully matched in the buffer
-                for (const prefix of SettleParser.PREFIXES) {
-                    if (this.buf.endsWith(prefix)) {
-                        this._active = true;
-                        break;
-                    }
-                }
+            if (this._active) {
+                out += this.processAnswerCharacter(ch);
             }
             else {
-                // Active: emit characters, handling JSON escapes
-                if (this.inEscape) {
-                    this.inEscape = false;
-                    switch (ch) {
-                        case '"':
-                            out += '"';
-                            break;
-                        case '\\':
-                            out += '\\';
-                            break;
-                        case 'n':
-                            out += '\n';
-                            break;
-                        case 't':
-                            out += '\t';
-                            break;
-                        case '/':
-                            out += '/';
-                            break;
-                        default:
-                            out += ch;
-                            break; // unknown escape: pass through character
+                this.scanForTopLevelAnswer(ch);
+            }
+            if (this._complete || this.invalid)
+                break;
+        }
+        return out;
+    }
+    finish() {
+        if (this.terminalResult)
+            return this.terminalResult;
+        if (this.invalid) {
+            return this.setTerminalFailure("invalid_settle_arguments");
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(this.rawArguments);
+        }
+        catch (error) {
+            const errorCode = this.isIncompleteAtEof(error)
+                ? "incomplete_settle_arguments"
+                : "invalid_settle_arguments";
+            return this.setTerminalFailure(errorCode);
+        }
+        if (typeof parsed !== "object"
+            || parsed === null
+            || Array.isArray(parsed)
+            || typeof parsed.answer !== "string"
+            || !this._active
+            || !this._complete) {
+            return this.setTerminalFailure("invalid_settle_arguments");
+        }
+        const answer = parsed.answer;
+        if (answer !== this.decodedAnswer) {
+            return this.setTerminalFailure("invalid_settle_arguments");
+        }
+        this.terminalResult = { ok: true, answer };
+        return this.terminalResult;
+    }
+    scanForTopLevelAnswer(character) {
+        if (this.scanInString) {
+            if (this.scanEscape) {
+                this.scanStringRaw += character;
+                this.scanEscape = false;
+                return;
+            }
+            if (character === "\\") {
+                this.scanStringRaw += character;
+                this.scanEscape = true;
+                return;
+            }
+            if (character !== '"') {
+                this.scanStringRaw += character;
+                return;
+            }
+            this.scanInString = false;
+            this.rootLastSignificant = '"';
+            if (this.scanStringIsRootKey) {
+                try {
+                    if (JSON.parse(`"${this.scanStringRaw}"`) === "answer") {
+                        this.answerKeyState = "after_key";
                     }
                 }
-                else if (ch === '\\') {
-                    this.inEscape = true;
-                }
-                else if (ch === '"') {
-                    this._complete = true;
-                    return out; // stop processing, closing quote found
-                }
-                else {
-                    out += ch;
+                catch {
+                    this.invalid = true;
                 }
             }
+            this.scanStringRaw = "";
+            this.scanStringIsRootKey = false;
+            return;
         }
-        return out;
+        if (this.answerKeyState === "after_key") {
+            if (isJsonWhitespace(character))
+                return;
+            if (character === ":") {
+                this.answerKeyState = "after_colon";
+                this.rootLastSignificant = character;
+                return;
+            }
+            this.invalid = true;
+            return;
+        }
+        if (this.answerKeyState === "after_colon") {
+            if (isJsonWhitespace(character))
+                return;
+            this.answerKeyState = "none";
+            if (character === '"') {
+                this._active = true;
+                this.rootLastSignificant = "value";
+                return;
+            }
+        }
+        if (isJsonWhitespace(character))
+            return;
+        const atRootObject = this.containers.length === 1 && this.containers[0] === "object";
+        if (character === '"') {
+            this.scanInString = true;
+            this.scanEscape = false;
+            this.scanStringRaw = "";
+            this.scanStringIsRootKey = atRootObject
+                && (this.rootLastSignificant === "{" || this.rootLastSignificant === ",");
+            return;
+        }
+        if (character === "{" || character === "[") {
+            if (atRootObject)
+                this.rootLastSignificant = "value";
+            this.containers.push(character === "{" ? "object" : "array");
+            if (this.containers.length === 1 && character === "{") {
+                this.rootLastSignificant = character;
+            }
+            return;
+        }
+        if (character === "}" || character === "]") {
+            const expected = character === "}" ? "object" : "array";
+            if (this.containers.at(-1) !== expected) {
+                this.invalid = true;
+                return;
+            }
+            this.containers.pop();
+            if (this.containers.length === 1 && this.containers[0] === "object") {
+                this.rootLastSignificant = "value";
+            }
+            return;
+        }
+        if (atRootObject)
+            this.rootLastSignificant = character;
+    }
+    processAnswerCharacter(character) {
+        if (this.decodeState === "unicode") {
+            if (!/^[0-9A-Fa-f]$/.test(character)) {
+                this.invalid = true;
+                return "";
+            }
+            this.unicodeDigits += character;
+            if (this.unicodeDigits.length < 4)
+                return "";
+            const decoded = String.fromCharCode(Number.parseInt(this.unicodeDigits, 16));
+            this.unicodeDigits = "";
+            this.decodeState = "normal";
+            return this.appendDecodedUnit(decoded);
+        }
+        if (this.decodeState === "escape") {
+            this.decodeState = "normal";
+            switch (character) {
+                case '"': return this.appendDecodedUnit('"');
+                case "\\": return this.appendDecodedUnit("\\");
+                case "/": return this.appendDecodedUnit("/");
+                case "b": return this.appendDecodedUnit("\b");
+                case "f": return this.appendDecodedUnit("\f");
+                case "n": return this.appendDecodedUnit("\n");
+                case "r": return this.appendDecodedUnit("\r");
+                case "t": return this.appendDecodedUnit("\t");
+                case "u":
+                    this.decodeState = "unicode";
+                    return "";
+                default:
+                    this.invalid = true;
+                    return "";
+            }
+        }
+        if (character === "\\") {
+            this.decodeState = "escape";
+            return "";
+        }
+        if (character === '"') {
+            const trailing = this.flushPendingHighSurrogate();
+            this._complete = true;
+            return trailing;
+        }
+        if (character.charCodeAt(0) <= 0x1F) {
+            this.invalid = true;
+            return "";
+        }
+        return this.appendDecodedUnit(character);
+    }
+    appendDecodedUnit(character) {
+        let out = "";
+        if (this.pendingHighSurrogate) {
+            if (isLowSurrogate(character)) {
+                const pair = this.pendingHighSurrogate + character;
+                this.pendingHighSurrogate = "";
+                this.decodedAnswer += pair;
+                return pair;
+            }
+            out = this.flushPendingHighSurrogate();
+        }
+        if (isHighSurrogate(character)) {
+            this.pendingHighSurrogate = character;
+            return out;
+        }
+        this.decodedAnswer += character;
+        return out + character;
+    }
+    flushPendingHighSurrogate() {
+        if (!this.pendingHighSurrogate)
+            return "";
+        const pending = this.pendingHighSurrogate;
+        this.pendingHighSurrogate = "";
+        this.decodedAnswer += pending;
+        return pending;
+    }
+    isIncompleteAtEof(error) {
+        if (this._active && !this._complete)
+            return true;
+        if (this.rawArguments.length === 0)
+            return true;
+        if (!(error instanceof SyntaxError))
+            return false;
+        if (/Unexpected end|Unterminated string/i.test(error.message))
+            return true;
+        const position = /position (\d+)/i.exec(error.message);
+        return position ? Number(position[1]) >= this.rawArguments.length : false;
+    }
+    setTerminalFailure(errorCode) {
+        this.terminalResult = { ok: false, errorCode };
+        return this.terminalResult;
     }
 }
 exports.SettleParser = SettleParser;
@@ -84,14 +289,23 @@ exports.SettleParser = SettleParser;
 class SettleStreamer {
     parser = new SettleParser();
     _detected = false;
+    _streamed = false;
     callbacks;
     enabled;
+    mode;
+    observedArguments = "";
+    eagerAnswer = "";
+    terminalResult;
+    cancelled = false;
     constructor(callbacks, enabled = true) {
         this.callbacks = callbacks;
         this.enabled = enabled;
+        // Production callback owners declare their mode explicitly. Retain the
+        // historical retractable default for third-party/in-test callback objects.
+        this.mode = callbacks.settleOutputMode ?? "retractable_buffer";
     }
     get detected() { return this._detected; }
-    get streamed() { return this.parser.active; }
+    get streamed() { return this._streamed; }
     /** Mark settle as detected. Calls onClearText on the callbacks. */
     activate() {
         if (!this.enabled)
@@ -99,7 +313,8 @@ class SettleStreamer {
         if (this._detected)
             return;
         this._detected = true;
-        this.callbacks.onClearText?.();
+        if (this.mode === "retractable_buffer")
+            this.callbacks.onClearText?.();
     }
     /** Feed an argument delta through the parser. Emits text via onTextChunk. */
     processDelta(delta) {
@@ -107,12 +322,115 @@ class SettleStreamer {
             return;
         if (!this._detected)
             return;
+        if (this.cancelled || this.terminalResult)
+            return;
+        this.observedArguments += delta;
         const text = this.parser.process(delta);
-        if (text)
+        if (text && this.mode === "retractable_buffer") {
             this.callbacks.onTextChunk(text);
+            this.eagerAnswer += text;
+        }
+    }
+    /** Validate the completed provider arguments exactly once, then commit or
+     * retract callback-visible output according to the callback owner's mode. */
+    finish(completedArguments) {
+        if (!this.enabled || !this._detected || this.cancelled)
+            return undefined;
+        if (this.terminalResult)
+            return this.terminalResult;
+        let finalSuffix = "";
+        let replacedObservedArguments = false;
+        if (completedArguments.startsWith(this.observedArguments)) {
+            const suffix = completedArguments.slice(this.observedArguments.length);
+            this.observedArguments = completedArguments;
+            finalSuffix = this.parser.process(suffix);
+        }
+        else {
+            // A provider may normalize or replace its streamed argument fragments in
+            // the completed tool call. Re-parse that one authoritative final value;
+            // any eager output from the divergent fragment is retracted below.
+            replacedObservedArguments = true;
+            this.parser = new SettleParser();
+            this.observedArguments = completedArguments;
+            finalSuffix = this.parser.process(completedArguments);
+        }
+        const result = this.parser.finish();
+        // Cache before invoking callbacks: a callback failure must never make a
+        // repeated finish parse or commit the answer again.
+        this.terminalResult = result;
+        if (!result.ok) {
+            if (this.mode === "retractable_buffer")
+                this.callbacks.onClearText?.();
+            return result;
+        }
+        if (this.mode === "retractable_buffer") {
+            if (replacedObservedArguments) {
+                this.callbacks.onClearText?.();
+                this.callbacks.onTextChunk(result.answer);
+            }
+            else if (finalSuffix) {
+                this.callbacks.onTextChunk(finalSuffix);
+            }
+            this._streamed = true;
+        }
+        return result;
+    }
+    /** Cancel a partial provider stream without terminal parsing or commit. */
+    cancel() {
+        if (!this.enabled || !this._detected || this.cancelled || this.terminalResult)
+            return;
+        this.cancelled = true;
+        if (this.mode === "retractable_buffer" && this.eagerAnswer) {
+            this.callbacks.onClearText?.();
+        }
     }
 }
 exports.SettleStreamer = SettleStreamer;
+function finalizeSettleStream(streamer, completedArguments) {
+    try {
+        return streamer.finish(completedArguments);
+    }
+    catch (error) {
+        throw new SettleFinalizationCallbackError(error);
+    }
+}
+/** Holds ordinary provider text until a final-only response is known not to be
+ * an invalid settle. Retractable callback owners continue receiving deltas. */
+class ProviderTextOutput {
+    callbacks;
+    bufferedText = "";
+    deferred;
+    suppressed = false;
+    constructor(callbacks) {
+        this.callbacks = callbacks;
+        this.deferred = callbacks.settleOutputMode === "final_only";
+    }
+    emit(text) {
+        if (this.suppressed)
+            return;
+        if (this.deferred) {
+            this.bufferedText += text;
+        }
+        else {
+            this.callbacks.onTextChunk(text);
+        }
+    }
+    suppress() {
+        this.bufferedText = "";
+        this.suppressed = true;
+    }
+    discard() {
+        this.bufferedText = "";
+    }
+    flush() {
+        if (!this.bufferedText)
+            return;
+        const text = this.bufferedText;
+        this.bufferedText = "";
+        this.callbacks.onTextChunk(text);
+    }
+}
+exports.ProviderTextOutput = ProviderTextOutput;
 exports.RESPONSES_FUNCTION_CALL_OUTPUT_CAP = 200_000;
 function truncateResponsesFunctionCallOutput(output, maxChars = exports.RESPONSES_FUNCTION_CALL_OUTPUT_CAP) {
     if (output.length <= maxChars)
@@ -259,6 +577,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal, eag
     let streamStarted = false;
     let usage;
     const answerStreamer = new SettleStreamer(callbacks, eagerSettleStreaming);
+    const textOutput = new ProviderTextOutput(callbacks);
     // State machine for parsing inline <think> tags (MiniMax pattern)
     let contentBuf = "";
     let inThinkTag = false;
@@ -301,7 +620,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal, eag
                 if (start !== -1) {
                     const text = contentBuf.slice(0, start);
                     if (text)
-                        callbacks.onTextChunk(text);
+                        textOutput.emit(text);
                     contentBuf = contentBuf.slice(start + OPEN_TAG.length);
                     inThinkTag = true;
                 }
@@ -316,92 +635,117 @@ async function streamChatCompletion(client, createParams, callbacks, signal, eag
                         if (retain > 0) {
                             const text = contentBuf.slice(0, -retain);
                             if (text)
-                                callbacks.onTextChunk(text);
+                                textOutput.emit(text);
                             contentBuf = contentBuf.slice(-retain);
                             return;
                         }
                     }
                     // All content, flush it
-                    callbacks.onTextChunk(contentBuf);
+                    textOutput.emit(contentBuf);
                     contentBuf = "";
                 }
             }
         }
     }
-    for await (const chunk of response) {
-        if (signal?.aborted)
-            break;
-        // Capture usage from final chunk (sent when stream_options.include_usage is true)
-        if (chunk.usage) {
-            const u = chunk.usage;
-            usage = {
-                input_tokens: u.prompt_tokens,
-                output_tokens: u.completion_tokens,
-                reasoning_tokens: u.completion_tokens_details?.reasoning_tokens ?? 0,
-                total_tokens: u.total_tokens,
-            };
-        }
-        const d = chunk.choices[0]?.delta;
-        if (!d)
-            continue;
-        // Handle reasoning_content (Azure AI models like DeepSeek-R1)
-        if (d.reasoning_content) {
-            if (!streamStarted) {
-                callbacks.onModelStreamStart();
-                streamStarted = true;
+    try {
+        for await (const chunk of response) {
+            if (signal?.aborted)
+                break;
+            // Capture usage from final chunk (sent when stream_options.include_usage is true)
+            if (chunk.usage) {
+                const u = chunk.usage;
+                usage = {
+                    input_tokens: u.prompt_tokens,
+                    output_tokens: u.completion_tokens,
+                    reasoning_tokens: u.completion_tokens_details?.reasoning_tokens ?? 0,
+                    total_tokens: u.total_tokens,
+                };
             }
-            callbacks.onReasoningChunk(d.reasoning_content);
-        }
-        if (d.content) {
-            if (!streamStarted) {
-                callbacks.onModelStreamStart();
-                streamStarted = true;
+            const d = chunk.choices[0]?.delta;
+            if (!d)
+                continue;
+            // Handle reasoning_content (Azure AI models like DeepSeek-R1)
+            if (d.reasoning_content) {
+                if (!streamStarted) {
+                    callbacks.onModelStreamStart();
+                    streamStarted = true;
+                }
+                callbacks.onReasoningChunk(d.reasoning_content);
             }
-            content += d.content;
-            contentBuf += d.content;
-            processContentBuf(false);
-        }
-        if (d.tool_calls) {
-            for (const tc of d.tool_calls) {
-                if (!toolCalls[tc.index])
-                    toolCalls[tc.index] = {
-                        id: tc.id ?? "",
-                        name: tc.function?.name ?? "",
-                        arguments: "",
-                    };
-                if (tc.id)
-                    toolCalls[tc.index].id = tc.id;
-                if (tc.function?.name) {
-                    toolCalls[tc.index].name = tc.function.name;
-                    // Detect settle tool call on first name delta.
-                    // Only activate streaming if this is the sole tool call (index 0
-                    // and no other indices seen). Mixed calls are rejected by core.ts.
-                    if (tc.function.name === "settle" && !answerStreamer.detected
-                        && tc.index === 0 && Object.keys(toolCalls).length === 1) {
-                        answerStreamer.activate();
-                    }
+            if (d.content) {
+                if (!streamStarted) {
+                    callbacks.onModelStreamStart();
+                    streamStarted = true;
                 }
-                if (tc.function?.arguments) {
-                    toolCalls[tc.index].arguments += tc.function.arguments;
-                    // Feed settle argument deltas to the parser for progressive
-                    // streaming, but only when it appears to be the sole tool call.
-                    if (answerStreamer.detected && toolCalls[tc.index].name === "settle"
-                        && Object.keys(toolCalls).length === 1) {
-                        answerStreamer.processDelta(tc.function.arguments);
+                content += d.content;
+                contentBuf += d.content;
+                processContentBuf(false);
+            }
+            if (d.tool_calls) {
+                for (const tc of d.tool_calls) {
+                    if (!toolCalls[tc.index])
+                        toolCalls[tc.index] = {
+                            id: tc.id ?? "",
+                            name: tc.function?.name ?? "",
+                            arguments: "",
+                        };
+                    if (tc.id)
+                        toolCalls[tc.index].id = tc.id;
+                    if (tc.function?.name) {
+                        toolCalls[tc.index].name = tc.function.name;
+                        // Detect settle tool call on first name delta.
+                        // Only activate streaming if this is the sole tool call (index 0
+                        // and no other indices seen). Mixed calls are rejected by core.ts.
+                        if (tc.function.name === "settle" && !answerStreamer.detected
+                            && tc.index === 0 && Object.keys(toolCalls).length === 1) {
+                            answerStreamer.activate();
+                            textOutput.suppress();
+                        }
+                    }
+                    if (tc.function?.arguments) {
+                        toolCalls[tc.index].arguments += tc.function.arguments;
+                        // Feed settle argument deltas to the parser for progressive
+                        // streaming, but only when it appears to be the sole tool call.
+                        if (answerStreamer.detected && toolCalls[tc.index].name === "settle"
+                            && Object.keys(toolCalls).length === 1) {
+                            answerStreamer.processDelta(tc.function.arguments);
+                        }
                     }
                 }
             }
         }
     }
+    catch (error) {
+        textOutput.discard();
+        answerStreamer.cancel();
+        throw error;
+    }
     // Flush any remaining buffer at end of stream
     if (contentBuf)
         processContentBuf(true);
+    const completedToolCalls = Object.values(toolCalls);
+    let settleFinalization;
+    if (signal?.aborted) {
+        textOutput.discard();
+        answerStreamer.cancel();
+    }
+    else if (completedToolCalls.length === 1
+        && completedToolCalls[0].name === "settle"
+        && answerStreamer.detected) {
+        textOutput.discard();
+        settleFinalization = finalizeSettleStream(answerStreamer, completedToolCalls[0].arguments);
+    }
+    else {
+        answerStreamer.cancel();
+        textOutput.flush();
+    }
     return {
         content,
-        toolCalls: Object.values(toolCalls),
+        toolCalls: completedToolCalls,
         outputItems: [],
         usage,
         settleStreamed: answerStreamer.streamed,
+        ...(settleFinalization ? { settleFinalization } : {}),
     };
 }
 async function streamResponsesApi(client, createParams, callbacks, signal, eagerSettleStreaming = true) {
@@ -420,84 +764,119 @@ async function streamResponsesApi(client, createParams, callbacks, signal, eager
     let currentToolCall = null;
     let usage;
     const answerStreamer = new SettleStreamer(callbacks, eagerSettleStreaming);
+    const textOutput = new ProviderTextOutput(callbacks);
     let functionCallCount = 0;
-    for await (const event of response) {
-        if (signal?.aborted)
-            break;
-        switch (event.type) {
-            case "response.output_text.delta":
-            case "response.reasoning_summary_text.delta": {
-                if (!streamStarted) {
-                    callbacks.onModelStreamStart();
-                    streamStarted = true;
-                }
-                const delta = String(event.delta);
-                if (event.type === "response.output_text.delta") {
-                    callbacks.onTextChunk(delta);
-                    content += delta;
-                }
-                else {
-                    callbacks.onReasoningChunk(delta);
-                }
+    try {
+        for await (const event of response) {
+            if (signal?.aborted)
                 break;
-            }
-            case "response.output_item.added": {
-                if (event.item?.type === "function_call") {
-                    functionCallCount++;
-                    currentToolCall = {
-                        call_id: String(event.item.call_id),
-                        name: String(event.item.name),
-                        arguments: "",
-                    };
-                    // Detect settle function call -- clear any streamed noise.
-                    // Only activate when this is the first (and so far only) function call.
-                    // Mixed calls are rejected by core.ts; no need to stream their args.
-                    if (String(event.item.name) === "settle" && functionCallCount === 1) {
-                        answerStreamer.activate();
+            switch (event.type) {
+                case "response.output_text.delta":
+                case "response.reasoning_summary_text.delta": {
+                    if (!streamStarted) {
+                        callbacks.onModelStreamStart();
+                        streamStarted = true;
+                    }
+                    const delta = String(event.delta);
+                    if (event.type === "response.output_text.delta") {
+                        textOutput.emit(delta);
+                        content += delta;
                     }
+                    else {
+                        callbacks.onReasoningChunk(delta);
+                    }
+                    break;
                 }
-                break;
-            }
-            case "response.function_call_arguments.delta": {
-                if (currentToolCall) {
-                    currentToolCall.arguments += event.delta;
-                    // Feed settle argument deltas to the parser for progressive
-                    // streaming, but only when it appears to be the sole function call.
-                    if (answerStreamer.detected && currentToolCall.name === "settle"
-                        && functionCallCount === 1) {
-                        answerStreamer.processDelta(String(event.delta));
+                case "response.output_item.added": {
+                    if (event.item?.type === "function_call") {
+                        functionCallCount++;
+                        currentToolCall = {
+                            call_id: String(event.item.call_id),
+                            name: String(event.item.name),
+                            arguments: "",
+                        };
+                        // Detect settle function call -- clear any streamed noise.
+                        // Only activate when this is the first (and so far only) function call.
+                        // Mixed calls are rejected by core.ts; no need to stream their args.
+                        if (String(event.item.name) === "settle" && functionCallCount === 1) {
+                            answerStreamer.activate();
+                            textOutput.suppress();
+                        }
                     }
+                    break;
                 }
-                break;
-            }
-            case "response.output_item.done": {
-                outputItems.push(event.item);
-                if (event.item?.type === "function_call") {
-                    toolCalls.push({
-                        id: String(event.item.call_id),
-                        name: String(event.item.name),
-                        arguments: String(event.item.arguments),
-                    });
-                    currentToolCall = null;
+                case "response.function_call_arguments.delta": {
+                    if (currentToolCall) {
+                        currentToolCall.arguments += event.delta;
+                        // Feed settle argument deltas to the parser for progressive
+                        // streaming, but only when it appears to be the sole function call.
+                        if (answerStreamer.detected && currentToolCall.name === "settle"
+                            && functionCallCount === 1) {
+                            answerStreamer.processDelta(String(event.delta));
+                        }
+                    }
+                    break;
                 }
-                break;
-            }
-            case "response.completed":
-            case "response.done": {
-                const u = event.response?.usage;
-                if (u) {
-                    usage = {
-                        input_tokens: u.input_tokens,
-                        output_tokens: u.output_tokens,
-                        reasoning_tokens: u.output_tokens_details?.reasoning_tokens ?? 0,
-                        total_tokens: u.total_tokens,
-                    };
+                case "response.output_item.done": {
+                    outputItems.push(event.item);
+                    if (event.item?.type === "function_call") {
+                        toolCalls.push({
+                            id: String(event.item.call_id),
+                            name: String(event.item.name),
+                            arguments: String(event.item.arguments),
+                        });
+                        currentToolCall = null;
+                    }
+                    break;
                 }
-                break;
+                case "response.completed":
+                case "response.done": {
+                    const u = event.response?.usage;
+                    if (u) {
+                        usage = {
+                            input_tokens: u.input_tokens,
+                            output_tokens: u.output_tokens,
+                            reasoning_tokens: u.output_tokens_details?.reasoning_tokens ?? 0,
+                            total_tokens: u.total_tokens,
+                        };
+                    }
+                    break;
+                }
+                default:
+                    // Unknown/unhandled events silently ignored
+                    break;
             }
-            default:
-                // Unknown/unhandled events silently ignored
-                break;
+        }
+    }
+    catch (error) {
+        textOutput.discard();
+        answerStreamer.cancel();
+        throw error;
+    }
+    let settleFinalization;
+    if (signal?.aborted) {
+        textOutput.discard();
+        answerStreamer.cancel();
+    }
+    else {
+        if (toolCalls.length === 0 && functionCallCount === 1 && currentToolCall?.name === "settle") {
+            toolCalls.push({
+                id: currentToolCall.call_id,
+                name: currentToolCall.name,
+                arguments: currentToolCall.arguments,
+            });
+            currentToolCall = null;
+        }
+        const completedSettle = toolCalls.length === 1 && toolCalls[0].name === "settle"
+            ? toolCalls[0]
+            : undefined;
+        if (completedSettle && answerStreamer.detected) {
+            textOutput.discard();
+            settleFinalization = finalizeSettleStream(answerStreamer, completedSettle.arguments);
+        }
+        else {
+            answerStreamer.cancel();
+            textOutput.flush();
         }
     }
     return {
@@ -506,5 +885,6 @@ async function streamResponsesApi(client, createParams, callbacks, signal, eager
         outputItems,
         usage,
         settleStreamed: answerStreamer.streamed,
+        ...(settleFinalization ? { settleFinalization } : {}),
     };
 }