@langchain/langgraph-sdk 1.8.9 → 1.9.0

package/dist/stream/projections/values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.js","names":[],"sources":["../../../src/stream/projections/values.ts"],"sourcesContent":["/**\n * Namespace-scoped `values` projection.\n *\n * Opens `thread.subscribe({ channels: [\"values\"], namespaces: [ns] })`\n * and stores the most-recent `values.data` payload. Mirrors\n * {@link ThreadStream.values} but scoped to an arbitrary namespace so\n * subgraphs and subagents can expose their own state.\n *\n * When the state payload carries a `messages` array of serialized\n * messages, those are coerced to `BaseMessage` class instances so the\n * surface shape matches the root snapshot.\n */\nimport type { ValuesEvent } from \"@langchain/protocol\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  ensureMessageInstances,\n  tryCoerceMessageLikeToMessage,\n} from \"../../ui/messages.js\";\nimport type { Message } from \"../../types.messages.js\";\nimport type { ProjectionSpec, ProjectionRuntime } from \"../types.js\";\nimport { isRootNamespace, namespaceKey } from \"../namespace.js\";\nimport { openProjectionSubscription } from \"./runtime.js\";\n\nexport function valuesProjection<T = unknown>(\n  namespace: readonly string[],\n  messagesKey: string = \"messages\"\n): ProjectionSpec<T | undefined> {\n  const ns = [...namespace];\n  const key = `values|${messagesKey}|${namespaceKey(ns)}`;\n\n  return {\n    key,\n    namespace: ns,\n    initial: undefined,\n    open({ thread, store, rootBus }): ProjectionRuntime {\n      const applyValuesEvent = (event: ValuesEvent): void => {\n        const coerced = coerceMessagesInState(event.params.data, messagesKey);\n        store.setValue(coerced as T);\n      };\n\n      // See `messagesProjection` — root-scoped projections attach to\n      // the controller's root bus instead of opening a duplicate\n      // server subscription.\n      const rootShortCircuit =\n        isRootNamespace(ns) && rootBus.channels.includes(\"values\");\n\n      if (rootShortCircuit) {\n        const unsubscribe = rootBus.subscribe((event) => {\n          if (event.method !== \"values\") return;\n          if (!isRootNamespace(event.params.namespace)) return;\n          applyValuesEvent(event as ValuesEvent);\n        });\n        return {\n          dispose() {\n            unsubscribe();\n          },\n        };\n      }\n\n      return openProjectionSubscription({\n        thread,\n        channels: [\"values\"],\n        namespace: ns,\n        onEvent(event) {\n          if (event.method !== \"values\") return;\n          applyValuesEvent(event as ValuesEvent);\n        },\n      });\n    },\n  };\n}\n\nfunction coerceMessagesInState(value: unknown, messagesKey: string): unknown {\n  if (value == null || typeof value !== \"object\" || Array.isArray(value)) {\n    return value;\n  }\n  const state = value as Record<string, unknown>;\n  const maybeMessages = state[messagesKey];\n  if (!Array.isArray(maybeMessages) || maybeMessages.length === 0) {\n    return value;\n  }\n  // Fast path: array already contains class instances.\n  const hasPlain = maybeMessages.some(\n    (m) => m != null && typeof (m as BaseMessage).getType !== \"function\"\n  );\n  if (!hasPlain) return value;\n  return {\n    ...state,\n    [messagesKey]: ensureMessageInstances(\n      maybeMessages as (Message | BaseMessage)[]\n    ),\n  };\n}\n\nexport { tryCoerceMessageLikeToMessage };\n"],"mappings":";;;;AAuBA,SAAgB,iBACd,WACA,cAAsB,YACS;CAC/B,MAAM,KAAK,CAAC,GAAG,UAAU;AAGzB,QAAO;EACL,KAHU,UAAU,YAAY,GAAG,aAAa,GAAG;EAInD,WAAW;EACX,SAAS,KAAA;EACT,KAAK,EAAE,QAAQ,OAAO,WAA8B;GAClD,MAAM,oBAAoB,UAA6B;IACrD,MAAM,UAAU,sBAAsB,MAAM,OAAO,MAAM,YAAY;AACrE,UAAM,SAAS,QAAa;;AAS9B,OAFE,gBAAgB,GAAG,IAAI,QAAQ,SAAS,SAAS,SAAS,EAEtC;IACpB,MAAM,cAAc,QAAQ,WAAW,UAAU;AAC/C,SAAI,MAAM,WAAW,SAAU;AAC/B,SAAI,CAAC,gBAAgB,MAAM,OAAO,UAAU,CAAE;AAC9C,sBAAiB,MAAqB;MACtC;AACF,WAAO,EACL,UAAU;AACR,kBAAa;OAEhB;;AAGH,UAAO,2BAA2B;IAChC;IACA,UAAU,CAAC,SAAS;IACpB,WAAW;IACX,QAAQ,OAAO;AACb,SAAI,MAAM,WAAW,SAAU;AAC/B,sBAAiB,MAAqB;;IAEzC,CAAC;;EAEL;;AAGH,SAAS,sBAAsB,OAAgB,aAA8B;AAC3E,KAAI,SAAS,QAAQ,OAAO,UAAU,YAAY,MAAM,QAAQ,MAAM,CACpE,QAAO;CAET,MAAM,QAAQ;CACd,MAAM,gBAAgB,MAAM;AAC5B,KAAI,CAAC,MAAM,QAAQ,cAAc,IAAI,cAAc,WAAW,EAC5D,QAAO;AAMT,KAAI,CAHa,cAAc,MAC5B,MAAM,KAAK,QAAQ,OAAQ,EAAkB,YAAY,WAC3D,CACc,QAAO;AACtB,QAAO;EACL,GAAG;GACF,cAAc,uBACb,cACD;EACF"}

package/dist/stream/root-message-projection.cjs

