@sema-ai/core 1.275.1

package/dist/brain/stream-engine.js

@@ -0,0 +1,391 @@
+import { createAssistantMessageEventStream, } from "../internal/llm.js";
+import { BrainError, classifyHttp } from "./errors.js";
+import { retryBackoffMs } from "./retry.js";
+import { emitBrainStatus, emitBrainTelemetry } from "./status-sink.js";
+import { makeConnectController } from "./timeout.js";
+const EMPTY_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+function emptyAssistant(model) {
+    return {
+        role: "assistant",
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        stopReason: "stop",
+        usage: { ...EMPTY_USAGE, cost: { ...EMPTY_USAGE.cost } },
+        timestamp: Date.now(),
+    };
+}
+function isAbortError(err) {
+    return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted)
+            return resolve(); // already aborted → don't even start the timer
+        // A wired cancellation must interrupt the backoff promptly — without this an outer abort during a long
+        // Retry-After backoff (up to MAX_RETRY_AFTER_MS) keeps the brain call alive for up to that long. The loop
+        // top re-checks signal?.aborted and throws AbortError, so resolving early here cancels the wait cleanly.
+        // The task `signal` is LONG-LIVED (one per task, shared across every turn), so the normal timer path MUST
+        // remove the abort listener too — `{once:true}` only auto-removes it when abort actually fires, else each
+        // completed backoff leaks one listener (MaxListenersExceededWarning), mirroring timeout.ts dispose discipline.
+        let t;
+        const onAbort = () => {
+            clearTimeout(t);
+            resolve();
+        };
+        t = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/**
+ * Run one streaming request end-to-end and drive the provider `parser`. Returns a fresh event stream;
+ * never throws (errors are pushed as `error` events, mirroring the Brain contract).
+ */
+export function runStreamingBrain(args) {
+    const { model, doFetch, signal, config, httpLabel, buildRequest, makeParser } = args;
+    const out = createAssistantMessageEventStream();
+    // `cleanup` releases the connect controller (its outer-abort listener) + any armed timers. Run it in
+    // `.finally` so it fires EXACTLY once however the request settles — including a mid-stream throw that
+    // would otherwise leak the `onAbort` listener on the task signal across turns.
+    // It's reassigned in three phases as more resources exist: undefined → `connect.dispose` the instant
+    // the controller escapes the connect loop (closes a leak window if synchronous init then throws) →
+    // full timers+connect cleanup once the timers are armed. The reassignments are synchronous, before any
+    // await that could let `.finally` observe a half-set cleanup.
+    let cleanup;
+    void run()
+        .catch((err) => {
+        const aborted = signal?.aborted === true || isAbortError(err);
+        const errorMsg = emptyAssistant(model);
+        errorMsg.stopReason = aborted ? "aborted" : "error";
+        errorMsg.errorMessage = err instanceof Error ? err.message : String(err);
+        out.push({ type: "error", reason: aborted ? "aborted" : "error", error: errorMsg });
+    })
+        .finally(() => cleanup?.());
+    return out;
+    async function run() {
+        const req = buildRequest();
+        const maxRetries = config.maxRetries ?? 2;
+        const baseDelay = config.retryDelayMs ?? 400;
+        // design/124 mid-stream recovery — attempt boundary (§0.5-1): one stream() emits EXACTLY ONE
+        // `start` event, however many attempts. A retry attempt's parser streams its events with a FRESH
+        // partial snapshot; a consumer applying snapshot-replacement semantics (agent-loop
+        // resolveAssistantMessageUpdate returns `event.partial` wholesale) sees the previous attempt's
+        // streamed prefix (e.g. tier-B thinking) vanish from context — CC's "drop the thinking, retry the
+        // whole turn" expressed in our event protocol. Budgets: tier C (zero substantive events) draws
+        // from the SAME `maxRetries` pool as connect failures ("headers arrived" no longer immunizes the
+        // attempt); tier B (thinking-only) has its own small pool (CC: stale-conn ≤ 2, backoff 100×n ms).
+        let attempt = 0; // shared budget: connect failures + tier-C mid-stream retries
+        let thinkingRetries = 0; // tier-B budget, ≤ 2
+        let startEmitted = false;
+        for (;;) {
+            // --- connect with timeout + retry transient failures until we have a streamable response ---
+            let res;
+            let connect;
+            for (;; attempt++) {
+                if (signal?.aborted) {
+                    const e = new Error("aborted");
+                    e.name = "AbortError";
+                    throw e;
+                }
+                // Per-attempt connect controller: fires if headers don't arrive in time while still forwarding an
+                // outer abort; once headers are in, its signal keeps governing the body.
+                const cc = makeConnectController(config.connectTimeoutMs, signal);
+                let r;
+                let netErr;
+                try {
+                    r = await doFetch(req.url, { method: "POST", headers: req.headers, body: req.body, signal: cc.signal });
+                }
+                catch (e) {
+                    if (cc.timedOut()) {
+                        netErr = new Error(`connect timeout after ${config.connectTimeoutMs}ms`); // retryable network failure
+                    }
+                    else if (isAbortError(e) || signal?.aborted) {
+                        cc.dispose();
+                        throw e;
+                    }
+                    else {
+                        netErr = e;
+                    }
+                }
+                if (r && r.ok && r.body) {
+                    cc.clearTimer(); // headers in: stop the connect timer, keep the outer-abort link for the body
+                    connect = cc;
+                    // Minimal cleanup the instant the controller escapes the loop — closes the leak window if any
+                    // synchronous init below throws before the fuller cleanup is assigned (council R2).
+                    cleanup = () => connect?.dispose();
+                    res = r;
+                    break;
+                }
+                cc.dispose(); // this attempt failed — clean up before retry/throw
+                // CC-parity round-3: 408 (request timeout) / 409 (lock timeout) are transient — retry in-loop like 5xx/429
+                // (this is the connect/pre-body path, so a re-send is safe + idempotent). Matches CC withRetry.
+                const retryable = netErr !== undefined ||
+                    (r !== undefined && (r.status >= 500 || r.status === 429 || r.status === 408 || r.status === 409));
+                if (retryable && attempt < maxRetries) {
+                    const delayMs = retryBackoffMs(baseDelay, attempt, r); // full jitter + honor Retry-After (§10 N1/N2)
+                    // design/99 §E3/§E10: surface the brain's (otherwise silent) wait as a live, provider-neutral status so
+                    // a UI can show "rate limited / retrying in Ns". 429 → rate_limited; a network/connect failure →
+                    // reconnecting; a 5xx → retrying. Fire-and-forget (no-op outside a Runner task).
+                    const statusPhase = r?.status === 429 ? "rate_limited" : netErr !== undefined ? "reconnecting" : "retrying";
+                    // service [398] C6: the abandoned attempt's cost is unknowable (its usage frame never arrived —
+                    // that's why it failed), so report the honest signal: which attempt was abandoned, which lane.
+                    emitBrainTelemetry({ kind: "retry", attempt: attempt + 1, phase: "connect" });
+                    emitBrainStatus({
+                        phase: statusPhase,
+                        // Neutral hint (NO HTTP status / provider taxonomy — BrainStatus.detail contract). One per phase.
+                        detail: statusPhase === "rate_limited"
+                            ? "rate limited, backing off"
+                            : statusPhase === "reconnecting"
+                                ? "connection lost, reconnecting"
+                                : "transient error, retrying",
+                        retryInSec: Math.ceil(delayMs / 1000),
+                    });
+                    await sleep(delayMs, signal); // abortable: an outer cancel during the backoff interrupts promptly (loop top throws)
+                    continue;
+                }
+                if (netErr)
+                    throw new BrainError("network", netErr instanceof Error ? netErr.message : String(netErr));
+                const detail = r ? await r.text().catch(() => "") : "";
+                const status = r?.status ?? 0;
+                throw new BrainError(classifyHttp(status), `${httpLabel} HTTP ${status || "ERR"}: ${detail.slice(0, 500)}`, status);
+            }
+            // --- streaming: timers + read loop (the single source of truth for the timer-reset logic) ---
+            const partial = emptyAssistant(model);
+            if (!startEmitted) {
+                startEmitted = true; // §0.5-1: retry attempts must NOT re-emit start (no orphan partial, no wire double message_start)
+                out.push({ type: "start", partial: { ...partial } });
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            let firstTokenSeen = false;
+            let firstTokenTimedOut = false;
+            let ftTimer;
+            if (config.firstTokenTimeoutMs && config.firstTokenTimeoutMs > 0) {
+                ftTimer = setTimeout(() => {
+                    firstTokenTimedOut = true;
+                    void reader.cancel().catch(() => undefined);
+                }, config.firstTokenTimeoutMs);
+            }
+            let idleTimedOut = false;
+            let idleTimer;
+            const bumpIdle = () => {
+                if (!config.idleTimeoutMs || config.idleTimeoutMs <= 0)
+                    return;
+                // A delta just arrived → NOT idle. Reset the flag too (symmetric with firstTokenTimedOut): a timer
+                // that fired just before a buffered delta is processed must not spuriously throw idle timeout + retry.
+                idleTimedOut = false;
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                idleTimer = setTimeout(() => {
+                    idleTimedOut = true;
+                    void reader.cancel().catch(() => undefined);
+                }, config.idleTimeoutMs);
+            };
+            const sawContentToken = () => {
+                bumpIdle(); // every content delta resets the idle watchdog (runs even after the first token)
+                if (firstTokenSeen)
+                    return;
+                firstTokenSeen = true;
+                // Clear BOTH the timer and the timed-out flag: if the timer already fired but a buffered first
+                // delta is now processed, the turn must NOT be failed as a timeout (council #2/#3).
+                firstTokenTimedOut = false;
+                if (ftTimer) {
+                    clearTimeout(ftTimer);
+                    ftTimer = undefined;
+                }
+            };
+            cleanup = () => {
+                if (ftTimer) {
+                    clearTimeout(ftTimer);
+                    ftTimer = undefined;
+                }
+                if (idleTimer) {
+                    clearTimeout(idleTimer);
+                    idleTimer = undefined;
+                }
+                connect?.dispose();
+                // Release the HTTP response-body reader too — connect.dispose() only clears timers + the abort listener,
+                // it does NOT cancel the body stream. When parser.onLine / parser.finalize throws, the `.finally(cleanup)`
+                // path must cancel the reader or the socket/stream leaks until GC (R5 bug-hunt).
+                void reader.cancel().catch(() => undefined);
+            };
+            // design/124 tier A: when a mid-stream failure is promoted to a partial finalize, the parser's
+            // OWN terminal event must carry the marker + the CC-verbatim warning. The parser pushes its
+            // terminal itself, so hand it a facade whose push stamps the final message in flight (prototype
+            // delegation keeps every other stream method intact). Inert while `midstreamWarning` is unset.
+            let midstreamWarning;
+            const parserOut = Object.create(out);
+            parserOut.push = (ev) => {
+                if (midstreamWarning !== undefined && (ev.type === "done" || ev.type === "error")) {
+                    const msg = ev.type === "done" ? ev.message : ev.error;
+                    msg.partialFinalized = true;
+                    // codex 实现审 #1: finalize may have set its OWN errorMessage (malformed-tool-call note,
+                    // streamed refusal, …). BOTH verdicts must survive — `partialFinalized` must always ride
+                    // with a visible "may be incomplete" warning (it is the model's self-heal cue next turn,
+                    // and the toolUse branch has no continue-nudge backstop), so APPEND, never fill-the-gap.
+                    msg.errorMessage = msg.errorMessage ? `${msg.errorMessage}\n${midstreamWarning}` : midstreamWarning;
+                }
+                out.push(ev);
+            };
+            const parser = makeParser({
+                out: parserOut,
+                partial,
+                sawContentToken,
+                // triggers reader.cancel(); the read loop then exits on `done` (no separate break needed).
+                cancel: () => void reader.cancel().catch(() => undefined),
+            });
+            // The two tier hooks (design/124 §1): ① the read-catch below (connection class — the 1.225
+            // BrainError("network") classification point) and ② the watchdog verdicts after the loop (stall
+            // class). An abort re-throws untouched (pin below).
+            //
+            // design/124 r3 (CC 2.1.199 rebaseline — supersedes the r2 "in-band frame stays OUT" decision):
+            // an anthropic in-band `{type:"error"}` frame of the OVERLOAD/server class (overloaded_error /
+            // api_error / 529 → BrainError code "server", see anthropicStreamErrorCode) that arrives AFTER
+            // substantive text already streamed now downgrades to tier A (finalize + partialFinalized + the
+            // CC "may be incomplete" notice) — CC 2.1.199 changed direction here. Everything ELSE keeps the
+            // r2 fail-closed throw, preserving the CC-parity B1 invariant (a protocol error is never
+            // finalized as a finished answer): non-overload frame classes (rate_limit/auth/invalid_request),
+            // and an overload frame with NO substantive content, still propagate to the terminal catch.
+            const INBAND_OVERLOAD_WARNING = "API overloaded mid-response. The response above may be incomplete.";
+            /** Feed one line to the parser; returns true iff an in-band overload frame downgraded to tier A. */
+            const onLineOverloadTierA = (line) => {
+                try {
+                    parser.onLine(line);
+                    return false;
+                }
+                catch (e) {
+                    if (!(e instanceof BrainError) || e.code !== "server" || !parser.snapshot().hasSubstantiveText)
+                        throw e;
+                    return true;
+                }
+            };
+            let failure;
+            readLoop: for (;;) {
+                let readRes;
+                try {
+                    readRes = await reader.read();
+                }
+                catch (e) {
+                    // Mid-stream drop (connection reset while the body was streaming). Abort stays abort (§1 pin:
+                    // the tiers must never promote/retry a deliberate cancellation).
+                    if (isAbortError(e) || signal?.aborted)
+                        throw e;
+                    failure = {
+                        kind: "connection",
+                        err: new BrainError("network", `mid-stream read failed: ${e instanceof Error ? e.message : String(e)}`),
+                    };
+                    break readLoop;
+                }
+                const { done, value } = readRes;
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Cursor scan: slice the consumed prefix once per chunk, not once per line (avoids O(n²)).
+                let nl;
+                let start = 0;
+                while ((nl = buffer.indexOf("\n", start)) !== -1) {
+                    const line = buffer.slice(start, nl);
+                    start = nl + 1;
+                    if (onLineOverloadTierA(line)) {
+                        // r3 tier-A downgrade: promote the streamed partial (the facade stamps partialFinalized +
+                        // the notice); `.finally(cleanup)` releases timers/controller/reader like the normal path.
+                        midstreamWarning = INBAND_OVERLOAD_WARNING;
+                        parser.finalize();
+                        return;
+                    }
+                }
+                if (start > 0)
+                    buffer = buffer.slice(start);
+            }
+            if (ftTimer) {
+                clearTimeout(ftTimer);
+                ftTimer = undefined;
+            }
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+                idleTimer = undefined;
+            }
+            if (!failure && firstTokenTimedOut) {
+                failure = { kind: "stalled", err: new BrainError("network", `first-token timeout after ${config.firstTokenTimeoutMs}ms`) };
+            }
+            if (!failure && idleTimedOut) {
+                failure = { kind: "stalled", err: new BrainError("network", `stream idle timeout after ${config.idleTimeoutMs}ms`) };
+            }
+            if (!failure) {
+                // Flush decoder + process any trailing line not terminated by a newline (same r3 in-band
+                // overload downgrade applies — a final unterminated `{type:"error"}` line is still a frame).
+                buffer += decoder.decode();
+                if (buffer.trim() && onLineOverloadTierA(buffer))
+                    midstreamWarning = INBAND_OVERLOAD_WARNING;
+                parser.finalize();
+                return;
+            }
+            // ---- design/124 §1: mid-stream failure tiering (CC 198 queryModelStreaming parity) ----
+            const snap = parser.snapshot();
+            if (snap.hasSubstantiveText || snap.hasCompletedToolCall) {
+                // Tier A — substantive content already streamed: PROMOTE, don't re-send (no double billing;
+                // what streamed stays consistent with the result). finalize() is safe after a cut (no
+                // finish_reason + real content synthesizes the CC-equivalent stopReason: tool call → toolUse,
+                // else stop) and the facade stamps partialFinalized + the CC-verbatim warning; the model sees
+                // "may be incomplete" in the transcript (self-heal prompt), agent-loop nudges a bounded continue.
+                midstreamWarning =
+                    failure.kind === "stalled"
+                        ? "Response stalled mid-stream. The response above may be incomplete."
+                        : "Connection closed mid-response. The response above may be incomplete.";
+                parser.finalize();
+                return;
+            }
+            // §0.5-4 defensive assertion: tiers B/C re-send the whole turn. Once a toolcall_end was emitted
+            // this attempt, an in-stream executor may ALREADY be running the call — a re-send could execute
+            // it twice. Structurally unreachable (hasCompletedToolCall ⇒ tier A above); pinned against
+            // drift: abandon the retry, take the existing error path.
+            if (snap.hasCompletedToolCall)
+                throw failure.err;
+            // Release THIS attempt's resources (timers/controller/reader) before re-sending; the next
+            // attempt assigns a fresh cleanup, and the terminal `.finally` then only sees the live one.
+            cleanup?.();
+            cleanup = undefined;
+            if (snap.hasOnlyThinking) {
+                // Tier B — only thinking streamed: seal the UI stream (thinking_end from the parser, which
+                // owns the block state) and retry the whole turn; the retry's snapshot replacement drops the
+                // attempt's thinking (CC: "drop the thinking"). Budget ≤ 2, backoff 100×n ms (CC stale-conn).
+                // Honest gap vs CC: a cut usually loses the usage frame, so the discarded attempt's cost goes
+                // unrecorded (r2 记档).
+                if (thinkingRetries >= 2)
+                    throw failure.err;
+                thinkingRetries++;
+                parser.sealForRetry();
+                const delayMs = 100 * thinkingRetries;
+                emitBrainTelemetry({ kind: "retry", attempt: thinkingRetries, phase: "midstream" }); // [398] C6 (tier B)
+                emitBrainStatus({ phase: "reconnecting", detail: "connection lost, reconnecting", retryInSec: Math.ceil(delayMs / 1000) });
+                await sleep(delayMs, signal);
+                continue;
+            }
+            // Tier C — nothing substantive streamed (zero events, or a DANGLING tool call: toolcall_start/
+            // deltas but no completed call, no text, no thinking — execution-safe, nothing was admitted):
+            // retry out of the SAME budget as connect failures; the dangling block disappears with the
+            // snapshot replacement. Past the budget → the existing error path (BrainError network).
+            if (attempt >= maxRetries)
+                throw failure.err;
+            const delayMs = retryBackoffMs(baseDelay, attempt);
+            attempt++;
+            emitBrainTelemetry({ kind: "retry", attempt, phase: "midstream" }); // [398] C6 (tier C)
+            emitBrainStatus({ phase: "reconnecting", detail: "connection lost, reconnecting", retryInSec: Math.ceil(delayMs / 1000) });
+            await sleep(delayMs, signal);
+            // loop back: reconnect (fresh controller/parser); `start` stays suppressed.
+        }
+    }
+}
+//# sourceMappingURL=stream-engine.js.map

