@sema-agent/core 2.13.0 → 4.0.0

package/dist/agents/verify.d.ts

@@ -1,6 +1,6 @@
 import { Type, type Static } from "typebox";
 import type { Runner, ResumeTaskConfig } from "../core/runner/runtask.js";
-import type { CheckpointToken, ResumeOutcome } from "../core/checkpoint-store.js";
+import type { CheckpointGate, CheckpointToken, ResumeOutcome } from "../core/checkpoint-store.js";
 import type { ModelRef, TaskResult, TaskSpec, ToolSpec } from "../core/types.js";
 export declare const VERIFICATION_PROMPT = "You are a verification specialist. Your job is NOT to confirm the implementation works \u2014 it is to try to BREAK it.\n\nYou have two documented failure patterns. First, verification avoidance: faced with a check, you find reasons not to run it \u2014 you read code, narrate what you would test, declare \"PASS,\" and move on. Second, being seduced by the first 80%: a polished result or a passing test suite makes you inclined to pass it, not noticing the edge that crashes, the state that vanishes, the bad input that is unhandled. The first 80% is the easy part. Your entire value is in finding the last 20%.\n\n## Hard boundary \u2014 do not modify the project\nYou are STRICTLY a verifier. Do NOT create, modify, or delete project files; do NOT install packages; do NOT run version-control write operations. Use only the read/probe/execute tools available to you. (If you need a scratch file, use a temp directory, and clean up.)\n\n## Evidence is mandatory\nReading code is NOT verification. Every check must actually run something \u2014 execute the code, hit the endpoint, run the build/tests \u2014 and record the command and its real output. A \"PASS\" with no command output is a skip, not a pass.\n\n## Strategy (adapt to what changed)\n- Build/lib changes: build it, run the full test suite, exercise the public API as a consumer would.\n- Backend/API: start it, call endpoints, check response *shapes* (not just status codes), test error paths.\n- CLI/script: run with representative AND edge inputs (empty, malformed, boundary); check stdout/stderr/exit codes.\n- Bug fix: reproduce the original bug first, verify the fix, then check for regressions and side effects.\n- Refactor (no behavior change): the existing suite must pass unchanged; diff the public surface; same inputs \u2192 same outputs.\nRun the project's own build/tests/linters as a baseline, then apply the type-specific checks. Test results are context, not proof \u2014 the implementer is an LLM too; its tests may be happy-path or circular.\n\n## Adversarial probes (pick the ones that fit)\nBoundary values (0, -1, empty, very long, unicode, max), idempotency (same mutating call twice), orphan operations (ids that don't exist), concurrency (parallel create-if-not-exists). Your verdict must include at least one adversarial probe you actually ran and its result \u2014 even if it was handled correctly.\n\n## Before you FAIL\nCheck you haven't missed why it's actually fine: defensive code elsewhere, intentional behavior documented in comments/specs, or an unfixable external-contract limitation (note that as an observation, not a FAIL). Don't wave away real issues, but don't FAIL on intentional behavior.\n\n## Verdict\nSubmit exactly one verdict via the provided output tool:\n- PASS \u2014 you ran real checks (including \u22651 adversarial probe) and it holds up. Put the commands + observed output in `evidence`.\n- FAIL \u2014 something is broken. Put each concrete problem (with how to reproduce) in `findings`.\n- PARTIAL \u2014 environmental limitation only (no test framework, a tool/server unavailable). Not for \"I'm unsure\": if you can run the check, decide PASS or FAIL. Note what you couldn't verify and why in `findings`.";
 export declare const STATIC_VERIFICATION_PROMPT = "You are a verification judge. Your job is NOT to confirm the change works \u2014 it is to find where it BREAKS.\n\nYou are READ-ONLY by design: the build and tests have ALREADY been run by a separate mechanical gate. Their results and the code change (a diff) are usually supplied to you as evidence; but if little or no diff/results are supplied this round (e.g. a re-verification AFTER a fix), judge the CURRENT working tree directly \u2014 do NOT return PARTIAL merely because a diff is absent. Do NOT try to execute code, run tests, or invoke a runtime \u2014 the environment will refuse it, and that is expected, not a limitation. Judge from any supplied diff/results plus read-only inspection of the working tree (read files, search, list).\n\nYou have two documented failure patterns. First, being seduced by the first 80%: a clean diff or a green test run makes you inclined to pass it, not noticing the edge that crashes, the state that vanishes, the bad input that is unhandled, the cross-module assumption that breaks. Second, hiding behind PARTIAL because you couldn't run something \u2014 that is NOT what PARTIAL is for here; execution was the mechanical gate's job. Your entire value is finding the last 20% by READING.\n\n## What to scrutinize (adapt to the diff)\n- Boundary/edge cases the tests likely miss: 0, -1, empty, very long, unicode, max, malformed input, idempotency, orphan ids, off-by-one, negative numbers, EOF/empty fields.\n- Semantic correctness vs the task spec: does the change actually do what was asked, including cases the tests don't cover (the title()/CSV/base62 class of defect)?\n- Cross-module/integration hazards in the diff: a changed signature/export/contract/default a caller elsewhere still assumes; a deleted helper something depends on.\n- If the provided test results show failures, that is a concrete FAIL with the failing output as evidence.\n\n## Verdict\nSubmit exactly one verdict via the provided output tool:\n- PASS \u2014 you read the diff + results, looked for the edges above, and it holds. Cite the specific things you checked in `evidence`.\n- FAIL \u2014 you found a concrete defect. Put each problem (with the diff location / input that breaks it) in `findings`.\n- PARTIAL \u2014 ONLY when the evidence itself is genuinely insufficient to judge (e.g. the diff is empty or unrelated to the task, no results supplied). NOT for \"I couldn't execute it.\" Say what's missing in `findings`.";