@@ -0,0 +1,256 @@
+const require_messages = require("../client/stream/messages.cjs");
+const require_namespace = require("./namespace.cjs");
+const require_assembled_to_message = require("./assembled-to-message.cjs");
+const require_message_reconciliation = require("./message-reconciliation.cjs");
+//#region src/stream/root-message-projection.ts
+/**
+* Root-namespace message projection. Owns the merge between the
+* `messages` (streamed deltas) and `values` (authoritative
+* snapshots) channels for the root namespace.
+*
+* @typeParam StateType     - Root state shape; the messages array is read
+*   from `values[messagesKey]`.
+* @typeParam InterruptType - Shape of root protocol interrupts (forwarded
+*   into `RootSnapshot` updates).
+*/
+var RootMessageProjection = class {
+	/**
+	* Key inside `values` that holds the message array. Defaults to
+	* `"messages"` in the controller; configurable for state graphs
+	* that surface messages under a different slot.
+	*/
+	#messagesKey;
+	/** Root snapshot store written to on every merge. */
+	#store;
+	/**
+	* Subagent discovery runner notified about every assembled root
+	* message. Driving discovery from assembled messages (rather than
+	* raw events) lets us discover subagents from synthesized
+	* `tool_calls` without re-parsing protocol payloads.
+	*/
+	#subagents;
+	/**
+	* Stateful chunk assembler for in-flight messages. Reset (via a
+	* fresh instance) on every {@link reset} so a new thread starts
+	* with no half-built messages from the previous one.
+	*/
+	#assembler = new require_messages.MessageAssembler();
+	/**
+	* `messageId → role/toolCallId` captured from `message-start` events.
+	* The assembler's intermediate output drops these fields, so we cache
+	* them at start-time and reapply when projecting to a `BaseMessage`.
+	*/
+	#roles = /* @__PURE__ */ new Map();
+	/**
+	* `messageId → position in #store.messages` for fast in-place
+	* updates as deltas arrive. Rebuilt on every full reconciliation
+	* driven by a `values` event.
+	*/
+	#indexById = /* @__PURE__ */ new Map();
+	/**
+	* Ids observed in the most recent `values.messages` snapshot.
+	* Reconciliation uses this to detect server-side removals: a
+	* previously-seen id missing from the next snapshot means it was
+	* removed by the server (and should drop from the projection).
+	*/
+	#valuesMessageIds = /* @__PURE__ */ new Set();
+	/**
+	* `namespaceKey → tool_call_id` captured from root `tool-started`
+	* events. Used as a fallback when a tool-role `message-start` is
+	* missing its `tool_call_id` field.
+	*/
+	#toolCallIdByNamespace = /* @__PURE__ */ new Map();
+	/**
+	* @param params.messagesKey - Key inside `values` that holds the
+	*   message array.
+	* @param params.store       - Root snapshot store to mutate.
+	* @param params.subagents   - Discovery runner fed by each new
+	*   assembled message.
+	*/
+	constructor(params) {
+		this.#messagesKey = params.messagesKey;
+		this.#store = params.store;
+		this.#subagents = params.subagents;
+	}
+	/**
+	* Drop all per-thread state. Called by the controller on thread
+	* rebind / dispose so a swap doesn't surface stale messages.
+	*/
+	reset() {
+		this.#assembler = new require_messages.MessageAssembler();
+		this.#roles.clear();
+		this.#indexById.clear();
+		this.#valuesMessageIds = /* @__PURE__ */ new Set();
+		this.#toolCallIdByNamespace.clear();
+	}
+	/**
+	* Record a `namespace → tool_call_id` mapping captured from a root
+	* `tool-started` event.
+	*
+	* The companion tool-role `message-start` event may not carry a
+	* `tool_call_id`, so we fall back to the most recent value recorded
+	* here for the same namespace.
+	*
+	* @param namespace  - Event namespace from the `tool-started` event.
+	* @param toolCallId - Tool call id from the same event.
+	*/
+	recordToolCallNamespace(namespace, toolCallId) {
+		this.#toolCallIdByNamespace.set(require_namespace.namespaceKey(namespace), toolCallId);
+	}
+	/**
+	* Apply a `messages` channel event to the projection.
+	*
+	* Captures role/tool metadata on `message-start`, feeds the chunk
+	* to the assembler, projects the assembled output to a
+	* {@link BaseMessage}, and either appends or in-place updates the
+	* store's messages array based on whether the id was seen before.
+	*
+	* @param event - The `messages` channel event to consume.
+	*/
+	handleMessage(event) {
+		const data = event.params.data;
+		if (data.event === "message-start") {
+			const startData = data;
+			const role = startData.role ?? "ai";
+			const extendedRole = startData.role ?? role;
+			let toolCallId = startData.tool_call_id;
+			if (extendedRole === "tool" && toolCallId == null) {
+				const messageId = startData.id;
+				if (messageId != null) {
+					const match = /-tool-(.+)$/.exec(messageId);
+					if (match != null) toolCallId = match[1];
+				}
+				if (toolCallId == null) toolCallId = this.#toolCallIdByNamespace.get(require_namespace.namespaceKey(event.params.namespace));
+			}
+			if (startData.id != null) this.#roles.set(startData.id, {
+				role: extendedRole,
+				toolCallId
+			});
+		}
+		const update = this.#assembler.consume(event);
+		if (update == null) return;
+		const id = update.message.id;
+		if (id == null) return;
+		const captured = this.#roles.get(id) ?? { role: "ai" };
+		const base = require_assembled_to_message.assembledMessageToBaseMessage(update.message, captured.role, { toolCallId: captured.toolCallId });
+		this.#subagents.discoverFromMessage(base, event.params.namespace);
+		this.#store.setState((s) => {
+			const existingIdx = this.#indexById.get(id);
+			let messages;
+			if (existingIdx == null) {
+				this.#indexById.set(id, s.messages.length);
+				messages = [...s.messages, base];
+			} else if (require_message_reconciliation.messagesEqual(s.messages[existingIdx], base)) return s;
+			else {
+				messages = s.messages.slice();
+				messages[existingIdx] = base;
+			}
+			const values = syncMessagesIntoValues(s.values, this.#messagesKey, messages);
+			return values === s.values ? {
+				...s,
+				messages
+			} : {
+				...s,
+				messages,
+				values
+			};
+		});
+	}
+	/**
+	* Reconcile a full `values` snapshot into the projection.
+	*
+	* Delegates the merge to {@link reconcileMessagesFromValues}:
+	* values stays authoritative for ordering and removals, while
+	* streamed in-flight messages keep their content until the server
+	* echoes them back. Empty messages just refresh the values blob.
+	*
+	* Rebuilds {@link #indexById} after the merge so subsequent delta
+	* applications target the new positions.
+	*
+	* @param nextValues   - Full values snapshot from the `values` event.
+	* @param nextMessages - The messages array extracted from
+	*   `values[messagesKey]` and coerced to `BaseMessage` instances.
+	*/
+	applyValues(nextValues, nextMessages) {
+		this.#store.setState((s) => {
+			if (nextMessages.length === 0) return stateValuesShallowEqual(s.values, nextValues, this.#messagesKey) ? s : {
+				...s,
+				values: nextValues
+			};
+			const reconciliation = require_message_reconciliation.reconcileMessagesFromValues({
+				valueMessages: nextMessages,
+				currentMessages: s.messages,
+				currentIndexById: this.#indexById,
+				previousValueMessageIds: this.#valuesMessageIds,
+				preferValuesMessage: require_message_reconciliation.shouldPreferValuesMessageForToolCalls
+			});
+			this.#valuesMessageIds = reconciliation.valueMessageIds;
+			const messages = reconciliation.messages;
+			const values = {
+				...nextValues,
+				[this.#messagesKey]: messages
+			};
+			if (messages === s.messages && stateValuesShallowEqual(s.values, values, this.#messagesKey)) return s;
+			this.#indexById.clear();
+			for (const [id, idx] of require_message_reconciliation.buildMessageIndex(messages)) this.#indexById.set(id, idx);
+			return {
+				...s,
+				values,
+				messages
+			};
+		});
+	}
+};
+/**
+* Mirror a freshly-updated message list into `values[messagesKey]`.
+*
+* Returns the same `values` reference when the list is already
+* equal-by-content so the caller can keep the existing snapshot
+* identity (and avoid spurious `setSnapshot` notifications).
+*/
+function syncMessagesIntoValues(values, messagesKey, messages) {
+	const record = values;
+	const current = record[messagesKey];
+	if (Array.isArray(current) && messagesEqualList(current, messages)) return values;
+	return {
+		...record,
+		[messagesKey]: messages
+	};
+}
+/**
+* True when two `BaseMessage` arrays carry the same per-message
+* content (using {@link messagesEqual}).
+*/
+function messagesEqualList(previous, next) {
+	if (previous === next) return true;
+	if (previous.length !== next.length) return false;
+	for (let i = 0; i < previous.length; i += 1) if (!require_message_reconciliation.messagesEqual(previous[i], next[i])) return false;
+	return true;
+}
+/**
+* Shallow-equal for `values` objects, *ignoring* the messages slot.
+*
+* The messages array is compared separately by the caller (via
+* {@link messagesEqualList}) because both arrays contain class
+* instances whose JSON representation is not stable across reads.
+*/
+function stateValuesShallowEqual(previous, next, messagesKey) {
+	if (previous === next) return true;
+	const previousRecord = previous;
+	const nextRecord = next;
+	const previousKeys = Object.keys(previousRecord);
+	const nextKeys = Object.keys(nextRecord);
+	if (previousKeys.length !== nextKeys.length) return false;
+	for (const key of previousKeys) {
+		if (!Object.prototype.hasOwnProperty.call(nextRecord, key)) return false;
+		const previousValue = previousRecord[key];
+		const nextValue = nextRecord[key];
+		if (key === messagesKey && Array.isArray(previousValue) && Array.isArray(nextValue)) continue;
+		if (!Object.is(previousValue, nextValue)) return false;
+	}
+	return true;
+}
+//#endregion
+exports.RootMessageProjection = RootMessageProjection;
+
+//# sourceMappingURL=root-message-projection.cjs.map

