@sema-ai/core 1.275.1

package/dist/brain/request-params.js

@@ -0,0 +1,78 @@
+/**
+ * Request-parameter passthrough (design/40). A deployment can set official provider params it wants but
+ * core doesn't model as first-class fields (OpenAI `frequency_penalty`/`presence_penalty`/`top_p`/`seed`/
+ * `logit_bias`; Anthropic `top_k`/`top_p`/`stop_sequences`; …) via `Model.extraBody`, and core merges them
+ * into the brain's request body. Anchored at the **Model** level (not per-turn) so the serialized body
+ * stays byte-stable across turns → the prefix cache holds (design/9/31).
+ *
+ * Symmetric: each brain owns its structural + tuning keys (`reserved`) and ALWAYS wins — `extraBody` can
+ * only supply the long tail, never clobber `messages`/`tools`/`temperature`/etc. Stripping is the safety
+ * enforcement (the brains are standalone-usable); `prepareTask` separately warns on a collision (it has
+ * `onError`, the brain doesn't — council design/40).
+ */
+/** OpenAI request-body keys core owns; `extraBody` cannot override these. */
+export const OPENAI_RESERVED = new Set([
+    "model",
+    "messages",
+    "stream",
+    "stream_options",
+    "tools",
+    "temperature",
+    "max_tokens",
+    "stop",
+    "reasoning_effort",
+    // Thinking-enable keys owned by `applyThinking` per `model.compat.thinkingFormat` (design/46): each
+    // is set by core, so `extraBody` must not override them (collision → warned, like any reserved key).
+    "thinking", // deepseek
+    "reasoning", // openrouter / together
+    "enable_thinking", // qwen / zai
+    "chat_template_kwargs", // qwen-chat-template
+]);
+/** Anthropic request-body keys core owns; `extraBody` cannot override these. (Note the asymmetry vs
+ *  OpenAI — e.g. `stop`/`stop_sequences` is NOT reserved here because the Anthropic brain never sets it.) */
+export const ANTHROPIC_RESERVED = new Set([
+    "model",
+    "messages",
+    "system",
+    "stream",
+    "tools",
+    "temperature",
+    "max_tokens",
+    "thinking",
+    // design/119 (CC 198 rebaseline): effort rides output_config — core owns it (the brain derives it
+    // from the resolved thinking tier + compat.effortLevels; an extraBody preset would silently
+    // desync the reasoning.resolved trace from the wire).
+    "output_config",
+    // design/119 S4 review (codex MINOR): context_management is capability-gated (compat.contextManagement
+    // + its beta) — an extraBody preset would bypass the gate and desync the beta header.
+    "context_management",
+]);
+/** Reserved set for a model's API. */
+export function reservedFor(api) {
+    // Canonical Anthropic api value is "anthropic-messages" (the value every shipped Anthropic model uses;
+    // mirrors usage-accounting.ts). The bare "anthropic" never ships, so the old `=== "anthropic"` always fell
+    // through to OPENAI_RESERVED for real Anthropic deployments → the design/40 collision warning used the wrong
+    // reserved set (missed `system`, spuriously flagged `reasoning_effort`). (P-18)
+    return api === "anthropic-messages" ? ANTHROPIC_RESERVED : OPENAI_RESERVED;
+}
+/**
+ * Merge `extraBody` into a brain's already-built request `body`, dropping any key the brain owns so core
+ * always wins. Returns a NEW object (passthrough keys first, then core keys) when `extraBody` is set; the
+ * exact `body` reference (no allocation, byte-identical serialization) when it isn't — so an existing
+ * deployment with no `extraBody` is unaffected.
+ */
+export function applyExtraBody(body, extraBody, reserved) {
+    if (!extraBody)
+        return body;
+    const passthrough = {};
+    for (const [k, v] of Object.entries(extraBody)) {
+        if (!reserved.has(k))
+            passthrough[k] = v;
+    }
+    return { ...passthrough, ...body }; // core body wins over passthrough
+}
+/** Names in `extraBody` that collide with a reserved (core-owned) key — for a load-time warning. */
+export function reservedCollisions(extraBody, reserved) {
+    return extraBody ? Object.keys(extraBody).filter((k) => reserved.has(k)) : [];
+}
+//# sourceMappingURL=request-params.js.map