package/dist/brain/stream-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-engine.js","sourceRoot":"","sources":["../../src/brain/stream-engine.ts"],"names":[],"mappings":"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"}

package/dist/brain/timeout.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Tiered timeouts (1.38.1, design/17 §5B). The task-level `timeoutSec` only bounds the *whole* run;
+ * it can't tell apart a gateway that never accepts the connection from one that accepts it, opens the
+ * SSE stream, then hangs forever without emitting a token (the most common gateway-stall symptom).
+ * Two finer levels close that gap, each retryable as a transient `network` failure:
+ *
+ * - **connect**: `fetch` hasn't returned response headers in time.
+ * - **first-token**: the SSE stream is open but no content delta has arrived (see brain read loops).
+ *
+ * Both default to `undefined` (disabled) so existing behavior is unchanged.
+ */
+export interface BrainTimeoutConfig {
+    /** Abort the request if `fetch` doesn't return response headers within this many ms. Retryable. */
+    connectTimeoutMs?: number;
+    /**
+     * After the stream opens, cancel it if no content delta (text / thinking / tool input) arrives
+     * within this many ms → `BrainError("network", "first-token timeout")`. For reasoning models the
+     * **first thinking delta also counts** as the first token, so a long-thinking model isn't killed
+     * for being slow to its first *visible* word (design/17 O5).
+     */
+    firstTokenTimeoutMs?: number;
+    /**
+     * **Idle / mid-stream stall watchdog** (1.40.1, design/24 — gap found in the Claude Code source study).
+     * After the first delta, re-armed on every delta; if the stream then goes silent for this many ms
+     * (a gateway that hung mid-output) → `reader.cancel()` + `BrainError("network", "stream idle timeout")`.
+     * Complements `firstTokenTimeoutMs`: that one tolerates a long *first* token (reasoning), this one
+     * catches a stall *after* output has started, where a healthy stream emits steadily. Default off.
+     */
+    idleTimeoutMs?: number;
+}
+/**
+ * A per-fetch-attempt abort controller that fires on a connect timeout while still forwarding an
+ * outer (task) abort. The returned `signal` governs the **whole** request including the streamed body
+ * — so once headers arrive, call `clearTimer()` (NOT `dispose()`) to stop the connect timer while
+ * keeping the outer-abort link alive for the body read; call `dispose()` only when the request is
+ * fully done or being discarded.
+ */
+export declare function makeConnectController(connectTimeoutMs: number | undefined, outerSignal: AbortSignal | undefined): {
+    signal: AbortSignal;
+    timedOut: () => boolean;
+    clearTimer: () => void;
+    dispose: () => void;
+};
+//# sourceMappingURL=timeout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/brain/timeout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,mGAAmG;IACnG,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,WAAW,EAAE,WAAW,GAAG,SAAS,GACnC;IACD,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CA4BA"}