package/dist/stream/root-message-projection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-message-projection.cjs","names":["#messagesKey","#store","#subagents","MessageAssembler","#roles","#indexById","#toolCallIdByNamespace","#assembler","#valuesMessageIds","namespaceKey","assembledMessageToBaseMessage","messagesEqual","reconcileMessagesFromValues","shouldPreferValuesMessageForToolCalls","buildMessageIndex"],"sources":["../../src/stream/root-message-projection.ts"],"sourcesContent":["/**\n * Root-namespace message projection.\n *\n * # What this module is\n *\n * The {@link RootMessageProjection} is the piece of the\n * {@link StreamController} that owns \"what messages does the root\n * namespace currently contain?\". It assembles streamed message deltas\n * via {@link MessageAssembler}, reconciles them against authoritative\n * `values.messages` snapshots from the server, and writes the merged\n * list back into the controller's root snapshot store.\n *\n * It also feeds {@link SubagentDiscovery} from each new root message\n * — that's the layer that surfaces `task` tool calls as discovered\n * subagents, even before any subagent-scoped subscription is opened.\n *\n * # Two streams of truth\n *\n * Root messages arrive on two channels and need to merge cleanly:\n *\n *   - **`messages` channel.** Token-level deltas that build messages\n *     incrementally. The {@link MessageAssembler} keeps partial\n *     messages by id and emits an updated `BaseMessage` per delta.\n *   - **`values` channel.** Periodic full-state snapshots that include\n *     the authoritative messages array. Used for ordering, removals,\n *     and forks (where the streamed messages may pre-date the new\n *     timeline).\n *\n * The reconciliation rules (delegated to\n * {@link reconcileMessagesFromValues}) preserve in-flight streamed\n * content while letting values dictate ordering and removals.\n *\n * # Tool-message namespace correlation\n *\n * Tool messages arrive on `messages-start` events with `role: \"tool\"`\n * but the start event doesn't always include a `tool_call_id`. We\n * recover it via three fallbacks:\n *\n *   1. The start event itself, when the server includes it.\n *   2. The legacy `<id>-tool-<call_id>` message id format.\n *   3. The most recent `tool-started` event recorded under the same\n *      namespace via {@link recordToolCallNamespace}.\n *\n * Without this correlation, tool messages render with empty\n * `tool_call_id` and downstream UIs can't pair them with the\n * originating tool call.\n *\n * # Lifecycle\n *\n *   - `handleMessage(event)`              — apply a `messages` event delta.\n *   - `applyValues(values, msgs)`         — merge a `values` snapshot.\n *   - `recordToolCallNamespace(ns, id)`   — capture `namespace → tool_call_id`\n *     so subsequent tool message starts can recover the id.\n *   - `reset()`                           — clear all state on thread rebind.\n */\nimport type {\n  MessagesEvent,\n  MessageRole,\n  MessageStartData,\n} from \"@langchain/protocol\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport { MessageAssembler } from \"../client/stream/messages.js\";\nimport {\n  assembledMessageToBaseMessage,\n  type ExtendedMessageRole,\n} from \"./assembled-to-message.js\";\nimport type { StreamStore } from \"./store.js\";\nimport type { RootSnapshot } from \"./types.js\";\nimport type { SubagentDiscovery } from \"./discovery/index.js\";\nimport { namespaceKey } from \"./namespace.js\";\nimport {\n  buildMessageIndex,\n  messagesEqual,\n  reconcileMessagesFromValues,\n  shouldPreferValuesMessageForToolCalls,\n} from \"./message-reconciliation.js\";\n\n/**\n * Root-namespace message projection. Owns the merge between the\n * `messages` (streamed deltas) and `values` (authoritative\n * snapshots) channels for the root namespace.\n *\n * @typeParam StateType     - Root state shape; the messages array is read\n *   from `values[messagesKey]`.\n * @typeParam InterruptType - Shape of root protocol interrupts (forwarded\n *   into `RootSnapshot` updates).\n */\nexport class RootMessageProjection<\n  StateType extends object,\n  InterruptType = unknown,\n> {\n  /**\n   * Key inside `values` that holds the message array. Defaults to\n   * `\"messages\"` in the controller; configurable for state graphs\n   * that surface messages under a different slot.\n   */\n  readonly #messagesKey: string;\n\n  /** Root snapshot store written to on every merge. */\n  readonly #store: StreamStore<RootSnapshot<StateType, InterruptType>>;\n\n  /**\n   * Subagent discovery runner notified about every assembled root\n   * message. Driving discovery from assembled messages (rather than\n   * raw events) lets us discover subagents from synthesized\n   * `tool_calls` without re-parsing protocol payloads.\n   */\n  readonly #subagents: SubagentDiscovery;\n\n  /**\n   * Stateful chunk assembler for in-flight messages. Reset (via a\n   * fresh instance) on every {@link reset} so a new thread starts\n   * with no half-built messages from the previous one.\n   */\n  #assembler = new MessageAssembler();\n\n  /**\n   * `messageId → role/toolCallId` captured from `message-start` events.\n   * The assembler's intermediate output drops these fields, so we cache\n   * them at start-time and reapply when projecting to a `BaseMessage`.\n   */\n  readonly #roles = new Map<\n    string,\n    { role: ExtendedMessageRole; toolCallId?: string }\n  >();\n\n  /**\n   * `messageId → position in #store.messages` for fast in-place\n   * updates as deltas arrive. Rebuilt on every full reconciliation\n   * driven by a `values` event.\n   */\n  readonly #indexById = new Map<string, number>();\n\n  /**\n   * Ids observed in the most recent `values.messages` snapshot.\n   * Reconciliation uses this to detect server-side removals: a\n   * previously-seen id missing from the next snapshot means it was\n   * removed by the server (and should drop from the projection).\n   */\n  #valuesMessageIds = new Set<string>();\n\n  /**\n   * `namespaceKey → tool_call_id` captured from root `tool-started`\n   * events. Used as a fallback when a tool-role `message-start` is\n   * missing its `tool_call_id` field.\n   */\n  readonly #toolCallIdByNamespace = new Map<string, string>();\n\n  /**\n   * @param params.messagesKey - Key inside `values` that holds the\n   *   message array.\n   * @param params.store       - Root snapshot store to mutate.\n   * @param params.subagents   - Discovery runner fed by each new\n   *   assembled message.\n   */\n  constructor(params: {\n    messagesKey: string;\n    store: StreamStore<RootSnapshot<StateType, InterruptType>>;\n    subagents: SubagentDiscovery;\n  }) {\n    this.#messagesKey = params.messagesKey;\n    this.#store = params.store;\n    this.#subagents = params.subagents;\n  }\n\n  /**\n   * Drop all per-thread state. Called by the controller on thread\n   * rebind / dispose so a swap doesn't surface stale messages.\n   */\n  reset(): void {\n    this.#assembler = new MessageAssembler();\n    this.#roles.clear();\n    this.#indexById.clear();\n    this.#valuesMessageIds = new Set();\n    this.#toolCallIdByNamespace.clear();\n  }\n\n  /**\n   * Record a `namespace → tool_call_id` mapping captured from a root\n   * `tool-started` event.\n   *\n   * The companion tool-role `message-start` event may not carry a\n   * `tool_call_id`, so we fall back to the most recent value recorded\n   * here for the same namespace.\n   *\n   * @param namespace  - Event namespace from the `tool-started` event.\n   * @param toolCallId - Tool call id from the same event.\n   */\n  recordToolCallNamespace(\n    namespace: readonly string[],\n    toolCallId: string\n  ): void {\n    this.#toolCallIdByNamespace.set(namespaceKey(namespace), toolCallId);\n  }\n\n  /**\n   * Apply a `messages` channel event to the projection.\n   *\n   * Captures role/tool metadata on `message-start`, feeds the chunk\n   * to the assembler, projects the assembled output to a\n   * {@link BaseMessage}, and either appends or in-place updates the\n   * store's messages array based on whether the id was seen before.\n   *\n   * @param event - The `messages` channel event to consume.\n   */\n  handleMessage(event: MessagesEvent): void {\n    const data = event.params.data;\n    if (data.event === \"message-start\") {\n      const startData = data as MessageStartData;\n      const role = (startData.role ?? \"ai\") as MessageRole;\n      const extendedRole =\n        (startData as { role?: ExtendedMessageRole }).role ?? role;\n      let toolCallId = (startData as { tool_call_id?: string }).tool_call_id;\n      // Tool messages need a tool_call_id to render. Fall back through:\n      //   1. legacy `<id>-tool-<call_id>` message id format\n      //   2. namespace-recorded tool_call_id (from #recordToolCallNamespace)\n      if (extendedRole === \"tool\" && toolCallId == null) {\n        const messageId = startData.id;\n        if (messageId != null) {\n          const match = /-tool-(.+)$/.exec(messageId);\n          if (match != null) toolCallId = match[1];\n        }\n        if (toolCallId == null) {\n          toolCallId = this.#toolCallIdByNamespace.get(\n            namespaceKey(event.params.namespace)\n          );\n        }\n      }\n      if (startData.id != null) {\n        this.#roles.set(startData.id, {\n          role: extendedRole,\n          toolCallId,\n        });\n      }\n    }\n\n    const update = this.#assembler.consume(event);\n    if (update == null) return;\n    const id = update.message.id;\n    if (id == null) return;\n    const captured = this.#roles.get(id) ?? { role: \"ai\" as const };\n    const base = assembledMessageToBaseMessage(update.message, captured.role, {\n      toolCallId: captured.toolCallId,\n    });\n    this.#subagents.discoverFromMessage(base, event.params.namespace);\n\n    this.#store.setState((s) => {\n      const existingIdx = this.#indexById.get(id);\n      let messages: BaseMessage[];\n      if (existingIdx == null) {\n        // First sighting: append at end and remember its index for\n        // future delta updates.\n        this.#indexById.set(id, s.messages.length);\n        messages = [...s.messages, base];\n      } else if (messagesEqual(s.messages[existingIdx], base)) {\n        // Identical re-emission of an already-projected message —\n        // skip the store write to keep snapshot identity stable.\n        return s;\n      } else {\n        // In-place update for a known id.\n        messages = s.messages.slice();\n        messages[existingIdx] = base;\n      }\n\n      // Mirror the new messages list into `values[messagesKey]` so\n      // direct `values` reads (used by some hooks and by the eventual\n      // `values` reconciliation) stay in sync.\n      const values = syncMessagesIntoValues(\n        s.values,\n        this.#messagesKey,\n        messages\n      );\n      return values === s.values\n        ? { ...s, messages }\n        : { ...s, messages, values };\n    });\n  }\n\n  /**\n   * Reconcile a full `values` snapshot into the projection.\n   *\n   * Delegates the merge to {@link reconcileMessagesFromValues}:\n   * values stays authoritative for ordering and removals, while\n   * streamed in-flight messages keep their content until the server\n   * echoes them back. Empty messages just refresh the values blob.\n   *\n   * Rebuilds {@link #indexById} after the merge so subsequent delta\n   * applications target the new positions.\n   *\n   * @param nextValues   - Full values snapshot from the `values` event.\n   * @param nextMessages - The messages array extracted from\n   *   `values[messagesKey]` and coerced to `BaseMessage` instances.\n   */\n  applyValues(nextValues: StateType, nextMessages: BaseMessage[]): void {\n    this.#store.setState((s) => {\n      if (nextMessages.length === 0) {\n        return stateValuesShallowEqual(s.values, nextValues, this.#messagesKey)\n          ? s\n          : { ...s, values: nextValues };\n      }\n\n      const reconciliation = reconcileMessagesFromValues({\n        valueMessages: nextMessages,\n        currentMessages: s.messages,\n        currentIndexById: this.#indexById,\n        previousValueMessageIds: this.#valuesMessageIds,\n        preferValuesMessage: shouldPreferValuesMessageForToolCalls,\n      });\n      this.#valuesMessageIds = reconciliation.valueMessageIds;\n      const messages = reconciliation.messages as BaseMessage[];\n      const values = {\n        ...(nextValues as Record<string, unknown>),\n        [this.#messagesKey]: messages,\n      } as StateType;\n      if (\n        messages === s.messages &&\n        stateValuesShallowEqual(s.values, values, this.#messagesKey)\n      ) {\n        return s;\n      }\n\n      // Reconciliation may reorder, drop, or substitute messages, so\n      // rebuild the id → index map to match the new array.\n      this.#indexById.clear();\n      for (const [id, idx] of buildMessageIndex(messages)) {\n        this.#indexById.set(id, idx);\n      }\n      return {\n        ...s,\n        values,\n        messages,\n      };\n    });\n  }\n}\n\n/**\n * Mirror a freshly-updated message list into `values[messagesKey]`.\n *\n * Returns the same `values` reference when the list is already\n * equal-by-content so the caller can keep the existing snapshot\n * identity (and avoid spurious `setSnapshot` notifications).\n */\nfunction syncMessagesIntoValues<StateType extends object>(\n  values: StateType,\n  messagesKey: string,\n  messages: BaseMessage[]\n): StateType {\n  const record = values as Record<string, unknown>;\n  const current = record[messagesKey];\n  if (Array.isArray(current) && messagesEqualList(current, messages)) {\n    return values;\n  }\n  return {\n    ...record,\n    [messagesKey]: messages,\n  } as StateType;\n}\n\n/**\n * True when two `BaseMessage` arrays carry the same per-message\n * content (using {@link messagesEqual}).\n */\nfunction messagesEqualList(\n  previous: readonly BaseMessage[],\n  next: readonly BaseMessage[]\n): boolean {\n  if (previous === next) return true;\n  if (previous.length !== next.length) return false;\n  for (let i = 0; i < previous.length; i += 1) {\n    if (!messagesEqual(previous[i], next[i])) return false;\n  }\n  return true;\n}\n\n/**\n * Shallow-equal for `values` objects, *ignoring* the messages slot.\n *\n * The messages array is compared separately by the caller (via\n * {@link messagesEqualList}) because both arrays contain class\n * instances whose JSON representation is not stable across reads.\n */\nfunction stateValuesShallowEqual(\n  previous: object,\n  next: object,\n  messagesKey: string\n): boolean {\n  if (previous === next) return true;\n  const previousRecord = previous as Record<string, unknown>;\n  const nextRecord = next as Record<string, unknown>;\n  const previousKeys = Object.keys(previousRecord);\n  const nextKeys = Object.keys(nextRecord);\n  if (previousKeys.length !== nextKeys.length) return false;\n  for (const key of previousKeys) {\n    if (!Object.prototype.hasOwnProperty.call(nextRecord, key)) return false;\n    const previousValue = previousRecord[key];\n    const nextValue = nextRecord[key];\n    if (\n      key === messagesKey &&\n      Array.isArray(previousValue) &&\n      Array.isArray(nextValue)\n    ) {\n      continue;\n    }\n    if (!Object.is(previousValue, nextValue)) return false;\n  }\n  return true;\n}\n"],"mappings":"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"}