package/dist/brain/request-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-params.js","sourceRoot":"","sources":["../../src/brain/request-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,6EAA6E;AAC7E,MAAM,CAAC,MAAM,eAAe,GAAwB,IAAI,GAAG,CAAC;IAC1D,OAAO;IACP,UAAU;IACV,QAAQ;IACR,gBAAgB;IAChB,OAAO;IACP,aAAa;IACb,YAAY;IACZ,MAAM;IACN,kBAAkB;IAClB,oGAAoG;IACpG,qGAAqG;IACrG,UAAU,EAAE,WAAW;IACvB,WAAW,EAAE,wBAAwB;IACrC,iBAAiB,EAAE,aAAa;IAChC,sBAAsB,EAAE,qBAAqB;CAC9C,CAAC,CAAC;AAEH;6GAC6G;AAC7G,MAAM,CAAC,MAAM,kBAAkB,GAAwB,IAAI,GAAG,CAAC;IAC7D,OAAO;IACP,UAAU;IACV,QAAQ;IACR,QAAQ;IACR,OAAO;IACP,aAAa;IACb,YAAY;IACZ,UAAU;IACV,kGAAkG;IAClG,4FAA4F;IAC5F,sDAAsD;IACtD,eAAe;IACf,uGAAuG;IACvG,sFAAsF;IACtF,oBAAoB;CACrB,CAAC,CAAC;AAEH,sCAAsC;AACtC,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,uGAAuG;IACvG,2GAA2G;IAC3G,6GAA6G;IAC7G,gFAAgF;IAChF,OAAO,GAAG,KAAK,oBAAoB,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,eAAe,CAAC;AAC7E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAC5B,IAA6B,EAC7B,SAA8C,EAC9C,QAA6B;IAE7B,IAAI,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAC5B,MAAM,WAAW,GAA4B,EAAE,CAAC;IAChD,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;QAC/C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;YAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,EAAE,GAAG,WAAW,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,kCAAkC;AACxE,CAAC;AAED,oGAAoG;AACpG,MAAM,UAAU,kBAAkB,CAChC,SAA8C,EAC9C,QAA6B;IAE7B,OAAO,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAChF,CAAC"}

package/dist/brain/retry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Transient-failure retry backoff (1.38, §10 N1/N2).
+ *
+ * Two production must-haves that the plain `base * 2^attempt` backoff lacked:
+ * - **Full jitter** — `random(0, min(cap, base*2^attempt))` — so many clients retrying after the same
+ *   429 don't synchronize into a thundering herd that worsens the outage they're recovering from.
+ * - **Respect `Retry-After`** — when the server tells us how long to wait (429/503), honor it as a
+ *   floor: `wait = max(retryAfter, jittered)`. Retrying earlier just gets rejected again.
+ */
+/** Parse a `Retry-After` header (delta-seconds or HTTP-date) to ms; undefined if absent/unparseable. */
+export declare function parseRetryAfter(res: Response | undefined): number | undefined;
+/**
+ * Backoff (ms) for retry `attempt` (0-based) of a transient failure. Full jitter over exponential
+ * backoff, capped; when the response carried `Retry-After`, that is honored as a lower bound.
+ * `rand` is injectable for deterministic tests.
+ */
+export declare function retryBackoffMs(baseDelayMs: number, attempt: number, res?: Response, rand?: () => number): number;
+//# sourceMappingURL=retry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/brain/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,wGAAwG;AACxG,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAQ7E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,QAAQ,EACd,IAAI,GAAE,MAAM,MAAoB,GAC/B,MAAM,CAOR"}

package/dist/brain/retry.js

