@sema-ai/core 1.275.1

package/dist/brain/anthropic.js

@@ -0,0 +1,830 @@
+import {} from "../internal/llm.js";
+import { BrainError } from "./errors.js";
+import { DEGENERATE_MESSAGE, inspectDegenerate } 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";
+/** Anthropic's hard floor for an extended-thinking budget. */
+const MIN_THINKING_TOKENS = 1024;
+/**
+ * Resolve `max_tokens` and `budget_tokens` for extended thinking. Anthropic requires
+ * `1024 ≤ budget_tokens < max_tokens` (422 otherwise) — unsatisfiable when the caller's `max_tokens`
+ * is itself ≤ 1024, so we raise `max_tokens` to host a minimum budget plus answer room. `budget` is
+ * then clamped strictly below `max_tokens`.
+ */
+function thinkingBudget(maxTokens, share, fixed, hardCap = false) {
+    // design/119 #2 review (codex H4): an EXPLICIT per-request cap (options.maxTokens) is a hard bound —
+    // never raise it. The raise applies only to the model/default-sourced value (pre-existing behavior).
+    const max = hardCap ? maxTokens : Math.max(maxTokens, MIN_THINKING_TOKENS * 2); // ≥1024 thinking + ≥1024 answer room
+    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" };
+/** PDF read: honest placeholder when the serving Anthropic model declares no vision (document processing
+ *  requires a vision-capable model) — mirrors the image placeholder discipline (service [398] C4). */
+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("");
+}
+/** A user/tool-result message's content blocks (text + images + tool_result). 无视觉模型 ⇒ 图像块降级为
+ *  文本占位符(TB 战线 pytorch-model-cli 逮的 400 类;model 元数据缺席 = 维持今日行为发图)。 */
+function toUserBlocks(content, supportsVision = true) {
+    if (typeof content === "string") {
+        return [{ type: "text", text: content }];
+    }
+    const blocks = [];
+    let omitted = 0; // service [398] C4: count placeholder substitutions → one telemetry frame
+    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;
+}
+/** Convert unified messages → Anthropic messages, replaying thinking (with signature) + merging
+ *  consecutive same-role messages (Anthropic requires strict user/assistant alternation). */
+function toAnthropicMessages(ctx, model) {
+    const supportsVision = model?.input === undefined ? true : model.input.includes("image");
+    const raw = [];
+    // PDF read: document blocks hoisted out of tool_result batches (see the toolResult branch below).
+    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) {
+                        // CC-parity B2: a redacted_thinking block must go back as `{type:"redacted_thinking",data}` with
+                        // its opaque payload (stored in thinkingSignature). Without this the required block vanishes on
+                        // replay and Anthropic 400s the continuation of a thinking+tool-use turn.
+                        if (sig)
+                            blocks.push({ type: "redacted_thinking", data: sig });
+                    }
+                    else if (sig) {
+                        // Replay normal extended-thinking blocks ONLY with their signature (Anthropic rejects otherwise);
+                        // a signature-less thinking block (e.g. from another provider) is dropped.
+                        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") {
+            // design/66 image: the Anthropic API accepts image blocks INSIDE tool_result.content natively
+            // (CC messages.ts:2526) — pass blocks through when a tool returned an image. Two CC-parity rules:
+            // an is_error tool_result must contain ONLY text (image-in-error 400s forever — messages.ts:2342),
+            // and all-text content keeps the legacy string shape.
+            // PDF read: `document` blocks do NOT ride inside tool_result — CC (FileReadTool.ts:1000-1016) emits
+            // the PDF as a document block on a SEPARATE user message (createUserMessage, isMeta), never inside
+            // tool_result content. We buffer them (pendingDocs) and flush AFTER the whole consecutive tool-result
+            // batch, so tool_result blocks stay first in the coalesced user message (API ordering constraint) even
+            // with parallel PDF reads. In error results documents are sanitized away like images (text-only rule);
+            // a no-vision model gets an honest text placeholder + telemetry instead (never a silent drop).
+            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();
+    // Coalesce consecutive same-role messages (e.g. several tool results in a row).
+    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 } : {}),
+    }));
+}
+// CC-parity round-2 B1: Anthropic 400s ("text content blocks must contain non-whitespace text") on an
+// empty/whitespace assistant content block. A non-final empty assistant turn (a clean empty `end_turn`, or a
+// stored `text:""` whose only block was filtered at replay, or a cross-provider signature-less-thinking-only
+// turn) would replay an empty block and DETERMINISTICALLY poison the session (every later request 400s).
+// Substitute a non-empty placeholder at SEND time (mirrors CC's `ensureNonEmptyAssistantContent`,
+// messages.ts:4933 + NO_CONTENT_MESSAGE). Send-time only → the stored message keeps `text:""` (result semantics
+// unchanged); this is the load-bearing catch-all that also covers already-stored/old-session empties.
+const NO_CONTENT = "(no content)";
+function mapStopReason(reason, hadToolUse) {
+    if (hadToolUse || reason === "tool_use")
+        return "toolUse";
+    if (reason === "max_tokens")
+        return "length";
+    return "stop";
+}
+/** CC-parity B1: map an Anthropic mid-stream error frame's `error.type` to our BrainError code so the
+ *  failover/breaker/degrading stack classifies it. overloaded_error/api_error and unknowns are transient
+ *  server errors (retryable, mirroring the SDK's withRetry); auth/rate-limit/invalid are terminal-ish. */
+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,
+        // A-3: cacheRead/cacheWrite occupy the context window too, so they MUST be in totalTokens. Anthropic's
+        // `input_tokens` excludes cache (API semantics), and downstream calculateContextTokens short-circuits on
+        // a non-zero totalTokens — omitting cache here made the compaction anchor severely underestimate a
+        // cache-heavy long task (most prompt is cacheRead) → compaction never fired → provider context overflow.
+        totalTokens: input + output + cacheRead + cacheWrite,
+        cost: {
+            input: costInput,
+            output: costOutput,
+            cacheRead: costCacheRead,
+            cacheWrite: costCacheWrite,
+            total: costInput + costOutput + costCacheRead + costCacheWrite,
+        },
+    };
+}
+/**
+ * design/120 P2.0: close a streamed tool_use block into a ToolCall. Returns undefined when the block
+ * has no name or its accumulated input_json is not a valid JSON object (fail-closed: no `toolcall_end`
+ * is emitted for it, so it can never execute in-stream; finalize() then surfaces it via the existing
+ * malformed-drop + note path). Idempotent on success (cached); a failure is NOT cached so finalize can
+ * retry with the complete accumulation.
+ */
+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);
+            // bug-hunt #6 (kept from finalize): a top-level string/array/number/null must fail closed so a
+            // non-object never reaches tool.execute / the MCP wire.
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+                return undefined;
+            args = parsed;
+        }
+        catch {
+            return undefined; // truncated/invalid input_json — finalize's malformed path reports it
+        }
+    }
+    else {
+        args = {}; // genuinely a no-argument tool call (empty input_schema)
+    }
+    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;
+}
+/**
+ * Create a Brain for the Anthropic Messages API (`/v1/messages`) with **prompt caching** and
+ * **extended-thinking replay**. Translates the unified Context into an Anthropic request and the
+ * streamed response back into the unified AssistantMessageEvent protocol. The connect/retry/timeout/
+ * read-loop machinery lives in the shared {@link runStreamingBrain} engine (design/32); this adapter
+ * owns the Anthropic request shaping + typed content-block SSE parsing + finalization.
+ */
+export function createAnthropicBrain(config = {}) {
+    const doFetch = config.fetchImpl ?? fetch;
+    const cacheBreakpoints = config.cacheBreakpoints !== false;
+    const stream = (model, context, options) => {
+        // [477] 文案修: whether THIS request actually carried a `thinking` field — set by buildRequest
+        // (re-set on every retry attempt), read by finalize() so the truncatedEmpty fail-loud message
+        // only suggests thinkingBudgetShare when that knob is actually in play for the request.
+        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;
+                // design/119 (CC 2.1.198 rebaseline): per-endpoint capability bits for the Fable-5 class.
+                const anthCompat = (model.compat ?? {});
+                // CC 198 sends temperature only to a legacy allowlist — a `supportsTemperature:false` model
+                // (Fable-5 class) never receives it, independent of thinking state (sIn semantics, not just
+                // the thinking-enabled 400 rule below).
+                if (options?.temperature !== undefined && anthCompat.supportsTemperature !== false) {
+                    body.temperature = options.temperature;
+                }
+                if (model.reasoning && options?.reasoning && options.reasoning !== "off") {
+                    // `"off"` is treated as absence (no thinking block). The StreamOptions type excludes "off" and the
+                    // harness already maps off→undefined, but defend the public primitive: a raw/untyped caller passing
+                    // the string "off" must NOT enable thinking at the 1024-token floor (the opposite of off). Hence the
+                    // cast — the guard is belt-and-suspenders against an out-of-contract input, not a type-reachable one.
+                    // The requested intensity tier sets the budget share so a higher tier actually buys more thinking
+                    // (design/96 S5: before this, the share was fixed regardless of tier). Explicit config still wins:
+                    // thinkingBudgetTokens (fixed) > thinkingBudgetShare > tier-derived share > 0.5 default. A non-tier
+                    // `reasoning` value (legacy boolean/unknown) falls through to the 0.5 default (back-compat).
+                    if (anthCompat.thinkingMode === "adaptive") {
+                        // design/119 (CC 198): adaptive-thinking models take `{type:"adaptive"}` with NO
+                        // budget_tokens (they 400 on a budget) and no max_tokens bump — the intensity rides
+                        // `output_config.effort` below. `off` stays "omit the field" (these models also reject
+                        // `{type:"disabled"}`), which is the pre-existing off behavior of this brain.
+                        body.thinking = { type: "adaptive" };
+                    }
+                    else {
+                        const hardCap = options?.maxTokens !== undefined;
+                        if (hardCap && body.max_tokens < MIN_THINKING_TOKENS * 2) {
+                            // design/119 #2 review (codex H4): the caller's explicit per-request output cap is too
+                            // small to host a legal thinking budget (≥1024) plus answer room — the CAP WINS and
+                            // thinking is skipped for this request (the alternative silently raised max_tokens above
+                            // the documented hard bound). Temperature stays (no thinking ⇒ no 400 rule).
+                            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 };
+                        }
+                    }
+                    // CC-parity round-3: Anthropic 400s `temperature != 1` when extended thinking is enabled. A caller
+                    // setting a non-1 temperature (e.g. `temperature: 0` for determinism) on a reasoning model would 400
+                    // EVERY request. Drop it here (the API's only legal value under thinking is 1, which it defaults to) —
+                    // mirrors CC claude.ts (`temperature = !hasThinking ? (override ?? 1) : undefined`). The non-thinking
+                    // path keeps the caller's temperature (set at :293 above).
+                    if (body.thinking !== undefined)
+                        delete body.temperature;
+                }
+                // design/119 (CC 198): effort is ORTHOGONAL to thinking form — an endpoint that declares
+                // `effortLevels` carries the requested intensity as `output_config.effort` (string tier) plus
+                // the `effort-2025-11-24` beta. Clamped DOWN into the declared set with the same resolver the
+                // `reasoning.resolved` trace uses (resolveReasoning format:"effort"), so trace and wire can't
+                // drift. `minimal` isn't a wire tier — it clamps to the lowest declared level. Thinking `off`
+                // sends no output_config (intensity of nothing).
+                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");
+                // design/119 S4: context_management (declared endpoints only) — with thinking enabled, tell
+                // the server to KEEP all thinking blocks (opt-out of default clearing; cross-turn reasoning
+                // continuity, CC vhc :591212). Response-side applied_edits is not consumed (CC doesn't either).
+                if (anthCompat.contextManagement && body.thinking !== undefined) {
+                    body.context_management = { edits: [{ type: "clear_thinking_20251015", keep: "all" }] };
+                    betas.push("context-management-2025-06-27");
+                }
+                // design/119 S4: interleaved thinking beta — CC 198 attaches it whenever the model supports it
+                // (kzr :132494 gates only on the capability + a disable env; no tools/thinking condition), so a
+                // declared endpoint gets it unconditionally.
+                if (anthCompat.interleavedThinking) {
+                    betas.push("interleaved-thinking-2025-05-14");
+                }
+                // User-supplied headers augment; structural + auth headers hard-locked AFTER (council design/40).
+                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;
+                // [477]: record whether the outgoing body carries a thinking field (per attempt — a retry
+                // rebuilds the request and re-evaluates; the value is identical for a same-shape retry).
+                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; // tripped if the model loops on the same char/phrase forever
+                // Repetition telemetry (clay 2026-07-10): the cut event + allowance-spared hits for THIS stream.
+                // Polls re-inspect the same growing text every ~64 chars — dedupe spared by rule+segment so one
+                // boot block doesn't log once per poll. Attached to the final message as `repetition`.
+                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; // keep the loop's PEAK depth across polls
+                    }
+                    if (insp.degenerate)
+                        repCut = insp.cut;
+                    return insp.degenerate;
+                };
+                // design/130 P2b: tripped when the wall clock crossed the soft per-call deadline — a
+                // DELIBERATE cut like `degenerate` (salvage the prefix; the loop drives a write-out turn).
+                let walltimeCut = false;
+                const callDeadlineMs = options?.callDeadlineMs;
+                let lastDegenCheck = 0;
+                let lastDegenCheckThinking = 0; // bug-hunt #4: separate cursor for the thinking block
+                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(); // a block opened (thinking/text/tool_use) — the gateway is producing
+                            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";
+                                // CC-parity B2: a redacted_thinking block carries no deltas — its whole payload is `cb.data`
+                                // delivered at block_start. Stash it in `signature` (the replay carrier) + mark redacted, so
+                                // finalize emits it with the payload preserved and replay sends it back as redacted_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 } });
+                                // Poll for degenerate repetition (~every 64 chars); on a hit, cancel the stream (read loop ends).
+                                if (detectRep && !degenerate && acc.text.length - lastDegenCheck >= 64) {
+                                    lastDegenCheck = acc.text.length;
+                                    if (pollRepetition(acc.text)) {
+                                        degenerate = true;
+                                        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 } });
+                                // bug-hunt #4: a reasoning model can loop forever inside the thinking block with no answer.
+                                // The text path polls looksDegenerate; mirror it for thinking (separate cursor) so a looping
+                                // extended-thinking turn is cut cheaply instead of running to the timeout.
+                                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; // design/124: sealForRetry() must not double-close this block
+                            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") {
+                                // design/120 P2.0: the block's input_json is complete — emit `toolcall_end` NOW so an
+                                // in-stream tool executor (agent-loop P2) can start the call while the model is still
+                                // streaming. Fail-closed: a malformed close emits nothing (the call can never execute
+                                // in-stream) and finalize()'s malformed-drop + note path reports it as before. Provider
+                                // contract (llm/types.ts): every emitted toolcall_end's call appears in the `done`
+                                // message's content — guaranteed here because finalize() reuses the cached closedTc.
+                                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;
+                            // design/119 S4 (CC 198 :593078): a refusal carries stop_details{category,explanation} —
+                            // capture for diagnostics so the caller can distinguish refusal classes (cyber/AUP) and
+                            // build refusal-failover policy. Dropped before = fail-closed but opaque.
+                            if (d?.stop_details)
+                                stopDetails = d.stop_details;
+                            // CC-parity round-2 B2: the closing `message_delta` carries the final `output_tokens` AND may
+                            // CORRECT the input/cache counts set at `message_start`. We used to read ONLY output_tokens (a
+                            // narrow cast), discarding a non-zero cache/input refinement → wrong cost + a cache-break
+                            // false-signal downstream (computeUsage feeds usageCostMicroUsd + the cache-break detector).
+                            // Merge all four like CC's `updateUsage` (claude.ts), guarding input/cache with `> 0` so a
+                            // delta-0 (the common case: Anthropic emits 0 for unchanged fields) never clobbers message_start.
+                            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": {
+                            // CC-parity B1: Anthropic emits a mid-stream `{type:"error",error:{type,message}}` frame AFTER
+                            // the 200 OK (e.g. overloaded_error/api_error during generation). The official SDK THROWS on it
+                            // (→ CC retries via withRetry); our parser used to fall through to the default no-op and
+                            // finalize() reported the partial content as a clean `stop` SUCCESS — a silent false-negative
+                            // with no retry. Throw a coded BrainError: it propagates out of onLine → runStreamingBrain's
+                            // catch → a `[code]`-prefixed error event that the failover/breaker/degrading stack classifies
+                            // (transient overloaded/api → server → retried). design/124 r3 (CC 2.1.199): the ENGINE
+                            // may downgrade an overload-class ("server") frame to a tier-A partial finalize when
+                            // substantive text already streamed; every other class stays fail-closed (B1).
+                            const e = evt.error;
+                            throw new BrainError(anthropicStreamErrorCode(e?.type), `anthropic stream error (${e?.type ?? "unknown"}): ${e?.message ?? ""}`);
+                        }
+                        default:
+                            break; // ping / message_stop / unknown
+                    }
+                };
+                return {
+                    // design/124 §0.5-2: tiering introspection — direct reads off the accumulated blocks. A
+                    // redacted_thinking block (payload delivered whole at block_start, no deltas) counts as
+                    // thinking streamed; a tool_use block only counts as completed once it CLOSED successfully
+                    // (closedTc cached ⟺ its toolcall_end was emitted at content_block_stop).
+                    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,
+                        };
+                    },
+                    // design/124 tier B: emit `thinking_end` for every thinking block still OPEN (no
+                    // content_block_stop seen) so the UI stream is sealed before the whole turn is re-sent.
+                    // Idempotent (marks the block stopped).
+                    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) {
+                        // design/130 P2b: poll the soft call deadline once per provider chunk (cheap — one
+                        // Date.now()). Crossing it cancels the stream deliberately; the salvage below keeps
+                        // the prefix and the sentinel errorMessage drives the loop's bounded write-out turn.
+                        // (A fully-stalled stream emits no chunks — the engine's idle watchdog owns that case.)
+                        if (callDeadlineMs !== undefined && !walltimeCut && !degenerate && Date.now() >= callDeadlineMs) {
+                            walltimeCut = true;
+                            ctrl.cancel();
+                            return; // codex HIGH: do NOT parse the triggering chunk — its delta must not join the salvage
+                        }
+                        if (walltimeCut)
+                            return; // any residual buffered line after the cut is equally dropped
+                        const line = rawLine.trim();
+                        if (!line.startsWith("data:"))
+                            return; // ignore `event:` lines; data: carries the JSON
+                        const data = line.slice(5).trim();
+                        if (!data)
+                            return;
+                        let evt;
+                        try {
+                            evt = JSON.parse(data);
+                        }
+                        catch {
+                            return;
+                        }
+                        handleEvent(evt);
+                    },
+                    finalize() {
+                        // --- assemble final message, preserving block order (thinking → text → tool_use) ---
+                        const finalContent = [];
+                        const toolCalls = [];
+                        const malformed = [];
+                        let anyText = false;
+                        // [477]: reasoning OBSERVED on this stream (a non-empty or redacted thinking block) —
+                        // the brain-local equivalent of the runner's callCapRef.reasoningObserved, decided from
+                        // what actually streamed so it needs no cross-layer plumbing.
+                        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; // store for replay
+                                if (acc.redacted)
+                                    block.redacted = true; // CC-parity B2: round-trips as redacted_thinking
+                                finalContent.push(block);
+                            }
+                            else if (acc.type === "text") {
+                                if (acc.text) {
+                                    finalContent.push({ type: "text", text: acc.text });
+                                    if (acc.text.trim())
+                                        anyText = true;
+                                }
+                            }
+                            else if (acc.type === "tool_use" && acc.toolName) {
+                                // design/120 P2.0: parse/id logic lives in closeToolUseBlock (shared with the in-stream
+                                // `toolcall_end` emission at content_block_stop — same parse discipline, same cached
+                                // ToolCall object, so the streamed id and the final content id can never diverge).
+                                const tc = closeToolUseBlock(acc);
+                                if (tc) {
+                                    toolCalls.push(tc);
+                                    finalContent.push(tc);
+                                }
+                                else {
+                                    // Truncated/invalid input_json (common on stop_reason="max_tokens") or a non-object
+                                    // top level. Do NOT execute the tool with empty `{}` — surface it instead.
+                                    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;
+                        // bug-hunt #2: a partial tool batch (valid call + a truncated one). Keep executing the valid
+                        // call (a brain error is a terminal task failure here), but make the dropped call VISIBLE so the
+                        // model re-issues it — it otherwise vanished silently (errorMessage rode the `done` event).
+                        // Emit the note whenever ANY call was malformed — INCLUDING text + all-calls-truncated (the
+                        // `toolCalls.length > 0` guard left that silent → clean `done`, loop ended the task prematurely).
+                        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;
+                        // service [405] P0: dynamic-cap truncation is the ENGINE's own doing — recoverable
+                        // `length` stop, not the static-config fail-loud error (see openai.ts, same discipline).
+                        const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
+                        // Blackboard [477] — the STATIC leg of the [405] family: a budget-ignoring thinking
+                        // model (Qwen anthropic 形态) burns the whole STATIC max_tokens on one long thought →
+                        // truncatedEmpty used to fail loud even though the loop's reasoning-cut continue nudge
+                        // recovers this shape verbatim. Downgrade to a recoverable `length` ONLY when (a) the
+                        // stream actually carried reasoning (a no-reasoning truncatedEmpty is still a genuine
+                        // config bug — fail loud, unchanged) and (b) the caller opted in for THIS call (the loop
+                        // grants it while its 2-per-run stop-loss budget lasts; direct callers like the
+                        // compaction summarizer never grant it, keeping their length_empty escalation contract).
+                        const staticReasoningCut = truncatedEmpty && !dynamicCut && reasoningSeen && options?.staticReasoningCutDowngrade === true;
+                        // bug-hunt #3: a provider SAFETY cut (Anthropic stop_reason="refusal") — `mapStopReason`
+                        // collapsed it to a clean "stop", reporting a refused/compromised turn as success. Fail closed.
+                        const safetyCut = stopReason === "refusal";
+                        // design/119 (CC 198): 4.5+ models can end a 200 stream with
+                        // stop_reason="model_context_window_exceeded" — the context no longer fits. Mapping it to
+                        // a clean "stop" would report a silently-incomplete turn as success AND bypass the loop's
+                        // prompt-too-long recovery. Fail closed as an error whose message the PTL classifier
+                        // matches (agent-loop PROMPT_TOO_LONG_RE), so a wired recovery can compact and retry.
+                        const contextWindowExceeded = stopReason === "model_context_window_exceeded";
+                        // bug-hunt #8: a conforming stream always sends a message_delta stop_reason. No content AND no
+                        // stop_reason ⇒ a torn stream / swallowed error frame — must not be an empty "stop" success.
+                        const emptyNoFinish = noUsableContent && stopReason == null && !degenerate && !walltimeCut;
+                        // P2b: `walltimeCut` wins the whole chain — the cut is OURS (deliberate, wall-clock), so no
+                        // downstream cause may re-attribute it; the sentinel must survive verbatim for the loop's
+                        // write-out recovery + the assembler's timeout-with-salvage mapping.
+                        // `degenerate` wins over `toolError` (design/39 + council): the loop is the root cause, so
+                        // `DEGENERATE_MESSAGE` must survive for the assembler to map it to `output.degenerate` + salvage.
+                        // `toolError` is INTENTIONALLY ahead of `emptyNoFinish` (cross-model review): on the rare collision
+                        // the tool-error string is more specific (names the tool, signals the missing close via `?`).
+                        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
+                                                // [477] 文案修: only suggest the knobs that are actually in play. A request that
+                                                // never carried a thinking field must not point at thinkingBudgetShare.
+                                                ? 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);
+                        // Structured cause, mirroring the errorMessage precedence chain: tagged ONLY when truncatedEmpty
+                        // is the selected cause, so callers can escalate max_tokens without parsing prose.
+                        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 } : {}), // T1-5: no provider frame → UNKNOWN
+                            timestamp: Date.now(),
+                            ...(errorMessage ? { errorMessage } : {}),
+                            ...(errorKind ? { errorKind } : {}),
+                            // Repetition telemetry: cut event + allowance-spared hits (deduped) observed on this stream.
+                            ...(repCut !== undefined || repSpared.size > 0
+                                ? { repetition: { ...(repCut !== undefined ? { cut: repCut } : {}), ...(repSpared.size > 0 ? { spared: [...repSpared.values()] } : {}) } }
+                                : {}),
+                            // [477]: tag the downgraded turn so the loop can count it against the 2-per-run stop-loss.
+                            ...(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