@msm-core/mini 0.8.0 → 0.14.0

package/dist/adapters/redis-lock.d.ts

@@ -8,11 +8,15 @@
  * TTL: timeoutMs + 30s safety margin
  */
 import type { RedisLike } from "./redis-types.js";
-export interface LockHandle {
-    release(): Promise<void>;
-    extend(ttlMs: number): Promise<boolean>;
-}
-export declare class RedisDistributedLock {
+import type { LockHandle, RunLockPort } from "../core/types.js";
+/**
+ * Re-exported from its new home in `core/types.ts` (س٦), where it belongs with
+ * the port every lock implements rather than with one implementation of it.
+ * Every existing `import { LockHandle } from "@msm-core/mini/adapters"` keeps
+ * working, unchanged.
+ */
+export type { LockHandle };
+export declare class RedisDistributedLock implements RunLockPort {
     private readonly redis;
     private readonly prefix;
     constructor(redis: RedisLike, prefix?: string);

package/dist/brain/anthropic.js

@@ -2,6 +2,7 @@
  * Anthropic Brain — Claude via Messages API.
  * Peer dependency: @anthropic-ai/sdk >= 0.20.0
  */
+import { respondingModel } from "../core/types.js";
 import { computeCostUsd } from "./pricing.js";
 import { withRetry } from "./retry.js";
 import { foldToolResults, toolParamsToJsonSchema, toWireMessage, useToolOrchestration, } from "./tool-context.js";
@@ -63,7 +64,7 @@ export function createAnthropicBrain(opts) {
             // land in `AnthropicMessage` — the fields this brain reads — so the
             // payload is built once, from one shape.
             const response = input.onChunk
-                ? await withRetry(() => streamMessage(client, params, input.onChunk, input.signal), input.signal ? { signal: input.signal } : {})
+                ? await withRetry((emitOnce) => streamMessage(client, params, emitOnce(input.onChunk), input.signal), input.signal ? { signal: input.signal } : {})
                 : await withRetry(() => client.messages.create(params, input.signal ? { signal: input.signal } : {}), input.signal ? { signal: input.signal } : {});
             const content = response.content;
             const inputTokens = response.usage.input_tokens;
@@ -87,6 +88,7 @@ export function createAnthropicBrain(opts) {
                     orchestration,
                     usage: { inputTokens, outputTokens },
                     costUsd,
+                    ...respondingModel(response),
                 };
             }
             // Text
@@ -97,6 +99,11 @@ export function createAnthropicBrain(opts) {
                 orchestration: { action: "respond", confidence: 0.95 },
                 usage: { inputTokens, outputTokens },
                 costUsd,
+                // Who answered, off the message itself — Claude names the model that
+                // served the request, which is not always the alias that was asked for.
+                // Streamed or not, `response` is the same shape: `message_start`
+                // carries the name and `accumulateAnthropic` keeps it.
+                ...respondingModel(response),
             };
         },
     };

package/dist/brain/gemini.js

@@ -2,6 +2,7 @@
  * Gemini Brain — Google Gemini 2.5 Flash (primary brain for UTS).
  * Peer dependency: @google/generative-ai >= 0.14.0
  */
+import { respondingModel } from "../core/types.js";
 import { withRetry } from "./retry.js";
 import { foldToolResults, toWireMessage, useToolOrchestration, } from "./tool-context.js";
 import { accumulateGemini, consumeStream, geminiDelta, } from "./streaming.js";