@@ -0,0 +1,42 @@
+/**
+ * Transient-failure retry backoff (1.38, §10 N1/N2).
+ *
+ * Two production must-haves that the plain `base * 2^attempt` backoff lacked:
+ * - **Full jitter** — `random(0, min(cap, base*2^attempt))` — so many clients retrying after the same
+ *   429 don't synchronize into a thundering herd that worsens the outage they're recovering from.
+ * - **Respect `Retry-After`** — when the server tells us how long to wait (429/503), honor it as a
+ *   floor: `wait = max(retryAfter, jittered)`. Retrying earlier just gets rejected again.
+ */
+const MAX_BACKOFF_MS = 30_000;
+/** Honor a server `Retry-After` up to 2 min; cap beyond that to defend against a hostile/buggy huge
+ *  value (e.g. `Retry-After: 2147483647` → ~24 days of sleep). Larger than MAX_BACKOFF_MS so a
+ *  reasonable server hint is still respected rather than truncated below what the server asked. */
+const MAX_RETRY_AFTER_MS = 120_000;
+/** Parse a `Retry-After` header (delta-seconds or HTTP-date) to ms; undefined if absent/unparseable. */
+export function parseRetryAfter(res) {
+    const h = res?.headers?.get?.("retry-after");
+    if (!h)
+        return undefined;
+    const secs = Number(h);
+    if (Number.isFinite(secs))
+        return Math.max(0, secs * 1000);
+    const date = Date.parse(h);
+    if (Number.isFinite(date))
+        return Math.max(0, date - Date.now());
+    return undefined;
+}
+/**
+ * Backoff (ms) for retry `attempt` (0-based) of a transient failure. Full jitter over exponential
+ * backoff, capped; when the response carried `Retry-After`, that is honored as a lower bound.
+ * `rand` is injectable for deterministic tests.
+ */
+export function retryBackoffMs(baseDelayMs, attempt, res, rand = Math.random) {
+    const exp = Math.min(MAX_BACKOFF_MS, baseDelayMs * 2 ** attempt);
+    const jittered = rand() * exp; // full jitter ∈ [0, exp)
+    const retryAfter = parseRetryAfter(res);
+    if (retryAfter === undefined)
+        return jittered;
+    // Honor Retry-After as a floor (capped so a hostile/buggy value can't pin us for days, §10 N2/#3).
+    return Math.max(Math.min(MAX_RETRY_AFTER_MS, retryAfter), jittered);
+}
+//# sourceMappingURL=retry.js.map

package/dist/brain/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../src/brain/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,cAAc,GAAG,MAAM,CAAC;AAC9B;;mGAEmG;AACnG,MAAM,kBAAkB,GAAG,OAAO,CAAC;AAEnC,wGAAwG;AACxG,MAAM,UAAU,eAAe,CAAC,GAAyB;IACvD,MAAM,CAAC,GAAG,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,CAAC;IAC7C,IAAI,CAAC,CAAC;QAAE,OAAO,SAAS,CAAC;IACzB,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACvB,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC,CAAC;IAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC3B,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IACjE,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAC5B,WAAmB,EACnB,OAAe,EACf,GAAc,EACd,OAAqB,IAAI,CAAC,MAAM;IAEhC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,WAAW,GAAG,CAAC,IAAI,OAAO,CAAC,CAAC;IACjE,MAAM,QAAQ,GAAG,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,yBAAyB;IACxD,MAAM,UAAU,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;IACxC,IAAI,UAAU,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC;IAC9C,mGAAmG;IACnG,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC;AACtE,CAAC"}

package/dist/brain/routing.d.ts

@@ -0,0 +1,19 @@
+import type { Brain } from "../core/types.js";
+export interface RoutingBrainOptions {
+    /** Which field of the Model selects the route. Default "provider". */
+    by?: "provider" | "api";
+    /** Brain used when no route matches. If omitted, an unmatched model yields an error. */
+    fallback?: Brain;
+}
+/**
+ * Route to different brains by a Model field (default `model.provider`). Lets one Runner serve
+ * multiple providers/gateways; compose with `createFailoverBrain` for per-route failover.
+ *
+ * @example
+ * createRoutingBrain({
+ *   "vllm":   createOpenAIBrain({ baseUrl: VLLM }),
+ *   "openai": createOpenAIBrain({ baseUrl: OPENAI, apiKey }),
+ * }, { fallback: createOpenAIBrain({ baseUrl: VLLM }) });
+ */
+export declare function createRoutingBrain(routes: Record<string, Brain>, opts?: RoutingBrainOptions): Brain;
+//# sourceMappingURL=routing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/brain/routing.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAG9C,MAAM,WAAW,mBAAmB;IAClC,sEAAsE;IACtE,EAAE,CAAC,EAAE,UAAU,GAAG,KAAK,CAAC;IACxB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,KAAK,CAAC;CAClB;AAgBD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAC7B,IAAI,GAAE,mBAAwB,GAC7B,KAAK,CAiBP"}