package/dist/brain/timeout.js

@@ -0,0 +1,41 @@
+/**
+ * A per-fetch-attempt abort controller that fires on a connect timeout while still forwarding an
+ * outer (task) abort. The returned `signal` governs the **whole** request including the streamed body
+ * — so once headers arrive, call `clearTimer()` (NOT `dispose()`) to stop the connect timer while
+ * keeping the outer-abort link alive for the body read; call `dispose()` only when the request is
+ * fully done or being discarded.
+ */
+export function makeConnectController(connectTimeoutMs, outerSignal) {
+    const ac = new AbortController();
+    let timedOut = false;
+    const onAbort = () => ac.abort(outerSignal?.reason);
+    if (outerSignal) {
+        if (outerSignal.aborted)
+            ac.abort(outerSignal.reason);
+        else
+            outerSignal.addEventListener("abort", onAbort, { once: true });
+    }
+    let timer;
+    if (connectTimeoutMs && connectTimeoutMs > 0) {
+        timer = setTimeout(() => {
+            timedOut = true;
+            ac.abort();
+        }, connectTimeoutMs);
+    }
+    const clearTimer = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = undefined;
+    };
+    return {
+        signal: ac.signal,
+        timedOut: () => timedOut,
+        clearTimer,
+        dispose: () => {
+            clearTimer();
+            if (outerSignal)
+                outerSignal.removeEventListener("abort", onAbort);
+        },
+    };
+}
+//# sourceMappingURL=timeout.js.map