@@ -68,7 +69,7 @@ export function createGeminiBrain(opts) {
             // land in `GeminiResponse` — the fields this brain reads — so the payload
             // is built once, from one shape.
             const response = input.onChunk
-                ? await withRetry(() => streamContent(() => geminiModel.generateContentStream(request, input.signal ? { signal: input.signal } : {}), input.onChunk, input.signal), input.signal ? { signal: input.signal } : {})
+                ? await withRetry((emitOnce) => streamContent(() => geminiModel.generateContentStream(request, input.signal ? { signal: input.signal } : {}), emitOnce(input.onChunk), input.signal), input.signal ? { signal: input.signal } : {})
                 : (await withRetry(() => geminiModel.generateContent(request, input.signal ? { signal: input.signal } : {}), input.signal ? { signal: input.signal } : {})).response;
             const parts = response?.candidates?.[0]?.content?.parts ?? [];
             // Token usage + cost — computed ONCE and returned on BOTH the tool-call and text
@@ -100,7 +101,12 @@ export function createGeminiBrain(opts) {
             }
             const orchestration = useToolOrchestration(calls, 0.9);
             if (orchestration) {
-                return { orchestration, costUsd, ...(usage ? { usage } : {}) };
+                return {
+                    orchestration,
+                    costUsd,
+                    ...(usage ? { usage } : {}),
+                    ...respondingModel(response),
+                };
             }
             // Text response
             const textPart = parts.find((p) => "text" in p && typeof p.text === "string");
@@ -110,6 +116,13 @@ export function createGeminiBrain(opts) {
                 orchestration: { action: "respond", confidence: 0.95 },
                 costUsd,
                 ...(usage ? { usage } : {}),
+                // Who answered — Gemini spells it `modelVersion`, and it is the field
+                // that tells `gemini-2.5-flash` from the dated build that served it.
+                // The SDK's non-streaming path hands back the parsed response body as
+                // it arrived, so the field survives even though its own `.d.ts` stops
+                // at three properties; on the streamed path every element repeats it
+                // and `accumulateGemini` carries it through. One line, both paths.
+                ...respondingModel(response),
             };
         },
     };

package/dist/brain/ollama.js

@@ -2,6 +2,7 @@
  * Ollama Brain — local model via Ollama REST API.
  * No peer dependencies — plain HTTP fetch.
  */
+import { respondingModel } from "../core/types.js";
 import { withRetry } from "./retry.js";
 import { foldToolResults, toolParamsToJsonSchema, toWireMessage, useToolOrchestration, } from "./tool-context.js";
 import { accumulateOllama, consumeNdjson, } from "./streaming.js";
@@ -60,7 +61,7 @@ export function createOllamaBrain(opts) {
             });
             let data;
             if (input.onChunk) {
-                data = await withRetry(() => streamChat(post, input.onChunk, input.signal), input.signal ? { signal: input.signal } : {});
+                data = await withRetry((emitOnce) => streamChat(post, emitOnce(input.onChunk), input.signal), input.signal ? { signal: input.signal } : {});
             }
             else {
                 // Verbatim: the fetch is retried, the status check and the body read
@@ -88,13 +89,18 @@ export function createOllamaBrain(opts) {
             if (calls[0]?.name) {
                 const orchestration = useToolOrchestration(calls, 0.9);
                 if (orchestration)
-                    return { orchestration, ...usageBlock };
+                    return { orchestration, ...usageBlock, ...respondingModel(data) };
             }
             const text = data.message?.content ?? "";
             return {
                 generation: { response_text: text },
                 orchestration: { action: "respond", confidence: 0.85 },
                 ...usageBlock,
+                // Who answered — `/api/chat` echoes the served model at the top level,
+                // and on a local host that is the one place a swapped or re-tagged
+                // model shows itself. Streamed too: every NDJSON line repeats it and
+                // `accumulateOllama` keeps the last.
+                ...respondingModel(data),
             };
         },
     };

package/dist/brain/openai.js

@@ -2,6 +2,7 @@
  * OpenAI Brain — wraps the OpenAI Chat Completions API.
  * Peer dependency: openai >= 4.0.0
  */
+import { respondingModel } from "../core/types.js";
 import { computeCostUsd } from "./pricing.js";
 import { withRetry } from "./retry.js";
 import { foldToolResults, toolParamsToJsonSchema, toWireMessage, useToolOrchestration, } from "./tool-context.js";
