@sema-agent/core 1.279.0

package/dist/brain/model-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-presets.d.ts","sourceRoot":"","sources":["../../src/brain/model-presets.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,uBAAuB,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AASzE,eAAO,MAAM,cAAc,EAAE,uBAI5B,CAAC;AAQF,eAAO,MAAM,uBAAuB,EAAE,MAAM,EAO3C,CAAC;AAQF,wBAAgB,WAAW,CAAC,SAAS,GAAE,OAAO,CAAC,KAAK,CAAM,GAAG,KAAK,CAoBjE"}

package/dist/brain/model-presets.js

@@ -0,0 +1,30 @@
+export const FABLE_5_COMPAT = {
+    thinkingMode: "adaptive",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    supportsTemperature: false,
+};
+export const FABLE_5_PROMPT_GUIDANCE = [
+    "Your final message of a turn is the only text the caller is guaranteed to read. Put every conclusion, answer, and deliverable in it — lead with the outcome, then supporting detail. Never leave a result only in an intermediate message or in your reasoning.",
+    "When operating autonomously: before ending your turn, check that the task is actually complete (not just planned); before any state-changing action, re-verify that the evidence supports that specific action rather than pattern-matching a familiar case.",
+    "When calling tools, provide exactly ONE complete JSON value per parameter — never concatenate multiple values, never truncate, never wrap a value in commentary.",
+];
+export function fable5Model(overrides = {}) {
+    return {
+        id: "claude-fable-5",
+        name: "Claude Fable 5",
+        api: "anthropic-messages",
+        provider: "anthropic",
+        baseUrl: "https://api.anthropic.com",
+        reasoning: true,
+        defaultThinking: "high",
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 1_000_000,
+        maxTokens: 64_000,
+        charsPerToken: 3,
+        compat: { ...FABLE_5_COMPAT },
+        promptGuidance: [...FABLE_5_PROMPT_GUIDANCE],
+        ...overrides,
+    };
+}
+//# sourceMappingURL=model-presets.js.map

package/dist/brain/model-presets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-presets.js","sourceRoot":"","sources":["../../src/brain/model-presets.ts"],"names":[],"mappings":"AAqBA,MAAM,CAAC,MAAM,cAAc,GAA4B;IACrD,YAAY,EAAE,UAAU;IACxB,YAAY,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC;IACvD,mBAAmB,EAAE,KAAK;CAC3B,CAAC;AAQF,MAAM,CAAC,MAAM,uBAAuB,GAAa;IAE/C,iQAAiQ;IAEjQ,8PAA8P;IAE9P,kKAAkK;CACnK,CAAC;AAQF,MAAM,UAAU,WAAW,CAAC,YAA4B,EAAE;IACxD,OAAO;QACL,EAAE,EAAE,gBAAgB;QACpB,IAAI,EAAE,gBAAgB;QACtB,GAAG,EAAE,oBAAoB;QACzB,QAAQ,EAAE,WAAW;QACrB,OAAO,EAAE,2BAA2B;QACpC,SAAS,EAAE,IAAI;QACf,eAAe,EAAE,MAAM;QACvB,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;QACxB,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE;QAC1D,aAAa,EAAE,SAAS;QACxB,SAAS,EAAE,MAAM;QAGjB,aAAa,EAAE,CAAC;QAChB,MAAM,EAAE,EAAE,GAAG,cAAc,EAAE;QAC7B,cAAc,EAAE,CAAC,GAAG,uBAAuB,CAAC;QAC5C,GAAG,SAAS;KACb,CAAC;AACJ,CAAC"}

package/dist/brain/openai.d.ts

@@ -0,0 +1,13 @@
+import type { Brain } from "../core/types.js";
+import { type StreamEngineConfig } from "./stream-engine.js";
+export interface OpenAIBrainConfig extends StreamEngineConfig {
+    baseUrl?: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    fetchImpl?: typeof fetch;
+    repairTextToolCalls?: boolean;
+    replayThinking?: boolean;
+    detectRepetition?: boolean;
+}
+export declare function createOpenAIBrain(config?: OpenAIBrainConfig): Brain;
+//# sourceMappingURL=openai.d.ts.map

package/dist/brain/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../src/brain/openai.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAQ9C,OAAO,EAAE,KAAK,kBAAkB,EAA8E,MAAM,oBAAoB,CAAC;AAEzI,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;IAE3D,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IAMzB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAU9B,cAAc,CAAC,EAAE,OAAO,CAAC;IAMzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AA2YD,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,iBAAsB,GAAG,KAAK,CA6avE"}

