@sema-agent/core 1.294.0 → 1.296.0

package/dist/brain/openai.js

@@ -258,324 +258,354 @@ function computeUsage(model, raw) {
         cost: { input: costInput, output: costOutput, cacheRead: 0, cacheWrite: 0, total: costInput + costOutput },
     };
 }
+export function inferMaxTokensField(modelId) {
+    const id = modelId.toLowerCase();
+    if (/^gpt-5/.test(id) || /^chatgpt-4o/.test(id) || /^o[134](?:$|[-.])/.test(id))
+        return "max_completion_tokens";
+    return "max_tokens";
+}
 export function createOpenAIBrain(config = {}) {
     const doFetch = config.fetchImpl ?? fetch;
-    const stream = (model, context, options) => runStreamingBrain({
-        model,
-        doFetch,
-        signal: options?.signal,
-        config,
-        httpLabel: "gateway",
-        buildRequest: () => {
-            const apiKey = options?.apiKey ?? config.apiKey;
-            const root = (model.baseUrl || config.baseUrl || "").replace(/\/+$/, "");
-            if (!root) {
-                throw new Error("createOpenAIBrain: no baseUrl configured (set config.baseUrl or model.baseUrl)");
-            }
-            const body = {
-                model: model.id,
-                messages: toOpenAIMessages(context, config.replayThinking, model),
-                stream: true,
-                stream_options: { include_usage: true },
-            };
-            const tools = toOpenAITools(context);
-            if (tools)
-                body.tools = tools;
-            if (options?.temperature !== undefined)
-                body.temperature = options.temperature;
-            if (options?.maxTokens !== undefined) {
-                const mtField = (model.compat ?? {}).maxTokensField;
-                body[mtField ?? "max_tokens"] = options.maxTokens;
-            }
-            if (options?.stop)
-                body.stop = options.stop;
-            applyThinking(body, model, options?.reasoning);
-            const headers = {
-                ...model.headers,
-                ...config.headers,
-                ...options?.headers,
-            };
-            headers["content-type"] = "application/json";
-            if (apiKey)
-                headers["authorization"] = `Bearer ${apiKey}`;
-            return { url: `${root}/chat/completions`, headers, body: JSON.stringify(applyExtraBody(body, model.extraBody, OPENAI_RESERVED)) };
-        },
-        makeParser: (ctrl) => {
-            const { out, partial } = ctrl;
-            let accumText = "";
-            let accumReasoning = "";
-            let accumRefusal = "";
-            let degenerate = false;
-            let degenFace;
-            let repCut;
-            const repSpared = new Map();
-            const pollRepetition = (text) => {
-                const insp = inspectDegenerate(text);
-                for (const s of insp.spared) {
-                    const k = `${s.rule} ${s.segment}`;
-                    const prev = repSpared.get(k);
-                    if (prev === undefined)
-                        repSpared.set(k, s);
-                    else if (s.reps > prev.reps)
-                        prev.reps = s.reps;
-                }
-                if (insp.degenerate)
-                    repCut = insp.cut;
-                return insp.degenerate;
-            };
-            let walltimeCut = false;
-            const callDeadlineMs = options?.callDeadlineMs;
-            let lastDegenCheck = 0;
-            let lastDegenCheckReasoning = 0;
-            const detectRep = config.detectRepetition !== false;
-            let emittedTextStart = false;
-            let emittedThinkingStart = false;
-            let thinkingClosed = false;
-            let textIndex = 0;
-            const toolAccum = new Map();
-            let finishReason = null;
-            let usageRaw;
-            const thinkingBlock = { type: "thinking", thinking: "" };
-            const textBlock = { type: "text", text: "" };
-            const pushReasoningDelta = (delta) => {
-                if (!delta)
-                    return;
-                ctrl.sawContentToken();
-                if (thinkingClosed)
-                    return;
-                if (!emittedThinkingStart) {
-                    emittedThinkingStart = true;
-                    partial.content = [thinkingBlock];
-                    out.push({ type: "thinking_start", contentIndex: 0, partial: { ...partial } });
-                }
-                accumReasoning += delta;
-                thinkingBlock.thinking = accumReasoning;
-                out.push({ type: "thinking_delta", contentIndex: 0, delta, partial: { ...partial } });
-                if (detectRep && !degenerate && accumReasoning.length - lastDegenCheckReasoning >= 64) {
-                    lastDegenCheckReasoning = accumReasoning.length;
-                    if (pollRepetition(accumReasoning)) {
-                        degenerate = true;
-                        degenFace = "reasoning";
-                        ctrl.cancel();
-                    }
+    const stream = (model, context, options) => {
+        let sentMaxTokens;
+        let sentMaxTokensLane = "unset";
+        return runStreamingBrain({
+            model,
+            doFetch,
+            signal: options?.signal,
+            config,
+            httpLabel: "gateway",
+            callDeadlineMs: options?.callDeadlineMs,
+            stallTimeouts: options?.stallTimeouts,
+            buildRequest: () => {
+                const apiKey = options?.apiKey ?? config.apiKey;
+                const root = (model.baseUrl || config.baseUrl || "").replace(/\/+$/, "");
+                if (!root) {
+                    throw new Error("createOpenAIBrain: no baseUrl configured (set config.baseUrl or model.baseUrl)");
                 }
-            };
-            const closeThinking = () => {
-                if (emittedThinkingStart && !thinkingClosed) {
-                    thinkingClosed = true;
-                    out.push({ type: "thinking_end", contentIndex: 0, content: accumReasoning, partial: { ...partial } });
+                const body = {
+                    model: model.id,
+                    messages: toOpenAIMessages(context, config.replayThinking, model),
+                    stream: true,
+                    stream_options: { include_usage: true },
+                };
+                const tools = toOpenAITools(context);
+                if (tools)
+                    body.tools = tools;
+                if (options?.temperature !== undefined)
+                    body.temperature = options.temperature;
+                const requestedMaxTokens = options?.maxTokens ?? model.maxTokens;
+                if (requestedMaxTokens !== undefined) {
+                    const declared = (model.compat ?? {}).maxTokensField;
+                    const mtField = declared ?? inferMaxTokensField(model.id);
+                    const capped = Math.max(1, requestedMaxTokens);
+                    body[mtField] = capped;
+                    sentMaxTokens = capped;
+                    sentMaxTokensLane = options?.maxTokens !== undefined ? "options" : "model";
                 }
-            };
-            const pushTextDelta = (delta) => {
-                if (!delta)
-                    return;
-                ctrl.sawContentToken();
-                if (!emittedTextStart) {
-                    closeThinking();
-                    emittedTextStart = true;
-                    textIndex = emittedThinkingStart ? 1 : 0;
-                    partial.content = [textBlock];
-                    out.push({ type: "text_start", contentIndex: textIndex, partial: { ...partial } });
+                else {
+                    sentMaxTokens = undefined;
+                    sentMaxTokensLane = "unset";
                 }
-                accumText += delta;
-                textBlock.text = accumText;
-                out.push({ type: "text_delta", contentIndex: textIndex, delta, partial: { ...partial } });
-                if (detectRep && !degenerate && accumText.length - lastDegenCheck >= 64) {
-                    lastDegenCheck = accumText.length;
-                    if (pollRepetition(accumText)) {
-                        degenerate = true;
-                        degenFace = "text";
-                        ctrl.cancel();
+                if (options?.stop)
+                    body.stop = options.stop;
+                applyThinking(body, model, options?.reasoning);
+                const headers = {
+                    ...model.headers,
+                    ...config.headers,
+                    ...options?.headers,
+                };
+                headers["content-type"] = "application/json";
+                if (apiKey)
+                    headers["authorization"] = `Bearer ${apiKey}`;
+                return { url: `${root}/chat/completions`, headers, body: JSON.stringify(applyExtraBody(body, model.extraBody, OPENAI_RESERVED)) };
+            },
+            makeParser: (ctrl) => {
+                const { out, partial } = ctrl;
+                let accumText = "";
+                let accumReasoning = "";
+                let accumRefusal = "";
+                let degenerate = false;
+                let degenFace;
+                let repCut;
+                const repSpared = new Map();
+                const pollRepetition = (text) => {
+                    const insp = inspectDegenerate(text);
+                    for (const s of insp.spared) {
+                        const k = `${s.rule} ${s.segment}`;
+                        const prev = repSpared.get(k);
+                        if (prev === undefined)
+                            repSpared.set(k, s);
+                        else if (s.reps > prev.reps)
+                            prev.reps = s.reps;
                     }
-                }
-            };
-            return {
-                snapshot() {
-                    const hasCompletedToolCall = [...toolAccum.values()].some((a) => a.closedTc !== undefined);
-                    const hasSubstantiveText = accumText.trim() !== "" || accumRefusal.trim() !== "";
-                    return {
-                        hasSubstantiveText,
-                        hasCompletedToolCall,
-                        hasOnlyThinking: accumReasoning.length > 0 && !hasSubstantiveText && !hasCompletedToolCall,
-                    };
-                },
-                sealForRetry() {
-                    closeThinking();
-                },
-                onLine(rawLine) {
-                    if (callDeadlineMs !== undefined && !walltimeCut && !degenerate && Date.now() >= callDeadlineMs) {
-                        walltimeCut = true;
-                        ctrl.cancel();
-                        return;
-                    }
-                    if (walltimeCut)
-                        return;
-                    const line = rawLine.trim();
-                    if (!line.startsWith("data:"))
+                    if (insp.degenerate)
+                        repCut = insp.cut;
+                    return insp.degenerate;
+                };
+                let walltimeCut = false;
+                const callDeadlineMs = options?.callDeadlineMs;
+                let lastDegenCheck = 0;
+                let lastDegenCheckReasoning = 0;
+                const detectRep = config.detectRepetition !== false;
+                let emittedTextStart = false;
+                let emittedThinkingStart = false;
+                let thinkingClosed = false;
+                let textIndex = 0;
+                const toolAccum = new Map();
+                let finishReason = null;
+                let usageRaw;
+                const thinkingBlock = { type: "thinking", thinking: "" };
+                const textBlock = { type: "text", text: "" };
+                const pushReasoningDelta = (delta) => {
+                    if (!delta)
                         return;
-                    const data = line.slice(5).trim();
-                    if (!data || data === "[DONE]")
+                    ctrl.sawContentToken();
+                    if (thinkingClosed)
                         return;
-                    let chunk;
-                    try {
-                        chunk = JSON.parse(data);
+                    if (!emittedThinkingStart) {
+                        emittedThinkingStart = true;
+                        partial.content = [thinkingBlock];
+                        out.push({ type: "thinking_start", contentIndex: 0, partial: { ...partial } });
                     }
-                    catch {
-                        return;
+                    accumReasoning += delta;
+                    thinkingBlock.thinking = accumReasoning;
+                    out.push({ type: "thinking_delta", contentIndex: 0, delta, partial: { ...partial } });
+                    if (detectRep && !degenerate && accumReasoning.length - lastDegenCheckReasoning >= 64) {
+                        lastDegenCheckReasoning = accumReasoning.length;
+                        if (pollRepetition(accumReasoning)) {
+                            degenerate = true;
+                            degenFace = "reasoning";
+                            ctrl.cancel();
+                        }
+                    }
+                };
+                const closeThinking = () => {
+                    if (emittedThinkingStart && !thinkingClosed) {
+                        thinkingClosed = true;
+                        out.push({ type: "thinking_end", contentIndex: 0, content: accumReasoning, partial: { ...partial } });
                     }
-                    if (chunk.usage)
-                        usageRaw = chunk.usage;
-                    const choice = chunk.choices?.[0];
-                    if (!choice)
+                };
+                const pushTextDelta = (delta) => {
+                    if (!delta)
                         return;
-                    if (choice.finish_reason)
-                        finishReason = choice.finish_reason;
-                    const delta = choice.delta;
-                    if (delta?.reasoning)
-                        pushReasoningDelta(delta.reasoning);
-                    else if (delta?.reasoning_content)
-                        pushReasoningDelta(delta.reasoning_content);
-                    if (delta?.refusal) {
-                        ctrl.sawContentToken();
-                        accumRefusal += delta.refusal;
+                    ctrl.sawContentToken();
+                    if (!emittedTextStart) {
+                        closeThinking();
+                        emittedTextStart = true;
+                        textIndex = emittedThinkingStart ? 1 : 0;
+                        partial.content = [textBlock];
+                        out.push({ type: "text_start", contentIndex: textIndex, partial: { ...partial } });
+                    }
+                    accumText += delta;
+                    textBlock.text = accumText;
+                    out.push({ type: "text_delta", contentIndex: textIndex, delta, partial: { ...partial } });
+                    if (detectRep && !degenerate && accumText.length - lastDegenCheck >= 64) {
+                        lastDegenCheck = accumText.length;
+                        if (pollRepetition(accumText)) {
+                            degenerate = true;
+                            degenFace = "text";
+                            ctrl.cancel();
+                        }
                     }
-                    if (delta?.content)
-                        pushTextDelta(delta.content);
-                    if (delta?.tool_calls) {
-                        ctrl.sawContentToken();
-                        for (const tc of delta.tool_calls) {
-                            const idx = tc.index ?? (tc.id ? toolAccum.size : Math.max(0, toolAccum.size - 1));
-                            if (!toolAccum.has(idx)) {
-                                for (const [prevIdx, prevAcc] of [...toolAccum.entries()].sort((a, b) => a[0] - b[0])) {
-                                    if (prevIdx >= idx || prevAcc.closedTc)
-                                        continue;
-                                    if (prevAcc.args === "")
-                                        continue;
-                                    const closed = closeToolCallAccum(prevAcc);
-                                    if (closed) {
-                                        out.push({ type: "toolcall_end", contentIndex: prevIdx, toolCall: closed, partial: { ...partial } });
+                };
+                return {
+                    snapshot() {
+                        const hasCompletedToolCall = [...toolAccum.values()].some((a) => a.closedTc !== undefined);
+                        const hasSubstantiveText = accumText.trim() !== "" || accumRefusal.trim() !== "";
+                        return {
+                            hasSubstantiveText,
+                            hasCompletedToolCall,
+                            hasOnlyThinking: accumReasoning.length > 0 && !hasSubstantiveText && !hasCompletedToolCall,
+                        };
+                    },
+                    sealForRetry() {
+                        closeThinking();
+                    },
+                    onDeadline() {
+                        if (degenerate)
+                            return false;
+                        walltimeCut = true;
+                        return true;
+                    },
+                    onLine(rawLine) {
+                        if (callDeadlineMs !== undefined && !walltimeCut && !degenerate && Date.now() >= callDeadlineMs) {
+                            walltimeCut = true;
+                            ctrl.cancel();
+                            return;
+                        }
+                        if (walltimeCut)
+                            return;
+                        const line = rawLine.trim();
+                        if (!line.startsWith("data:"))
+                            return;
+                        const data = line.slice(5).trim();
+                        if (!data || data === "[DONE]")
+                            return;
+                        let chunk;
+                        try {
+                            chunk = JSON.parse(data);
+                        }
+                        catch {
+                            return;
+                        }
+                        if (chunk.usage)
+                            usageRaw = chunk.usage;
+                        const choice = chunk.choices?.[0];
+                        if (!choice)
+                            return;
+                        if (choice.finish_reason)
+                            finishReason = choice.finish_reason;
+                        const delta = choice.delta;
+                        if (delta?.reasoning)
+                            pushReasoningDelta(delta.reasoning);
+                        else if (delta?.reasoning_content)
+                            pushReasoningDelta(delta.reasoning_content);
+                        if (delta?.refusal) {
+                            ctrl.sawContentToken();
+                            accumRefusal += delta.refusal;
+                        }
+                        if (delta?.content)
+                            pushTextDelta(delta.content);
+                        if (delta?.tool_calls) {
+                            ctrl.sawContentToken();
+                            for (const tc of delta.tool_calls) {
+                                const idx = tc.index ?? (tc.id ? toolAccum.size : Math.max(0, toolAccum.size - 1));
+                                if (!toolAccum.has(idx)) {
+                                    for (const [prevIdx, prevAcc] of [...toolAccum.entries()].sort((a, b) => a[0] - b[0])) {
+                                        if (prevIdx >= idx || prevAcc.closedTc)
+                                            continue;
+                                        if (prevAcc.args === "")
+                                            continue;
+                                        const closed = closeToolCallAccum(prevAcc);
+                                        if (closed) {
+                                            out.push({ type: "toolcall_end", contentIndex: prevIdx, toolCall: closed, partial: { ...partial } });
+                                        }
                                     }
                                 }
+                                const acc = toolAccum.get(idx) ?? { id: "", name: "", args: "" };
+                                if (tc.id)
+                                    acc.id = tc.id;
+                                if (tc.function?.name)
+                                    acc.name = tc.function.name;
+                                if (tc.function?.arguments && !acc.closedTc)
+                                    acc.args += tc.function.arguments;
+                                toolAccum.set(idx, acc);
                             }
-                            const acc = toolAccum.get(idx) ?? { id: "", name: "", args: "" };
-                            if (tc.id)
-                                acc.id = tc.id;
-                            if (tc.function?.name)
-                                acc.name = tc.function.name;
-                            if (tc.function?.arguments && !acc.closedTc)
-                                acc.args += tc.function.arguments;
-                            toolAccum.set(idx, acc);
                         }
-                    }
-                },
-                finalize() {
-                    closeThinking();
-                    if (emittedTextStart) {
-                        out.push({ type: "text_end", contentIndex: textIndex, content: accumText, partial: { ...partial } });
-                    }
-                    const finalContent = [];
-                    if (accumReasoning)
-                        finalContent.push({ type: "thinking", thinking: accumReasoning });
-                    const textFace = degenerate && degenFace === "text" && repCut !== undefined ? trimDegenerateTail(accumText, repCut) : accumText;
-                    if (textFace)
-                        finalContent.push({ type: "text", text: textFace });
-                    const toolCalls = [];
-                    const malformed = [];
-                    for (const acc of [...toolAccum.entries()].sort((a, b) => a[0] - b[0]).map((e) => e[1])) {
-                        if (!acc.name)
-                            continue;
-                        const tc = closeToolCallAccum(acc);
-                        if (tc) {
-                            toolCalls.push(tc);
-                            finalContent.push(tc);
-                        }
-                        else {
-                            malformed.push(`${acc.name}(${acc.args.slice(0, 200)})`);
+                    },
+                    finalize() {
+                        closeThinking();
+                        if (emittedTextStart) {
+                            out.push({ type: "text_end", contentIndex: textIndex, content: accumText, partial: { ...partial } });
                         }
-                    }
-                    if (config.repairTextToolCalls && toolCalls.length === 0 && textFace && context.tools && context.tools.length > 0) {
-                        const names = new Set(context.tools.flatMap((t) => [t.name, ...(t.aliases ?? [])]));
-                        const repaired = repairTextToolCalls(textFace, names);
-                        if (repaired.toolCalls.length > 0) {
-                            finalContent.length = 0;
-                            if (accumReasoning)
-                                finalContent.push({ type: "thinking", thinking: accumReasoning });
-                            if (repaired.cleanedText)
-                                finalContent.push({ type: "text", text: repaired.cleanedText });
-                            for (const tc of repaired.toolCalls) {
-                                finalContent.push(tc);
+                        const finalContent = [];
+                        if (accumReasoning)
+                            finalContent.push({ type: "thinking", thinking: accumReasoning });
+                        const textFace = degenerate && degenFace === "text" && repCut !== undefined ? trimDegenerateTail(accumText, repCut) : accumText;
+                        if (textFace)
+                            finalContent.push({ type: "text", text: textFace });
+                        const toolCalls = [];
+                        const malformed = [];
+                        for (const acc of [...toolAccum.entries()].sort((a, b) => a[0] - b[0]).map((e) => e[1])) {
+                            if (!acc.name)
+                                continue;
+                            const tc = closeToolCallAccum(acc);
+                            if (tc) {
                                 toolCalls.push(tc);
+                                finalContent.push(tc);
+                            }
+                            else {
+                                malformed.push(`${acc.name}(${acc.args.slice(0, 200)})`);
                             }
                         }
-                    }
-                    const toolError = malformed.length > 0
-                        ? `tool call argument(s) not valid JSON (likely truncated, finish_reason="${finishReason ?? "?"}"): ${malformed.join("; ")}`
-                        : undefined;
-                    const noUsableContent = toolCalls.length === 0 && !accumText.trim();
-                    if (toolError !== undefined) {
-                        finalContent.push({
-                            type: "text",
-                            text: `\n[note: ${malformed.length} tool call(s) were truncated (finish_reason="${finishReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
-                        });
-                    }
-                    const truncatedEmpty = finishReason === "length" && noUsableContent && !toolError;
-                    const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
-                    const safetyCut = finishReason === "content_filter";
-                    const refused = accumRefusal.trim().length > 0;
-                    const emptyNoFinish = noUsableContent && finishReason == null && !degenerate && !walltimeCut;
-                    const errorMessage = walltimeCut
-                        ? WALLTIME_CUTOFF_MESSAGE
-                        : degenerate
-                            ? DEGENERATE_MESSAGE
-                            : safetyCut
-                                ? `response cut by the provider content filter (finish_reason="content_filter") — the output was censored/truncated for policy and is unreliable`
-                                : refused
-                                    ? `response refused by the model for policy reasons: ${accumRefusal.trim()}`
-                                    : (toolError ??
-                                        (truncatedEmpty && !dynamicCut
-                                            ? accumReasoning.trim()
-                                                ? `response truncated at max_tokens (finish_reason="length") with no answer text — the model spent the whole budget on reasoning (${accumReasoning.length} reasoning chars). Raise max_tokens, or disable thinking for this task.`
-                                                : `response truncated at max_tokens (finish_reason="length") with no answer text — raise max_tokens`
-                                            : emptyNoFinish
-                                                ? `model stream ended with no content and no finish_reason — the response was lost (a torn stream or an in-band provider error frame)`
-                                                : undefined));
-                    const errored = walltimeCut ||
-                        degenerate ||
-                        safetyCut ||
-                        refused ||
-                        emptyNoFinish ||
-                        (toolError !== undefined && noUsableContent) ||
-                        (truncatedEmpty && !dynamicCut);
-                    const errorKind = !walltimeCut && !degenerate && !safetyCut && !refused && toolError === undefined && truncatedEmpty && !dynamicCut
-                        ? "length_empty"
-                        : undefined;
-                    const finalMessage = {
-                        ...partial,
-                        content: finalContent.length > 0 ? finalContent : [{ type: "text", text: "" }],
-                        stopReason: errored ? "error" : mapFinishReason(finishReason, toolCalls.length > 0),
-                        usage: computeUsage(model, usageRaw),
-                        ...(usageRaw === undefined ? { usageMissing: true } : {}),
-                        timestamp: Date.now(),
-                        ...(errorMessage ? { errorMessage } : {}),
-                        ...(errorKind ? { errorKind } : {}),
-                        ...(repCut !== undefined || repSpared.size > 0
-                            ? { repetition: { ...(repCut !== undefined ? { cut: repCut } : {}), ...(repSpared.size > 0 ? { spared: [...repSpared.values()] } : {}) } }
-                            : {}),
-                    };
-                    if (errored) {
-                        out.push({ type: "error", reason: "error", error: finalMessage });
-                    }
-                    else {
-                        out.push({
-                            type: "done",
-                            reason: finalMessage.stopReason,
-                            message: finalMessage,
-                        });
-                    }
-                },
-            };
-        },
-    });
+                        if (config.repairTextToolCalls && toolCalls.length === 0 && textFace && context.tools && context.tools.length > 0) {
+                            const names = new Set(context.tools.flatMap((t) => [t.name, ...(t.aliases ?? [])]));
+                            const repaired = repairTextToolCalls(textFace, names);
+                            if (repaired.toolCalls.length > 0) {
+                                finalContent.length = 0;
+                                if (accumReasoning)
+                                    finalContent.push({ type: "thinking", thinking: accumReasoning });
+                                if (repaired.cleanedText)
+                                    finalContent.push({ type: "text", text: repaired.cleanedText });
+                                for (const tc of repaired.toolCalls) {
+                                    finalContent.push(tc);
+                                    toolCalls.push(tc);
+                                }
+                            }
+                        }
+                        const toolError = malformed.length > 0
+                            ? `tool call argument(s) not valid JSON (likely truncated, finish_reason="${finishReason ?? "?"}"): ${malformed.join("; ")}`
+                            : undefined;
+                        const noUsableContent = toolCalls.length === 0 && !accumText.trim();
+                        if (toolError !== undefined) {
+                            finalContent.push({
+                                type: "text",
+                                text: `\n[note: ${malformed.length} tool call(s) were truncated (finish_reason="${finishReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
+                            });
+                        }
+                        const truncatedEmpty = finishReason === "length" && noUsableContent && !toolError;
+                        const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
+                        const safetyCut = finishReason === "content_filter";
+                        const refused = accumRefusal.trim().length > 0;
+                        const emptyNoFinish = noUsableContent && finishReason == null && !degenerate && !walltimeCut;
+                        const maxTokensNote = sentMaxTokens !== undefined
+                            ? `effective max_tokens=${sentMaxTokens} (from ${sentMaxTokensLane === "options" ? "options.maxTokens" : "model.maxTokens"})`
+                            : "max_tokens not set (neither options.maxTokens nor model.maxTokens — the provider's default cap applied)";
+                        const errorMessage = walltimeCut
+                            ? WALLTIME_CUTOFF_MESSAGE
+                            : degenerate
+                                ? DEGENERATE_MESSAGE
+                                : safetyCut
+                                    ? `response cut by the provider content filter (finish_reason="content_filter") — the output was censored/truncated for policy and is unreliable`
+                                    : refused
+                                        ? `response refused by the model for policy reasons: ${accumRefusal.trim()}`
+                                        : (toolError ??
+                                            (truncatedEmpty && !dynamicCut
+                                                ? accumReasoning.trim()
+                                                    ? `response truncated at max_tokens (finish_reason="length", ${maxTokensNote}) with no answer text — the model spent the whole budget on reasoning (${accumReasoning.length} reasoning chars). Raise max_tokens, or disable thinking for this task.`
+                                                    : `response truncated at max_tokens (finish_reason="length", ${maxTokensNote}) with no answer text — raise max_tokens`
+                                                : emptyNoFinish
+                                                    ? `model stream ended with no content and no finish_reason — the response was lost (a torn stream or an in-band provider error frame)`
+                                                    : undefined));
+                        const errored = walltimeCut ||
+                            degenerate ||
+                            safetyCut ||
+                            refused ||
+                            emptyNoFinish ||
+                            (toolError !== undefined && noUsableContent) ||
+                            (truncatedEmpty && !dynamicCut);
+                        const errorKind = !walltimeCut && !degenerate && !safetyCut && !refused && toolError === undefined && truncatedEmpty && !dynamicCut
+                            ? "length_empty"
+                            : undefined;
+                        const finalMessage = {
+                            ...partial,
+                            content: finalContent.length > 0 ? finalContent : [{ type: "text", text: "" }],
+                            stopReason: errored ? "error" : mapFinishReason(finishReason, toolCalls.length > 0),
+                            usage: computeUsage(model, usageRaw),
+                            ...(usageRaw === undefined ? { usageMissing: true } : {}),
+                            timestamp: Date.now(),
+                            ...(errorMessage ? { errorMessage } : {}),
+                            ...(errorKind ? { errorKind } : {}),
+                            ...(repCut !== undefined || repSpared.size > 0
+                                ? { repetition: { ...(repCut !== undefined ? { cut: repCut } : {}), ...(repSpared.size > 0 ? { spared: [...repSpared.values()] } : {}) } }
+                                : {}),
+                        };
+                        if (errored) {
+                            out.push({ type: "error", reason: "error", error: finalMessage });
+                        }
+                        else {
+                            out.push({
+                                type: "done",
+                                reason: finalMessage.stopReason,
+                                message: finalMessage,
+                            });
+                        }
+                    },
+                };
+            },
+        });
+    };
     return { stream };
 }
 //# sourceMappingURL=openai.js.map