@@ -56,7 +57,7 @@ export function createOpenAIBrain(opts) {
             // construction (`OpenAICompletion`), so there is one payload builder,
             // not two that must be kept in step.
             const response = input.onChunk
-                ? await withRetry(() => streamCompletion(client, body, input.onChunk, input.signal), input.signal ? { signal: input.signal } : {})
+                ? await withRetry((emitOnce) => streamCompletion(client, body, emitOnce(input.onChunk), input.signal), input.signal ? { signal: input.signal } : {})
                 : await withRetry(() => client.chat.completions.create(body, input.signal ? { signal: input.signal } : {}), input.signal ? { signal: input.signal } : {});
             const choice = response.choices[0];
             if (!choice)
@@ -93,13 +94,19 @@ export function createOpenAIBrain(opts) {
                 });
                 const orchestration = useToolOrchestration(calls, 0.9);
                 if (orchestration)
-                    return { orchestration, ...usageBlock };
+                    return { orchestration, ...usageBlock, ...respondingModel(response) };
             }
             const text = msg.content ?? "";
             return {
                 generation: { response_text: text },
                 orchestration: { action: "respond", confidence: 0.95 },
                 ...usageBlock,
+                // Who answered, off the completion itself — `gpt-4o-mini` asked for can
+                // come back as `gpt-4o-mini-2024-07-18`, and an override can make it
+                // something else entirely. `response` is the SAME shape either way, so
+                // this one line covers the streamed path too: the chunks carry `model`
+                // and `accumulateOpenAI` folds it in.
+                ...respondingModel(response),
             };
         },
     };

package/dist/brain/retry.d.ts

@@ -5,7 +5,96 @@
  * run with an error outcome. Every built-in brain now wraps its provider call
  * in withRetry(): a single bounded retry on transient failures, abort-aware
  * (never retries a cancelled call — that's the loop's time budget firing).
+ *
+ * ── Retrying a STREAM is not retrying a call (ب١/٢) ──────────────────────────
+ *
+ * A retried non-streaming call is invisible: the first attempt's response is
+ * thrown away and only the second one is ever seen. A retried STREAMING call is
+ * not, because the first attempt already spoke. It pushed "The contract sta"
+ * into the consumer's `onChunk` and then died on a 429; the second attempt
+ * opens a fresh stream and says the whole sentence again, and what the human
+ * watching reads is "The contract staThe contract states…". The payload was
+ * always right — only the display lied — which is exactly why it survived ب١.
+ *
+ * The cure has to live at the retry boundary, because that is the only place
+ * that knows an earlier attempt existed. `emitOnce` below is that boundary made
+ * available to the caller: wrap a sink in it and the run's chunks are delivered
+ * by AT MOST ONE attempt.
+ *
+ * **The invariant this buys.** What reaches the consumer is always a PREFIX of
+ * the payload the call finally returns. Never a different string, never a
+ * longer one. That is the whole property: a display may lag the truth, it may
+ * stop short of it, but it may never contradict it — and "The contract staThe
+ * contract states…" contradicts it, because no payload ever said that.
+ *
+ * **Gated on delivery, not on attempt number.** "Mute every attempt after the
+ * first" is the obvious rule and it is wrong: a first attempt that dies while
+ * opening the socket has shown the reader nothing, and muting the retry would
+ * turn a recoverable stumble into a run that streams not one character. So the
+ * gate closes only once a chunk has actually been DELIVERED, and a silent
+ * failure costs the reader nothing.
+ *
+ * **The decision is taken per attempt, before the call.** An attempt either
+ * speaks or it does not; a gate re-read mid-flight could fall silent halfway
+ * through a sentence, which is a worse artifact than the duplicate it replaced.
+ *
+ * **What this costs, stated plainly.** When the first attempt dies mid-sentence
+ * the reader's display stops there: the retry's text is suppressed, and the rest
+ * of the answer arrives with the payload rather than character by character. It
+ * is a truncated display, not a wrong one — and `onChunk` is display, not truth
+ * (ب١), so the returned payload is complete either way.
+ *
+ * **The alternative that was rejected.** Suppressing only the already-delivered
+ * PREFIX and streaming the remainder would keep the display live — but only if
+ * the retry repeats itself word for word, and a re-issued model call is under no
+ * obligation to. When it diverges, prefix-skipping splices the head of one
+ * answer onto the tail of another and hands the reader a sentence neither
+ * attempt produced. Stopping is honest; splicing is not. Delivering the retry
+ * losslessly needs a "discard what I showed you" signal on `BrainChunk`, which
+ * is a consumer-visible contract change and not this file's to make.
+ *
+ * ── The signal, and the covenant it must not break (ص٢/٢) ───────────────────
+ *
+ * That signal now exists: `BrainChunk.reset`. So the gate has TWO patterns, and
+ * which one a run gets is decided by the consumer, never by this file.
+ *
+ *   • **prefix** — the default, and the ص١ path unchanged. A retried attempt is
+ *     muted; the display stops where the dead attempt stopped; what reached the
+ *     reader is a prefix of the payload.
+ *
+ *   • **reset** — only for a sink that went through `acceptResets`. The retried
+ *     attempt is NOT muted. Its first delivered chunk carries `reset: true`,
+ *     meaning "throw away what I sent, start here", and the rest stream
+ *     normally. The reader ends up holding the whole payload: nothing lost,
+ *     nothing doubled.
+ *
+ * **A consumer that did not declare is not affected by any of this.** It is not
+ * a softer default — it is the same branch, the same `SILENT`, the same bytes,
+ * and the reset branch is unreachable without the declaration. That matters
+ * because delivering `reset` to a consumer that appends and ignores it would
+ * reproduce ب١/٢'s duplicate display exactly.
+ *
+ * **The reset rides on a real chunk rather than arriving as its own empty one.**
+ * Two reasons. It cannot be split — a reader that acts on one message and drops
+ * the next can never clear without also receiving the text that replaces it.
+ * And every chunk still corresponds to model text, so "concatenate, clearing at
+ * a reset" yields the payload with no zero-length special case. It is also LAZY:
+ * built when the retried attempt actually delivers, so an attempt that dies
+ * silently a second time clears nothing and leaves the display where ص١ would
+ * have left it.
+ */
+/**
+ * Wrap a side-effecting sink so that only the attempt that first delivers
+ * through it may deliver at all — unless the sink declared `acceptResets`, in
+ * which case a later attempt may deliver after telling it to clear (ص٢/٢).
+ *
+ * Handed to the retried function; ignoring it is the pre-ب١/٢ behaviour, so no
+ * caller is broken by its existence. The signature stays generic on purpose:
+ * every call site today passes a chunk sink, but narrowing the parameter to
+ * `BrainChunk` would be a surface change for no gain — the reset branch reaches
+ * the chunk type through `isResetAware`, which is a runtime fact, not a guess.
  */