package/dist/stream/root-message-projection.js

@@ -0,0 +1,256 @@
+import { MessageAssembler } from "../client/stream/messages.js";
+import { namespaceKey } from "./namespace.js";
+import { assembledMessageToBaseMessage } from "./assembled-to-message.js";
+import { buildMessageIndex, messagesEqual, reconcileMessagesFromValues, shouldPreferValuesMessageForToolCalls } from "./message-reconciliation.js";
+//#region src/stream/root-message-projection.ts
+/**
+* Root-namespace message projection. Owns the merge between the
+* `messages` (streamed deltas) and `values` (authoritative
+* snapshots) channels for the root namespace.
+*
+* @typeParam StateType     - Root state shape; the messages array is read
+*   from `values[messagesKey]`.
+* @typeParam InterruptType - Shape of root protocol interrupts (forwarded
+*   into `RootSnapshot` updates).
+*/
+var RootMessageProjection = class {
+	/**
+	* Key inside `values` that holds the message array. Defaults to
+	* `"messages"` in the controller; configurable for state graphs
+	* that surface messages under a different slot.
+	*/
+	#messagesKey;
+	/** Root snapshot store written to on every merge. */
+	#store;
+	/**
+	* Subagent discovery runner notified about every assembled root
+	* message. Driving discovery from assembled messages (rather than
+	* raw events) lets us discover subagents from synthesized
+	* `tool_calls` without re-parsing protocol payloads.
+	*/
+	#subagents;
+	/**
+	* Stateful chunk assembler for in-flight messages. Reset (via a
+	* fresh instance) on every {@link reset} so a new thread starts
+	* with no half-built messages from the previous one.
+	*/
+	#assembler = new MessageAssembler();
+	/**
+	* `messageId → role/toolCallId` captured from `message-start` events.
+	* The assembler's intermediate output drops these fields, so we cache
+	* them at start-time and reapply when projecting to a `BaseMessage`.
+	*/
+	#roles = /* @__PURE__ */ new Map();
+	/**
+	* `messageId → position in #store.messages` for fast in-place
+	* updates as deltas arrive. Rebuilt on every full reconciliation
+	* driven by a `values` event.
+	*/
+	#indexById = /* @__PURE__ */ new Map();
+	/**
+	* Ids observed in the most recent `values.messages` snapshot.
+	* Reconciliation uses this to detect server-side removals: a
+	* previously-seen id missing from the next snapshot means it was
+	* removed by the server (and should drop from the projection).
+	*/
+	#valuesMessageIds = /* @__PURE__ */ new Set();
+	/**
+	* `namespaceKey → tool_call_id` captured from root `tool-started`
+	* events. Used as a fallback when a tool-role `message-start` is
+	* missing its `tool_call_id` field.
+	*/
+	#toolCallIdByNamespace = /* @__PURE__ */ new Map();
+	/**
+	* @param params.messagesKey - Key inside `values` that holds the
+	*   message array.
+	* @param params.store       - Root snapshot store to mutate.
+	* @param params.subagents   - Discovery runner fed by each new
+	*   assembled message.
+	*/
+	constructor(params) {
+		this.#messagesKey = params.messagesKey;
+		this.#store = params.store;
+		this.#subagents = params.subagents;
+	}
+	/**
+	* Drop all per-thread state. Called by the controller on thread
+	* rebind / dispose so a swap doesn't surface stale messages.
+	*/
+	reset() {
+		this.#assembler = new MessageAssembler();
+		this.#roles.clear();
+		this.#indexById.clear();
+		this.#valuesMessageIds = /* @__PURE__ */ new Set();
+		this.#toolCallIdByNamespace.clear();
+	}
+	/**
+	* Record a `namespace → tool_call_id` mapping captured from a root
+	* `tool-started` event.
+	*
+	* The companion tool-role `message-start` event may not carry a
+	* `tool_call_id`, so we fall back to the most recent value recorded
+	* here for the same namespace.
+	*
+	* @param namespace  - Event namespace from the `tool-started` event.
+	* @param toolCallId - Tool call id from the same event.
+	*/
+	recordToolCallNamespace(namespace, toolCallId) {
+		this.#toolCallIdByNamespace.set(namespaceKey(namespace), toolCallId);
+	}
+	/**
+	* Apply a `messages` channel event to the projection.
+	*
+	* Captures role/tool metadata on `message-start`, feeds the chunk
+	* to the assembler, projects the assembled output to a
+	* {@link BaseMessage}, and either appends or in-place updates the
+	* store's messages array based on whether the id was seen before.
+	*
+	* @param event - The `messages` channel event to consume.
+	*/
+	handleMessage(event) {
+		const data = event.params.data;
+		if (data.event === "message-start") {
+			const startData = data;
+			const role = startData.role ?? "ai";
+			const extendedRole = startData.role ?? role;
+			let toolCallId = startData.tool_call_id;
+			if (extendedRole === "tool" && toolCallId == null) {
+				const messageId = startData.id;
+				if (messageId != null) {
+					const match = /-tool-(.+)$/.exec(messageId);
+					if (match != null) toolCallId = match[1];
+				}
+				if (toolCallId == null) toolCallId = this.#toolCallIdByNamespace.get(namespaceKey(event.params.namespace));
+			}
+			if (startData.id != null) this.#roles.set(startData.id, {
+				role: extendedRole,
+				toolCallId
+			});
+		}
+		const update = this.#assembler.consume(event);
+		if (update == null) return;
+		const id = update.message.id;
+		if (id == null) return;
+		const captured = this.#roles.get(id) ?? { role: "ai" };
+		const base = assembledMessageToBaseMessage(update.message, captured.role, { toolCallId: captured.toolCallId });
+		this.#subagents.discoverFromMessage(base, event.params.namespace);
+		this.#store.setState((s) => {
+			const existingIdx = this.#indexById.get(id);
+			let messages;
+			if (existingIdx == null) {
+				this.#indexById.set(id, s.messages.length);
+				messages = [...s.messages, base];
+			} else if (messagesEqual(s.messages[existingIdx], base)) return s;
+			else {
+				messages = s.messages.slice();
+				messages[existingIdx] = base;
+			}
+			const values = syncMessagesIntoValues(s.values, this.#messagesKey, messages);
+			return values === s.values ? {
+				...s,
+				messages
+			} : {
+				...s,
+				messages,
+				values
+			};
+		});
+	}
+	/**
+	* Reconcile a full `values` snapshot into the projection.
+	*
+	* Delegates the merge to {@link reconcileMessagesFromValues}:
+	* values stays authoritative for ordering and removals, while
+	* streamed in-flight messages keep their content until the server
+	* echoes them back. Empty messages just refresh the values blob.
+	*
+	* Rebuilds {@link #indexById} after the merge so subsequent delta
+	* applications target the new positions.
+	*
+	* @param nextValues   - Full values snapshot from the `values` event.
+	* @param nextMessages - The messages array extracted from
+	*   `values[messagesKey]` and coerced to `BaseMessage` instances.
+	*/
+	applyValues(nextValues, nextMessages) {
+		this.#store.setState((s) => {
+			if (nextMessages.length === 0) return stateValuesShallowEqual(s.values, nextValues, this.#messagesKey) ? s : {
+				...s,
+				values: nextValues
+			};
+			const reconciliation = reconcileMessagesFromValues({
+				valueMessages: nextMessages,
+				currentMessages: s.messages,
+				currentIndexById: this.#indexById,
+				previousValueMessageIds: this.#valuesMessageIds,
+				preferValuesMessage: shouldPreferValuesMessageForToolCalls
+			});
+			this.#valuesMessageIds = reconciliation.valueMessageIds;
+			const messages = reconciliation.messages;
+			const values = {
+				...nextValues,
+				[this.#messagesKey]: messages
+			};
+			if (messages === s.messages && stateValuesShallowEqual(s.values, values, this.#messagesKey)) return s;
+			this.#indexById.clear();
+			for (const [id, idx] of buildMessageIndex(messages)) this.#indexById.set(id, idx);
+			return {
+				...s,
+				values,
+				messages
+			};
+		});
+	}
+};
+/**
+* Mirror a freshly-updated message list into `values[messagesKey]`.
+*
+* Returns the same `values` reference when the list is already
+* equal-by-content so the caller can keep the existing snapshot
+* identity (and avoid spurious `setSnapshot` notifications).
+*/
+function syncMessagesIntoValues(values, messagesKey, messages) {
+	const record = values;
+	const current = record[messagesKey];
+	if (Array.isArray(current) && messagesEqualList(current, messages)) return values;
+	return {
+		...record,
+		[messagesKey]: messages
+	};
+}
+/**
+* True when two `BaseMessage` arrays carry the same per-message
+* content (using {@link messagesEqual}).
+*/
+function messagesEqualList(previous, next) {
+	if (previous === next) return true;
+	if (previous.length !== next.length) return false;
+	for (let i = 0; i < previous.length; i += 1) if (!messagesEqual(previous[i], next[i])) return false;
+	return true;
+}
+/**
+* Shallow-equal for `values` objects, *ignoring* the messages slot.
+*
+* The messages array is compared separately by the caller (via
+* {@link messagesEqualList}) because both arrays contain class
+* instances whose JSON representation is not stable across reads.
+*/
+function stateValuesShallowEqual(previous, next, messagesKey) {
+	if (previous === next) return true;
+	const previousRecord = previous;
+	const nextRecord = next;
+	const previousKeys = Object.keys(previousRecord);
+	const nextKeys = Object.keys(nextRecord);
+	if (previousKeys.length !== nextKeys.length) return false;
+	for (const key of previousKeys) {
+		if (!Object.prototype.hasOwnProperty.call(nextRecord, key)) return false;
+		const previousValue = previousRecord[key];
+		const nextValue = nextRecord[key];
+		if (key === messagesKey && Array.isArray(previousValue) && Array.isArray(nextValue)) continue;
+		if (!Object.is(previousValue, nextValue)) return false;
+	}
+	return true;
+}
+//#endregion
+export { RootMessageProjection };
+
+//# sourceMappingURL=root-message-projection.js.map