package/dist/brain/routing.js

@@ -0,0 +1,44 @@
+import { createAssistantMessageEventStream, } from "../internal/llm.js";
+import { ZERO_USAGE } from "./errors.js";
+function errorMessage(model, text) {
+    return {
+        role: "assistant",
+        content: [{ type: "text", text: "" }],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        stopReason: "error",
+        errorMessage: text,
+        usage: ZERO_USAGE,
+        timestamp: Date.now(),
+    };
+}
+/**
+ * Route to different brains by a Model field (default `model.provider`). Lets one Runner serve
+ * multiple providers/gateways; compose with `createFailoverBrain` for per-route failover.
+ *
+ * @example
+ * createRoutingBrain({
+ *   "vllm":   createOpenAIBrain({ baseUrl: VLLM }),
+ *   "openai": createOpenAIBrain({ baseUrl: OPENAI, apiKey }),
+ * }, { fallback: createOpenAIBrain({ baseUrl: VLLM }) });
+ */
+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;
+        if (!target) {
+            const out = createAssistantMessageEventStream();
+            out.push({
+                type: "error",
+                reason: "error",
+                error: errorMessage(model, `createRoutingBrain: no brain for ${by}="${key}"`),
+            });
+            return out;
+        }
+        return target.stream(model, context, options);
+    };
+    return { stream };
+}
+//# sourceMappingURL=routing.js.map

package/dist/brain/routing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.js","sourceRoot":"","sources":["../../src/brain/routing.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,iCAAiC,GAClC,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AASzC,SAAS,YAAY,CAAC,KAAY,EAAE,IAAY;IAC9C,OAAO;QACL,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;QACrC,GAAG,EAAE,KAAK,CAAC,GAAG;QACd,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,KAAK,EAAE,KAAK,CAAC,EAAE;QACf,UAAU,EAAE,OAAO;QACnB,YAAY,EAAE,IAAI;QAClB,KAAK,EAAE,UAAU;QACjB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;KACtB,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAA6B,EAC7B,OAA4B,EAAE;IAE9B,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,IAAI,UAAU,CAAC;IACjC,MAAM,MAAM,GAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE;QAC1D,MAAM,GAAG,GAAG,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC;QACtD,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC;QAC5C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,GAAG,GAAG,iCAAiC,EAAE,CAAC;YAChD,GAAG,CAAC,IAAI,CAAC;gBACP,IAAI,EAAE,OAAO;gBACb,MAAM,EAAE,OAAO;gBACf,KAAK,EAAE,YAAY,CAAC,KAAK,EAAE,oCAAoC,EAAE,KAAK,GAAG,GAAG,CAAC;aAC9E,CAAC,CAAC;YACH,OAAO,GAAG,CAAC;QACb,CAAC;QACD,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC,CAAC;IACF,OAAO,EAAE,MAAM,EAAE,CAAC;AACpB,CAAC"}

package/dist/brain/status-sink.d.ts