+export type SinkGate = <A extends unknown[]>(sink: (...args: A) => void) => (...args: A) => void;
 export interface RetryOpts {
     /** Total attempts including the first (default: 2 = one retry). */
     attempts?: number;
@@ -16,5 +105,12 @@ export interface RetryOpts {
 }
 /** True for errors worth one retry: 429, 5xx, or low-level network failures. */
 export declare function isTransientError(err: unknown): boolean;
-/** Run `fn`, retrying once (by default) on transient provider errors. */
-export declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOpts): Promise<T>;
+/**
+ * Run `fn`, retrying once (by default) on transient provider errors.
+ *
+ * `fn` receives an `emitOnce` gate (see the header): wrap the consumer's chunk
+ * sink in it and no text is delivered twice across attempts. A zero-argument
+ * thunk — every caller written before ب١/٢ — is assignable unchanged and behaves
+ * exactly as it did.
+ */
+export declare function withRetry<T>(fn: (emitOnce: SinkGate) => Promise<T>, opts?: RetryOpts): Promise<T>;

package/dist/brain/retry.js

@@ -5,7 +5,105 @@
  * run with an error outcome. Every built-in brain now wraps its provider call
  * in withRetry(): a single bounded retry on transient failures, abort-aware
  * (never retries a cancelled call — that's the loop's time budget firing).
