@sema-agent/core 5.8.0 → 5.10.0

package/dist/brain/open-responses.js

@@ -0,0 +1,736 @@
+import {} from "../internal/llm.js";
+import { BrainError } from "./errors.js";
+import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
+import { createRepetitionPoll, parseStreamedToolArgs } from "./stream-shared.js";
+import { mintFallbackToolCallId } from "./tool-call-id.js";
+import { emitBrainTelemetry } from "./status-sink.js";
+import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imagesOmittedNoVisionNote, modelSupportsVision, sendableImages } from "./media-degrade.js";
+import { RESPONSES_RESERVED, applyExtraBody, stripAuthHeaders } from "./request-params.js";
+import { DEFAULT_EFFORT_LEVELS, isThinkingLevel, resolveEffort } from "./reasoning.js";
+import { runStreamingBrain } from "./stream-engine.js";
+const DEGENERATE_POLL_CHARS = 64;
+const MALFORMED_SAMPLE_CHARS = 160;
+const MALFORMED_ARGS_CHARS = 200;
+const CAPABILITY_DIAGNOSTIC_TYPE = "responses_capability";
+function responsesCompat(model) {
+    return (model.compat ?? {});
+}
+const NO_CONTENT = "(no content)";
+const DOCUMENT_OMITTED = "[PDF document omitted: PDF direct read requires an Anthropic-family model; re-Read the file (the engine will extract text/render pages when possible) or extract the text via Bash instead (e.g. `pdftotext`).]";
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((c) => c.type === "text" && typeof c.text === "string")
+        .map((c) => c.text)
+        .join("");
+}
+function functionCallOutputText(text, hasCarriedImages, original) {
+    if (text !== "")
+        return text;
+    if (hasCarriedImages)
+        return "(image attached below)";
+    return Array.isArray(original) && original.length > 0 ? "(non-text tool result omitted)" : "";
+}
+function toUserParts(content, supportsVision) {
+    if (typeof content === "string") {
+        return content === "" ? [] : [{ type: "input_text", text: content }];
+    }
+    const nDocs = content.filter((c) => c.type === "document").length;
+    if (nDocs > 0)
+        emitBrainTelemetry({ kind: "document_placeholder", count: nDocs });
+    const images = content.filter((c) => c.type === "image" && c.data !== undefined && c.mimeType !== undefined);
+    if (!supportsVision && images.length > 0)
+        emitBrainTelemetry({ kind: "vision_placeholder", count: images.length });
+    const parts = [];
+    for (const c of content) {
+        if (c.type === "text" && typeof c.text === "string" && c.text.length > 0) {
+            parts.push({ type: "input_text", text: c.text });
+        }
+        else if (c.type === "image" && c.data !== undefined && c.mimeType !== undefined) {
+            if (supportsVision)
+                parts.push({ type: "input_image", image_url: `data:${c.mimeType};base64,${c.data}` });
+        }
+        else if (c.type === "document") {
+            parts.push({ type: "input_text", text: DOCUMENT_OMITTED });
+        }
+    }
+    if (!supportsVision && images.length > 0)
+        parts.push({ type: "input_text", text: imagesOmittedNoVisionNote(images.length) });
+    return parts;
+}
+function toResponsesInput(ctx, model, replayReasoning) {
+    const supportsVision = modelSupportsVision(model);
+    const out = [];
+    let pendingImages = [];
+    const flushImages = () => {
+        if (pendingImages.length === 0)
+            return;
+        const ids = [...new Set(pendingImages.map((i) => i.toolCallId))].join(", ");
+        out.push({
+            type: "message",
+            role: "user",
+            content: [
+                { type: "input_text", text: `[Image${pendingImages.length > 1 ? "s" : ""} from tool result ${ids}]` },
+                ...pendingImages.map((i) => ({ type: "input_image", image_url: `data:${i.mimeType};base64,${i.data}` })),
+            ],
+        });
+        pendingImages = [];
+    };
+    for (const m of ctx.messages) {
+        if (m.role !== "toolResult")
+            flushImages();
+        if (m.role === "user") {
+            const parts = toUserParts(m.content, supportsVision);
+            out.push({
+                type: "message",
+                role: "user",
+                content: parts.length > 0 ? parts : [{ type: "input_text", text: NO_CONTENT }],
+            });
+        }
+        else if (m.role === "assistant") {
+            const toolCalls = m.content.filter((c) => c.type === "toolCall");
+            const thinking = m.content.filter((c) => c.type === "thinking");
+            const text = m.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("");
+            if (replayReasoning && toolCalls.length > 0) {
+                for (const t of thinking) {
+                    if (t.thinking === "")
+                        continue;
+                    out.push({
+                        type: "reasoning",
+                        ...(t.thinkingSignature !== undefined ? { id: t.thinkingSignature } : {}),
+                        content: [{ type: "reasoning_text", text: t.thinking }],
+                        summary: [],
+                    });
+                }
+            }
+            if (text !== "")
+                out.push({ type: "message", role: "assistant", content: [{ type: "output_text", text }] });
+            for (const tc of toolCalls) {
+                out.push({ type: "function_call", call_id: tc.id, name: tc.name, arguments: JSON.stringify(tc.arguments ?? {}) });
+            }
+        }
+        else if (m.role === "toolResult") {
+            const mediaImages = sendableImages(Array.isArray(m.content) ? m.content : []);
+            const rawImages = m.isError ? [] : mediaImages;
+            const images = supportsVision ? rawImages : [];
+            if (!supportsVision && rawImages.length > 0)
+                emitBrainTelemetry({ kind: "vision_placeholder", count: rawImages.length });
+            const nDocs = Array.isArray(m.content) ? m.content.filter((c) => c.type === "document").length : 0;
+            if (nDocs > 0)
+                emitBrainTelemetry({ kind: "document_placeholder", count: nDocs });
+            const baseText0 = textOf(m.content);
+            const baseText = nDocs > 0 ? (baseText0 ? `${baseText0}\n${DOCUMENT_OMITTED}` : DOCUMENT_OMITTED) : baseText0;
+            const withVisionNote = !supportsVision && rawImages.length > 0 ? (baseText ? `${baseText}\n${IMAGE_OMITTED_NO_VISION}` : IMAGE_OMITTED_NO_VISION) : baseText;
+            const errorNote = m.isError ? errorResultMediaNote({ images: mediaImages.length, documents: 0 }) : undefined;
+            const finalText = errorNote === undefined ? withVisionNote : withVisionNote ? `${withVisionNote}\n${errorNote}` : errorNote;
+            out.push({
+                type: "function_call_output",
+                call_id: m.toolCallId,
+                output: functionCallOutputText(finalText, images.length > 0, m.content),
+            });
+            for (const img of images)
+                pendingImages.push({ toolCallId: m.toolCallId, data: img.data, mimeType: img.mimeType });
+        }
+    }
+    flushImages();
+    return out;
+}
+function toResponsesTools(ctx) {
+    if (!ctx.tools || ctx.tools.length === 0)
+        return undefined;
+    return ctx.tools.map((t) => ({
+        type: "function",
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+        strict: false,
+    }));
+}
+function resolveWireEffort(model, reasoning) {
+    if (!model.reasoning || !isThinkingLevel(reasoning) || reasoning === "off")
+        return undefined;
+    const compat = responsesCompat(model);
+    if (compat.supportsReasoningEffort === false)
+        return undefined;
+    const effort = resolveEffort(reasoning, compat.reasoningEffortLevels ?? DEFAULT_EFFORT_LEVELS).effective;
+    const mapped = model.thinkingLevelMap?.[effort];
+    if (mapped === null)
+        return undefined;
+    return mapped ?? effort;
+}
+function computeUsage(model, raw) {
+    const input = raw?.input_tokens ?? 0;
+    const output = raw?.output_tokens ?? 0;
+    const total = raw?.total_tokens ?? input + output;
+    const cacheRead = raw?.input_tokens_details?.cached_tokens ?? 0;
+    const c = model.cost;
+    const costInput = (input / 1e6) * (c?.input ?? 0);
+    const costOutput = (output / 1e6) * (c?.output ?? 0);
+    return {
+        input,
+        output,
+        cacheRead,
+        cacheWrite: 0,
+        totalTokens: total,
+        cost: { input: costInput, output: costOutput, cacheRead: 0, cacheWrite: 0, total: costInput + costOutput },
+    };
+}
+function responsesErrorCode(code) {
+    switch (code) {
+        case "rate_limit_exceeded":
+            return "rate_limit";
+        case "authentication_error":
+        case "invalid_api_key":
+        case "permission_error":
+            return "auth";
+        case "invalid_request_error":
+        case "invalid_prompt":
+            return "invalid_request";
+        default:
+            return "server";
+    }
+}
+const INCOMPLETE_MAX_OUTPUT_TOKENS = "max_output_tokens";
+const INCOMPLETE_CONTENT_FILTER = "content_filter";
+function closeFunctionCall(acc) {
+    if (acc.closedTc)
+        return acc.closedTc;
+    if (!acc.name)
+        return undefined;
+    const args = parseStreamedToolArgs(acc.args);
+    if (args === undefined)
+        return undefined;
+    if (!acc.callId)
+        acc.callId = mintFallbackToolCallId("call_");
+    acc.closedTc = { type: "toolCall", id: acc.callId, name: acc.name, arguments: args };
+    return acc.closedTc;
+}
+function mapTerminalStopReason(incompleteReason, hadToolCalls) {
+    if (hadToolCalls)
+        return "toolUse";
+    if (incompleteReason === INCOMPLETE_MAX_OUTPUT_TOKENS)
+        return "length";
+    return "stop";
+}
+export function createOpenResponsesBrain(config = {}) {
+    const doFetch = config.fetchImpl ?? fetch;
+    const stream = (model, context, options) => {
+        let sentMaxTokens;
+        let sentMaxTokensLane = "unset";
+        let sentEffort;
+        return runStreamingBrain({
+            model,
+            doFetch,
+            signal: options?.signal,
+            config,
+            httpLabel: "responses",
+            stallTimeouts: options?.stallTimeouts,
+            buildRequest: () => {
+                const apiKey = options?.apiKey ?? config.apiKey;
+                const root = (model.baseUrl || config.baseUrl || "").replace(/\/+$/, "");
+                if (!root) {
+                    throw new Error("createOpenResponsesBrain: no baseUrl configured (set config.baseUrl or model.baseUrl)");
+                }
+                if (options?.stop !== undefined && options.stop.length > 0) {
+                    throw new Error("createOpenResponsesBrain: options.stop is not expressible in the Open Responses request (the wire form has no stop-sequence field); " +
+                        "remove it, or serve this model through the chat-completions lane, which does support it");
+                }
+                const requestedMaxTokens = options?.maxTokens ?? model.maxTokens;
+                const effort = resolveWireEffort(model, options?.reasoning);
+                sentEffort = effort;
+                const body = {
+                    model: model.id,
+                    input: toResponsesInput(context, model, config.replayReasoning !== false),
+                    stream: true,
+                };
+                if (context.systemPrompt)
+                    body.instructions = context.systemPrompt;
+                const tools = toResponsesTools(context);
+                if (tools)
+                    body.tools = tools;
+                if (options?.temperature !== undefined)
+                    body.temperature = options.temperature;
+                if (requestedMaxTokens !== undefined) {
+                    const capped = Math.max(1, requestedMaxTokens);
+                    body.max_output_tokens = capped;
+                    sentMaxTokens = capped;
+                    sentMaxTokensLane = options?.maxTokens !== undefined ? "options" : "model";
+                }
+                else {
+                    sentMaxTokens = undefined;
+                    sentMaxTokensLane = "unset";
+                }
+                if (effort !== undefined)
+                    body.reasoning = { effort };
+                const headers = {
+                    ...model.headers,
+                    ...config.headers,
+                    ...options?.headers,
+                };
+                if (options?.apiKey !== undefined)
+                    stripAuthHeaders(headers);
+                headers["content-type"] = "application/json";
+                if (apiKey)
+                    headers["authorization"] = `Bearer ${apiKey}`;
+                return {
+                    url: `${root}/responses`,
+                    headers,
+                    body: JSON.stringify(applyExtraBody(body, model.extraBody, RESPONSES_RESERVED)),
+                };
+            },
+            makeParser: (ctrl) => {
+                const { out, partial } = ctrl;
+                const items = new Map();
+                let usageRaw;
+                let responseId;
+                let terminalStatus;
+                let incompleteReason;
+                let accumRefusal = "";
+                const capabilityNotes = [];
+                let degenerate = false;
+                let degenFace;
+                let degenItem;
+                const rep = createRepetitionPoll();
+                let lastDegenCheckText = 0;
+                let lastDegenCheckReasoning = 0;
+                const detectRep = config.detectRepetition !== false;
+                let malformedFrames = 0;
+                let malformedSample;
+                const auditEcho = (env) => {
+                    if (env.store === true) {
+                        capabilityNotes.push("endpoint reports store=true although the request never sent `store` — server-side response state may be retained");
+                    }
+                    if (env.previous_response_id !== undefined && env.previous_response_id !== null) {
+                        capabilityNotes.push("endpoint echoed a previous_response_id although the request never sent one — the turn may have been linked server-side");
+                    }
+                    if (env.conversation !== undefined && env.conversation !== null) {
+                        capabilityNotes.push("endpoint echoed a conversation binding although the request never sent one — the turn may have been linked server-side");
+                    }
+                    if (sentEffort !== undefined) {
+                        const echoed = env.reasoning?.effort;
+                        if (echoed !== sentEffort) {
+                            capabilityNotes.push(`reasoning effort "${sentEffort}" was requested but the endpoint reports ${echoed === null || echoed === undefined ? "none" : `"${echoed}"`}`);
+                        }
+                    }
+                    if (env.parallel_tool_calls === false) {
+                        capabilityNotes.push("endpoint reports parallel_tool_calls=false — tool calls will arrive one per turn on this lane");
+                    }
+                };
+                const openItem = (index, kind, itemId) => {
+                    const acc = { kind, text: "", itemId, callId: "", name: "", args: "", closed: false };
+                    items.set(index, acc);
+                    return acc;
+                };
+                const pushReasoningDelta = (acc, index, delta) => {
+                    if (delta === "")
+                        return;
+                    ctrl.sawContentToken();
+                    if (acc.closed)
+                        return;
+                    if (!acc.block) {
+                        acc.block = { type: "thinking", thinking: "" };
+                        partial.content = [acc.block];
+                        out.push({ type: "thinking_start", contentIndex: index, partial: { ...partial } });
+                    }
+                    acc.text += delta;
+                    if (acc.block.type === "thinking")
+                        acc.block.thinking = acc.text;
+                    partial.content = [acc.block];
+                    out.push({ type: "thinking_delta", contentIndex: index, delta, partial: { ...partial } });
+                    if (detectRep && !degenerate && acc.text.length - lastDegenCheckReasoning >= DEGENERATE_POLL_CHARS) {
+                        lastDegenCheckReasoning = acc.text.length;
+                        if (rep.poll(acc.text)) {
+                            degenerate = true;
+                            degenFace = "reasoning";
+                            degenItem = acc;
+                            ctrl.cancel();
+                        }
+                    }
+                };
+                const pushTextDelta = (acc, index, delta) => {
+                    if (delta === "")
+                        return;
+                    ctrl.sawContentToken();
+                    if (acc.closed)
+                        return;
+                    if (!acc.block) {
+                        acc.block = { type: "text", text: "" };
+                        partial.content = [acc.block];
+                        out.push({ type: "text_start", contentIndex: index, partial: { ...partial } });
+                    }
+                    acc.text += delta;
+                    if (acc.block.type === "text")
+                        acc.block.text = acc.text;
+                    partial.content = [acc.block];
+                    out.push({ type: "text_delta", contentIndex: index, delta, partial: { ...partial } });
+                    if (detectRep && !degenerate && acc.text.length - lastDegenCheckText >= DEGENERATE_POLL_CHARS) {
+                        lastDegenCheckText = acc.text.length;
+                        if (rep.poll(acc.text)) {
+                            degenerate = true;
+                            degenFace = "text";
+                            degenItem = acc;
+                            ctrl.cancel();
+                        }
+                    }
+                };
+                const closeItem = (index, acc) => {
+                    if (acc.closed)
+                        return;
+                    acc.closed = true;
+                    if (acc.kind === "reasoning") {
+                        if (acc.block)
+                            out.push({ type: "thinking_end", contentIndex: index, content: acc.text, partial: { ...partial } });
+                    }
+                    else if (acc.kind === "message") {
+                        if (acc.block)
+                            out.push({ type: "text_end", contentIndex: index, content: acc.text, partial: { ...partial } });
+                    }
+                    else {
+                        const tc = closeFunctionCall(acc);
+                        if (tc)
+                            out.push({ type: "toolcall_end", contentIndex: index, toolCall: tc, partial: { ...partial } });
+                    }
+                };
+                const handleFrame = (frame) => {
+                    const type = frame.type;
+                    if (type === undefined)
+                        return;
+                    switch (type) {
+                        case "response.created": {
+                            const env = frame.response;
+                            if (env) {
+                                if (env.id !== undefined)
+                                    responseId = env.id;
+                                if (env.model !== undefined && env.model !== model.id)
+                                    partial.responseModel = env.model;
+                                auditEcho(env);
+                            }
+                            return;
+                        }
+                        case "response.output_item.added": {
+                            ctrl.sawContentToken();
+                            const index = frame.output_index;
+                            if (index === undefined)
+                                return;
+                            const itemType = frame.item?.type;
+                            const itemId = frame.item?.id ?? "";
+                            if (itemType === "reasoning") {
+                                openItem(index, "reasoning", itemId);
+                            }
+                            else if (itemType === "message") {
+                                openItem(index, "message", itemId);
+                            }
+                            else if (itemType === "function_call") {
+                                const acc = openItem(index, "function_call", itemId);
+                                acc.callId = frame.item?.call_id ?? "";
+                                acc.name = frame.item?.name ?? "";
+                                if (frame.item?.arguments)
+                                    acc.args += frame.item.arguments;
+                            }
+                            return;
+                        }
+                        case "response.reasoning_text.delta": {
+                            const index = frame.output_index;
+                            if (index === undefined || frame.delta === undefined)
+                                return;
+                            const acc = items.get(index) ?? openItem(index, "reasoning", "");
+                            pushReasoningDelta(acc, index, frame.delta);
+                            return;
+                        }
+                        case "response.output_text.delta": {
+                            const index = frame.output_index;
+                            if (index === undefined || frame.delta === undefined)
+                                return;
+                            const acc = items.get(index) ?? openItem(index, "message", "");
+                            pushTextDelta(acc, index, frame.delta);
+                            return;
+                        }
+                        case "response.refusal.delta": {
+                            if (frame.delta === undefined)
+                                return;
+                            ctrl.sawContentToken();
+                            accumRefusal += frame.delta;
+                            return;
+                        }
+                        case "response.refusal.done": {
+                            if (frame.refusal === undefined || accumRefusal !== "")
+                                return;
+                            ctrl.sawContentToken();
+                            accumRefusal = frame.refusal;
+                            return;
+                        }
+                        case "response.reasoning_text.done": {
+                            const index = frame.output_index;
+                            if (index === undefined || frame.text === undefined)
+                                return;
+                            const acc = items.get(index) ?? openItem(index, "reasoning", "");
+                            if (acc.text === "")
+                                pushReasoningDelta(acc, index, frame.text);
+                            return;
+                        }
+                        case "response.output_text.done": {
+                            const index = frame.output_index;
+                            if (index === undefined || frame.text === undefined)
+                                return;
+                            const acc = items.get(index) ?? openItem(index, "message", "");
+                            if (acc.text === "")
+                                pushTextDelta(acc, index, frame.text);
+                            return;
+                        }
+                        case "response.function_call_arguments.delta": {
+                            const index = frame.output_index;
+                            if (index === undefined || frame.delta === undefined)
+                                return;
+                            const acc = items.get(index);
+                            if (!acc || acc.kind !== "function_call")
+                                return;
+                            ctrl.sawContentToken();
+                            if (!acc.closed)
+                                acc.args += frame.delta;
+                            return;
+                        }
+                        case "response.function_call_arguments.done": {
+                            const index = frame.output_index;
+                            if (index === undefined || frame.arguments === undefined)
+                                return;
+                            const acc = items.get(index);
+                            if (!acc || acc.kind !== "function_call" || acc.closed)
+                                return;
+                            ctrl.sawContentToken();
+                            if (acc.args === "")
+                                acc.args = frame.arguments;
+                            return;
+                        }
+                        case "response.output_item.done": {
+                            const index = frame.output_index;
+                            if (index === undefined)
+                                return;
+                            const acc = items.get(index);
+                            if (!acc)
+                                return;
+                            if (acc.kind === "function_call") {
+                                if (!acc.callId && frame.item?.call_id)
+                                    acc.callId = frame.item.call_id;
+                                if (!acc.name && frame.item?.name)
+                                    acc.name = frame.item.name;
+                                if (acc.args === "" && frame.item?.arguments)
+                                    acc.args = frame.item.arguments;
+                            }
+                            if (!acc.itemId && frame.item?.id)
+                                acc.itemId = frame.item.id;
+                            closeItem(index, acc);
+                            return;
+                        }
+                        case "response.completed":
+                        case "response.incomplete": {
+                            const env = frame.response;
+                            terminalStatus = env?.status ?? (type === "response.completed" ? "completed" : "incomplete");
+                            incompleteReason = env?.incomplete_details?.reason;
+                            if (env?.usage)
+                                usageRaw = env.usage;
+                            if (env?.id !== undefined)
+                                responseId = env.id;
+                            return;
+                        }
+                        case "response.failed": {
+                            const err = frame.response?.error;
+                            throw new BrainError(responsesErrorCode(err?.code), `responses stream failed (${err?.code ?? "unknown"}): ${err?.message ?? ""}`);
+                        }
+                        case "error": {
+                            throw new BrainError(responsesErrorCode(frame.code), `responses stream error (${frame.code ?? "unknown"}): ${frame.message ?? ""}`);
+                        }
+                        default:
+                            return;
+                    }
+                };
+                return {
+                    snapshot() {
+                        const accs = [...items.values()];
+                        const hasCompletedToolCall = accs.some((a) => a.closedTc !== undefined);
+                        const hasSubstantiveText = accs.some((a) => a.kind === "message" && a.text.trim() !== "") || accumRefusal.trim() !== "";
+                        const hasReasoning = accs.some((a) => a.kind === "reasoning" && a.text.length > 0);
+                        return {
+                            hasSubstantiveText,
+                            hasCompletedToolCall,
+                            hasOnlyThinking: hasReasoning && !hasSubstantiveText && !hasCompletedToolCall,
+                        };
+                    },
+                    sealForRetry() {
+                        for (const [index, acc] of [...items.entries()].sort((a, b) => a[0] - b[0])) {
+                            if (acc.kind === "reasoning" && !acc.closed) {
+                                acc.closed = true;
+                                if (acc.block)
+                                    out.push({ type: "thinking_end", contentIndex: index, content: acc.text, partial: { ...partial } });
+                            }
+                        }
+                    },
+                    onLine(rawLine) {
+                        const line = rawLine.trim();
+                        if (!line.startsWith("data:"))
+                            return;
+                        const data = line.slice(5).trim();
+                        if (!data)
+                            return;
+                        let frame;
+                        try {
+                            frame = JSON.parse(data);
+                        }
+                        catch {
+                            malformedFrames++;
+                            malformedSample ??= data.slice(0, MALFORMED_SAMPLE_CHARS);
+                            return;
+                        }
+                        handleFrame(frame);
+                    },
+                    finalize() {
+                        for (const [index, acc] of [...items.entries()].sort((a, b) => a[0] - b[0])) {
+                            if (acc.closed)
+                                continue;
+                            if (acc.kind === "function_call") {
+                                acc.closed = true;
+                                continue;
+                            }
+                            closeItem(index, acc);
+                        }
+                        const finalContent = [];
+                        const toolCalls = [];
+                        const malformed = [];
+                        const unnamed = [];
+                        let anyText = false;
+                        let reasoningSeen = false;
+                        for (const [, acc] of [...items.entries()].sort((a, b) => a[0] - b[0])) {
+                            if (acc.kind === "reasoning") {
+                                if (acc.text.length === 0)
+                                    continue;
+                                reasoningSeen = true;
+                                finalContent.push({
+                                    type: "thinking",
+                                    thinking: acc.text,
+                                    ...(acc.itemId !== "" ? { thinkingSignature: acc.itemId } : {}),
+                                });
+                            }
+                            else if (acc.kind === "message") {
+                                const text = acc === degenItem && degenFace === "text" && rep.cut !== undefined ? trimDegenerateTail(acc.text, rep.cut) : acc.text;
+                                if (text !== "") {
+                                    finalContent.push({ type: "text", text });
+                                    if (text.trim() !== "")
+                                        anyText = true;
+                                }
+                            }
+                            else {
+                                const tc = closeFunctionCall(acc);
+                                if (tc) {
+                                    toolCalls.push(tc);
+                                    finalContent.push(tc);
+                                }
+                                else if (acc.name) {
+                                    malformed.push(`${acc.name}(${acc.args.slice(0, MALFORMED_ARGS_CHARS)})`);
+                                }
+                                else {
+                                    unnamed.push(`call_id="${acc.callId || "?"}"(${acc.args.slice(0, MALFORMED_ARGS_CHARS)})`);
+                                }
+                            }
+                        }
+                        const noUsableContent = toolCalls.length === 0 && !anyText;
+                        const terminalLabel = terminalStatus ?? "?";
+                        const toolErrorParts = [];
+                        if (malformed.length > 0) {
+                            toolErrorParts.push(`tool call argument(s) not valid JSON (likely truncated, status="${terminalLabel}"): ${malformed.join("; ")}`);
+                        }
+                        if (unnamed.length > 0) {
+                            toolErrorParts.push(`tool call(s) arrived with no tool name and cannot be executed (status="${terminalLabel}"): ${unnamed.join("; ")}`);
+                        }
+                        const toolError = toolErrorParts.length > 0 ? toolErrorParts.join(" | ") : undefined;
+                        if (malformed.length > 0) {
+                            finalContent.push({
+                                type: "text",
+                                text: `\n[note: ${malformed.length} tool call(s) were truncated (status="${terminalLabel}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
+                            });
+                        }
+                        if (unnamed.length > 0) {
+                            finalContent.push({
+                                type: "text",
+                                text: `\n[note: ${unnamed.length} tool call(s) arrived with no tool name and were dropped — re-issue them next turn with an explicit tool name: ${unnamed.join("; ")}]`,
+                            });
+                        }
+                        if (malformedFrames > 0) {
+                            finalContent.push({
+                                type: "text",
+                                text: `\n[note: ${malformedFrames} provider stream frame(s) were not valid JSON and were dropped — the streamed output may be missing content (first sample: ${JSON.stringify(malformedSample)})]`,
+                            });
+                        }
+                        const truncated = incompleteReason === INCOMPLETE_MAX_OUTPUT_TOKENS;
+                        const truncatedEmpty = truncated && noUsableContent && !toolError;
+                        const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
+                        const staticReasoningCut = truncatedEmpty && !dynamicCut && reasoningSeen && options?.staticReasoningCutDowngrade === true;
+                        const safetyCut = incompleteReason === INCOMPLETE_CONTENT_FILTER;
+                        const refused = accumRefusal.trim().length > 0;
+                        const emptyNoFinish = noUsableContent && terminalStatus === undefined && !degenerate;
+                        const maxTokensNote = sentMaxTokens !== undefined
+                            ? `effective max_output_tokens=${sentMaxTokens} (from ${sentMaxTokensLane === "options" ? "options.maxTokens" : "model.maxTokens"})`
+                            : "max_output_tokens not set (neither options.maxTokens nor model.maxTokens — the endpoint's default cap applied)";
+                        const errorMessage = degenerate
+                            ? DEGENERATE_MESSAGE
+                            : safetyCut
+                                ? `[refusal] response cut by the provider content filter (incomplete_details.reason="${INCOMPLETE_CONTENT_FILTER}") — the output was censored/truncated for policy and is unreliable`
+                                : refused
+                                    ? `[refusal] response refused by the model for policy reasons: ${accumRefusal.trim()}`
+                                    : (toolError ??
+                                        (truncatedEmpty && !dynamicCut && !staticReasoningCut
+                                            ? reasoningSeen
+                                                ? `[length_empty] response truncated at max_output_tokens (${maxTokensNote}) with no answer text — the model spent the whole budget on reasoning; raise the cap, or lower the reasoning effort for this task.`
+                                                : `[length_empty] response truncated at max_output_tokens (${maxTokensNote}) with no answer text — raise the cap`
+                                            : emptyNoFinish
+                                                ? `[stream_torn] model stream ended with no content and no terminal response event — the response was lost (a torn stream or an in-band provider error frame)${malformedFrames > 0 ? ` — ${malformedFrames} unparseable data frame(s) were dropped on this stream (first sample: ${JSON.stringify(malformedSample)})` : ""}`
+                                                : undefined));
+                        const errored = degenerate ||
+                            safetyCut ||
+                            refused ||
+                            emptyNoFinish ||
+                            (toolError !== undefined && noUsableContent) ||
+                            (truncatedEmpty && !dynamicCut && !staticReasoningCut);
+                        const errorKind = degenerate
+                            ? "degenerate"
+                            : !safetyCut && !refused && toolError === undefined && truncatedEmpty && !dynamicCut && !staticReasoningCut
+                                ? "length_empty"
+                                : undefined;
+                        const diagnostics = capabilityNotes.length > 0
+                            ? [...(partial.diagnostics ?? []), { type: CAPABILITY_DIAGNOSTIC_TYPE, timestamp: Date.now(), details: { notes: [...capabilityNotes] } }]
+                            : [];
+                        const finalMessage = {
+                            ...partial,
+                            content: finalContent.length > 0 ? finalContent : [{ type: "text", text: "" }],
+                            stopReason: errored ? "error" : mapTerminalStopReason(incompleteReason, toolCalls.length > 0),
+                            usage: computeUsage(model, usageRaw),
+                            ...(usageRaw === undefined ? { usageMissing: true } : {}),
+                            timestamp: Date.now(),
+                            ...(responseId !== undefined ? { responseId } : {}),
+                            ...(errorMessage ? { errorMessage } : {}),
+                            ...(errorKind ? { errorKind } : {}),
+                            ...(rep.cut !== undefined || rep.spared.length > 0
+                                ? { repetition: { ...(rep.cut !== undefined ? { cut: rep.cut } : {}), ...(rep.spared.length > 0 ? { spared: rep.spared } : {}) } }
+                                : {}),
+                            ...(staticReasoningCut ? { staticReasoningCut: true } : {}),
+                            ...(diagnostics.length > 0 ? { diagnostics } : {}),
+                        };
+                        if (errored) {
+                            out.push({ type: "error", reason: "error", error: finalMessage });
+                        }
+                        else {
+                            out.push({
+                                type: "done",
+                                reason: finalMessage.stopReason,
+                                message: finalMessage,
+                            });
+                        }
+                    },
+                };
+            },
+        });
+    };
+    return { stream };
+}