@@ -0,0 +1,46 @@
+import type { BrainStatus } from "../core/types.js";
+/** Run `fn` with a per-task brain-status sink in scope. ALS propagates it through the async brain calls
+ *  inside `fn` (the harness's prompt → brain.stream → connect/retry loop), so {@link emitBrainStatus}
+ *  reaches THIS task's sink and nothing else. */
+export declare function runWithStatusSink<T>(emit: (s: BrainStatus) => void, fn: () => Promise<T>): Promise<T>;
+/** Report a brain-layer liveness status to the active per-task sink, if any. A no-op outside a
+ *  {@link runWithStatusSink} scope (e.g. compaction's `complete`, or a brain used standalone). */
+export declare function emitBrainStatus(status: BrainStatus): void;
+/**
+ * Silent-fallback telemetry (service [398] C1/C4/C5/C6) — the brain→runner TELEMETRY channel, a
+ * SECOND ALS sink parallel to the status one. Statuses are user-facing liveness frames (wire
+ * `status` events); telemetry is operator-facing fallback accounting the Runner bridges to trace
+ * events (`brain.failover` / `breaker.transition` / `brain.retry` / `vision.placeholder`). Kept
+ * separate so widening telemetry never bloats the shell-visible status vocabulary. Same contract:
+ * fire-and-forget, no-op outside a {@link runWithBrainTelemetry} scope, MUST NOT throw.
+ */
+export type BrainTelemetry = {
+    kind: "failover";
+    servedIndex: number;
+    total: number;
+    errorCode?: string;
+} | {
+    kind: "breaker";
+    key: string;
+    phase: "open" | "half-open" | "closed";
+    failures: number;
+} | {
+    kind: "retry";
+    attempt: number;
+    phase: "connect" | "midstream";
+} | {
+    kind: "vision_placeholder";
+    count: number;
+}
+/** PDF read: a `document` content block was substituted with a text placeholder because the serving
+ *  API/model cannot take native document input (openai brain always; anthropic brain when the model
+ *  declares no vision). Silent quality loss → frame (same [398] C4 discipline as vision_placeholder). */
+ | {
+    kind: "document_placeholder";
+    count: number;
+};
+/** Run `fn` with a per-task brain-telemetry sink in scope (Runner-side; compose with runWithStatusSink). */
+export declare function runWithBrainTelemetry<T>(emit: (t: BrainTelemetry) => void, fn: () => Promise<T>): Promise<T>;
+/** Report a brain-layer fallback/telemetry event to the active per-task sink, if any. */
+export declare function emitBrainTelemetry(t: BrainTelemetry): void;
+//# sourceMappingURL=status-sink.d.ts.map

package/dist/brain/status-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-sink.d.ts","sourceRoot":"","sources":["../../src/brain/status-sink.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAYpD;;iDAEiD;AACjD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAErG;AAED;kGACkG;AAClG,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAEzD;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5E;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC1F;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,GAAG,WAAW,CAAA;CAAE,GAClE;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AAC/C;;yGAEyG;GACvG;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAIpD,4GAA4G;AAC5G,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAE5G;AAED,yFAAyF;AACzF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,cAAc,GAAG,IAAI,CAM1D"}

package/dist/brain/status-sink.js

@@ -0,0 +1,36 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+/**
+ * design/99 §E3/§E10 — the brain→runner status channel, an {@link AsyncLocalStorage} sink (the same
+ * decoupling pattern as the workflow-depth store). The Runner establishes a per-task sink around the
+ * brain-driving call ({@link runWithStatusSink}); the brain's connect/retry loop and circuit breaker
+ * report graduated liveness ({@link emitBrainStatus}) WITHOUT the brain interface, the vendored harness,
+ * or the per-call options carrying an extra field. The signal is fire-and-forget: when no sink is active
+ * (no task context, or a brain used outside the Runner) the emit is a cheap no-op.
+ */
+const statusSinkStore = new AsyncLocalStorage();
+/** Run `fn` with a per-task brain-status sink in scope. ALS propagates it through the async brain calls
+ *  inside `fn` (the harness's prompt → brain.stream → connect/retry loop), so {@link emitBrainStatus}
+ *  reaches THIS task's sink and nothing else. */
+export function runWithStatusSink(emit, fn) {
+    return statusSinkStore.run({ emit }, fn);
+}
+/** Report a brain-layer liveness status to the active per-task sink, if any. A no-op outside a
+ *  {@link runWithStatusSink} scope (e.g. compaction's `complete`, or a brain used standalone). */
+export function emitBrainStatus(status) {
+    statusSinkStore.getStore()?.emit(status);
+}
+const telemetrySinkStore = new AsyncLocalStorage();
+/** Run `fn` with a per-task brain-telemetry sink in scope (Runner-side; compose with runWithStatusSink). */
+export function runWithBrainTelemetry(emit, fn) {
+    return telemetrySinkStore.run({ emit }, fn);
+}
+/** Report a brain-layer fallback/telemetry event to the active per-task sink, if any. */
+export function emitBrainTelemetry(t) {
+    try {
+        telemetrySinkStore.getStore()?.emit(t);
+    }
+    catch {
+        /* telemetry must never break a brain call */
+    }
+}
+//# sourceMappingURL=status-sink.js.map