+ *
+ * ── Retrying a STREAM is not retrying a call (ب١/٢) ──────────────────────────
+ *
+ * A retried non-streaming call is invisible: the first attempt's response is
+ * thrown away and only the second one is ever seen. A retried STREAMING call is
+ * not, because the first attempt already spoke. It pushed "The contract sta"
+ * into the consumer's `onChunk` and then died on a 429; the second attempt
+ * opens a fresh stream and says the whole sentence again, and what the human
+ * watching reads is "The contract staThe contract states…". The payload was
+ * always right — only the display lied — which is exactly why it survived ب١.
+ *
+ * The cure has to live at the retry boundary, because that is the only place
+ * that knows an earlier attempt existed. `emitOnce` below is that boundary made
+ * available to the caller: wrap a sink in it and the run's chunks are delivered
+ * by AT MOST ONE attempt.
+ *
+ * **The invariant this buys.** What reaches the consumer is always a PREFIX of
+ * the payload the call finally returns. Never a different string, never a
+ * longer one. That is the whole property: a display may lag the truth, it may
+ * stop short of it, but it may never contradict it — and "The contract staThe
+ * contract states…" contradicts it, because no payload ever said that.
+ *
+ * **Gated on delivery, not on attempt number.** "Mute every attempt after the
+ * first" is the obvious rule and it is wrong: a first attempt that dies while
+ * opening the socket has shown the reader nothing, and muting the retry would
+ * turn a recoverable stumble into a run that streams not one character. So the
+ * gate closes only once a chunk has actually been DELIVERED, and a silent
+ * failure costs the reader nothing.
+ *
+ * **The decision is taken per attempt, before the call.** An attempt either
+ * speaks or it does not; a gate re-read mid-flight could fall silent halfway
+ * through a sentence, which is a worse artifact than the duplicate it replaced.
+ *
+ * **What this costs, stated plainly.** When the first attempt dies mid-sentence
+ * the reader's display stops there: the retry's text is suppressed, and the rest
+ * of the answer arrives with the payload rather than character by character. It
+ * is a truncated display, not a wrong one — and `onChunk` is display, not truth
+ * (ب١), so the returned payload is complete either way.
+ *
+ * **The alternative that was rejected.** Suppressing only the already-delivered
+ * PREFIX and streaming the remainder would keep the display live — but only if
+ * the retry repeats itself word for word, and a re-issued model call is under no
+ * obligation to. When it diverges, prefix-skipping splices the head of one
+ * answer onto the tail of another and hands the reader a sentence neither
+ * attempt produced. Stopping is honest; splicing is not. Delivering the retry
+ * losslessly needs a "discard what I showed you" signal on `BrainChunk`, which
+ * is a consumer-visible contract change and not this file's to make.
+ *
+ * ── The signal, and the covenant it must not break (ص٢/٢) ───────────────────
+ *
+ * That signal now exists: `BrainChunk.reset`. So the gate has TWO patterns, and
+ * which one a run gets is decided by the consumer, never by this file.
+ *
+ *   • **prefix** — the default, and the ص١ path unchanged. A retried attempt is
+ *     muted; the display stops where the dead attempt stopped; what reached the
+ *     reader is a prefix of the payload.
+ *
+ *   • **reset** — only for a sink that went through `acceptResets`. The retried
+ *     attempt is NOT muted. Its first delivered chunk carries `reset: true`,
+ *     meaning "throw away what I sent, start here", and the rest stream
+ *     normally. The reader ends up holding the whole payload: nothing lost,
+ *     nothing doubled.
+ *
+ * **A consumer that did not declare is not affected by any of this.** It is not
+ * a softer default — it is the same branch, the same `SILENT`, the same bytes,
+ * and the reset branch is unreachable without the declaration. That matters
+ * because delivering `reset` to a consumer that appends and ignores it would
+ * reproduce ب١/٢'s duplicate display exactly.
+ *
+ * **The reset rides on a real chunk rather than arriving as its own empty one.**
+ * Two reasons. It cannot be split — a reader that acts on one message and drops
+ * the next can never clear without also receiving the text that replaces it.
+ * And every chunk still corresponds to model text, so "concatenate, clearing at
+ * a reset" yields the payload with no zero-length special case. It is also LAZY:
+ * built when the retried attempt actually delivers, so an attempt that dies
+ * silently a second time clears nothing and leaves the display where ص١ would
+ * have left it.
+ */
+import { isResetAware } from "../core/types.js";
+/** What a muted attempt streams into. */
+const SILENT = () => { };
+/**
+ * The reset pattern's sink for one retried attempt: the first thing it delivers
+ * says "start over", everything after it is ordinary.
+ *
+ * `cleared` is per-attempt, which is what makes a third attempt clear again —
+ * each retry replaces the display, it does not append to the one before it.
  */