package/dist/stream/root-message-projection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-message-projection.js","names":["#messagesKey","#store","#subagents","#roles","#indexById","#toolCallIdByNamespace","#assembler","#valuesMessageIds"],"sources":["../../src/stream/root-message-projection.ts"],"sourcesContent":["/**\n * Root-namespace message projection.\n *\n * # What this module is\n *\n * The {@link RootMessageProjection} is the piece of the\n * {@link StreamController} that owns \"what messages does the root\n * namespace currently contain?\". It assembles streamed message deltas\n * via {@link MessageAssembler}, reconciles them against authoritative\n * `values.messages` snapshots from the server, and writes the merged\n * list back into the controller's root snapshot store.\n *\n * It also feeds {@link SubagentDiscovery} from each new root message\n * — that's the layer that surfaces `task` tool calls as discovered\n * subagents, even before any subagent-scoped subscription is opened.\n *\n * # Two streams of truth\n *\n * Root messages arrive on two channels and need to merge cleanly:\n *\n *   - **`messages` channel.** Token-level deltas that build messages\n *     incrementally. The {@link MessageAssembler} keeps partial\n *     messages by id and emits an updated `BaseMessage` per delta.\n *   - **`values` channel.** Periodic full-state snapshots that include\n *     the authoritative messages array. Used for ordering, removals,\n *     and forks (where the streamed messages may pre-date the new\n *     timeline).\n *\n * The reconciliation rules (delegated to\n * {@link reconcileMessagesFromValues}) preserve in-flight streamed\n * content while letting values dictate ordering and removals.\n *\n * # Tool-message namespace correlation\n *\n * Tool messages arrive on `messages-start` events with `role: \"tool\"`\n * but the start event doesn't always include a `tool_call_id`. We\n * recover it via three fallbacks:\n *\n *   1. The start event itself, when the server includes it.\n *   2. The legacy `<id>-tool-<call_id>` message id format.\n *   3. The most recent `tool-started` event recorded under the same\n *      namespace via {@link recordToolCallNamespace}.\n *\n * Without this correlation, tool messages render with empty\n * `tool_call_id` and downstream UIs can't pair them with the\n * originating tool call.\n *\n * # Lifecycle\n *\n *   - `handleMessage(event)`              — apply a `messages` event delta.\n *   - `applyValues(values, msgs)`         — merge a `values` snapshot.\n *   - `recordToolCallNamespace(ns, id)`   — capture `namespace → tool_call_id`\n *     so subsequent tool message starts can recover the id.\n *   - `reset()`                           — clear all state on thread rebind.\n */\nimport type {\n  MessagesEvent,\n  MessageRole,\n  MessageStartData,\n} from \"@langchain/protocol\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport { MessageAssembler } from \"../client/stream/messages.js\";\nimport {\n  assembledMessageToBaseMessage,\n  type ExtendedMessageRole,\n} from \"./assembled-to-message.js\";\nimport type { StreamStore } from \"./store.js\";\nimport type { RootSnapshot } from \"./types.js\";\nimport type { SubagentDiscovery } from \"./discovery/index.js\";\nimport { namespaceKey } from \"./namespace.js\";\nimport {\n  buildMessageIndex,\n  messagesEqual,\n  reconcileMessagesFromValues,\n  shouldPreferValuesMessageForToolCalls,\n} from \"./message-reconciliation.js\";\n\n/**\n * Root-namespace message projection. Owns the merge between the\n * `messages` (streamed deltas) and `values` (authoritative\n * snapshots) channels for the root namespace.\n *\n * @typeParam StateType     - Root state shape; the messages array is read\n *   from `values[messagesKey]`.\n * @typeParam InterruptType - Shape of root protocol interrupts (forwarded\n *   into `RootSnapshot` updates).\n */\nexport class RootMessageProjection<\n  StateType extends object,\n  InterruptType = unknown,\n> {\n  /**\n   * Key inside `values` that holds the message array. Defaults to\n   * `\"messages\"` in the controller; configurable for state graphs\n   * that surface messages under a different slot.\n   */\n  readonly #messagesKey: string;\n\n  /** Root snapshot store written to on every merge. */\n  readonly #store: StreamStore<RootSnapshot<StateType, InterruptType>>;\n\n  /**\n   * Subagent discovery runner notified about every assembled root\n   * message. Driving discovery from assembled messages (rather than\n   * raw events) lets us discover subagents from synthesized\n   * `tool_calls` without re-parsing protocol payloads.\n   */\n  readonly #subagents: SubagentDiscovery;\n\n  /**\n   * Stateful chunk assembler for in-flight messages. Reset (via a\n   * fresh instance) on every {@link reset} so a new thread starts\n   * with no half-built messages from the previous one.\n   */\n  #assembler = new MessageAssembler();\n\n  /**\n   * `messageId → role/toolCallId` captured from `message-start` events.\n   * The assembler's intermediate output drops these fields, so we cache\n   * them at start-time and reapply when projecting to a `BaseMessage`.\n   */\n  readonly #roles = new Map<\n    string,\n    { role: ExtendedMessageRole; toolCallId?: string }\n  >();\n\n  /**\n   * `messageId → position in #store.messages` for fast in-place\n   * updates as deltas arrive. Rebuilt on every full reconciliation\n   * driven by a `values` event.\n   */\n  readonly #indexById = new Map<string, number>();\n\n  /**\n   * Ids observed in the most recent `values.messages` snapshot.\n   * Reconciliation uses this to detect server-side removals: a\n   * previously-seen id missing from the next snapshot means it was\n   * removed by the server (and should drop from the projection).\n   */\n  #valuesMessageIds = new Set<string>();\n\n  /**\n   * `namespaceKey → tool_call_id` captured from root `tool-started`\n   * events. Used as a fallback when a tool-role `message-start` is\n   * missing its `tool_call_id` field.\n   */\n  readonly #toolCallIdByNamespace = new Map<string, string>();\n\n  /**\n   * @param params.messagesKey - Key inside `values` that holds the\n   *   message array.\n   * @param params.store       - Root snapshot store to mutate.\n   * @param params.subagents   - Discovery runner fed by each new\n   *   assembled message.\n   */\n  constructor(params: {\n    messagesKey: string;\n    store: StreamStore<RootSnapshot<StateType, InterruptType>>;\n    subagents: SubagentDiscovery;\n  }) {\n    this.#messagesKey = params.messagesKey;\n    this.#store = params.store;\n    this.#subagents = params.subagents;\n  }\n\n  /**\n   * Drop all per-thread state. Called by the controller on thread\n   * rebind / dispose so a swap doesn't surface stale messages.\n   */\n  reset(): void {\n    this.#assembler = new MessageAssembler();\n    this.#roles.clear();\n    this.#indexById.clear();\n    this.#valuesMessageIds = new Set();\n    this.#toolCallIdByNamespace.clear();\n  }\n\n  /**\n   * Record a `namespace → tool_call_id` mapping captured from a root\n   * `tool-started` event.\n   *\n   * The companion tool-role `message-start` event may not carry a\n   * `tool_call_id`, so we fall back to the most recent value recorded\n   * here for the same namespace.\n   *\n   * @param namespace  - Event namespace from the `tool-started` event.\n   * @param toolCallId - Tool call id from the same event.\n   */\n  recordToolCallNamespace(\n    namespace: readonly string[],\n    toolCallId: string\n  ): void {\n    this.#toolCallIdByNamespace.set(namespaceKey(namespace), toolCallId);\n  }\n\n  /**\n   * Apply a `messages` channel event to the projection.\n   *\n   * Captures role/tool metadata on `message-start`, feeds the chunk\n   * to the assembler, projects the assembled output to a\n   * {@link BaseMessage}, and either appends or in-place updates the\n   * store's messages array based on whether the id was seen before.\n   *\n   * @param event - The `messages` channel event to consume.\n   */\n  handleMessage(event: MessagesEvent): void {\n    const data = event.params.data;\n    if (data.event === \"message-start\") {\n      const startData = data as MessageStartData;\n      const role = (startData.role ?? \"ai\") as MessageRole;\n      const extendedRole =\n        (startData as { role?: ExtendedMessageRole }).role ?? role;\n      let toolCallId = (startData as { tool_call_id?: string }).tool_call_id;\n      // Tool messages need a tool_call_id to render. Fall back through:\n      //   1. legacy `<id>-tool-<call_id>` message id format\n      //   2. namespace-recorded tool_call_id (from #recordToolCallNamespace)\n      if (extendedRole === \"tool\" && toolCallId == null) {\n        const messageId = startData.id;\n        if (messageId != null) {\n          const match = /-tool-(.+)$/.exec(messageId);\n          if (match != null) toolCallId = match[1];\n        }\n        if (toolCallId == null) {\n          toolCallId = this.#toolCallIdByNamespace.get(\n            namespaceKey(event.params.namespace)\n          );\n        }\n      }\n      if (startData.id != null) {\n        this.#roles.set(startData.id, {\n          role: extendedRole,\n          toolCallId,\n        });\n      }\n    }\n\n    const update = this.#assembler.consume(event);\n    if (update == null) return;\n    const id = update.message.id;\n    if (id == null) return;\n    const captured = this.#roles.get(id) ?? { role: \"ai\" as const };\n    const base = assembledMessageToBaseMessage(update.message, captured.role, {\n      toolCallId: captured.toolCallId,\n    });\n    this.#subagents.discoverFromMessage(base, event.params.namespace);\n\n    this.#store.setState((s) => {\n      const existingIdx = this.#indexById.get(id);\n      let messages: BaseMessage[];\n      if (existingIdx == null) {\n        // First sighting: append at end and remember its index for\n        // future delta updates.\n        this.#indexById.set(id, s.messages.length);\n        messages = [...s.messages, base];\n      } else if (messagesEqual(s.messages[existingIdx], base)) {\n        // Identical re-emission of an already-projected message —\n        // skip the store write to keep snapshot identity stable.\n        return s;\n      } else {\n        // In-place update for a known id.\n        messages = s.messages.slice();\n        messages[existingIdx] = base;\n      }\n\n      // Mirror the new messages list into `values[messagesKey]` so\n      // direct `values` reads (used by some hooks and by the eventual\n      // `values` reconciliation) stay in sync.\n      const values = syncMessagesIntoValues(\n        s.values,\n        this.#messagesKey,\n        messages\n      );\n      return values === s.values\n        ? { ...s, messages }\n        : { ...s, messages, values };\n    });\n  }\n\n  /**\n   * Reconcile a full `values` snapshot into the projection.\n   *\n   * Delegates the merge to {@link reconcileMessagesFromValues}:\n   * values stays authoritative for ordering and removals, while\n   * streamed in-flight messages keep their content until the server\n   * echoes them back. Empty messages just refresh the values blob.\n   *\n   * Rebuilds {@link #indexById} after the merge so subsequent delta\n   * applications target the new positions.\n   *\n   * @param nextValues   - Full values snapshot from the `values` event.\n   * @param nextMessages - The messages array extracted from\n   *   `values[messagesKey]` and coerced to `BaseMessage` instances.\n   */\n  applyValues(nextValues: StateType, nextMessages: BaseMessage[]): void {\n    this.#store.setState((s) => {\n      if (nextMessages.length === 0) {\n        return stateValuesShallowEqual(s.values, nextValues, this.#messagesKey)\n          ? s\n          : { ...s, values: nextValues };\n      }\n\n      const reconciliation = reconcileMessagesFromValues({\n        valueMessages: nextMessages,\n        currentMessages: s.messages,\n        currentIndexById: this.#indexById,\n        previousValueMessageIds: this.#valuesMessageIds,\n        preferValuesMessage: shouldPreferValuesMessageForToolCalls,\n      });\n      this.#valuesMessageIds = reconciliation.valueMessageIds;\n      const messages = reconciliation.messages as BaseMessage[];\n      const values = {\n        ...(nextValues as Record<string, unknown>),\n        [this.#messagesKey]: messages,\n      } as StateType;\n      if (\n        messages === s.messages &&\n        stateValuesShallowEqual(s.values, values, this.#messagesKey)\n      ) {\n        return s;\n      }\n\n      // Reconciliation may reorder, drop, or substitute messages, so\n      // rebuild the id → index map to match the new array.\n      this.#indexById.clear();\n      for (const [id, idx] of buildMessageIndex(messages)) {\n        this.#indexById.set(id, idx);\n      }\n      return {\n        ...s,\n        values,\n        messages,\n      };\n    });\n  }\n}\n\n/**\n * Mirror a freshly-updated message list into `values[messagesKey]`.\n *\n * Returns the same `values` reference when the list is already\n * equal-by-content so the caller can keep the existing snapshot\n * identity (and avoid spurious `setSnapshot` notifications).\n */\nfunction syncMessagesIntoValues<StateType extends object>(\n  values: StateType,\n  messagesKey: string,\n  messages: BaseMessage[]\n): StateType {\n  const record = values as Record<string, unknown>;\n  const current = record[messagesKey];\n  if (Array.isArray(current) && messagesEqualList(current, messages)) {\n    return values;\n  }\n  return {\n    ...record,\n    [messagesKey]: messages,\n  } as StateType;\n}\n\n/**\n * True when two `BaseMessage` arrays carry the same per-message\n * content (using {@link messagesEqual}).\n */\nfunction messagesEqualList(\n  previous: readonly BaseMessage[],\n  next: readonly BaseMessage[]\n): boolean {\n  if (previous === next) return true;\n  if (previous.length !== next.length) return false;\n  for (let i = 0; i < previous.length; i += 1) {\n    if (!messagesEqual(previous[i], next[i])) return false;\n  }\n  return true;\n}\n\n/**\n * Shallow-equal for `values` objects, *ignoring* the messages slot.\n *\n * The messages array is compared separately by the caller (via\n * {@link messagesEqualList}) because both arrays contain class\n * instances whose JSON representation is not stable across reads.\n */\nfunction stateValuesShallowEqual(\n  previous: object,\n  next: object,\n  messagesKey: string\n): boolean {\n  if (previous === next) return true;\n  const previousRecord = previous as Record<string, unknown>;\n  const nextRecord = next as Record<string, unknown>;\n  const previousKeys = Object.keys(previousRecord);\n  const nextKeys = Object.keys(nextRecord);\n  if (previousKeys.length !== nextKeys.length) return false;\n  for (const key of previousKeys) {\n    if (!Object.prototype.hasOwnProperty.call(nextRecord, key)) return false;\n    const previousValue = previousRecord[key];\n    const nextValue = nextRecord[key];\n    if (\n      key === messagesKey &&\n      Array.isArray(previousValue) &&\n      Array.isArray(nextValue)\n    ) {\n      continue;\n    }\n    if (!Object.is(previousValue, nextValue)) return false;\n  }\n  return true;\n}\n"],"mappings":"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"}