package/dist/brain/status-sink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-sink.js","sourceRoot":"","sources":["../../src/brain/status-sink.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGrD;;;;;;;GAOG;AACH,MAAM,eAAe,GAAG,IAAI,iBAAiB,EAAsC,CAAC;AAEpF;;iDAEiD;AACjD,MAAM,UAAU,iBAAiB,CAAI,IAA8B,EAAE,EAAoB;IACvF,OAAO,eAAe,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;AAC3C,CAAC;AAED;kGACkG;AAClG,MAAM,UAAU,eAAe,CAAC,MAAmB;IACjD,eAAe,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;AAC3C,CAAC;AAoBD,MAAM,kBAAkB,GAAG,IAAI,iBAAiB,EAAyC,CAAC;AAE1F,4GAA4G;AAC5G,MAAM,UAAU,qBAAqB,CAAI,IAAiC,EAAE,EAAoB;IAC9F,OAAO,kBAAkB,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;AAC9C,CAAC;AAED,yFAAyF;AACzF,MAAM,UAAU,kBAAkB,CAAC,CAAiB;IAClD,IAAI,CAAC;QACH,kBAAkB,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,6CAA6C;IAC/C,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,85 @@
+import { type AssistantMessage, type Model, createAssistantMessageEventStream } from "../internal/llm.js";
+import { type BrainTimeoutConfig } from "./timeout.js";
+/**
+ * Shared streaming engine for the OpenAI- and Anthropic-shaped brains (design/32, consolidation).
+ *
+ * It owns the **bug-prone machinery that was duplicated verbatim** across `openai.ts` and
+ * `anthropic.ts` — the connect-timeout + retry loop, the three-tier timer logic (first-token + idle
+ * watchdog) with their flag resets, the SSE read loop + line framing, the one-shot cleanup, and the
+ * `.catch/.finally` error wrapping. Centralizing the timer logic is the point: the same first-token /
+ * idle reset bug was fixed twice (1.38.2 / 1.40.2) precisely because this lived in two copies.
+ *
+ * Each provider keeps its OWN request-shaping (`buildRequest`) and SSE parsing + finalization
+ * (`makeParser`) — those genuinely differ (chat-completions deltas vs typed content-block events,
+ * thinking signatures, per-provider usage/finish-reason) and stay verbatim in the adapters, so this
+ * refactor is behavior-preserving (safety net: resilience/streaming/brain tests).
+ */
+export interface StreamEngineConfig extends BrainTimeoutConfig {
+    /** Retries for transient failures (network / 5xx / 429) BEFORE the body streams. Default 2. */
+    maxRetries?: number;
+    /** Base backoff ms (exponential * full-jitter). Default 400. */
+    retryDelayMs?: number;
+}
+export interface SSERequest {
+    url: string;
+    headers: Record<string, string>;
+    body: string;
+}
+/** Controls that the engine passes to the per-stream parser. */
+export interface StreamControls {
+    out: ReturnType<typeof createAssistantMessageEventStream>;
+    /** Shared mutable partial-snapshot message; the parser mutates `content` and emits `{ ...partial }`. */
+    partial: AssistantMessage;
+    /** Call on every CONTENT delta (text/thinking/tool input) — resets the first-token + idle watchdogs. */
+    sawContentToken(): void;
+    /** Cancel the underlying stream (e.g. degenerate-repetition cutoff). The read loop then ends. */
+    cancel(): void;
+}
+export interface StreamParser {
+    /** Handle one raw SSE line (`data: {...}`); parse, emit events, call `ctrl.sawContentToken()` on content. */
+    onLine(line: string): void;
+    /** Build + emit the final `done`/`error` message after the stream ends. */
+    finalize(): void;
+    /**
+     * design/124 §0.5-2: introspection for the mid-stream failure tiering. Read directly off the
+     * parser's accumulated state (cheap, no side effects):
+     * - `hasSubstantiveText`  — non-blank answer text (or a streamed refusal) has been emitted → tier A
+     *   (partial finalize) territory.
+     * - `hasCompletedToolCall` — at least one tool call CLOSED successfully (a `toolcall_end` was
+     *   emitted, so an in-stream executor may already be running it) → tier A; also the retry-safety
+     *   assertion (§0.5-4): a re-send is FORBIDDEN once this is true (double execution).
+     * - `hasOnlyThinking` — thinking streamed but nothing substantive (no non-blank text, no completed
+     *   tool call) → tier B (seal + whole-turn retry). A dangling tool-call accumulation alongside the
+     *   thinking does not veto this (nothing was admitted; the retry's snapshot replacement drops it).
+     */
+    snapshot(): {
+        hasSubstantiveText: boolean;
+        hasCompletedToolCall: boolean;
+        hasOnlyThinking: boolean;
+    };
+    /**
+     * design/124 §0.5-2 tier B: seal the UI stream before a whole-turn retry — emit `thinking_end` for
+     * any OPEN thinking block (the block state is parser-private; the engine cannot emit a correct
+     * close). The retry attempt's parser may then legally REOPEN a thinking block at the SAME
+     * contentIndex — consumers render by partial snapshot (replacement semantics), so index reuse is
+     * part of the event contract (see AssistantMessageEvent thinking_start note). Idempotent.
+     */
+    sealForRetry(): void;
+}
+/**
+ * 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 declare function runStreamingBrain(args: {
+    model: Model;
+    doFetch: typeof fetch;
+    signal?: AbortSignal;
+    config: StreamEngineConfig;
+    /** HTTP error message prefix (e.g. "gateway" / "anthropic"). */
+    httpLabel: string;
+    /** Build the one request. May throw (→ surfaced as an error event). */
+    buildRequest: () => SSERequest;
+    /** Create the per-stream parser once the partial + controls exist. */
+    makeParser: (ctrl: StreamControls) => StreamParser;
+}): ReturnType<typeof createAssistantMessageEventStream>;
+//# sourceMappingURL=stream-engine.d.ts.map