@@ -24,8 +24,15 @@ export interface VerifyConfig {
         verdict: VerificationOutcome["verdict"];
         findings: string[];
     }) => void;
+    onVerifierPause?: (info: {
+        round: number;
+        status: TaskResult["status"];
+        sessionId: string;
+        checkpointToken?: CheckpointToken;
+        checkpointGate?: CheckpointGate;
+    }) => void;
 }
-export type UnverifiedReason = "suspended" | "needs_review" | "no_verdict" | "opted_out" | "impl_incomplete" | "could_not_verify";
+export type UnverifiedReason = "suspended" | "needs_review" | "no_verdict" | "opted_out" | "impl_incomplete" | "could_not_verify" | "verifier_paused";
 export interface VerificationOutcome {
     verdict: "PASS" | "FAIL" | "PARTIAL" | "unverified";
     unverifiedReason?: UnverifiedReason;
@@ -33,6 +40,12 @@ export interface VerificationOutcome {
     findings: string[];
     evidence?: string;
     verifierCost?: number;
+    verifierPause?: {
+        status: TaskResult["status"];
+        sessionId: string;
+        checkpointToken?: CheckpointToken;
+        checkpointGate?: CheckpointGate;
+    };
 }
 export interface VerificationResult extends TaskResult {
     verification: VerificationOutcome;

package/dist/agents/verify.js

@@ -3,6 +3,7 @@ import { CODE_AGENT_PROMPT } from "../prompts/default.js";
 import { releaseSession } from "./session-util.js";
 import { mapNestedSuspend, isDurablePause } from "./suspend-guard.js";
 import { delimitUntrusted, sanitizeUntrustedText } from "../core/untrusted-text.js";
+import { createSafeNotifier } from "../core/safe-notify.js";
 export const VERIFICATION_PROMPT = `You are a verification specialist. Your job is NOT to confirm the implementation works — it is to try to BREAK it.
 
 You have two documented failure patterns. First, verification avoidance: faced with a check, you find reasons not to run it — you read code, narrate what you would test, declare "PASS," and move on. Second, being seduced by the first 80%: a polished result or a passing test suite makes you inclined to pass it, not noticing the edge that crashes, the state that vanishes, the bad input that is unhandled. The first 80% is the easy part. Your entire value is in finding the last 20%.
@@ -58,6 +59,8 @@ export const VerdictSchema = Type.Object({
     }),
     evidence: Type.Optional(Type.String({ description: "Commands run + observed output backing the verdict." })),
 });
+const VERIFY_ON_ROUND_SITE = "verify.onRound";
+const VERIFY_ON_VERIFIER_PAUSE_SITE = "verify.onVerifierPause";
 function fixObjective(findings) {
     const list = findings.length
         ? findings.map((f) => `- ${sanitizeUntrustedText(f)}`).join("\n")
@@ -82,7 +85,8 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
     if (result.status !== "completed") {
         return { ...result, verification: { verdict: "unverified", unverifiedReason: "impl_incomplete", rounds: 0, findings: [] } };
     }
-    const maxRounds = Math.max(1, Math.floor(config.maxRounds ?? 2));
+    const maxRounds = Number.isFinite(config.maxRounds) ? Math.max(1, Math.floor(config.maxRounds)) : 2;
+    const notifier = createSafeNotifier();
     const verifierTools = config.verifierTools ?? (specBase.tools ?? []).filter((t) => t.effect === "read");
     const evidenceMode = config.evidence != null && config.evidence.trim() !== "";
     const verifierPrompt = config.verifierPrompt ?? (evidenceMode ? STATIC_VERIFICATION_PROMPT : VERIFICATION_PROMPT);
@@ -102,7 +106,8 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
             signal: specBase.signal,
         });
         try {
-            return { verdict: v.structuredOutput, cost: (v.stats.costMicroUsd ?? 0) + (v.stats.nested?.costMicroUsd ?? 0) };
+            const cost = (v.stats.costMicroUsd ?? 0) + (v.stats.nested?.costMicroUsd ?? 0);
+            return { verdict: v.structuredOutput, cost, ...(isDurablePause(v.status) ? { paused: v } : {}) };
         }
         finally {
             if (!isDurablePause(v.status))
@@ -115,9 +120,40 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
     let spend = 0;
     let verifierSpend = 0;
     for (let round = 1; round <= maxRounds; round++) {
+        if (round > 1) {
+            if (config.totalTimeoutMs != null && Date.now() - startedAt >= config.totalTimeoutMs)
+                break;
+            if (config.costCeilingMicroUsd != null && spend >= config.costCeilingMicroUsd)
+                break;
+        }
         const v = await runVerifier(current, round);
         spend += v.cost;
         verifierSpend += v.cost;
+        if (v.paused) {
+            const paused = v.paused;
+            outcome = {
+                verdict: "unverified",
+                unverifiedReason: "verifier_paused",
+                rounds: round,
+                findings: [],
+                verifierCost: verifierSpend,
+                verifierPause: {
+                    status: v.paused.status,
+                    sessionId: v.paused.sessionId,
+                    ...(v.paused.checkpointToken ? { checkpointToken: v.paused.checkpointToken } : {}),
+                    ...(v.paused.checkpointGate ? { checkpointGate: v.paused.checkpointGate } : {}),
+                },
+            };
+            notifier.notify(() => config.onVerifierPause?.({
+                round,
+                status: paused.status,
+                sessionId: paused.sessionId,
+                ...(paused.checkpointToken ? { checkpointToken: paused.checkpointToken } : {}),
+                ...(paused.checkpointGate ? { checkpointGate: paused.checkpointGate } : {}),
+            }), VERIFY_ON_VERIFIER_PAUSE_SITE);
+            notifier.notify(() => config.onRound?.({ round, verdict: outcome.verdict, findings: outcome.findings }), VERIFY_ON_ROUND_SITE);
+            break;
+        }
         const rawVerdict = v.verdict?.verdict ?? "unverified";
         const verdict = rawVerdict === "PARTIAL" ? "unverified" : rawVerdict;
         const unverifiedReason = !v.verdict ? "no_verdict" : rawVerdict === "PARTIAL" ? "could_not_verify" : undefined;
@@ -129,7 +165,7 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
             evidence: v.verdict?.evidence,
             verifierCost: verifierSpend,
         };
-        config.onRound?.({ round, verdict: outcome.verdict, findings: outcome.findings });
+        notifier.notify(() => config.onRound?.({ round, verdict: outcome.verdict, findings: outcome.findings }), VERIFY_ON_ROUND_SITE);
         if (outcome.verdict !== "FAIL")
             break;
         if (round >= maxRounds)

package/dist/bin/sema-tb.js

@@ -289,7 +289,7 @@ async function main() {
         switch (e.kind) {
             case "brain.call":
                 lastServedModel = e.model;
-                line(`[call] model=${e.model} in=${e.promptTokens} out=${e.completionTokens} cache=${e.cacheRead} latMs=${e.latencyMs}` +
+                line(`[call] model=${e.model} in=${e.promptTokens} tot=${e.totalInputTokens} out=${e.completionTokens} cache=${e.cacheRead} latMs=${e.latencyMs}` +
                     (e.firstTokenMs !== undefined ? ` ttftMs=${e.firstTokenMs}` : "") +
                     (e.stopReason !== undefined ? ` stop=${e.stopReason}` : "") +
                     (e.callCap !== undefined ? ` cap=${e.callCap}${e.capThinkingSkipped ? "(think-skip)" : ""}` : "") +
@@ -403,7 +403,7 @@ async function main() {
                     reason.flush();
                     turns++;
                     const u = ev.usage;
-                    line(`[turn] ${turns}${u ? ` in=${u.inputTokens} out=${u.outputTokens} cache=${u.cacheReadTokens}` : ""}` +
+                    line(`[turn] ${turns}${u ? ` in=${u.inputTokens} tot=${u.totalInputTokens} out=${u.outputTokens} cache=${u.cacheReadTokens}` : ""}` +
                         (ev.usageMissing ? " usageMissing=1" : "") +
                         (ev.stopReason !== undefined ? ` stop=${ev.stopReason}` : ""));
                     break;

package/dist/brain/anthropic.js

@@ -1,7 +1,8 @@
 import {} from "../internal/llm.js";
 import { BrainError } from "./errors.js";
 import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
-import { createRepetitionPoll, createWalltimeGate } from "./stream-shared.js";
+import { createRepetitionPoll, createWalltimeGate, parseStreamedToolArgs } from "./stream-shared.js";
+import { mintFallbackToolCallId } from "./tool-call-id.js";
 import { WALLTIME_CUTOFF_MESSAGE } from "./walltime.js";
 import { emitBrainTelemetry } from "./status-sink.js";
 import { ANTHROPIC_RESERVED, applyExtraBody, stripAuthHeaders } from "./request-params.js";
@@ -201,23 +202,11 @@ function closeToolUseBlock(acc) {
         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 = {};
-    }
+    const args = parseStreamedToolArgs(acc.toolJson);
+    if (args === undefined)
+        return undefined;
     if (!acc.toolId)
-        acc.toolId = `toolu_${Math.random().toString(36).slice(2)}`;
+        acc.toolId = mintFallbackToolCallId("toolu_");
     acc.closedTc = { type: "toolCall", id: acc.toolId, name: acc.toolName, arguments: args };
     return acc.closedTc;
 }
@@ -339,6 +328,8 @@ export function createAnthropicBrain(config = {}) {
                 let stopReason = null;
                 let stopDetails;
                 let nextContentIndex = 0;
+                let malformedFrames = 0;
+                let malformedSample;
                 let degenerate = false;
                 let degenTextBlock;
                 const rep = createRepetitionPoll();
@@ -512,6 +503,8 @@ export function createAnthropicBrain(config = {}) {
                             evt = JSON.parse(data);
                         }
                         catch {
+                            malformedFrames++;
+                            malformedSample ??= data.slice(0, 160);
                             return;
                         }
                         handleEvent(evt);
@@ -563,6 +556,12 @@ export function createAnthropicBrain(config = {}) {
                                 text: `\n[note: ${malformed.length} tool call(s) were truncated (stop_reason="${stopReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
                             });
                         }
+                        if (malformedFrames > 0) {
+                            finalContent.push({
+                                type: "text",
+                                text: `\n[note: ${malformedFrames} provider stream frame(s) were not valid JSON and were dropped — the streamed output may be missing content (first sample: ${JSON.stringify(malformedSample)})]`,
+                            });
+                        }
                         const truncatedEmpty = stopReason === "max_tokens" && noUsableContent && !toolError;
                         const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
                         const staticReasoningCut = truncatedEmpty && !dynamicCut && reasoningSeen && options?.staticReasoningCutDowngrade === true;
@@ -586,7 +585,7 @@ export function createAnthropicBrain(config = {}) {
                                                         ? `[length_empty] response truncated at max_tokens with no answer text (${maxTokensNote}) — the model emitted reasoning although no thinking was requested (a budget-ignoring gateway?) and it consumed the entire output budget; raise max_tokens`
                                                         : `[length_empty] response truncated at max_tokens with no answer text (${maxTokensNote}); raise max_tokens`
                                                 : emptyNoFinish
-                                                    ? `[stream_torn] model stream ended with no content and no stop_reason — the response was lost (a torn stream or an in-band provider error frame)`
+                                                    ? `[stream_torn] model stream ended with no content and no stop_reason — the response was lost (a torn stream or an in-band provider error frame)${malformedFrames > 0 ? ` — ${malformedFrames} unparseable data frame(s) were dropped on this stream (first sample: ${JSON.stringify(malformedSample)})` : ""}`
                                                     : undefined));
                         const errored = walltime.cut ||
                             degenerate ||