package/dist/stream/store.cjs

@@ -0,0 +1,32 @@
+//#region src/stream/store.ts
+var StreamStore = class {
+	#snapshot;
+	#listeners = /* @__PURE__ */ new Set();
+	constructor(initial) {
+		this.#snapshot = initial;
+	}
+	subscribe = (listener) => {
+		this.#listeners.add(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	};
+	getSnapshot = () => this.#snapshot;
+	/** Replace the snapshot and notify every listener. */
+	setValue = (next) => {
+		if (Object.is(next, this.#snapshot)) return;
+		this.#snapshot = next;
+		for (const listener of this.#listeners) listener();
+	};
+	/**
+	* Functional update. The `updater` receives the current snapshot and
+	* MUST return a new object. Returning the same reference is a no-op.
+	*/
+	setState = (updater) => {
+		this.setValue(updater(this.#snapshot));
+	};
+};
+//#endregion
+exports.StreamStore = StreamStore;
+
+//# sourceMappingURL=store.cjs.map

package/dist/stream/store.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.cjs","names":["#listeners","#snapshot"],"sources":["../../src/stream/store.ts"],"sourcesContent":["/**\n * Minimal observable store backing every framework binding.\n *\n * The shape is intentionally tiny:\n *\n *  - `subscribe(listener) → unsubscribe` lines up with React's\n *    `useSyncExternalStore`.\n *  - `getSnapshot()` returns a referentially-stable value for\n *    unchanged state so React can bail out of renders.\n *  - Vue/Svelte/Angular bindings wrap `subscribe` + `getSnapshot` in\n *    their own reactivity primitive (`shallowRef` / `writable` /\n *    `signal`) in ~10 lines.\n *\n * Snapshot identity matters: a listener is only useful if\n * `getSnapshot()` returns a *different* reference when state changes.\n * Callers MUST pass a freshly-constructed value to {@link setState};\n * mutating the previous snapshot in place will break React's bail-out\n * and cause infinite re-renders.\n */\n\nexport type StoreListener = () => void;\n\nexport class StreamStore<T> {\n  #snapshot: T;\n  readonly #listeners = new Set<StoreListener>();\n\n  constructor(initial: T) {\n    this.#snapshot = initial;\n  }\n\n  subscribe = (listener: StoreListener): (() => void) => {\n    this.#listeners.add(listener);\n    return () => {\n      this.#listeners.delete(listener);\n    };\n  };\n\n  getSnapshot = (): T => this.#snapshot;\n\n  /** Replace the snapshot and notify every listener. */\n  setValue = (next: T): void => {\n    if (Object.is(next, this.#snapshot)) return;\n    this.#snapshot = next;\n    for (const listener of this.#listeners) listener();\n  };\n\n  /**\n   * Functional update. The `updater` receives the current snapshot and\n   * MUST return a new object. Returning the same reference is a no-op.\n   */\n  setState = (updater: (previous: T) => T): void => {\n    this.setValue(updater(this.#snapshot));\n  };\n}\n"],"mappings":";AAsBA,IAAa,cAAb,MAA4B;CAC1B;CACA,6BAAsB,IAAI,KAAoB;CAE9C,YAAY,SAAY;AACtB,QAAA,WAAiB;;CAGnB,aAAa,aAA0C;AACrD,QAAA,UAAgB,IAAI,SAAS;AAC7B,eAAa;AACX,SAAA,UAAgB,OAAO,SAAS;;;CAIpC,oBAAuB,MAAA;;CAGvB,YAAY,SAAkB;AAC5B,MAAI,OAAO,GAAG,MAAM,MAAA,SAAe,CAAE;AACrC,QAAA,WAAiB;AACjB,OAAK,MAAM,YAAY,MAAA,UAAiB,WAAU;;;;;;CAOpD,YAAY,YAAsC;AAChD,OAAK,SAAS,QAAQ,MAAA,SAAe,CAAC"}