package/dist/brain/stream-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-engine.d.ts","sourceRoot":"","sources":["../../src/brain/stream-engine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EAErB,KAAK,KAAK,EAEV,iCAAiC,EAClC,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAE,KAAK,kBAAkB,EAAyB,MAAM,cAAc,CAAC;AAE9E;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB;IAC5D,+FAA+F;IAC/F,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,gEAAgE;AAChE,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,UAAU,CAAC,OAAO,iCAAiC,CAAC,CAAC;IAC1D,wGAAwG;IACxG,OAAO,EAAE,gBAAgB,CAAC;IAC1B,wGAAwG;IACxG,eAAe,IAAI,IAAI,CAAC;IACxB,iGAAiG;IACjG,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,6GAA6G;IAC7G,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,2EAA2E;IAC3E,QAAQ,IAAI,IAAI,CAAC;IACjB;;;;;;;;;;;OAWG;IACH,QAAQ,IAAI;QAAE,kBAAkB,EAAE,OAAO,CAAC;QAAC,oBAAoB,EAAE,OAAO,CAAC;QAAC,eAAe,EAAE,OAAO,CAAA;KAAE,CAAC;IACrG;;;;;;OAMG;IACH,YAAY,IAAI,IAAI,CAAC;CACtB;AAiDD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,OAAO,KAAK,CAAC;IACtB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,YAAY,EAAE,MAAM,UAAU,CAAC;IAC/B,sEAAsE;IACtE,UAAU,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,YAAY,CAAC;CACpD,GAAG,UAAU,CAAC,OAAO,iCAAiC,CAAC,CAkVvD"}