@sema-agent/core 1.279.0

package/dist/brain/anthropic.js

@@ -0,0 +1,635 @@
+import {} from "../internal/llm.js";
+import { BrainError } from "./errors.js";
+import { DEGENERATE_MESSAGE, inspectDegenerate, trimDegenerateTail } from "./repetition.js";
+import { WALLTIME_CUTOFF_MESSAGE } from "./walltime.js";
+import { emitBrainTelemetry } from "./status-sink.js";
+import { ANTHROPIC_RESERVED, applyExtraBody } from "./request-params.js";
+import { isThinkingLevel, reasoningBudgetShare, resolveEffort } from "./reasoning.js";
+import { runStreamingBrain } from "./stream-engine.js";
+const MIN_THINKING_TOKENS = 1024;
+function thinkingBudget(maxTokens, share, fixed, hardCap = false) {
+    const max = hardCap ? maxTokens : Math.max(maxTokens, MIN_THINKING_TOKENS * 2);
+    const want = fixed ?? Math.floor(max * share);
+    const budget = Math.min(Math.max(MIN_THINKING_TOKENS, want), max - 1);
+    return { max, budget };
+}
+const EPHEMERAL = { type: "ephemeral" };
+const DOCUMENT_OMITTED_NO_VISION = "[PDF document omitted: the serving model does not support document input; extract the text via Bash instead (e.g. `pdftotext`).]";
+function textOf(content) {
+    return typeof content === "string"
+        ? content
+        : content.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
+}
+function toUserBlocks(content, supportsVision = true) {
+    if (typeof content === "string") {
+        return [{ type: "text", text: content }];
+    }
+    const blocks = [];
+    let omitted = 0;
+    for (const c of content) {
+        if (c.type === "text" && typeof c.text === "string") {
+            blocks.push({ type: "text", text: c.text });
+        }
+        else if (c.type === "image" && c.data && c.mimeType) {
+            if (supportsVision)
+                blocks.push({ type: "image", source: { type: "base64", media_type: c.mimeType, data: c.data } });
+            else {
+                omitted++;
+                blocks.push({ type: "text", text: "[image omitted: the serving model does not support image input]" });
+            }
+        }
+    }
+    if (omitted > 0)
+        emitBrainTelemetry({ kind: "vision_placeholder", count: omitted });
+    return blocks;
+}
+function toAnthropicMessages(ctx, model) {
+    const supportsVision = model?.input === undefined ? true : model.input.includes("image");
+    const raw = [];
+    let pendingDocs = [];
+    const flushDocs = () => {
+        if (pendingDocs.length === 0)
+            return;
+        raw.push({ role: "user", content: pendingDocs });
+        pendingDocs = [];
+    };
+    for (const m of ctx.messages) {
+        if (m.role !== "toolResult")
+            flushDocs();
+        if (m.role === "user") {
+            raw.push({ role: "user", content: toUserBlocks(m.content, supportsVision) });
+        }
+        else if (m.role === "assistant") {
+            const blocks = [];
+            for (const c of m.content) {
+                if (c.type === "thinking") {
+                    const tc = c;
+                    const sig = tc.thinkingSignature;
+                    if (tc.redacted) {
+                        if (sig)
+                            blocks.push({ type: "redacted_thinking", data: sig });
+                    }
+                    else if (sig) {
+                        blocks.push({ type: "thinking", thinking: c.thinking, signature: sig });
+                    }
+                }
+                else if (c.type === "text" && c.text) {
+                    blocks.push({ type: "text", text: c.text });
+                }
+                else if (c.type === "toolCall") {
+                    blocks.push({ type: "tool_use", id: c.id, name: c.name, input: c.arguments ?? {} });
+                }
+            }
+            raw.push({ role: "assistant", content: blocks.length ? blocks : [{ type: "text", text: NO_CONTENT }] });
+        }
+        else if (m.role === "toolResult") {
+            const parts = Array.isArray(m.content) ? m.content : undefined;
+            const docs = parts ? parts.filter((c) => c.type === "document") : [];
+            const rest = docs.length > 0 && parts ? parts.filter((c) => c.type !== "document") : m.content;
+            const hasImage = !m.isError && Array.isArray(rest) && rest.some((c) => c.type === "image");
+            let inner = hasImage ? toUserBlocks(rest, supportsVision) : textOf(rest);
+            if (docs.length > 0 && !m.isError) {
+                if (supportsVision) {
+                    for (const d of docs) {
+                        if (d.data && d.mimeType)
+                            pendingDocs.push({ type: "document", source: { type: "base64", media_type: d.mimeType, data: d.data } });
+                    }
+                    const pointer = "(PDF document attached below)";
+                    if (typeof inner === "string")
+                        inner = inner ? `${inner}\n${pointer}` : pointer;
+                    else
+                        inner.push({ type: "text", text: pointer });
+                }
+                else {
+                    emitBrainTelemetry({ kind: "document_placeholder", count: docs.length });
+                    const note = DOCUMENT_OMITTED_NO_VISION;
+                    if (typeof inner === "string")
+                        inner = inner ? `${inner}\n${note}` : note;
+                    else
+                        inner.push({ type: "text", text: note });
+                }
+            }
+            raw.push({
+                role: "user",
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: m.toolCallId,
+                        content: inner,
+                        ...(m.isError ? { is_error: true } : {}),
+                    },
+                ],
+            });
+        }
+    }
+    flushDocs();
+    const merged = [];
+    for (const msg of raw) {
+        const prev = merged[merged.length - 1];
+        if (prev && prev.role === msg.role) {
+            prev.content.push(...msg.content);
+        }
+        else {
+            merged.push({ role: msg.role, content: [...msg.content] });
+        }
+    }
+    return merged;
+}
+function toAnthropicTools(ctx, cacheBreakpoints) {
+    if (!ctx.tools || ctx.tools.length === 0) {
+        return undefined;
+    }
+    return ctx.tools.map((t, i) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters,
+        ...(cacheBreakpoints && i === ctx.tools.length - 1 ? { cache_control: EPHEMERAL } : {}),
+    }));
+}
+const NO_CONTENT = "(no content)";
+function mapStopReason(reason, hadToolUse) {
+    if (hadToolUse || reason === "tool_use")
+        return "toolUse";
+    if (reason === "max_tokens")
+        return "length";
+    return "stop";
+}
+function anthropicStreamErrorCode(t) {
+    switch (t) {
+        case "rate_limit_error":
+            return "rate_limit";
+        case "authentication_error":
+        case "permission_error":
+            return "auth";
+        case "invalid_request_error":
+            return "invalid_request";
+        default:
+            return "server";
+    }
+}
+function computeUsage(model, u) {
+    const input = u.input_tokens ?? 0;
+    const output = u.output_tokens ?? 0;
+    const cacheRead = u.cache_read_input_tokens ?? 0;
+    const cacheWrite = u.cache_creation_input_tokens ?? 0;
+    const c = model.cost;
+    const costInput = (input / 1e6) * (c?.input ?? 0);
+    const costOutput = (output / 1e6) * (c?.output ?? 0);
+    const costCacheRead = (cacheRead / 1e6) * (c?.cacheRead ?? 0);
+    const costCacheWrite = (cacheWrite / 1e6) * (c?.cacheWrite ?? 0);
+    return {
+        input,
+        output,
+        cacheRead,
+        cacheWrite,
+        totalTokens: input + output + cacheRead + cacheWrite,
+        cost: {
+            input: costInput,
+            output: costOutput,
+            cacheRead: costCacheRead,
+            cacheWrite: costCacheWrite,
+            total: costInput + costOutput + costCacheRead + costCacheWrite,
+        },
+    };
+}
+function closeToolUseBlock(acc) {
+    if (acc.closedTc)
+        return acc.closedTc;
+    if (!acc.toolName)
+        return undefined;
+    let args;
+    if (acc.toolJson) {
+        try {
+            const parsed = JSON.parse(acc.toolJson);
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+                return undefined;
+            args = parsed;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    else {
+        args = {};
+    }
+    if (!acc.toolId)
+        acc.toolId = `toolu_${Math.random().toString(36).slice(2)}`;
+    acc.closedTc = { type: "toolCall", id: acc.toolId, name: acc.toolName, arguments: args };
+    return acc.closedTc;
+}
+export function createAnthropicBrain(config = {}) {
+    const doFetch = config.fetchImpl ?? fetch;
+    const cacheBreakpoints = config.cacheBreakpoints !== false;
+    const stream = (model, context, options) => {
+        let thinkingRequested = false;
+        return runStreamingBrain({
+            model,
+            doFetch,
+            signal: options?.signal,
+            config,
+            httpLabel: "anthropic",
+            buildRequest: () => {
+                const apiKey = options?.apiKey ?? config.apiKey;
+                const root = (model.baseUrl || config.baseUrl || "https://api.anthropic.com").replace(/\/+$/, "");
+                const system = context.systemPrompt
+                    ? [{ type: "text", text: context.systemPrompt, ...(cacheBreakpoints ? { cache_control: EPHEMERAL } : {}) }]
+                    : undefined;
+                const body = {
+                    model: model.id,
+                    max_tokens: options?.maxTokens ?? model.maxTokens ?? config.defaultMaxTokens ?? 4096,
+                    messages: toAnthropicMessages(context, model),
+                    stream: true,
+                };
+                if (system)
+                    body.system = system;
+                const tools = toAnthropicTools(context, cacheBreakpoints);
+                if (tools)
+                    body.tools = tools;
+                const anthCompat = (model.compat ?? {});
+                if (options?.temperature !== undefined && anthCompat.supportsTemperature !== false) {
+                    body.temperature = options.temperature;
+                }
+                if (model.reasoning && options?.reasoning && options.reasoning !== "off") {
+                    if (anthCompat.thinkingMode === "adaptive") {
+                        body.thinking = { type: "adaptive" };
+                    }
+                    else {
+                        const hardCap = options?.maxTokens !== undefined;
+                        if (hardCap && body.max_tokens < MIN_THINKING_TOKENS * 2) {
+                            body.thinking = undefined;
+                            delete body.thinking;
+                        }
+                        else {
+                            const tierShare = isThinkingLevel(options.reasoning) ? reasoningBudgetShare(options.reasoning) : undefined;
+                            const share = config.thinkingBudgetShare ?? tierShare ?? 0.5;
+                            const { max, budget } = thinkingBudget(body.max_tokens, share, config.thinkingBudgetTokens, hardCap);
+                            body.max_tokens = max;
+                            body.thinking = { type: "enabled", budget_tokens: budget };
+                        }
+                    }
+                    if (body.thinking !== undefined)
+                        delete body.temperature;
+                }
+                const betas = [];
+                let sendEffortBeta = false;
+                if (anthCompat.effortLevels &&
+                    anthCompat.effortLevels.length > 0 &&
+                    model.reasoning &&
+                    options?.reasoning &&
+                    options.reasoning !== "off" &&
+                    isThinkingLevel(options.reasoning)) {
+                    const { effective } = resolveEffort(options.reasoning, anthCompat.effortLevels.filter(isThinkingLevel));
+                    const wireEffort = effective === "minimal" ? "low" : effective;
+                    body.output_config = { effort: wireEffort };
+                    sendEffortBeta = true;
+                }
+                if (sendEffortBeta)
+                    betas.push("effort-2025-11-24");
+                if (anthCompat.contextManagement && body.thinking !== undefined) {
+                    body.context_management = { edits: [{ type: "clear_thinking_20251015", keep: "all" }] };
+                    betas.push("context-management-2025-06-27");
+                }
+                if (anthCompat.interleavedThinking) {
+                    betas.push("interleaved-thinking-2025-05-14");
+                }
+                const headers = {
+                    ...model.headers,
+                    ...config.headers,
+                    ...options?.headers,
+                };
+                if (betas.length > 0) {
+                    const existing = (headers["anthropic-beta"] ?? "").split(",").map((b) => b.trim()).filter(Boolean);
+                    for (const beta of betas) {
+                        if (!existing.includes(beta))
+                            existing.push(beta);
+                    }
+                    headers["anthropic-beta"] = existing.join(",");
+                }
+                headers["content-type"] = "application/json";
+                headers["anthropic-version"] = config.version ?? "2023-06-01";
+                if (apiKey)
+                    headers["x-api-key"] = apiKey;
+                thinkingRequested = body.thinking !== undefined;
+                return { url: `${root}/v1/messages`, headers, body: JSON.stringify(applyExtraBody(body, model.extraBody, ANTHROPIC_RESERVED)) };
+            },
+            makeParser: (ctrl) => {
+                const { out, partial } = ctrl;
+                const blocks = new Map();
+                const usageRaw = {};
+                let stopReason = null;
+                let stopDetails;
+                let nextContentIndex = 0;
+                let degenerate = false;
+                let degenTextBlock;
+                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 lastDegenCheckThinking = 0;
+                const detectRep = config.detectRepetition !== false;
+                const handleEvent = (evt) => {
+                    switch (evt.type) {
+                        case "message_start": {
+                            const u = evt.message?.usage;
+                            if (u) {
+                                usageRaw.input_tokens = u.input_tokens;
+                                usageRaw.cache_read_input_tokens = u.cache_read_input_tokens;
+                                usageRaw.cache_creation_input_tokens = u.cache_creation_input_tokens;
+                            }
+                            break;
+                        }
+                        case "content_block_start": {
+                            ctrl.sawContentToken();
+                            const idx = evt.index;
+                            const cb = evt.content_block;
+                            const acc = { type: "text", text: "", signature: "", toolId: "", toolName: "", toolJson: "" };
+                            if (cb.type === "thinking" || cb.type === "redacted_thinking") {
+                                acc.type = "thinking";
+                                if (cb.type === "redacted_thinking") {
+                                    acc.redacted = true;
+                                    acc.signature = cb.data ?? "";
+                                }
+                                acc.pb = { type: "thinking", thinking: "" };
+                                partial.content = [acc.pb];
+                                out.push({ type: "thinking_start", contentIndex: idx, partial: { ...partial } });
+                            }
+                            else if (cb.type === "tool_use") {
+                                acc.type = "tool_use";
+                                acc.toolId = cb.id ?? "";
+                                acc.toolName = cb.name ?? "";
+                            }
+                            else {
+                                acc.type = "text";
+                                acc.pb = { type: "text", text: "" };
+                                partial.content = [acc.pb];
+                                out.push({ type: "text_start", contentIndex: idx, partial: { ...partial } });
+                            }
+                            blocks.set(idx, acc);
+                            nextContentIndex = Math.max(nextContentIndex, idx + 1);
+                            break;
+                        }
+                        case "content_block_delta": {
+                            ctrl.sawContentToken();
+                            const idx = evt.index;
+                            const acc = blocks.get(idx);
+                            if (!acc)
+                                break;
+                            const d = evt.delta;
+                            if (d.type === "text_delta" && d.text) {
+                                acc.text += d.text;
+                                if (acc.pb && acc.pb.type === "text")
+                                    acc.pb.text = acc.text;
+                                out.push({ type: "text_delta", contentIndex: idx, delta: d.text, partial: { ...partial } });
+                                if (detectRep && !degenerate && acc.text.length - lastDegenCheck >= 64) {
+                                    lastDegenCheck = acc.text.length;
+                                    if (pollRepetition(acc.text)) {
+                                        degenerate = true;
+                                        degenTextBlock = acc;
+                                        ctrl.cancel();
+                                    }
+                                }
+                            }
+                            else if (d.type === "thinking_delta" && d.thinking) {
+                                acc.text += d.thinking;
+                                if (acc.pb && acc.pb.type === "thinking")
+                                    acc.pb.thinking = acc.text;
+                                out.push({ type: "thinking_delta", contentIndex: idx, delta: d.thinking, partial: { ...partial } });
+                                if (detectRep && !degenerate && acc.text.length - lastDegenCheckThinking >= 64) {
+                                    lastDegenCheckThinking = acc.text.length;
+                                    if (pollRepetition(acc.text)) {
+                                        degenerate = true;
+                                        ctrl.cancel();
+                                    }
+                                }
+                            }
+                            else if (d.type === "signature_delta" && d.signature) {
+                                acc.signature += d.signature;
+                            }
+                            else if (d.type === "input_json_delta" && d.partial_json) {
+                                acc.toolJson += d.partial_json;
+                            }
+                            break;
+                        }
+                        case "content_block_stop": {
+                            const idx = evt.index;
+                            const acc = blocks.get(idx);
+                            if (acc)
+                                acc.stopped = true;
+                            if (acc?.type === "thinking") {
+                                out.push({ type: "thinking_end", contentIndex: idx, content: acc.text, partial: { ...partial } });
+                            }
+                            else if (acc?.type === "text") {
+                                out.push({ type: "text_end", contentIndex: idx, content: acc.text, partial: { ...partial } });
+                            }
+                            else if (acc?.type === "tool_use") {
+                                const tc = closeToolUseBlock(acc);
+                                if (tc) {
+                                    out.push({ type: "toolcall_end", contentIndex: idx, toolCall: tc, partial: { ...partial } });
+                                }
+                            }
+                            break;
+                        }
+                        case "message_delta": {
+                            const d = evt.delta;
+                            if (d?.stop_reason)
+                                stopReason = d.stop_reason;
+                            if (d?.stop_details)
+                                stopDetails = d.stop_details;
+                            const u = evt.usage;
+                            if (u) {
+                                if (u.output_tokens !== undefined)
+                                    usageRaw.output_tokens = u.output_tokens;
+                                if (u.input_tokens != null && u.input_tokens > 0)
+                                    usageRaw.input_tokens = u.input_tokens;
+                                if (u.cache_read_input_tokens != null && u.cache_read_input_tokens > 0) {
+                                    usageRaw.cache_read_input_tokens = u.cache_read_input_tokens;
+                                }
+                                if (u.cache_creation_input_tokens != null && u.cache_creation_input_tokens > 0) {
+                                    usageRaw.cache_creation_input_tokens = u.cache_creation_input_tokens;
+                                }
+                            }
+                            break;
+                        }
+                        case "error": {
+                            const e = evt.error;
+                            throw new BrainError(anthropicStreamErrorCode(e?.type), `anthropic stream error (${e?.type ?? "unknown"}): ${e?.message ?? ""}`);
+                        }
+                        default:
+                            break;
+                    }
+                };
+                return {
+                    snapshot() {
+                        const accs = [...blocks.values()];
+                        const hasSubstantiveText = accs.some((a) => a.type === "text" && a.text.trim() !== "");
+                        const hasCompletedToolCall = accs.some((a) => a.closedTc !== undefined);
+                        const hasThinking = accs.some((a) => a.type === "thinking" && (a.text.length > 0 || a.redacted === true));
+                        return {
+                            hasSubstantiveText,
+                            hasCompletedToolCall,
+                            hasOnlyThinking: hasThinking && !hasSubstantiveText && !hasCompletedToolCall,
+                        };
+                    },
+                    sealForRetry() {
+                        for (const [idx, acc] of [...blocks.entries()].sort((a, b) => a[0] - b[0])) {
+                            if (acc.type === "thinking" && !acc.stopped) {
+                                acc.stopped = true;
+                                out.push({ type: "thinking_end", contentIndex: idx, content: acc.text, partial: { ...partial } });
+                            }
+                        }
+                    },
+                    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)
+                            return;
+                        let evt;
+                        try {
+                            evt = JSON.parse(data);
+                        }
+                        catch {
+                            return;
+                        }
+                        handleEvent(evt);
+                    },
+                    finalize() {
+                        const finalContent = [];
+                        const toolCalls = [];
+                        const malformed = [];
+                        let anyText = false;
+                        let reasoningSeen = false;
+                        for (const [, acc] of [...blocks.entries()].sort((a, b) => a[0] - b[0])) {
+                            if (acc.type === "thinking") {
+                                if (acc.text.length > 0 || acc.redacted === true)
+                                    reasoningSeen = true;
+                                const block = { type: "thinking", thinking: acc.text };
+                                if (acc.signature)
+                                    block.thinkingSignature = acc.signature;
+                                if (acc.redacted)
+                                    block.redacted = true;
+                                finalContent.push(block);
+                            }
+                            else if (acc.type === "text") {
+                                const text = acc === degenTextBlock && repCut !== undefined ? trimDegenerateTail(acc.text, repCut) : acc.text;
+                                if (text) {
+                                    finalContent.push({ type: "text", text });
+                                    if (text.trim())
+                                        anyText = true;
+                                }
+                            }
+                            else if (acc.type === "tool_use" && acc.toolName) {
+                                const tc = closeToolUseBlock(acc);
+                                if (tc) {
+                                    toolCalls.push(tc);
+                                    finalContent.push(tc);
+                                }
+                                else {
+                                    malformed.push(`${acc.toolName}(${acc.toolJson.slice(0, 200)})`);
+                                }
+                            }
+                        }
+                        const doneReason = mapStopReason(stopReason, toolCalls.length > 0);
+                        const noUsableContent = toolCalls.length === 0 && !anyText;
+                        const toolError = malformed.length > 0
+                            ? `tool call argument(s) not valid JSON (likely truncated, stop_reason="${stopReason ?? "?"}"): ${malformed.join("; ")}`
+                            : undefined;
+                        if (toolError !== undefined) {
+                            finalContent.push({
+                                type: "text",
+                                text: `\n[note: ${malformed.length} tool call(s) were truncated (stop_reason="${stopReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
+                            });
+                        }
+                        const truncatedEmpty = stopReason === "max_tokens" && noUsableContent && !toolError;
+                        const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
+                        const staticReasoningCut = truncatedEmpty && !dynamicCut && reasoningSeen && options?.staticReasoningCutDowngrade === true;
+                        const safetyCut = stopReason === "refusal";
+                        const contextWindowExceeded = stopReason === "model_context_window_exceeded";
+                        const emptyNoFinish = noUsableContent && stopReason == null && !degenerate && !walltimeCut;
+                        const errorMessage = walltimeCut
+                            ? WALLTIME_CUTOFF_MESSAGE
+                            : degenerate
+                                ? DEGENERATE_MESSAGE
+                                : safetyCut
+                                    ? `response refused by the model (stop_reason="refusal"${stopDetails?.category ? `, category="${stopDetails.category}"` : ""}) — ${stopDetails?.explanation ?? "the output was withheld for policy and is unreliable"}`
+                                    : contextWindowExceeded
+                                        ? `[invalid_request] model context window exceeded (stop_reason="model_context_window_exceeded") — the conversation no longer fits the model's context window`
+                                        : (toolError ??
+                                            (truncatedEmpty && !dynamicCut && !staticReasoningCut
+                                                ? thinkingRequested
+                                                    ? `response truncated at max_tokens with no answer text — extended thinking likely consumed the entire budget; raise max_tokens or lower thinkingBudgetShare`
+                                                    : reasoningSeen
+                                                        ? `response truncated at max_tokens with no answer text — the model emitted reasoning although no thinking was requested (a budget-ignoring gateway?) and it consumed the entire output budget; raise max_tokens`
+                                                        : `response truncated at max_tokens with no answer text; raise max_tokens`
+                                                : emptyNoFinish
+                                                    ? `model stream ended with no content and no stop_reason — the response was lost (a torn stream or an in-band provider error frame)`
+                                                    : undefined));
+                        const errored = walltimeCut ||
+                            degenerate ||
+                            safetyCut ||
+                            contextWindowExceeded ||
+                            emptyNoFinish ||
+                            (toolError !== undefined && noUsableContent) ||
+                            (truncatedEmpty && !dynamicCut && !staticReasoningCut);
+                        const errorKind = !walltimeCut && !degenerate && !safetyCut && toolError === undefined && truncatedEmpty && !dynamicCut && !staticReasoningCut
+                            ? "length_empty"
+                            : undefined;
+                        const finalMessage = {
+                            ...partial,
+                            content: finalContent.length > 0 ? finalContent : [{ type: "text", text: "" }],
+                            stopReason: errored ? "error" : doneReason,
+                            usage: computeUsage(model, usageRaw),
+                            ...(Object.keys(usageRaw).length === 0 ? { 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()] } : {}) } }
+                                : {}),
+                            ...(staticReasoningCut ? { staticReasoningCut: true } : {}),
+                            ...(stopDetails
+                                ? {
+                                    diagnostics: [
+                                        ...(partial.diagnostics ?? []),
+                                        { type: "stop_details", timestamp: Date.now(), details: { ...stopDetails } },
+                                    ],
+                                }
+                                : {}),
+                        };
+                        if (errored) {
+                            out.push({ type: "error", reason: "error", error: finalMessage });
+                        }
+                        else {
+                            out.push({ type: "done", reason: doneReason, message: finalMessage });
+                        }
+                    },
+                };
+            },
+        });
+    };
+    return { stream };
+}
+//# sourceMappingURL=anthropic.js.map