package/dist/brain/openai.js

@@ -0,0 +1,581 @@
+import {} from "../internal/llm.js";
+import { repairTextToolCalls } from "./tool-call-repair.js";
+import { DEGENERATE_MESSAGE, inspectDegenerate, trimDegenerateTail } from "./repetition.js";
+import { WALLTIME_CUTOFF_MESSAGE } from "./walltime.js";
+import { emitBrainTelemetry } from "./status-sink.js";
+import { OPENAI_RESERVED, applyExtraBody } from "./request-params.js";
+import { DEFAULT_EFFORT_LEVELS, isThinkingLevel, resolveEffort } from "./reasoning.js";
+import { runStreamingBrain } from "./stream-engine.js";
+function closeToolCallAccum(acc) {
+    if (acc.closedTc)
+        return acc.closedTc;
+    if (!acc.name)
+        return undefined;
+    let args;
+    if (acc.args) {
+        try {
+            const parsed = JSON.parse(acc.args);
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+                return undefined;
+            args = parsed;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    else {
+        args = {};
+    }
+    if (!acc.id)
+        acc.id = `call_${Math.random().toString(36).slice(2)}`;
+    acc.closedTc = { type: "toolCall", id: acc.id, name: acc.name, arguments: args };
+    return acc.closedTc;
+}
+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 visionOf(model) {
+    return model?.input === undefined ? true : model.input.includes("image");
+}
+const IMAGE_OMITTED = "[image omitted: the serving model does not support image input]";
+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 toUserContent(content, supportsVision = true) {
+    if (typeof content === "string") {
+        return content;
+    }
+    const hasImage = content.some((c) => c.type === "image");
+    const nDocs = content.filter((c) => c.type === "document").length;
+    if (nDocs > 0)
+        emitBrainTelemetry({ kind: "document_placeholder", count: nDocs });
+    if (!hasImage) {
+        const base = textOf(content);
+        if (nDocs === 0)
+            return base;
+        return base ? `${base}\n${DOCUMENT_OMITTED}` : DOCUMENT_OMITTED;
+    }
+    if (!supportsVision) {
+        const n = content.filter((c) => c.type === "image").length;
+        emitBrainTelemetry({ kind: "vision_placeholder", count: n });
+        const base = textOf(content);
+        const note = n > 1 ? `[${n} images omitted: the serving model does not support image input]` : IMAGE_OMITTED;
+        const withNote = base ? `${base}\n${note}` : note;
+        return nDocs > 0 ? `${withNote}\n${DOCUMENT_OMITTED}` : withNote;
+    }
+    const parts = [];
+    for (const c of content) {
+        if (c.type === "text" && typeof c.text === "string") {
+            parts.push({ type: "text", text: c.text });
+        }
+        else if (c.type === "image" && c.data && c.mimeType) {
+            parts.push({
+                type: "image_url",
+                image_url: { url: `data:${c.mimeType};base64,${c.data}` },
+            });
+        }
+        else if (c.type === "document") {
+            parts.push({ type: "text", text: DOCUMENT_OMITTED });
+        }
+    }
+    return parts;
+}
+function thinkingCompat(model) {
+    return (model.compat ?? {});
+}
+function applyThinking(body, model, reasoning) {
+    if (!model.reasoning || !reasoning || reasoning === "off")
+        return;
+    const compat = thinkingCompat(model);
+    const supportsEffort = compat.supportsReasoningEffort ?? true;
+    const effort = isThinkingLevel(reasoning)
+        ? resolveEffort(reasoning, compat.reasoningEffortLevels ?? DEFAULT_EFFORT_LEVELS).effective
+        : reasoning;
+    let effortWire = effort;
+    if (isThinkingLevel(effort) && model.thinkingLevelMap) {
+        const mapped = model.thinkingLevelMap[effort];
+        if (mapped === null)
+            effortWire = undefined;
+        else if (mapped !== undefined)
+            effortWire = mapped;
+    }
+    const format = compat.thinkingFormat ?? "openai";
+    switch (format) {
+        case "openai":
+            if (supportsEffort && effortWire !== undefined)
+                body.reasoning_effort = effortWire;
+            break;
+        case "openrouter":
+            body.reasoning = { effort: effortWire };
+            break;
+        case "deepseek":
+            body.thinking = { type: "enabled" };
+            if (supportsEffort && effortWire !== undefined)
+                body.reasoning_effort = effortWire;
+            break;
+        case "together":
+            body.reasoning = { enabled: true };
+            if (supportsEffort && effortWire !== undefined)
+                body.reasoning_effort = effortWire;
+            break;
+        case "qwen":
+        case "zai":
+            body.enable_thinking = true;
+            break;
+        case "qwen-chat-template": {
+            const k = (typeof body.chat_template_kwargs === "object" && body.chat_template_kwargs) || {};
+            body.chat_template_kwargs = { ...k, enable_thinking: true };
+            break;
+        }
+        default: {
+            const _exhaustive = format;
+            void _exhaustive;
+            break;
+        }
+    }
+}
+function toOpenAIMessages(ctx, replayThinking = true, model) {
+    const supportsVision = visionOf(model);
+    const out = [];
+    const needsEmptyReasoningField = !!model?.reasoning && thinkingCompat(model).requiresReasoningContentOnAssistantMessages === true;
+    if (ctx.systemPrompt) {
+        out.push({ role: "system", content: ctx.systemPrompt });
+    }
+    let pendingImages = [];
+    const flushImages = () => {
+        if (pendingImages.length === 0)
+            return;
+        const ids = [...new Set(pendingImages.map((i) => i.toolCallId))].join(", ");
+        out.push({
+            role: "user",
+            content: [
+                { type: "text", text: `[Image${pendingImages.length > 1 ? "s" : ""} from tool result ${ids}]` },
+                ...pendingImages.map((i) => ({ type: "image_url", image_url: { url: `data:${i.mimeType};base64,${i.data}` } })),
+            ],
+        });
+        pendingImages = [];
+    };
+    for (const m of ctx.messages) {
+        if (m.role !== "toolResult")
+            flushImages();
+        if (m.role === "user") {
+            out.push({ role: "user", content: toUserContent(m.content, supportsVision) });
+        }
+        else if (m.role === "assistant") {
+            const text = m.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("");
+            const toolCalls = m.content.filter((c) => c.type === "toolCall");
+            const msg = { role: "assistant", content: text };
+            const reasoning = m.content
+                .filter((c) => c.type === "thinking")
+                .map((c) => c.thinking)
+                .join("");
+            if (replayThinking && reasoning && toolCalls.length > 0) {
+                msg.reasoning_content = reasoning;
+            }
+            else if (needsEmptyReasoningField) {
+                msg.reasoning_content = "";
+            }
+            if (toolCalls.length > 0) {
+                msg.tool_calls = toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: { name: tc.name, arguments: JSON.stringify(tc.arguments ?? {}) },
+                }));
+            }
+            out.push(msg);
+        }
+        else if (m.role === "toolResult") {
+            const rawImages = !m.isError && Array.isArray(m.content)
+                ? m.content.filter((c) => c.type === "image" && typeof c.data === "string" && typeof c.mimeType === "string")
+                : [];
+            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 text = !supportsVision && rawImages.length > 0 ? (baseText ? `${baseText}\n${IMAGE_OMITTED}` : IMAGE_OMITTED) : baseText;
+            out.push({
+                role: "tool",
+                tool_call_id: m.toolCallId,
+                content: toolResultText(text, 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 toolResultText(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 toOpenAITools(ctx) {
+    if (!ctx.tools || ctx.tools.length === 0) {
+        return undefined;
+    }
+    return ctx.tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters },
+    }));
+}
+function mapFinishReason(reason, hadToolCalls) {
+    if (hadToolCalls) {
+        return "toolUse";
+    }
+    if (reason === "length") {
+        return "length";
+    }
+    return "stop";
+}
+function computeUsage(model, raw) {
+    const input = raw?.prompt_tokens ?? 0;
+    const output = raw?.completion_tokens ?? 0;
+    const total = raw?.total_tokens ?? input + output;
+    const cacheRead = raw?.prompt_tokens_details?.cached_tokens ?? raw?.prompt_cache_hit_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 },
+    };
+}
+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 closeThinking = () => {
+                if (emittedThinkingStart && !thinkingClosed) {
+                    thinkingClosed = true;
+                    out.push({ type: "thinking_end", contentIndex: 0, content: accumReasoning, partial: { ...partial } });
+                }
+            };
+            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 } });
+                }
+                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();
+                    }
+                }
+            };
+            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:"))
+                        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);
+                        }
+                    }
+                },
+                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)})`);
+                        }
+                    }
+                    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 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,
+                        });
+                    }
+                },
+            };
+        },
+    });
+    return { stream };
+}
+//# sourceMappingURL=openai.js.map