package/dist/brain/timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.js","sourceRoot":"","sources":["../../src/brain/timeout.ts"],"names":[],"mappings":"AA+BA;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,gBAAoC,EACpC,WAAoC;IAOpC,MAAM,EAAE,GAAG,IAAI,eAAe,EAAE,CAAC;IACjC,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,EAAE,CAAC,KAAK,CAAE,WAAuC,EAAE,MAAM,CAAC,CAAC;IACjF,IAAI,WAAW,EAAE,CAAC;QAChB,IAAI,WAAW,CAAC,OAAO;YAAE,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;;YACjD,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IACtE,CAAC;IACD,IAAI,KAAgD,CAAC;IACrD,IAAI,gBAAgB,IAAI,gBAAgB,GAAG,CAAC,EAAE,CAAC;QAC7C,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YACtB,QAAQ,GAAG,IAAI,CAAC;YAChB,EAAE,CAAC,KAAK,EAAE,CAAC;QACb,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IACD,MAAM,UAAU,GAAG,GAAG,EAAE;QACtB,IAAI,KAAK;YAAE,YAAY,CAAC,KAAK,CAAC,CAAC;QAC/B,KAAK,GAAG,SAAS,CAAC;IACpB,CAAC,CAAC;IACF,OAAO;QACL,MAAM,EAAE,EAAE,CAAC,MAAM;QACjB,QAAQ,EAAE,GAAG,EAAE,CAAC,QAAQ;QACxB,UAAU;QACV,OAAO,EAAE,GAAG,EAAE;YACZ,UAAU,EAAE,CAAC;YACb,IAAI,WAAW;gBAAE,WAAW,CAAC,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACrE,CAAC;KACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,15 @@
+import type { ToolCall } from "../internal/llm.js";
+/**
+ * Best-effort recovery of tool calls that a weaker (non-native-function-calling) model emitted as
+ * TEXT instead of structured tool calls. Recognizes `<tool_call>{...}</tool_call>` /
+ * `<function_call>...` tags and fenced ```json blocks containing `{name|tool, arguments|parameters|input}`
+ * (or an array of them). Only names present in `toolNames` are promoted.
+ *
+ * Returns the promoted tool calls and the text with those blocks removed. Off by default — enable via
+ * `createOpenAIBrain({ repairTextToolCalls: true })` only for models that need it.
+ */
+export declare function repairTextToolCalls(text: string, toolNames: Set<string>): {
+    toolCalls: ToolCall[];
+    cleanedText: string;
+};
+//# sourceMappingURL=tool-call-repair.d.ts.map