+function clearThenStream(sink) {
+    let cleared = false;
+    return (chunk) => {
+        if (cleared) {
+            sink(chunk);
+            return;
+        }
+        cleared = true;
+        sink({ ...chunk, reset: true });
+    };
+}
 const TRANSIENT_CODES = new Set([
     "ECONNRESET",
     "ECONNREFUSED",
@@ -38,14 +136,46 @@ export function isTransientError(err) {
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
-/** Run `fn`, retrying once (by default) on transient provider errors. */
+/**
+ * Run `fn`, retrying once (by default) on transient provider errors.
+ *
+ * `fn` receives an `emitOnce` gate (see the header): wrap the consumer's chunk
+ * sink in it and no text is delivered twice across attempts. A zero-argument
+ * thunk — every caller written before ب١/٢ — is assignable unchanged and behaves
+ * exactly as it did.
+ */
 export async function withRetry(fn, opts = {}) {
     const attempts = Math.max(1, opts.attempts ?? 2);
     const baseDelayMs = opts.baseDelayMs ?? 500;
+    /** Has any attempt so far actually pushed something through a gated sink? */
+    let delivered = false;
     let lastErr;
     for (let attempt = 1; attempt <= attempts; attempt++) {
+        // Read once, here, and not again inside the attempt — see the header.
+        const muted = delivered;
+        const emitOnce = muted
+            ? (sink) => {
+                // PREFIX pattern — the ص١ path, and the only one a sink that did not
+                // declare can reach.
+                if (!isResetAware(sink))
+                    return SILENT;
+                // RESET pattern. The predicate is the evidence: `acceptResets` is the
+                // only producer of the mark and it accepts nothing but a chunk sink,
+                // so this narrowed value really does take a `BrainChunk`. The gate's
+                // own signature stays `(...args: A) => void` for its caller; the args
+                // are ignored because the sink is called with the chunk it is given.
+                const declared = sink;
+                const stream = clearThenStream(declared);
+                return (...args) => {
+                    stream(args[0]);
+                };
+            }
+            : (sink) => (...args) => {
+                delivered = true;
+                sink(...args);
+            };
         try {
-            return await fn();
+            return await fn(emitOnce);
         }
         catch (err) {
             lastErr = err;

package/dist/brain/streaming.d.ts

@@ -23,6 +23,22 @@
  * a stream cannot reconstruct and no brain here consumes, so promising them
  * would be a lie the compiler would happily keep.
  *
+ * **The responder's name joined that set in س٦/٤**, by the same rule: the
+ * brains now read it (`respondingModel`) to record WHO answered in the session
+ * log, so it is a field this file has to carry or the answer is lost. And it is
+ * the one field here a stream CAN reconstruct — every provider stamps it on the
+ * wire, measured: OpenAI on each `ChatCompletionChunk`, Anthropic on the
+ * `message_start` message, Gemini as `modelVersion` on every stream element,
+ * Ollama on every NDJSON line. Leaving it out was not a design decision but the
+ * shape of the file before anyone needed it, and the cost was precise: nisus
+ * sets `hooks.onChunk` on every agent it builds, so EVERY turn it runs is a
+ * streamed turn, and every one of them would have logged no responder at all.
+ *
+ * **Absent stays absent.** Every carry below is a conditional spread: a stream
+ * that never names a model folds to the object it folded to yesterday, key for
+ * key, and the ب١ fixtures that assert `fold(chunks) === nonStreamed` keep
+ * passing untouched.
+ *
  * **Display, not truth (the governing limit of ب١).** Nothing in this file
  * writes a log event, touches a fingerprint, or decides anything. Chunks are
  * emitted for a human to look at; the payload the brain returns is the record.
@@ -67,6 +83,8 @@ export interface OpenAIStreamChunk {
         prompt_tokens?: number;
         completion_tokens?: number;
     } | null;
+    /** The serving model — OpenAI stamps it on every chunk (`ChatCompletionChunk.model`). */
+    model?: string;
 }
 /**
  * What the OpenAI brain reads off a completion — streamed or not.
@@ -89,6 +107,8 @@ export interface OpenAICompletion {
         prompt_tokens?: number;
         completion_tokens?: number;
     } | null;
+    /** Who answered — `ChatCompletion.model`, and the streamed chunks' `model`. */
+    model?: string;
 }
 /**
  * The text this chunk carries, or "" for a tool-call or usage-only chunk.
@@ -139,6 +159,8 @@ export interface AnthropicStreamEvent {
             input_tokens?: number;
             output_tokens?: number;
         };
+        /** The serving model — carried on the `message_start` event's message. */
+        model?: string;
     };
     content_block?: {
         type?: string;
@@ -162,6 +184,8 @@ export interface AnthropicMessage {
         input_tokens: number;
         output_tokens: number;
     };
+    /** Who answered — `Message.model`, and the `message_start` message's model. */
+    model?: string;
 }
 /**
  * The text this event carries, or "" for anything else (thinking included).
@@ -215,6 +239,16 @@ export interface GeminiResponse {
         promptTokenCount?: number;
         candidatesTokenCount?: number;
     };
+    /**
+     * Who answered. Google's spelling of the field, and the reason
+     * `respondingModel` knows two names for one thing.
+     *
+     * Undeclared by `@google/generative-ai`'s own `GenerateContentResponse` (it
+     * stops at three properties) — but the SDK hands back the parsed response
+     * body as it arrived, so the field is live on the wire and on the object.
+     * Declaring it here is what lets the brain read it without a cast.
+     */
+    modelVersion?: string;
 }
 /**
  * The text this stream item carries, across ALL of its text parts.
@@ -258,6 +292,8 @@ export interface OllamaStreamLine {
     };
     prompt_eval_count?: number;
     eval_count?: number;
+    /** The served tag — Ollama repeats it on every line. */
+    model?: string;
 }
 /** What the Ollama brain reads off `/api/chat` — streamed or not. */
 export interface OllamaChatResponse {
@@ -272,6 +308,12 @@ export interface OllamaChatResponse {
     };
     prompt_eval_count?: number;
     eval_count?: number;
+    /**
+     * Who answered — the served tag, top level in the `/api/chat` body. On a
+     * local host this is the one place a re-pulled or re-tagged model shows
+     * itself, since nothing about the request would change.
+     */
+    model?: string;
 }
 /**
  * The text this line carries.

package/dist/brain/streaming.js

@@ -23,6 +23,22 @@
  * a stream cannot reconstruct and no brain here consumes, so promising them
  * would be a lie the compiler would happily keep.
  *
+ * **The responder's name joined that set in س٦/٤**, by the same rule: the
+ * brains now read it (`respondingModel`) to record WHO answered in the session
+ * log, so it is a field this file has to carry or the answer is lost. And it is
+ * the one field here a stream CAN reconstruct — every provider stamps it on the
+ * wire, measured: OpenAI on each `ChatCompletionChunk`, Anthropic on the
+ * `message_start` message, Gemini as `modelVersion` on every stream element,
+ * Ollama on every NDJSON line. Leaving it out was not a design decision but the
+ * shape of the file before anyone needed it, and the cost was precise: nisus
+ * sets `hooks.onChunk` on every agent it builds, so EVERY turn it runs is a
+ * streamed turn, and every one of them would have logged no responder at all.
+ *
+ * **Absent stays absent.** Every carry below is a conditional spread: a stream
+ * that never names a model folds to the object it folded to yesterday, key for
+ * key, and the ب١ fixtures that assert `fold(chunks) === nonStreamed` keep
+ * passing untouched.
+ *
  * **Display, not truth (the governing limit of ب١).** Nothing in this file
  * writes a log event, touches a fingerprint, or decides anything. Chunks are
  * emitted for a human to look at; the payload the brain returns is the record.
@@ -94,10 +110,16 @@ export function accumulateOpenAI(chunks) {
     let content = "";
     let sawText = false;
     let usage;
+    let model;
     const fragments = new Map();
     for (const chunk of chunks) {
         if (chunk.usage)
             usage = chunk.usage;
+        // Every chunk repeats the serving model; the last one wins, exactly as
+        // `usage` does. They should all agree — and if a gateway ever re-routed
+        // mid-response, the name that answered LAST is the honest one to record.
+        if (chunk.model)
+            model = chunk.model;
         const delta = chunk.choices?.[0]?.delta;
         if (!delta)
             continue;
@@ -132,6 +154,7 @@ export function accumulateOpenAI(chunks) {
             },
         ],
         ...(usage ? { usage } : {}),
+        ...(model !== undefined ? { model } : {}),
     };
 }
 function blockDelta(delta) {
@@ -173,6 +196,7 @@ export function accumulateAnthropic(events) {
     const blocks = new Map();
     let inputTokens = 0;
     let outputTokens = 0;
+    let model;
     for (const event of events) {
         if (event.type === "message_start") {
             const usage = event.message?.usage;
@@ -180,6 +204,10 @@ export function accumulateAnthropic(events) {
                 inputTokens = usage.input_tokens;
             if (typeof usage?.output_tokens === "number")
                 outputTokens = usage.output_tokens;
+            // Claude names the serving model once, in the opening event's message —
+            // the same object the non-streamed call returns whole.
+            if (typeof event.message?.model === "string")
+                model = event.message.model;
             continue;
         }
         if (event.type === "message_delta") {
@@ -218,7 +246,11 @@ export function accumulateAnthropic(events) {
         .map(([, slot]) => slot.type === "tool_use"
         ? { type: "tool_use", name: slot.name, input: parseJsonObject(slot.json) }
         : { type: slot.type, text: slot.text });
-    return { content, usage: { input_tokens: inputTokens, output_tokens: outputTokens } };
+    return {
+        content,
+        usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+        ...(model !== undefined ? { model } : {}),
+    };
 }
 /**
  * The text this stream item carries, across ALL of its text parts.
@@ -260,9 +292,14 @@ export function accumulateGemini(items) {
     const parts = [];
     let textSlot = -1;
     let usage;
+    let modelVersion;
     for (const item of items) {
         if (item.usageMetadata)
             usage = item.usageMetadata;
+        // Every element repeats it (each is a whole `GenerateContentResponse`);
+        // last one wins, as with usage.
+        if (item.modelVersion)
+            modelVersion = item.modelVersion;
         for (const part of item.candidates?.[0]?.content?.parts ?? []) {
             if (typeof part.text === "string") {
                 if (textSlot === -1) {
@@ -281,6 +318,7 @@ export function accumulateGemini(items) {
     return {
         candidates: [{ content: { parts } }],
         ...(usage ? { usageMetadata: usage } : {}),
+        ...(modelVersion !== undefined ? { modelVersion } : {}),
     };
 }
 /**
@@ -323,6 +361,7 @@ export function accumulateOllama(lines) {
     const toolCalls = [];
     let promptEvalCount;
     let evalCount;
+    let model;
     for (const line of lines) {
         if (typeof line.message?.content === "string")
             content += line.message.content;
@@ -333,6 +372,9 @@ export function accumulateOllama(lines) {
         }
         if (typeof line.eval_count === "number")
             evalCount = line.eval_count;
+        // Repeated on every line; last one wins, as with the counts.
+        if (line.model)
+            model = line.model;
     }
     return {
         message: {
@@ -341,6 +383,7 @@ export function accumulateOllama(lines) {
         },
         ...(promptEvalCount !== undefined ? { prompt_eval_count: promptEvalCount } : {}),
         ...(evalCount !== undefined ? { eval_count: evalCount } : {}),
+        ...(model !== undefined ? { model } : {}),
     };
 }
 /**