@@ -595,9 +594,13 @@ export function createAnthropicBrain(config = {}) {
                             emptyNoFinish ||
                             (toolError !== undefined && noUsableContent) ||
                             (truncatedEmpty && !dynamicCut && !staticReasoningCut);
-                        const errorKind = !walltime.cut && !degenerate && !safetyCut && toolError === undefined && truncatedEmpty && !dynamicCut && !staticReasoningCut
-                            ? "length_empty"
-                            : undefined;
+                        const errorKind = walltime.cut
+                            ? "walltime_cutoff"
+                            : degenerate
+                                ? "degenerate"
+                                : !safetyCut && toolError === undefined && truncatedEmpty && !dynamicCut && !staticReasoningCut
+                                    ? "length_empty"
+                                    : undefined;
                         const finalMessage = {
                             ...partial,
                             content: finalContent.length > 0 ? finalContent : [{ type: "text", text: "" }],

package/dist/brain/circuit-breaker.d.ts

@@ -8,6 +8,7 @@ export interface BreakerSnapshot {
     failures: number;
     openedAt?: number;
     halfOpenInFlight?: number;
+    halfOpenAt?: number;
 }
 export interface BreakerState {
     get(key: string): BreakerSnapshot | undefined;

package/dist/brain/circuit-breaker.js

@@ -11,14 +11,14 @@ class InMemoryBreakerState {
         this.m.set(k, s);
     }
 }
-function errorAssistantMessage(model, code, detail) {
+function errorAssistantMessage(model, code, detail, stopReason = "error") {
     return {
         role: "assistant",
         content: [{ type: "text", text: "" }],
         api: model.api,
         provider: model.provider,
         model: model.id,
-        stopReason: "error",
+        stopReason,
         errorMessage: `[${code}] ${detail}`,
         usage: ZERO_USAGE,
         timestamp: Date.now(),
@@ -44,21 +44,33 @@ export function createCircuitBreakerBrain(inner, opts = {}) {
         if (s.phase === "closed")
             return { pass: true };
         if (s.phase === "open") {
-            if (s.openedAt === undefined)
-                return { pass: false };
+            if (s.openedAt === undefined) {
+                state.set(key, { ...s, openedAt: now() });
+                return { pass: false, retryInMs: cooldownMs };
+            }
             const elapsed = now() - s.openedAt;
             if (elapsed >= cooldownMs) {
-                setState(key, s.phase, { ...s, phase: "half-open", halfOpenInFlight: 1 });
+                setState(key, s.phase, { ...s, phase: "half-open", halfOpenInFlight: 1, halfOpenAt: now() });
                 return { pass: true };
             }
             return { pass: false, retryInMs: cooldownMs - elapsed };
         }
         const inFlight = s.halfOpenInFlight ?? 0;
         if (inFlight < halfOpenProbes) {
-            state.set(key, { ...s, halfOpenInFlight: inFlight + 1 });
+            state.set(key, { ...s, halfOpenInFlight: inFlight + 1, halfOpenAt: s.halfOpenAt ?? now() });
             return { pass: true };
         }
-        return { pass: false };
+        const leaseStart = s.halfOpenAt;
+        if (leaseStart === undefined) {
+            state.set(key, { ...s, halfOpenAt: now() });
+            return { pass: false, retryInMs: cooldownMs };
+        }
+        const held = now() - leaseStart;
+        if (held >= cooldownMs) {
+            state.set(key, { ...s, halfOpenInFlight: 1, halfOpenAt: now() });
+            return { pass: true };
+        }
+        return { pass: false, retryInMs: cooldownMs - held };
     };
     const record = (key, failedCode, viaProbe = true) => {
         const s = snap(key);
@@ -118,9 +130,14 @@ export function createCircuitBreakerBrain(inner, opts = {}) {
                 }
             }
             catch (e) {
+                const aborted = options?.signal?.aborted === true || (e instanceof Error && e.name === "AbortError");
                 const code = e instanceof BrainError ? e.code : "network";
-                record(key, code, !bypass);
-                out.push({ type: "error", reason: "error", error: errorAssistantMessage(model, code, e instanceof Error ? e.message : String(e)) });
+                record(key, aborted ? "http" : code, !bypass);
+                out.push({
+                    type: "error",
+                    reason: aborted ? "aborted" : "error",
+                    error: errorAssistantMessage(model, code, e instanceof Error ? e.message : String(e), aborted ? "aborted" : "error"),
+                });
             }
         })();
         return out;

package/dist/brain/degrading.js

@@ -91,8 +91,20 @@ export function passthroughStream(brain, model, context, options) {
     void (async () => {
         try {
             const inner = await brain.stream(model, context, options);
-            for await (const ev of inner)
+            let sawTerminal = false;
+            for await (const ev of inner) {
+                if (ev.type === "done" || ev.type === "error")
+                    sawTerminal = true;
                 out.push(ev);
+            }
+            if (!sawTerminal) {
+                await inner.result();
+                out.push({
+                    type: "error",
+                    reason: "error",
+                    error: errorMessageOf(model, new Error("brain stream ended without a terminal event"), false),
+                });
+            }
         }
         catch (e) {
             const aborted = options?.signal?.aborted === true ||

package/dist/brain/failover.js

@@ -53,6 +53,8 @@ export function createFailoverBrain(brains) {
                             ...(lastFailedCode !== undefined ? { errorCode: lastFailedCode } : {}),
                         });
                     }
+                    if (!sawContent && heldStart)
+                        out.push(heldStart);
                     out.push(terminal ?? {
                         type: "done",
                         reason: message.stopReason,

package/dist/brain/openai.js

@@ -1,7 +1,8 @@
 import {} from "../internal/llm.js";
 import { repairTextToolCalls } from "./tool-call-repair.js";
 import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
-import { createRepetitionPoll, createWalltimeGate } from "./stream-shared.js";
+import { createRepetitionPoll, createWalltimeGate, parseStreamedToolArgs } from "./stream-shared.js";
+import { mintFallbackToolCallId } from "./tool-call-id.js";
 import { WALLTIME_CUTOFF_MESSAGE } from "./walltime.js";
 import { emitBrainTelemetry } from "./status-sink.js";
 import { OPENAI_RESERVED, applyExtraBody, stripAuthHeaders } from "./request-params.js";
@@ -12,23 +13,11 @@ function closeToolCallAccum(acc) {
         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 = {};
-    }
+    const args = parseStreamedToolArgs(acc.args);
+    if (args === undefined)
+        return undefined;
     if (!acc.id)
-        acc.id = `call_${Math.random().toString(36).slice(2)}`;
+        acc.id = mintFallbackToolCallId("call_");
     acc.closedTc = { type: "toolCall", id: acc.id, name: acc.name, arguments: args };
     return acc.closedTc;
 }
@@ -356,6 +345,8 @@ export function createOpenAIBrain(config = {}) {
                 const toolAccum = new Map();
                 let finishReason = null;
                 let usageRaw;
+                let malformedFrames = 0;
+                let malformedSample;
                 const thinkingBlock = { type: "thinking", thinking: "" };
                 const textBlock = { type: "text", text: "" };
                 const pushReasoningDelta = (delta) => {
@@ -438,6 +429,8 @@ export function createOpenAIBrain(config = {}) {
                             chunk = JSON.parse(data);
                         }
                         catch {
+                            malformedFrames++;
+                            malformedSample ??= data.slice(0, 160);
                             return;
                         }
                         if (chunk.usage)
@@ -535,6 +528,12 @@ export function createOpenAIBrain(config = {}) {
                                 text: `\n[note: ${malformed.length} tool call(s) were truncated (finish_reason="${finishReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
                             });
                         }
+                        if (malformedFrames > 0) {
+                            finalContent.push({
+                                type: "text",
+                                text: `\n[note: ${malformedFrames} provider stream frame(s) were not valid JSON and were dropped — the streamed output may be missing content (first sample: ${JSON.stringify(malformedSample)})]`,
+                            });
+                        }
                         const truncatedEmpty = finishReason === "length" && noUsableContent && !toolError;
                         const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
                         const safetyCut = finishReason === "content_filter";
@@ -557,7 +556,7 @@ export function createOpenAIBrain(config = {}) {
                                                     ? `[length_empty] response truncated at max_tokens (finish_reason="length", ${maxTokensNote}) with no answer text — the model spent the whole budget on reasoning (${accumReasoning.length} reasoning chars). Raise max_tokens, or disable thinking for this task.`
                                                     : `[length_empty] response truncated at max_tokens (finish_reason="length", ${maxTokensNote}) with no answer text — raise max_tokens`
                                                 : emptyNoFinish
-                                                    ? `[stream_torn] model stream ended with no content and no finish_reason — the response was lost (a torn stream or an in-band provider error frame)`
+                                                    ? `[stream_torn] model stream ended with no content and no finish_reason — the response was lost (a torn stream or an in-band provider error frame)${malformedFrames > 0 ? ` — ${malformedFrames} unparseable data frame(s) were dropped on this stream (first sample: ${JSON.stringify(malformedSample)})` : ""}`
                                                     : undefined));
                         const errored = walltime.cut ||
                             degenerate ||
@@ -566,9 +565,13 @@ export function createOpenAIBrain(config = {}) {
                             emptyNoFinish ||
                             (toolError !== undefined && noUsableContent) ||
                             (truncatedEmpty && !dynamicCut);
-                        const errorKind = !walltime.cut && !degenerate && !safetyCut && !refused && toolError === undefined && truncatedEmpty && !dynamicCut
-                            ? "length_empty"
-                            : undefined;
+                        const errorKind = walltime.cut
+                            ? "walltime_cutoff"
+                            : degenerate
+                                ? "degenerate"
+                                : !safetyCut && !refused && toolError === undefined && truncatedEmpty && !dynamicCut
+                                    ? "length_empty"
+                                    : undefined;
                         const finalMessage = {
                             ...partial,
                             content: finalContent.length > 0 ? finalContent : [{ type: "text", text: "" }],

package/dist/brain/repetition.js

@@ -11,6 +11,15 @@ const SEGMENT_MAX = 120;
 function clipSegment(s) {
     return s.length > SEGMENT_MAX ? s.slice(0, SEGMENT_MAX) : s;
 }
+function trailingRepeats(text, unit, cap) {
+    let n = 0;
+    let end = text.length;
+    while (n < cap && end - unit.length >= 0 && text.startsWith(unit, end - unit.length)) {
+        n++;
+        end -= unit.length;
+    }
+    return n;
+}
 function looksLikeCodeLineUnit(unit) {
     if (!unit.includes("\n")) {
         return false;
@@ -59,7 +68,7 @@ export function inspectDegenerate(text) {
             if (!looksLikeCodeLineUnit(unit)) {
                 return { degenerate: true, cut: event, spared };
             }
-            if (t === WINDOW && reps >= SATURATION_REPS && reps * p >= t - p) {
+            if (t === WINDOW && reps * p >= t - p && trailingRepeats(text, unit, SATURATION_REPS) >= SATURATION_REPS) {
                 return { degenerate: true, cut: event, spared };
             }
             if (!sparedUnitLoop) {

package/dist/brain/routing.js

@@ -17,7 +17,11 @@ export function createRoutingBrain(routes, opts = {}) {
     const by = opts.by ?? "provider";
     const stream = (model, context, options) => {
         const key = by === "api" ? model.api : model.provider;
-        const target = routes[key] ?? opts.fallback;
+        const routed = Object.hasOwn(routes, key) ? routes[key] : undefined;
+        const matched = routed !== null && typeof routed === "object" && typeof routed.stream === "function"
+            ? routed
+            : undefined;
+        const target = matched ?? opts.fallback;
         if (!target) {
             const out = createAssistantMessageEventStream();
             out.push({

package/dist/brain/status-sink.js

@@ -4,7 +4,11 @@ export function runWithStatusSink(emit, fn) {
     return statusSinkStore.run({ emit }, fn);
 }
 export function emitBrainStatus(status) {
-    statusSinkStore.getStore()?.emit(status);
+    try {
+        statusSinkStore.getStore()?.emit(status);
+    }
+    catch {
+    }
 }
 const telemetrySinkStore = new AsyncLocalStorage();
 export function runWithBrainTelemetry(emit, fn) {

package/dist/brain/stream-engine.js

@@ -8,7 +8,7 @@ const DEFAULT_MAX_RETRIES = 10;
 const MAX_RETRIES_ENV_CEILING = 15;
 const MAX_RETRIES_ENV = "SEMA_MAX_RETRIES";
 export function resolveMaxRetries(configured) {
-    if (configured !== undefined)
+    if (configured !== undefined && Number.isFinite(configured))
         return configured;
     const raw = process.env[MAX_RETRIES_ENV];
     if (raw !== undefined && raw.trim() !== "") {
@@ -88,10 +88,13 @@ export function runStreamingBrain(args) {
         .catch((err) => {
         const aborted = signal?.aborted === true || isAbortError(err);
         terminalRetryPhase = "gave_up";
-        terminalRetryDetail = aborted ? "cancelled while retrying" : isWalltimeCutoff(err) ? "wall-clock deadline reached while retrying" : "retries exhausted";
+        const walltimeCut = isWalltimeCutoff(err);
+        terminalRetryDetail = aborted ? "cancelled while retrying" : walltimeCut ? "wall-clock deadline reached while retrying" : "retries exhausted";
         const errorMsg = emptyAssistant(model);
         errorMsg.stopReason = aborted ? "aborted" : "error";
         errorMsg.errorMessage = err instanceof Error ? err.message : String(err);
+        if (walltimeCut)
+            errorMsg.errorKind = "walltime_cutoff";
         errorMsg.usageMissing = true;
         out.push({ type: "error", reason: aborted ? "aborted" : "error", error: errorMsg });
     })

package/dist/brain/stream-shared.d.ts

@@ -1,4 +1,5 @@
 import { type RepetitionEvent } from "./repetition.js";
+export declare function parseStreamedToolArgs(json: string): Record<string, unknown> | undefined;
 export interface RepetitionPoll {
     poll(text: string): boolean;
     readonly cut: RepetitionEvent | undefined;

package/dist/brain/stream-shared.js

@@ -1,4 +1,18 @@
 import { inspectDegenerate } from "./repetition.js";
+export function parseStreamedToolArgs(json) {
+    if (!json)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        return undefined;
+    return parsed;
+}
 export function createRepetitionPoll() {
     let repCut;
     const repSpared = new Map();

package/dist/brain/terminal-cause.d.ts

@@ -0,0 +1,4 @@
+import type { AssistantMessage } from "../internal/llm.js";
+export type TerminalCauseCarrier = Pick<AssistantMessage, "errorKind" | "errorMessage">;
+export declare function isDegenerateCutMessage(message: TerminalCauseCarrier): boolean;
+export declare function isWalltimeCutMessage(message: TerminalCauseCarrier): boolean;

package/dist/brain/terminal-cause.js

@@ -0,0 +1,12 @@
+import { DEGENERATE_MESSAGE } from "./repetition.js";
+import { WALLTIME_CUTOFF_MESSAGE } from "./walltime.js";
+export function isDegenerateCutMessage(message) {
+    if (message.errorKind === "degenerate")
+        return true;
+    return message.errorMessage === DEGENERATE_MESSAGE;
+}
+export function isWalltimeCutMessage(message) {
+    if (message.errorKind === "walltime_cutoff")
+        return true;
+    return message.errorMessage === WALLTIME_CUTOFF_MESSAGE;
+}

package/dist/brain/tool-call-id.d.ts

@@ -0,0 +1 @@
+export declare function mintFallbackToolCallId(prefix: string): string;

package/dist/brain/tool-call-id.js

@@ -0,0 +1,3 @@
+export function mintFallbackToolCallId(prefix) {
+    return `${prefix}${Math.random().toString(36).slice(2)}`;
+}