package/dist/brain/tool-call-repair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-repair.d.ts","sourceRoot":"","sources":["../../src/brain/tool-call-repair.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAwDnD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GACrB;IAAE,SAAS,EAAE,QAAQ,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAShD"}

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

@@ -0,0 +1,67 @@
+const TAG_RE = /<(tool_call|function_call|tool_calls|function_calls)>\s*([\s\S]*?)\s*<\/\1>/gi;
+const FENCE_RE = /```(?:json|tool_call|tool|function)?\s*([\s\S]*?)```/gi;
+function asRecord(v) {
+    return v && typeof v === "object" && !Array.isArray(v) ? v : undefined;
+}
+function extractCall(obj, toolNames) {
+    const rec = asRecord(obj);
+    if (!rec) {
+        return undefined;
+    }
+    const fn = asRecord(rec.function);
+    const name = rec.name ?? rec.tool ?? rec.tool_name ?? fn?.name;
+    if (typeof name !== "string" || !toolNames.has(name)) {
+        return undefined;
+    }
+    let rawArgs = rec.arguments ?? rec.parameters ?? rec.input ?? rec.args ?? fn?.arguments;
+    if (typeof rawArgs === "string") {
+        try {
+            rawArgs = JSON.parse(rawArgs);
+        }
+        catch {
+            rawArgs = {};
+        }
+    }
+    const args = asRecord(rawArgs) ?? {};
+    return {
+        type: "toolCall",
+        id: `repair_${name}_${Math.random().toString(36).slice(2, 8)}`,
+        name,
+        arguments: args,
+    };
+}
+function parseBlock(raw, toolNames, out) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw.trim());
+    }
+    catch {
+        return false;
+    }
+    const items = Array.isArray(parsed) ? parsed : [parsed];
+    let any = false;
+    for (const item of items) {
+        const call = extractCall(item, toolNames);
+        if (call) {
+            out.push(call);
+            any = true;
+        }
+    }
+    return any;
+}
+/**
+ * Best-effort recovery of tool calls that a weaker (non-native-function-calling) model emitted as
+ * TEXT instead of structured tool calls. Recognizes `<tool_call>{...}</tool_call>` /
+ * `<function_call>...` tags and fenced ```json blocks containing `{name|tool, arguments|parameters|input}`
+ * (or an array of them). Only names present in `toolNames` are promoted.
+ *
+ * Returns the promoted tool calls and the text with those blocks removed. Off by default — enable via
+ * `createOpenAIBrain({ repairTextToolCalls: true })` only for models that need it.
+ */
+export function repairTextToolCalls(text, toolNames) {
+    const toolCalls = [];
+    let cleaned = text.replace(TAG_RE, (m, _tag, inner) => parseBlock(inner, toolNames, toolCalls) ? "" : m);
+    cleaned = cleaned.replace(FENCE_RE, (m, inner) => parseBlock(inner, toolNames, toolCalls) ? "" : m);
+    return { toolCalls, cleanedText: cleaned.trim() };
+}
+//# sourceMappingURL=tool-call-repair.js.map

package/dist/brain/tool-call-repair.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-repair.js","sourceRoot":"","sources":["../../src/brain/tool-call-repair.ts"],"names":[],"mappings":"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"}

package/dist/brain/walltime.d.ts

@@ -0,0 +1,14 @@
+/**
+ * design/130 P2b — soft per-call wall-clock deadline (deadline execution hardening).
+ *
+ * The runner passes an absolute soft deadline into each provider call (`StreamOptions.callDeadlineMs`);
+ * a brain that observes the wall clock crossing it CUTS the stream deliberately (like the degenerate-
+ * repetition cutoff) instead of letting the generation ride into the runner's hard abort — the salvaged
+ * prefix is real work, and the loop gets a bounded write-out turn before the hard deadline.
+ *
+ * The sentinel below is the cross-layer contract (brain → loop recovery → assembler), mirroring
+ * `DEGENERATE_MESSAGE` in ./repetition.js: match on THIS constant, never on prose fragments.
+ */
+/** Stamped as `errorMessage` on a turn the brain cut at the soft wall-clock deadline. */
+export declare const WALLTIME_CUTOFF_MESSAGE = "walltime cutoff: the response crossed the task's soft wall-clock deadline and was cut off to preserve a write-out window";
+//# sourceMappingURL=walltime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"walltime.d.ts","sourceRoot":"","sources":["../../src/brain/walltime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,yFAAyF;AACzF,eAAO,MAAM,uBAAuB,6HACwF,CAAC"}

package/dist/brain/walltime.js

@@ -0,0 +1,14 @@
+/**
+ * design/130 P2b — soft per-call wall-clock deadline (deadline execution hardening).
+ *
+ * The runner passes an absolute soft deadline into each provider call (`StreamOptions.callDeadlineMs`);
+ * a brain that observes the wall clock crossing it CUTS the stream deliberately (like the degenerate-
+ * repetition cutoff) instead of letting the generation ride into the runner's hard abort — the salvaged
+ * prefix is real work, and the loop gets a bounded write-out turn before the hard deadline.
+ *
+ * The sentinel below is the cross-layer contract (brain → loop recovery → assembler), mirroring
+ * `DEGENERATE_MESSAGE` in ./repetition.js: match on THIS constant, never on prose fragments.
+ */
+/** Stamped as `errorMessage` on a turn the brain cut at the soft wall-clock deadline. */
+export const WALLTIME_CUTOFF_MESSAGE = "walltime cutoff: the response crossed the task's soft wall-clock deadline and was cut off to preserve a write-out window";
+//# sourceMappingURL=walltime.js.map