@assistant-ui/core 0.3.13 → 0.3.14

package/dist/runtimes/tool-invocations/ToolInvocationTracker.js

@@ -2,6 +2,7 @@ import { isJSONValueEqual } from "../../utils/json/is-json-equal.js";
 import { ToolResponse, createAssistantStreamController, unstable_toolResultStream } from "assistant-stream";
 import { AssistantMetaTransformStream } from "assistant-stream/utils";
 //#region src/runtimes/tool-invocations/ToolInvocationTracker.ts
+const TOOL_EXECUTION_ID = Symbol.for("assistant-stream.tool-execution-id");
 const isArgsTextComplete = (argsText) => {
 	try {
 		JSON.parse(argsText);
@@ -23,6 +24,7 @@ const isEquivalentCompleteArgsText = (previous, next) => {
 	if (previousValue === void 0 || nextValue === void 0) return false;
 	return isJSONValueEqual(previousValue, nextValue);
 };
+const getToolExecutionId = (value) => value[TOOL_EXECUTION_ID];
 /**
 * Plain-class port of the former `useToolInvocations` React hook. Owns the
 * assistant-stream pipeline that drives client-side `streamCall` / `execute`
@@ -49,19 +51,7 @@ var ToolInvocationTracker = class {
 	_getTools;
 	_callbacks;
 	_entries = /* @__PURE__ */ new Map();
-	/**
-	* Tool call ids whose `execute` should be short-circuited in the wrapper.
-	* Populated when an entry is created with a result already attached
-	* (history reload, mid-run resume, etc.) — `execute` is suppressed so
-	* client-side side effects don't double-run. Membership outlives the
-	* entry: `reset()` deliberately does *not* clear this so post-abort
-	* cancellation `result` chunks for pre-resolved entries can still be
-	* recognized and dropped. Growth is bounded by the number of pre-resolved
-	* tool calls observed in the session.
-	*/
-	_skipExecuteStreamIds = /* @__PURE__ */ new Set();
 	_humanInput = /* @__PURE__ */ new Map();
-	/** In-flight `execute` invocations keyed by tool call id. */
 	_executing = /* @__PURE__ */ new Set();
 	_settledResolvers = [];
 	_statuses = /* @__PURE__ */ new Map();
@@ -94,9 +84,10 @@ var ToolInvocationTracker = class {
 	_initPipeline() {
 		const [stream, controller] = createAssistantStreamController();
 		this._controller = controller;
-		const transform = unstable_toolResultStream(() => this._getWrappedTools(), () => this._ac.signal, (toolCallId, payload) => this._onHumanInput(toolCallId, payload), {
-			onExecutionStart: (id) => this._onExecutionStart(id),
-			onExecutionEnd: (id) => this._onExecutionEnd(id)
+		const human = (toolCallId, payload, executionId) => this._onHumanInput(toolCallId, payload, executionId);
+		const transform = unstable_toolResultStream(() => this._getWrappedTools(), () => this._ac.signal, human, {
+			onExecutionStart: (id, _name, executionId) => this._onExecutionStart(id, executionId),
+			onExecutionEnd: (id, _name, executionId) => this._onExecutionEnd(id, executionId)
 		});
 		stream.pipeThrough(transform).pipeThrough(new AssistantMetaTransformStream()).pipeTo(new WritableStream({ write: (chunk) => {
 			try {
@@ -151,9 +142,11 @@ var ToolInvocationTracker = class {
 			this._pendingRestore = true;
 			this._entries.clear();
 			this._lastSnapshot = null;
-			this.abort().finally(() => {
-				this._executing.clear();
-			});
+			this.abort();
+			if (this._statuses.size > 0) {
+				this._statuses = /* @__PURE__ */ new Map();
+				this._invokeOnStatusesChange();
+			}
 		} catch (err) {
 			console.error("[ToolInvocationTracker] reset failed", err);
 		}
@@ -173,8 +166,12 @@ var ToolInvocationTracker = class {
 			this._ac.abort();
 			this._ac = new AbortController();
 			if (this._executing.size === 0) return Promise.resolve();
+			const executionIds = new Set(this._executing);
 			return new Promise((resolve) => {
-				this._settledResolvers.push(resolve);
+				this._settledResolvers.push({
+					executionIds,
+					resolve
+				});
 			});
 		} catch (err) {
 			console.error("[ToolInvocationTracker] abort failed", err);
@@ -214,23 +211,44 @@ var ToolInvocationTracker = class {
 		if (!tools) return void 0;
 		return Object.fromEntries(Object.entries(tools).map(([name, tool]) => {
 			const execute = tool.execute;
-			if (execute === void 0) return [name, tool];
+			const streamCall = tool.streamCall;
+			if (execute === void 0 && streamCall === void 0) return [name, tool];
 			return [name, {
 				...tool,
-				execute: (...[args, context]) => {
-					if (this._skipExecuteStreamIds.has(context.toolCallId)) return new Promise(() => {});
+				...execute !== void 0 && { execute: (...[args, context]) => {
+					const executionId = getToolExecutionId(context);
+					const entry = this._captureExecution(context.toolCallId, executionId);
+					if (!entry || entry.skipExecute) return new Promise(() => {});
 					return execute(args, context);
-				}
+				} },
+				...streamCall !== void 0 && { streamCall: (...[reader, context]) => {
+					const executionId = getToolExecutionId(context);
+					if (!this._captureExecution(context.toolCallId, executionId)) return;
+					return streamCall(reader, context);
+				} }
 			}];
 		}));
 	}
-	_onHumanInput(toolCallId, payload) {
+	_captureExecution(toolCallId, executionId) {
+		if (executionId === void 0) return void 0;
+		const entry = this._entries.get(toolCallId);
+		if (!entry?.controller) return void 0;
+		if (entry.executionId === void 0) entry.executionId = executionId;
+		return entry.executionId === executionId ? entry : void 0;
+	}
+	_onHumanInput(toolCallId, payload, executionId) {
 		return new Promise((resolve, reject) => {
+			const entry = this._entries.get(toolCallId);
+			if (!entry?.controller || entry.executionId !== executionId) {
+				reject(/* @__PURE__ */ new Error("Tool execution aborted"));
+				return;
+			}
 			const previous = this._humanInput.get(toolCallId);
 			if (previous) try {
 				previous.reject(/* @__PURE__ */ new Error("Human input request was superseded by a new request"));
 			} catch {}
 			this._humanInput.set(toolCallId, {
+				executionId,
 				resolve,
 				reject
 			});
@@ -243,24 +261,36 @@ var ToolInvocationTracker = class {
 			});
 		});
 	}
-	_onExecutionStart(toolCallId) {
-		if (this._skipExecuteStreamIds.has(toolCallId)) return;
-		this._executing.add(toolCallId);
+	_onExecutionStart(toolCallId, executionId) {
+		if (!this._captureExecution(toolCallId, executionId)) return;
+		if (this._entries.get(toolCallId).skipExecute) return;
+		this._executing.add(executionId);
 		this._setStatus(toolCallId, { type: "executing" });
 	}
-	_onExecutionEnd(toolCallId) {
-		if (!this._executing.delete(toolCallId)) return;
-		this._deleteStatus(toolCallId);
-		if (this._executing.size === 0) this._settledResolvers.splice(0).forEach((resolve) => {
+	_onExecutionEnd(toolCallId, executionId) {
+		if (executionId === void 0 || !this._executing.delete(executionId)) return;
+		if (this._entries.get(toolCallId)?.executionId === executionId) this._deleteStatus(toolCallId);
+		const pending = [];
+		this._settledResolvers.forEach(({ executionIds, resolve }) => {
+			if ([...executionIds].some((id) => this._executing.has(id))) {
+				pending.push({
+					executionIds,
+					resolve
+				});
+				return;
+			}
 			try {
 				resolve();
 			} catch {}
 		});
+		this._settledResolvers.length = 0;
+		this._settledResolvers.push(...pending);
 	}
 	_handleResultChunk(chunk) {
 		const toolCallId = chunk.meta.toolCallId;
+		const executionId = getToolExecutionId(chunk);
 		const entry = this._entries.get(toolCallId);
-		if (!entry && this._skipExecuteStreamIds.has(toolCallId)) return;
+		if (!entry || entry.executionId !== executionId) return;
 		if (entry?.hasResult) return;
 		this._invokeOnResult({
 			type: "add-tool-result",
@@ -309,16 +339,15 @@ var ToolInvocationTracker = class {
 		return isArgsTextComplete(argsText);
 	}
 	_startActiveEntry(toolCallId, toolName, skipExecute) {
-		const toolCallController = this._controller.addToolCallPart({
-			toolName,
-			toolCallId
-		});
-		if (skipExecute) this._skipExecuteStreamIds.add(toolCallId);
 		const entry = {
 			toolName,
-			controller: toolCallController,
+			controller: this._controller.addToolCallPart({
+				toolName,
+				toolCallId
+			}),
 			argsText: "",
 			hasResult: false,
+			skipExecute,
 			argsComplete: false
 		};
 		this._entries.set(toolCallId, entry);

package/dist/runtimes/tool-invocations/ToolInvocationTracker.js.map

@@ -1 +1 @@
-{"version":3,"file":"ToolInvocationTracker.js","names":["process","env","NODE_ENV","createAssistantStreamController","ToolCallStreamController","ToolResponse","unstable_toolResultStream","Tool","ToolModelContentPart","AssistantMetaTransformStream","ReadonlyJSONValue","isJSONValueEqual","ThreadMessage","ToolExecutionStatus","type","payload","AddToolResultCommand","toolCallId","toolName","result","isError","artifact","modelContent","ToolCallEntry","argsText","hasResult","controller","argsComplete","isArgsTextComplete","JSON","parse","parseArgsText","undefined","isEquivalentCompleteArgsText","previous","next","previousValue","nextValue","ToolInvocationTracker","_getTools","Record","_callbacks","Callbacks","_entries","Map","_skipExecuteStreamIds","Set","_humanInput","resolve","reject","reason","_executing","_settledResolvers","Array","_statuses","_ac","AbortController","_pendingRestore","_lastSnapshot","Snapshot","_isRunning","_controller","ReturnType","_pipelineDead","_pipelineRestartUsed","constructor","getTools","callbacks","_initPipeline","stream","transform","_getWrappedTools","signal","_onHumanInput","onExecutionStart","id","_onExecutionStart","onExecutionEnd","_onExecutionEnd","pipeThrough","pipeTo","WritableStream","write","chunk","_handleResultChunk","err","console","error","catch","setState","snapshot","_demoteEntriesToRestored","clear","messages","isRunning","isLoading","restoreFromLoading","previousIsRunning","_processMessages","reset","abort","finally","Promise","forEach","Error","size","push","resume","handlers","get","delete","_setStatus","getStatuses","ReadonlyMap","tools","Object","fromEntries","entries","map","name","tool","execute","wrappedTool","args","context","Parameters","NonNullable","has","set","add","_deleteStatus","resolvers","splice","meta","entry","_invokeOnResult","command","onResult","_invokeOnStatusesChange","onStatusesChange","status","_hasExecutableTool","streamCall","_shouldCloseArgsStream","_startActiveEntry","skipExecute","toolCallController","addToolCallPart","_processArgsText","content","shouldWriteArgsText","warn","startsWith","shouldClose","close","delta","slice","length","append","isRestore","message","isArray","existing","signatureChanged","activeController","setResponse","ExecutionStatus","statuses"],"sources":["../../../src/runtimes/tool-invocations/ToolInvocationTracker.ts"],"sourcesContent":["declare const process: { env: { NODE_ENV?: string } };\n\nimport {\n  createAssistantStreamController,\n  type ToolCallStreamController,\n  ToolResponse,\n  unstable_toolResultStream,\n  type Tool,\n  type ToolModelContentPart,\n} from \"assistant-stream\";\nimport {\n  AssistantMetaTransformStream,\n  type ReadonlyJSONValue,\n} from \"assistant-stream/utils\";\nimport { isJSONValueEqual } from \"../../utils/json/is-json-equal\";\nimport type { ThreadMessage } from \"../../types/message\";\n\n/**\n * Streaming execution state for a frontend tool.\n */\nexport type ToolExecutionStatus =\n  | { type: \"executing\" }\n  | {\n      type: \"interrupt\";\n      payload: { type: \"human\"; payload: unknown };\n    };\n\nexport type AddToolResultCommand = {\n  readonly type: \"add-tool-result\";\n  readonly toolCallId: string;\n  readonly toolName: string;\n  readonly result: ReadonlyJSONValue;\n  readonly isError: boolean;\n  readonly artifact?: ReadonlyJSONValue;\n  readonly modelContent?: readonly ToolModelContentPart[];\n};\n\ntype ToolCallEntry = {\n  toolName: string;\n  argsText: string;\n  hasResult: boolean;\n} & (\n  | {\n      /** Restored phase — observed during a history-load snapshot. */\n      controller?: undefined;\n      argsComplete?: undefined;\n    }\n  | {\n      /** Active phase — chunks are flowing through `controller`. */\n      controller: ToolCallStreamController;\n      argsComplete: boolean;\n    }\n);\n\nconst isArgsTextComplete = (argsText: string) => {\n  try {\n    JSON.parse(argsText);\n    return true;\n  } catch {\n    return false;\n  }\n};\n\nconst parseArgsText = (argsText: string) => {\n  try {\n    return JSON.parse(argsText);\n  } catch {\n    return undefined;\n  }\n};\n\nconst isEquivalentCompleteArgsText = (previous: string, next: string) => {\n  const previousValue = parseArgsText(previous);\n  const nextValue = parseArgsText(next);\n  if (previousValue === undefined || nextValue === undefined) return false;\n  return isJSONValueEqual(previousValue, nextValue);\n};\n\n/**\n * Plain-class port of the former `useToolInvocations` React hook. Owns the\n * assistant-stream pipeline that drives client-side `streamCall` / `execute`\n * for tool-call parts surfaced by a thread runtime, plus the per-tool-call\n * status map that consumers render against.\n *\n * **Contract**: `streamCall` (and `execute`) fires exactly once per logical\n * `toolCallId`. Args mutations after first completion, result replacement,\n * and result clearing are *not* surfaced through additional `streamCall`\n * invocations — by design — so hosts cannot observe spurious re-fires of\n * side effects. The follow-up `reader.events()` API will expose those\n * post-completion transitions to consumers that opt in.\n *\n * State-transition safety: every public method that observes runtime state\n * (`setState`, `reset`, `abort`, `resume`) wraps its work in try/catch and\n * logs to `console.error` rather than throwing. The tracker is built into\n * the hot message-processing path, so a malformed snapshot must never crash\n * the host runtime. See ./EDGE_CASES.md for the known non-trivial state\n * transitions and what each does today.\n *\n * @deprecated Internal — for framework bindings; not a public API. May change without notice.\n */\nexport class ToolInvocationTracker {\n  private readonly _getTools: () => Record<string, Tool> | undefined;\n  private readonly _callbacks: ToolInvocationTracker.Callbacks;\n\n  private readonly _entries = new Map<string, ToolCallEntry>();\n  /**\n   * Tool call ids whose `execute` should be short-circuited in the wrapper.\n   * Populated when an entry is created with a result already attached\n   * (history reload, mid-run resume, etc.) — `execute` is suppressed so\n   * client-side side effects don't double-run. Membership outlives the\n   * entry: `reset()` deliberately does *not* clear this so post-abort\n   * cancellation `result` chunks for pre-resolved entries can still be\n   * recognized and dropped. Growth is bounded by the number of pre-resolved\n   * tool calls observed in the session.\n   */\n  private readonly _skipExecuteStreamIds = new Set<string>();\n  private readonly _humanInput = new Map<\n    string,\n    {\n      resolve: (payload: unknown) => void;\n      reject: (reason: unknown) => void;\n    }\n  >();\n  /** In-flight `execute` invocations keyed by tool call id. */\n  private readonly _executing = new Set<string>();\n  private readonly _settledResolvers: Array<() => void> = [];\n\n  private _statuses = new Map<string, ToolExecutionStatus>();\n\n  private _ac: AbortController = new AbortController();\n  private _pendingRestore = true;\n\n  /** Cached last snapshot, used to skip processing on identical re-renders. */\n  private _lastSnapshot: ToolInvocationTracker.Snapshot | null = null;\n  private _isRunning = false;\n\n  private _controller!: ReturnType<typeof createAssistantStreamController>[1];\n\n  /**\n   * Set when the assistant-stream pipeline has died (errored out via\n   * `.pipeTo(...).catch(...)`). The next `setState` re-initializes the\n   * pipeline and demotes all active entries to restored so they survive\n   * across the restart without re-firing `streamCall` (preserves the\n   * \"exactly once\" contract). Capped at a single auto-restart per session\n   * — repeated failures keep the tracker dead with a more visible error.\n   */\n  private _pipelineDead = false;\n  private _pipelineRestartUsed = false;\n\n  constructor(\n    getTools: () => Record<string, Tool> | undefined,\n    callbacks: ToolInvocationTracker.Callbacks,\n  ) {\n    this._getTools = getTools;\n    this._callbacks = callbacks;\n\n    this._initPipeline();\n  }\n\n  /**\n   * Build the assistant-stream pipeline. Called once from the constructor\n   * and at most once again if `_pipelineDead` is set (see F.4 in\n   * EDGE_CASES.md).\n   */\n  private _initPipeline(): void {\n    const [stream, controller] = createAssistantStreamController();\n    this._controller = controller;\n\n    const transform = unstable_toolResultStream(\n      () => this._getWrappedTools(),\n      () => this._ac.signal,\n      (toolCallId, payload) => this._onHumanInput(toolCallId, payload),\n      {\n        onExecutionStart: (id) => this._onExecutionStart(id),\n        onExecutionEnd: (id) => this._onExecutionEnd(id),\n      },\n    );\n\n    stream\n      .pipeThrough(transform)\n      .pipeThrough(new AssistantMetaTransformStream())\n      .pipeTo(\n        new WritableStream({\n          write: (chunk) => {\n            try {\n              if (chunk.type !== \"result\") return;\n              this._handleResultChunk(chunk);\n            } catch (err) {\n              console.error(\n                \"[ToolInvocationTracker] result chunk handling failed\",\n                err,\n              );\n            }\n          },\n        }),\n      )\n      .catch((err) => {\n        console.error(\n          \"[ToolInvocationTracker] stream pipeline failed; will attempt single restart on next setState\",\n          err,\n        );\n        this._pipelineDead = true;\n      });\n  }\n\n  // ───────────────────────── public API ─────────────────────────\n\n  /**\n   * Feed the next observed snapshot into the tracker. Called from the host\n   * runtime whenever its message list / running state changes.\n   */\n  public setState(snapshot: ToolInvocationTracker.Snapshot): void {\n    try {\n      // Recover from a dead pipeline before processing anything. We demote\n      // all active entries to \"restored\" so the rebuilt pipeline does not\n      // re-fire `streamCall` for tool calls that already fired pre-death;\n      // preserves the \"exactly once per toolCallId\" contract.\n      if (this._pipelineDead) {\n        if (this._pipelineRestartUsed) {\n          // Already retried once and failed again. Stay dead.\n          return;\n        }\n        this._pipelineRestartUsed = true;\n        this._pipelineDead = false;\n        this._demoteEntriesToRestored();\n        this._executing.clear();\n        this._ac = new AbortController();\n        this._initPipeline();\n        // Fall through and process the snapshot against the fresh pipeline.\n      }\n\n      // Identical snapshot — skip processing entirely. Note: external-store\n      // runtimes rebuild the messages array on every adapter update, so this\n      // fast-path rarely triggers there; it's primarily for the React-hook\n      // shim where state references are stable.\n      if (\n        this._lastSnapshot &&\n        this._lastSnapshot.messages === snapshot.messages &&\n        this._lastSnapshot.isRunning === snapshot.isRunning &&\n        this._lastSnapshot.isLoading === snapshot.isLoading\n      ) {\n        return;\n      }\n\n      // While the host is still loading initial state, treat every snapshot\n      // as historical: tool calls are recorded so the next live snapshot can\n      // diff against them, but `streamCall` / `execute` do not fire.\n      const restoreFromLoading = snapshot.isLoading === true;\n      if (restoreFromLoading) {\n        this._pendingRestore = true;\n      }\n\n      // E.4 / AF3 — only mark `_lastSnapshot`/`_isRunning` as observed after\n      // processing succeeds. If `_processMessages` throws, the next snapshot\n      // (even if identical) gets re-processed against the recovered state.\n      const previousIsRunning = this._isRunning;\n      this._isRunning = snapshot.isRunning;\n      try {\n        this._processMessages(snapshot.messages);\n      } catch (err) {\n        this._isRunning = previousIsRunning;\n        throw err;\n      }\n      this._lastSnapshot = snapshot;\n      this._pendingRestore = false;\n    } catch (err) {\n      console.error(\n        \"[ToolInvocationTracker] setState failed; snapshot dropped\",\n        err,\n      );\n    }\n  }\n\n  /**\n   * Reset the tracker so the next observed snapshot is treated as historical.\n   * Clears entries and aborts any in-flight executions. Used by callers like\n   * `importExternalState` to mark a freshly loaded state as restored.\n   */\n  public reset(): void {\n    try {\n      this._pendingRestore = true;\n      this._entries.clear();\n      this._lastSnapshot = null;\n      // `_skipExecuteStreamIds` is intentionally not cleared — see field doc.\n      void this.abort().finally(() => {\n        this._executing.clear();\n      });\n    } catch (err) {\n      console.error(\"[ToolInvocationTracker] reset failed\", err);\n    }\n  }\n\n  /**\n   * Abort any in-flight `execute()` invocations. Resolves once all of them\n   * have settled (or immediately if none are running).\n   */\n  public abort(): Promise<void> {\n    try {\n      this._humanInput.forEach(({ reject }) => {\n        try {\n          reject(new Error(\"Tool execution aborted\"));\n        } catch {\n          // host rejection handler threw — already in the abort path,\n          // swallow so we continue cleaning up.\n        }\n      });\n      this._humanInput.clear();\n\n      this._ac.abort();\n      this._ac = new AbortController();\n\n      if (this._executing.size === 0) {\n        return Promise.resolve();\n      }\n      return new Promise<void>((resolve) => {\n        this._settledResolvers.push(resolve);\n      });\n    } catch (err) {\n      console.error(\"[ToolInvocationTracker] abort failed\", err);\n      return Promise.resolve();\n    }\n  }\n\n  /**\n   * Resolve a pending human-input request for the given tool call. Returns\n   * `true` if a pending request was resumed, `false` if the tracker has no\n   * outstanding request for that id (the caller should fall back to its own\n   * dispatch path).\n   */\n  public resume(toolCallId: string, payload: unknown): boolean {\n    try {\n      const handlers = this._humanInput.get(toolCallId);\n      if (!handlers) return false;\n      this._humanInput.delete(toolCallId);\n      this._setStatus(toolCallId, { type: \"executing\" });\n      handlers.resolve(payload);\n      return true;\n    } catch (err) {\n      console.error(\"[ToolInvocationTracker] resume failed\", err);\n      return false;\n    }\n  }\n\n  /**\n   * Returns the current tool execution status map. The returned `Map` is\n   * the tracker's internal store — do not mutate it. Treat the reference\n   * as a snapshot that may be replaced wholesale on the next status\n   * transition.\n   */\n  public getStatuses(): ReadonlyMap<string, ToolExecutionStatus> {\n    return this._statuses;\n  }\n\n  // ───────────────────── internal: tool wrapping ─────────────────────\n\n  private _getWrappedTools(): Record<string, Tool> | undefined {\n    const tools = this._getTools();\n    if (!tools) return undefined;\n\n    return Object.fromEntries(\n      Object.entries(tools).map(([name, tool]) => {\n        const execute = tool.execute;\n        if (execute === undefined) return [name, tool];\n\n        const wrappedTool = {\n          ...tool,\n          execute: (\n            ...[args, context]: Parameters<NonNullable<typeof execute>>\n          ) => {\n            if (this._skipExecuteStreamIds.has(context.toolCallId)) {\n              // Pre-resolved tool call: never invoke the host's execute.\n              // Returning a never-settling Promise keeps the executor's\n              // pending entry alive but enqueues nothing.\n              return new Promise(() => {}) as never;\n            }\n            return execute(args, context);\n          },\n        } as Tool;\n        return [name, wrappedTool];\n      }),\n    ) as Record<string, Tool>;\n  }\n\n  // ──────────────── internal: execution lifecycle callbacks ────────────────\n\n  private _onHumanInput(\n    toolCallId: string,\n    payload: unknown,\n  ): Promise<unknown> {\n    return new Promise<unknown>((resolve, reject) => {\n      const previous = this._humanInput.get(toolCallId);\n      if (previous) {\n        try {\n          previous.reject(\n            new Error(\"Human input request was superseded by a new request\"),\n          );\n        } catch {\n          // host rejection handler threw; ignore and proceed\n        }\n      }\n      this._humanInput.set(toolCallId, { resolve, reject });\n      this._setStatus(toolCallId, {\n        type: \"interrupt\",\n        payload: { type: \"human\", payload },\n      });\n    });\n  }\n\n  private _onExecutionStart(toolCallId: string): void {\n    if (this._skipExecuteStreamIds.has(toolCallId)) return;\n\n    this._executing.add(toolCallId);\n    this._setStatus(toolCallId, { type: \"executing\" });\n  }\n\n  private _onExecutionEnd(toolCallId: string): void {\n    if (!this._executing.delete(toolCallId)) return;\n\n    this._deleteStatus(toolCallId);\n\n    if (this._executing.size === 0) {\n      const resolvers = this._settledResolvers.splice(0);\n      resolvers.forEach((resolve) => {\n        try {\n          resolve();\n        } catch {\n          // ignore — settled-resolver consumer threw\n        }\n      });\n    }\n  }\n\n  private _handleResultChunk(chunk: {\n    type: \"result\";\n    result: ReadonlyJSONValue;\n    isError: boolean;\n    artifact?: ReadonlyJSONValue;\n    modelContent?: readonly ToolModelContentPart[];\n    meta: { toolCallId: string; toolName: string };\n  }): void {\n    const toolCallId = chunk.meta.toolCallId;\n    const entry = this._entries.get(toolCallId);\n\n    // Pre-resolved tool call whose entry has been cleared by `reset()`.\n    // The post-abort cancellation chunk lands here after the entry is\n    // gone; suppress via the long-lived skip-execute marker.\n    if (!entry && this._skipExecuteStreamIds.has(toolCallId)) {\n      return;\n    }\n\n    // The host already set the result (via the live snapshot's\n    // `setResponse` path). Suppress the executor's redundant emit.\n    if (entry?.hasResult) return;\n\n    this._invokeOnResult({\n      type: \"add-tool-result\",\n      toolCallId,\n      toolName: chunk.meta.toolName,\n      result: chunk.result,\n      isError: chunk.isError,\n      ...(chunk.artifact !== undefined && { artifact: chunk.artifact }),\n      ...(chunk.modelContent !== undefined && {\n        modelContent: chunk.modelContent,\n      }),\n    });\n  }\n\n  // ──────────────── internal: callback invocation (AF1/AF2) ────────────────\n\n  private _invokeOnResult(command: AddToolResultCommand): void {\n    try {\n      this._callbacks.onResult(command);\n    } catch (err) {\n      console.error(\n        \"[ToolInvocationTracker] onResult callback threw; result dropped\",\n        err,\n      );\n    }\n  }\n\n  private _invokeOnStatusesChange(): void {\n    try {\n      this._callbacks.onStatusesChange(this._statuses);\n    } catch (err) {\n      console.error(\n        \"[ToolInvocationTracker] onStatusesChange callback threw; status change not propagated\",\n        err,\n      );\n    }\n  }\n\n  // ──────────────── internal: status map mutations ────────────────\n\n  private _setStatus(toolCallId: string, status: ToolExecutionStatus): void {\n    const next = new Map(this._statuses);\n    next.set(toolCallId, status);\n    this._statuses = next;\n    this._invokeOnStatusesChange();\n  }\n\n  private _deleteStatus(toolCallId: string): void {\n    if (!this._statuses.has(toolCallId)) return;\n    const next = new Map(this._statuses);\n    next.delete(toolCallId);\n    this._statuses = next;\n    this._invokeOnStatusesChange();\n  }\n\n  // ──────────────── internal: snapshot processing ────────────────\n\n  private _hasExecutableTool(toolName: string): boolean {\n    const tool = this._getTools()?.[toolName];\n    return tool?.execute !== undefined || tool?.streamCall !== undefined;\n  }\n\n  private _shouldCloseArgsStream({\n    toolName,\n    argsText,\n    hasResult,\n  }: {\n    toolName: string;\n    argsText: string;\n    hasResult: boolean;\n  }): boolean {\n    if (hasResult) return true;\n    if (!this._hasExecutableTool(toolName)) {\n      return !this._isRunning && isArgsTextComplete(argsText);\n    }\n    return isArgsTextComplete(argsText);\n  }\n\n  private _startActiveEntry(\n    toolCallId: string,\n    toolName: string,\n    skipExecute: boolean,\n  ): ToolCallEntry {\n    const toolCallController = this._controller.addToolCallPart({\n      toolName,\n      toolCallId,\n    });\n    if (skipExecute) {\n      this._skipExecuteStreamIds.add(toolCallId);\n    }\n    const entry: ToolCallEntry = {\n      toolName,\n      controller: toolCallController,\n      argsText: \"\",\n      hasResult: false,\n      argsComplete: false,\n    };\n    this._entries.set(toolCallId, entry);\n    return entry;\n  }\n\n  /**\n   * Demote every active entry back to the restored phase. Used by the\n   * pipeline-restart path so that, after a fresh pipeline is built, the\n   * next observed snapshot does not re-fire `streamCall` for tool calls\n   * that already fired pre-death. Args / hasResult tracking is preserved\n   * so signature comparisons still work.\n   */\n  private _demoteEntriesToRestored(): void {\n    for (const [toolCallId, entry] of this._entries) {\n      if (!entry.controller) continue;\n      this._entries.set(toolCallId, {\n        toolName: entry.toolName,\n        argsText: entry.argsText,\n        hasResult: entry.hasResult,\n      });\n    }\n  }\n\n  private _processArgsText(\n    entry: ToolCallEntry,\n    content: {\n      toolCallId: string;\n      toolName: string;\n      argsText: string;\n      result?: unknown;\n    },\n  ): void {\n    if (!entry.controller) return;\n    const hasResult = content.result !== undefined;\n\n    if (content.argsText !== entry.argsText) {\n      let shouldWriteArgsText = true;\n\n      if (entry.argsComplete) {\n        if (isEquivalentCompleteArgsText(entry.argsText, content.argsText)) {\n          // A.3 — key reorder. Track new text, no re-fire needed.\n          entry.argsText = content.argsText;\n          shouldWriteArgsText = false;\n        } else {\n          // A.4 — args changed after first completion. Under the\n          // \"exactly once per toolCallId\" contract we do not restart the\n          // stream. The host's existing `streamCall` keeps its original\n          // args view; the snapshot's new text is recorded for diffing\n          // but not surfaced. Events API in a follow-up will expose this\n          // to consumers that opt in.\n          if (process.env.NODE_ENV !== \"production\") {\n            console.warn(\n              \"[ToolInvocationTracker] argsText changed after first completion; not re-firing streamCall (see EDGE_CASES.md A.4)\",\n              {\n                previous: entry.argsText,\n                next: content.argsText,\n                toolCallId: content.toolCallId,\n              },\n            );\n          }\n          shouldWriteArgsText = false;\n        }\n      } else if (!content.argsText.startsWith(entry.argsText)) {\n        if (\n          isArgsTextComplete(entry.argsText) &&\n          isArgsTextComplete(content.argsText) &&\n          isEquivalentCompleteArgsText(entry.argsText, content.argsText)\n        ) {\n          const shouldClose = this._shouldCloseArgsStream({\n            toolName: content.toolName,\n            argsText: content.argsText,\n            hasResult,\n          });\n          if (shouldClose) entry.controller.argsText.close();\n          entry.argsText = content.argsText;\n          entry.argsComplete = shouldClose;\n          shouldWriteArgsText = false;\n        } else {\n          // A.2 — args regressed mid-stream. Under the \"exactly once\"\n          // contract we do not restart. The controller keeps whatever\n          // prefix we already streamed; subsequent prefix-respecting\n          // updates can still flow against it. Snapshots that never\n          // re-converge to a prefix will leave the controller's args\n          // view stale relative to the snapshot. Events API in a\n          // follow-up will expose this to consumers that opt in.\n          if (process.env.NODE_ENV !== \"production\") {\n            console.warn(\n              \"[ToolInvocationTracker] argsText regressed mid-stream; not restarting (see EDGE_CASES.md A.2)\",\n              {\n                previous: entry.argsText,\n                next: content.argsText,\n                toolCallId: content.toolCallId,\n              },\n            );\n          }\n          shouldWriteArgsText = false;\n        }\n      }\n\n      if (shouldWriteArgsText && entry.controller) {\n        const delta = content.argsText.slice(entry.argsText.length);\n        entry.controller.argsText.append(delta);\n        const shouldClose = this._shouldCloseArgsStream({\n          toolName: content.toolName,\n          argsText: content.argsText,\n          hasResult,\n        });\n        if (shouldClose) entry.controller.argsText.close();\n        entry.argsText = content.argsText;\n        entry.argsComplete = shouldClose;\n      }\n    }\n\n    if (!entry.argsComplete && entry.controller) {\n      // ToolExecutionStream parses the streamed prefix on close, so the close\n      // gates on the streamed content; a divergent snapshot (A.2) can be\n      // complete while the controller still holds an incomplete stale prefix.\n      const shouldClose = this._shouldCloseArgsStream({\n        toolName: content.toolName,\n        argsText: entry.argsText,\n        hasResult,\n      });\n      if (shouldClose) {\n        entry.controller.argsText.close();\n        entry.argsComplete = true;\n      }\n    }\n  }\n\n  private _processMessages(messages: readonly ThreadMessage[]): void {\n    const isRestore = this._pendingRestore;\n\n    for (const message of messages) {\n      if (!message || !Array.isArray((message as ThreadMessage).content)) {\n        continue;\n      }\n      for (const content of message.content as readonly ThreadMessage[\"content\"][number][]) {\n        if (!content || content.type !== \"tool-call\") continue;\n\n        const existing = this._entries.get(content.toolCallId);\n\n        if (isRestore) {\n          // Don't overwrite an already-active entry (e.g. live tool-call\n          // observed before this restore snapshot landed). Restore can\n          // only seed entries the runtime has never seen.\n          if (!existing?.controller) {\n            this._entries.set(content.toolCallId, {\n              toolName: content.toolName,\n              argsText: content.argsText,\n              hasResult: content.result !== undefined,\n            });\n          }\n          if (content.messages) this._processMessages(content.messages);\n          continue;\n        }\n\n        // Live snapshot.\n        let entry = existing;\n\n        if (entry && !entry.controller) {\n          // Restored entry observed in a live snapshot. Promote if its\n          // signature has changed; otherwise treat as still-historical.\n          const signatureChanged =\n            content.argsText !== entry.argsText ||\n            (content.result !== undefined) !== entry.hasResult;\n          if (!signatureChanged) {\n            if (content.messages) this._processMessages(content.messages);\n            continue;\n          }\n          this._entries.delete(content.toolCallId);\n          entry = undefined;\n        }\n\n        if (!entry) {\n          entry = this._startActiveEntry(\n            content.toolCallId,\n            content.toolName,\n            content.result !== undefined,\n          );\n        }\n\n        this._processArgsText(entry, content);\n\n        if (content.result !== undefined && !entry.hasResult) {\n          // `entry` is in active phase from this point — either just\n          // created by `_startActiveEntry`, or pre-existing with a live\n          // controller. Narrow once instead of asserting at every use.\n          const { controller: activeController } = entry;\n          if (!activeController) continue;\n          entry.hasResult = true;\n          entry.argsComplete = true;\n          activeController.setResponse(\n            new ToolResponse({\n              result: content.result as ReadonlyJSONValue,\n              artifact: content.artifact as ReadonlyJSONValue | undefined,\n              isError: content.isError,\n              ...(content.modelContent !== undefined\n                ? { modelContent: content.modelContent }\n                : {}),\n            }),\n          );\n          activeController.close();\n        }\n\n        if (content.messages) this._processMessages(content.messages);\n      }\n    }\n  }\n}\n\nexport namespace ToolInvocationTracker {\n  export type ExecutionStatus = ToolExecutionStatus;\n\n  export type Snapshot = {\n    readonly messages: readonly ThreadMessage[];\n    /** Whether the producing runtime is currently streaming new output. */\n    readonly isRunning: boolean;\n    /**\n     * Whether the producing runtime is still loading historical state.\n     * When `true`, every snapshot is treated as historical (no `streamCall` /\n     * `execute` fires). When `false`, processing resumes as live.\n     */\n    readonly isLoading?: boolean;\n  };\n\n  export type Callbacks = {\n    /**\n     * Invoked when a client-side `execute()` returns a result and the runtime\n     * needs to feed it back into the conversation.\n     */\n    onResult: (command: AddToolResultCommand) => void;\n    /**\n     * Invoked whenever the per-tool-call status map changes (executing /\n     * interrupt / cleared). The callback receives a fresh map; mutating the\n     * argument is not supported.\n     */\n    onStatusesChange: (\n      statuses: ReadonlyMap<string, ToolExecutionStatus>,\n    ) => void;\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"ToolInvocationTracker.js","names":["process","env","NODE_ENV","createAssistantStreamController","ToolCallStreamController","ToolResponse","unstable_toolResultStream","Tool","ToolModelContentPart","ToolResultStreamOptions","AssistantMetaTransformStream","ReadonlyJSONValue","isJSONValueEqual","ThreadMessage","TOOL_EXECUTION_ID","Symbol","for","ToolExecutionStatus","type","payload","AddToolResultCommand","toolCallId","toolName","result","isError","artifact","modelContent","ToolCallEntry","argsText","hasResult","executionId","skipExecute","controller","argsComplete","SettledResolver","executionIds","ReadonlySet","resolve","isArgsTextComplete","JSON","parse","parseArgsText","undefined","isEquivalentCompleteArgsText","previous","next","previousValue","nextValue","getToolExecutionId","value","Record","PropertyKey","ToolInvocationTracker","_getTools","_callbacks","Callbacks","_entries","Map","_humanInput","reject","reason","_executing","Set","_settledResolvers","_statuses","_ac","AbortController","_pendingRestore","_lastSnapshot","Snapshot","_isRunning","_controller","ReturnType","_pipelineDead","_pipelineRestartUsed","constructor","getTools","callbacks","_initPipeline","stream","human","_onHumanInput","transform","_getWrappedTools","signal","onExecutionStart","id","_name","_onExecutionStart","onExecutionEnd","_onExecutionEnd","pipeThrough","pipeTo","WritableStream","write","chunk","_handleResultChunk","err","console","error","catch","setState","snapshot","_demoteEntriesToRestored","clear","messages","isRunning","isLoading","restoreFromLoading","previousIsRunning","_processMessages","reset","abort","size","_invokeOnStatusesChange","Promise","forEach","Error","push","resume","handlers","get","delete","_setStatus","getStatuses","ReadonlyMap","tools","Object","fromEntries","entries","map","name","tool","execute","streamCall","wrappedTool","args","context","Parameters","entry","_captureExecution","reader","set","add","_deleteStatus","pending","some","has","length","meta","_invokeOnResult","command","onResult","onStatusesChange","status","_hasExecutableTool","_shouldCloseArgsStream","_startActiveEntry","toolCallController","addToolCallPart","_processArgsText","content","shouldWriteArgsText","warn","startsWith","shouldClose","close","delta","slice","append","isRestore","message","Array","isArray","existing","signatureChanged","activeController","setResponse","ExecutionStatus","statuses"],"sources":["../../../src/runtimes/tool-invocations/ToolInvocationTracker.ts"],"sourcesContent":["declare const process: { env: { NODE_ENV?: string } };\n\nimport {\n  createAssistantStreamController,\n  type ToolCallStreamController,\n  ToolResponse,\n  unstable_toolResultStream,\n  type Tool,\n  type ToolModelContentPart,\n  type ToolResultStreamOptions,\n} from \"assistant-stream\";\nimport {\n  AssistantMetaTransformStream,\n  type ReadonlyJSONValue,\n} from \"assistant-stream/utils\";\nimport { isJSONValueEqual } from \"../../utils/json/is-json-equal\";\nimport type { ThreadMessage } from \"../../types/message\";\n\nconst TOOL_EXECUTION_ID = Symbol.for(\"assistant-stream.tool-execution-id\");\n\n/**\n * Streaming execution state for a frontend tool.\n */\nexport type ToolExecutionStatus =\n  | { type: \"executing\" }\n  | {\n      type: \"interrupt\";\n      payload: { type: \"human\"; payload: unknown };\n    };\n\nexport type AddToolResultCommand = {\n  readonly type: \"add-tool-result\";\n  readonly toolCallId: string;\n  readonly toolName: string;\n  readonly result: ReadonlyJSONValue;\n  readonly isError: boolean;\n  readonly artifact?: ReadonlyJSONValue;\n  readonly modelContent?: readonly ToolModelContentPart[];\n};\n\ntype ToolCallEntry = {\n  toolName: string;\n  argsText: string;\n  hasResult: boolean;\n  executionId?: symbol;\n  skipExecute?: boolean;\n} & (\n  | {\n      /** Restored phase — observed during a history-load snapshot. */\n      controller?: undefined;\n      argsComplete?: undefined;\n    }\n  | {\n      /** Active phase — chunks are flowing through `controller`. */\n      controller: ToolCallStreamController;\n      argsComplete: boolean;\n    }\n);\n\ntype SettledResolver = {\n  executionIds: ReadonlySet<symbol>;\n  resolve: () => void;\n};\n\nconst isArgsTextComplete = (argsText: string) => {\n  try {\n    JSON.parse(argsText);\n    return true;\n  } catch {\n    return false;\n  }\n};\n\nconst parseArgsText = (argsText: string) => {\n  try {\n    return JSON.parse(argsText);\n  } catch {\n    return undefined;\n  }\n};\n\nconst isEquivalentCompleteArgsText = (previous: string, next: string) => {\n  const previousValue = parseArgsText(previous);\n  const nextValue = parseArgsText(next);\n  if (previousValue === undefined || nextValue === undefined) return false;\n  return isJSONValueEqual(previousValue, nextValue);\n};\n\nconst getToolExecutionId = (value: object): symbol | undefined =>\n  (value as Record<PropertyKey, unknown>)[TOOL_EXECUTION_ID] as\n    | symbol\n    | undefined;\n\n/**\n * Plain-class port of the former `useToolInvocations` React hook. Owns the\n * assistant-stream pipeline that drives client-side `streamCall` / `execute`\n * for tool-call parts surfaced by a thread runtime, plus the per-tool-call\n * status map that consumers render against.\n *\n * **Contract**: `streamCall` (and `execute`) fires exactly once per logical\n * `toolCallId`. Args mutations after first completion, result replacement,\n * and result clearing are *not* surfaced through additional `streamCall`\n * invocations — by design — so hosts cannot observe spurious re-fires of\n * side effects. The follow-up `reader.events()` API will expose those\n * post-completion transitions to consumers that opt in.\n *\n * State-transition safety: every public method that observes runtime state\n * (`setState`, `reset`, `abort`, `resume`) wraps its work in try/catch and\n * logs to `console.error` rather than throwing. The tracker is built into\n * the hot message-processing path, so a malformed snapshot must never crash\n * the host runtime. See ./EDGE_CASES.md for the known non-trivial state\n * transitions and what each does today.\n *\n * @deprecated Internal — for framework bindings; not a public API. May change without notice.\n */\nexport class ToolInvocationTracker {\n  private readonly _getTools: () => Record<string, Tool> | undefined;\n  private readonly _callbacks: ToolInvocationTracker.Callbacks;\n\n  private readonly _entries = new Map<string, ToolCallEntry>();\n  private readonly _humanInput = new Map<\n    string,\n    {\n      executionId: symbol;\n      resolve: (payload: unknown) => void;\n      reject: (reason: unknown) => void;\n    }\n  >();\n  private readonly _executing = new Set<symbol>();\n  private readonly _settledResolvers: SettledResolver[] = [];\n\n  private _statuses = new Map<string, ToolExecutionStatus>();\n\n  private _ac: AbortController = new AbortController();\n  private _pendingRestore = true;\n\n  /** Cached last snapshot, used to skip processing on identical re-renders. */\n  private _lastSnapshot: ToolInvocationTracker.Snapshot | null = null;\n  private _isRunning = false;\n\n  private _controller!: ReturnType<typeof createAssistantStreamController>[1];\n\n  /**\n   * Set when the assistant-stream pipeline has died (errored out via\n   * `.pipeTo(...).catch(...)`). The next `setState` re-initializes the\n   * pipeline and demotes all active entries to restored so they survive\n   * across the restart without re-firing `streamCall` (preserves the\n   * \"exactly once\" contract). Capped at a single auto-restart per session\n   * — repeated failures keep the tracker dead with a more visible error.\n   */\n  private _pipelineDead = false;\n  private _pipelineRestartUsed = false;\n\n  constructor(\n    getTools: () => Record<string, Tool> | undefined,\n    callbacks: ToolInvocationTracker.Callbacks,\n  ) {\n    this._getTools = getTools;\n    this._callbacks = callbacks;\n\n    this._initPipeline();\n  }\n\n  /**\n   * Build the assistant-stream pipeline. Called once from the constructor\n   * and at most once again if `_pipelineDead` is set (see F.4 in\n   * EDGE_CASES.md).\n   */\n  private _initPipeline(): void {\n    const [stream, controller] = createAssistantStreamController();\n    this._controller = controller;\n\n    const human = (\n      toolCallId: string,\n      payload: unknown,\n      executionId?: symbol,\n    ) => this._onHumanInput(toolCallId, payload, executionId);\n    const transform = unstable_toolResultStream(\n      () => this._getWrappedTools(),\n      () => this._ac.signal,\n      human,\n      {\n        onExecutionStart: (id: string, _name: string, executionId?: symbol) =>\n          this._onExecutionStart(id, executionId),\n        onExecutionEnd: (id: string, _name: string, executionId?: symbol) =>\n          this._onExecutionEnd(id, executionId),\n      } as ToolResultStreamOptions,\n    );\n\n    stream\n      .pipeThrough(transform)\n      .pipeThrough(new AssistantMetaTransformStream())\n      .pipeTo(\n        new WritableStream({\n          write: (chunk) => {\n            try {\n              if (chunk.type !== \"result\") return;\n              this._handleResultChunk(chunk);\n            } catch (err) {\n              console.error(\n                \"[ToolInvocationTracker] result chunk handling failed\",\n                err,\n              );\n            }\n          },\n        }),\n      )\n      .catch((err) => {\n        console.error(\n          \"[ToolInvocationTracker] stream pipeline failed; will attempt single restart on next setState\",\n          err,\n        );\n        this._pipelineDead = true;\n      });\n  }\n\n  // ───────────────────────── public API ─────────────────────────\n\n  /**\n   * Feed the next observed snapshot into the tracker. Called from the host\n   * runtime whenever its message list / running state changes.\n   */\n  public setState(snapshot: ToolInvocationTracker.Snapshot): void {\n    try {\n      // Recover from a dead pipeline before processing anything. We demote\n      // all active entries to \"restored\" so the rebuilt pipeline does not\n      // re-fire `streamCall` for tool calls that already fired pre-death;\n      // preserves the \"exactly once per toolCallId\" contract.\n      if (this._pipelineDead) {\n        if (this._pipelineRestartUsed) {\n          // Already retried once and failed again. Stay dead.\n          return;\n        }\n        this._pipelineRestartUsed = true;\n        this._pipelineDead = false;\n        this._demoteEntriesToRestored();\n        this._executing.clear();\n        this._ac = new AbortController();\n        this._initPipeline();\n        // Fall through and process the snapshot against the fresh pipeline.\n      }\n\n      // Identical snapshot — skip processing entirely. Note: external-store\n      // runtimes rebuild the messages array on every adapter update, so this\n      // fast-path rarely triggers there; it's primarily for the React-hook\n      // shim where state references are stable.\n      if (\n        this._lastSnapshot &&\n        this._lastSnapshot.messages === snapshot.messages &&\n        this._lastSnapshot.isRunning === snapshot.isRunning &&\n        this._lastSnapshot.isLoading === snapshot.isLoading\n      ) {\n        return;\n      }\n\n      // While the host is still loading initial state, treat every snapshot\n      // as historical: tool calls are recorded so the next live snapshot can\n      // diff against them, but `streamCall` / `execute` do not fire.\n      const restoreFromLoading = snapshot.isLoading === true;\n      if (restoreFromLoading) {\n        this._pendingRestore = true;\n      }\n\n      // E.4 / AF3 — only mark `_lastSnapshot`/`_isRunning` as observed after\n      // processing succeeds. If `_processMessages` throws, the next snapshot\n      // (even if identical) gets re-processed against the recovered state.\n      const previousIsRunning = this._isRunning;\n      this._isRunning = snapshot.isRunning;\n      try {\n        this._processMessages(snapshot.messages);\n      } catch (err) {\n        this._isRunning = previousIsRunning;\n        throw err;\n      }\n      this._lastSnapshot = snapshot;\n      this._pendingRestore = false;\n    } catch (err) {\n      console.error(\n        \"[ToolInvocationTracker] setState failed; snapshot dropped\",\n        err,\n      );\n    }\n  }\n\n  /**\n   * Reset the tracker so the next observed snapshot is treated as historical.\n   * Clears entries and aborts any in-flight executions. Used by callers like\n   * `importExternalState` to mark a freshly loaded state as restored.\n   */\n  public reset(): void {\n    try {\n      this._pendingRestore = true;\n      this._entries.clear();\n      this._lastSnapshot = null;\n      void this.abort();\n      // Statuses are cleared synchronously: discarded executions may never\n      // settle (aborting hands the signal to the tool, it does not force\n      // settlement), and a late settlement of one sibling must not republish\n      // the others. `_deleteStatus` no-ops for cleared ids, so post-reset\n      // settlements stay silent.\n      if (this._statuses.size > 0) {\n        this._statuses = new Map();\n        this._invokeOnStatusesChange();\n      }\n    } catch (err) {\n      console.error(\"[ToolInvocationTracker] reset failed\", err);\n    }\n  }\n\n  /**\n   * Abort any in-flight `execute()` invocations. Resolves once all of them\n   * have settled (or immediately if none are running).\n   */\n  public abort(): Promise<void> {\n    try {\n      this._humanInput.forEach(({ reject }) => {\n        try {\n          reject(new Error(\"Tool execution aborted\"));\n        } catch {\n          // host rejection handler threw — already in the abort path,\n          // swallow so we continue cleaning up.\n        }\n      });\n      this._humanInput.clear();\n\n      this._ac.abort();\n      this._ac = new AbortController();\n\n      if (this._executing.size === 0) {\n        return Promise.resolve();\n      }\n      const executionIds = new Set(this._executing);\n      return new Promise<void>((resolve) => {\n        this._settledResolvers.push({ executionIds, resolve });\n      });\n    } catch (err) {\n      console.error(\"[ToolInvocationTracker] abort failed\", err);\n      return Promise.resolve();\n    }\n  }\n\n  /**\n   * Resolve a pending human-input request for the given tool call. Returns\n   * `true` if a pending request was resumed, `false` if the tracker has no\n   * outstanding request for that id (the caller should fall back to its own\n   * dispatch path).\n   */\n  public resume(toolCallId: string, payload: unknown): boolean {\n    try {\n      const handlers = this._humanInput.get(toolCallId);\n      if (!handlers) return false;\n      this._humanInput.delete(toolCallId);\n      this._setStatus(toolCallId, { type: \"executing\" });\n      handlers.resolve(payload);\n      return true;\n    } catch (err) {\n      console.error(\"[ToolInvocationTracker] resume failed\", err);\n      return false;\n    }\n  }\n\n  /**\n   * Returns the current tool execution status map. The returned `Map` is\n   * the tracker's internal store — do not mutate it. Treat the reference\n   * as a snapshot that may be replaced wholesale on the next status\n   * transition.\n   */\n  public getStatuses(): ReadonlyMap<string, ToolExecutionStatus> {\n    return this._statuses;\n  }\n\n  // ───────────────────── internal: tool wrapping ─────────────────────\n\n  private _getWrappedTools(): Record<string, Tool> | undefined {\n    const tools = this._getTools();\n    if (!tools) return undefined;\n\n    return Object.fromEntries(\n      Object.entries(tools).map(([name, tool]) => {\n        const execute = tool.execute;\n        const streamCall = tool.streamCall;\n        if (execute === undefined && streamCall === undefined)\n          return [name, tool];\n\n        const wrappedTool = {\n          ...tool,\n          ...(execute !== undefined && {\n            execute: (...[args, context]: Parameters<typeof execute>) => {\n              const executionId = getToolExecutionId(context);\n              const entry = this._captureExecution(\n                context.toolCallId,\n                executionId,\n              );\n              if (!entry || entry.skipExecute) {\n                return new Promise(() => {}) as never;\n              }\n              return execute(args, context);\n            },\n          }),\n          ...(streamCall !== undefined && {\n            streamCall: (\n              ...[reader, context]: Parameters<typeof streamCall>\n            ) => {\n              const executionId = getToolExecutionId(context);\n              const entry = this._captureExecution(\n                context.toolCallId,\n                executionId,\n              );\n              if (!entry) return;\n              return streamCall(reader, context);\n            },\n          }),\n        } as Tool;\n        return [name, wrappedTool];\n      }),\n    ) as Record<string, Tool>;\n  }\n\n  private _captureExecution(\n    toolCallId: string,\n    executionId: symbol | undefined,\n  ): ToolCallEntry | undefined {\n    if (executionId === undefined) return undefined;\n    const entry = this._entries.get(toolCallId);\n    if (!entry?.controller) return undefined;\n    if (entry.executionId === undefined) entry.executionId = executionId;\n    return entry.executionId === executionId ? entry : undefined;\n  }\n\n  // ──────────────── internal: execution lifecycle callbacks ────────────────\n\n  private _onHumanInput(\n    toolCallId: string,\n    payload: unknown,\n    executionId?: symbol,\n  ): Promise<unknown> {\n    return new Promise<unknown>((resolve, reject) => {\n      // A discarded execution must not resurrect a status entry or park an\n      // unanswerable request after its id has been reused.\n      const entry = this._entries.get(toolCallId);\n      if (!entry?.controller || entry.executionId !== executionId) {\n        reject(new Error(\"Tool execution aborted\"));\n        return;\n      }\n      const previous = this._humanInput.get(toolCallId);\n      if (previous) {\n        try {\n          previous.reject(\n            new Error(\"Human input request was superseded by a new request\"),\n          );\n        } catch {\n          // host rejection handler threw; ignore and proceed\n        }\n      }\n      this._humanInput.set(toolCallId, {\n        executionId: executionId!,\n        resolve,\n        reject,\n      });\n      this._setStatus(toolCallId, {\n        type: \"interrupt\",\n        payload: { type: \"human\", payload },\n      });\n    });\n  }\n\n  private _onExecutionStart(\n    toolCallId: string,\n    executionId: symbol | undefined,\n  ): void {\n    if (!this._captureExecution(toolCallId, executionId)) return;\n    const entry = this._entries.get(toolCallId)!;\n    if (entry.skipExecute) return;\n\n    this._executing.add(executionId!);\n    this._setStatus(toolCallId, { type: \"executing\" });\n  }\n\n  private _onExecutionEnd(\n    toolCallId: string,\n    executionId: symbol | undefined,\n  ): void {\n    if (executionId === undefined || !this._executing.delete(executionId))\n      return;\n\n    const entry = this._entries.get(toolCallId);\n    if (entry?.executionId === executionId) this._deleteStatus(toolCallId);\n\n    const pending: SettledResolver[] = [];\n    this._settledResolvers.forEach(({ executionIds, resolve }) => {\n      if ([...executionIds].some((id) => this._executing.has(id))) {\n        pending.push({ executionIds, resolve });\n        return;\n      }\n      try {\n        resolve();\n      } catch {\n        // ignore — settled-resolver consumer threw\n      }\n    });\n    this._settledResolvers.length = 0;\n    this._settledResolvers.push(...pending);\n  }\n\n  private _handleResultChunk(chunk: {\n    type: \"result\";\n    result: ReadonlyJSONValue;\n    isError: boolean;\n    artifact?: ReadonlyJSONValue;\n    modelContent?: readonly ToolModelContentPart[];\n    meta: { toolCallId: string; toolName: string };\n  }): void {\n    const toolCallId = chunk.meta.toolCallId;\n    const executionId = getToolExecutionId(chunk);\n    const entry = this._entries.get(toolCallId);\n\n    if (!entry || entry.executionId !== executionId) return;\n\n    // The host already set the result (via the live snapshot's\n    // `setResponse` path). Suppress the executor's redundant emit.\n    if (entry?.hasResult) return;\n\n    this._invokeOnResult({\n      type: \"add-tool-result\",\n      toolCallId,\n      toolName: chunk.meta.toolName,\n      result: chunk.result,\n      isError: chunk.isError,\n      ...(chunk.artifact !== undefined && { artifact: chunk.artifact }),\n      ...(chunk.modelContent !== undefined && {\n        modelContent: chunk.modelContent,\n      }),\n    });\n  }\n\n  // ──────────────── internal: callback invocation (AF1/AF2) ────────────────\n\n  private _invokeOnResult(command: AddToolResultCommand): void {\n    try {\n      this._callbacks.onResult(command);\n    } catch (err) {\n      console.error(\n        \"[ToolInvocationTracker] onResult callback threw; result dropped\",\n        err,\n      );\n    }\n  }\n\n  private _invokeOnStatusesChange(): void {\n    try {\n      this._callbacks.onStatusesChange(this._statuses);\n    } catch (err) {\n      console.error(\n        \"[ToolInvocationTracker] onStatusesChange callback threw; status change not propagated\",\n        err,\n      );\n    }\n  }\n\n  // ──────────────── internal: status map mutations ────────────────\n\n  private _setStatus(toolCallId: string, status: ToolExecutionStatus): void {\n    const next = new Map(this._statuses);\n    next.set(toolCallId, status);\n    this._statuses = next;\n    this._invokeOnStatusesChange();\n  }\n\n  private _deleteStatus(toolCallId: string): void {\n    if (!this._statuses.has(toolCallId)) return;\n    const next = new Map(this._statuses);\n    next.delete(toolCallId);\n    this._statuses = next;\n    this._invokeOnStatusesChange();\n  }\n\n  // ──────────────── internal: snapshot processing ────────────────\n\n  private _hasExecutableTool(toolName: string): boolean {\n    const tool = this._getTools()?.[toolName];\n    return tool?.execute !== undefined || tool?.streamCall !== undefined;\n  }\n\n  private _shouldCloseArgsStream({\n    toolName,\n    argsText,\n    hasResult,\n  }: {\n    toolName: string;\n    argsText: string;\n    hasResult: boolean;\n  }): boolean {\n    if (hasResult) return true;\n    if (!this._hasExecutableTool(toolName)) {\n      return !this._isRunning && isArgsTextComplete(argsText);\n    }\n    return isArgsTextComplete(argsText);\n  }\n\n  private _startActiveEntry(\n    toolCallId: string,\n    toolName: string,\n    skipExecute: boolean,\n  ): ToolCallEntry {\n    const toolCallController = this._controller.addToolCallPart({\n      toolName,\n      toolCallId,\n    });\n    const entry: ToolCallEntry = {\n      toolName,\n      controller: toolCallController,\n      argsText: \"\",\n      hasResult: false,\n      skipExecute,\n      argsComplete: false,\n    };\n    this._entries.set(toolCallId, entry);\n    return entry;\n  }\n\n  /**\n   * Demote every active entry back to the restored phase. Used by the\n   * pipeline-restart path so that, after a fresh pipeline is built, the\n   * next observed snapshot does not re-fire `streamCall` for tool calls\n   * that already fired pre-death. Args / hasResult tracking is preserved\n   * so signature comparisons still work.\n   */\n  private _demoteEntriesToRestored(): void {\n    for (const [toolCallId, entry] of this._entries) {\n      if (!entry.controller) continue;\n      this._entries.set(toolCallId, {\n        toolName: entry.toolName,\n        argsText: entry.argsText,\n        hasResult: entry.hasResult,\n      });\n    }\n  }\n\n  private _processArgsText(\n    entry: ToolCallEntry,\n    content: {\n      toolCallId: string;\n      toolName: string;\n      argsText: string;\n      result?: unknown;\n    },\n  ): void {\n    if (!entry.controller) return;\n    const hasResult = content.result !== undefined;\n\n    if (content.argsText !== entry.argsText) {\n      let shouldWriteArgsText = true;\n\n      if (entry.argsComplete) {\n        if (isEquivalentCompleteArgsText(entry.argsText, content.argsText)) {\n          // A.3 — key reorder. Track new text, no re-fire needed.\n          entry.argsText = content.argsText;\n          shouldWriteArgsText = false;\n        } else {\n          // A.4 — args changed after first completion. Under the\n          // \"exactly once per toolCallId\" contract we do not restart the\n          // stream. The host's existing `streamCall` keeps its original\n          // args view; the snapshot's new text is recorded for diffing\n          // but not surfaced. Events API in a follow-up will expose this\n          // to consumers that opt in.\n          if (process.env.NODE_ENV !== \"production\") {\n            console.warn(\n              \"[ToolInvocationTracker] argsText changed after first completion; not re-firing streamCall (see EDGE_CASES.md A.4)\",\n              {\n                previous: entry.argsText,\n                next: content.argsText,\n                toolCallId: content.toolCallId,\n              },\n            );\n          }\n          shouldWriteArgsText = false;\n        }\n      } else if (!content.argsText.startsWith(entry.argsText)) {\n        if (\n          isArgsTextComplete(entry.argsText) &&\n          isArgsTextComplete(content.argsText) &&\n          isEquivalentCompleteArgsText(entry.argsText, content.argsText)\n        ) {\n          const shouldClose = this._shouldCloseArgsStream({\n            toolName: content.toolName,\n            argsText: content.argsText,\n            hasResult,\n          });\n          if (shouldClose) entry.controller.argsText.close();\n          entry.argsText = content.argsText;\n          entry.argsComplete = shouldClose;\n          shouldWriteArgsText = false;\n        } else {\n          // A.2 — args regressed mid-stream. Under the \"exactly once\"\n          // contract we do not restart. The controller keeps whatever\n          // prefix we already streamed; subsequent prefix-respecting\n          // updates can still flow against it. Snapshots that never\n          // re-converge to a prefix will leave the controller's args\n          // view stale relative to the snapshot. Events API in a\n          // follow-up will expose this to consumers that opt in.\n          if (process.env.NODE_ENV !== \"production\") {\n            console.warn(\n              \"[ToolInvocationTracker] argsText regressed mid-stream; not restarting (see EDGE_CASES.md A.2)\",\n              {\n                previous: entry.argsText,\n                next: content.argsText,\n                toolCallId: content.toolCallId,\n              },\n            );\n          }\n          shouldWriteArgsText = false;\n        }\n      }\n\n      if (shouldWriteArgsText && entry.controller) {\n        const delta = content.argsText.slice(entry.argsText.length);\n        entry.controller.argsText.append(delta);\n        const shouldClose = this._shouldCloseArgsStream({\n          toolName: content.toolName,\n          argsText: content.argsText,\n          hasResult,\n        });\n        if (shouldClose) entry.controller.argsText.close();\n        entry.argsText = content.argsText;\n        entry.argsComplete = shouldClose;\n      }\n    }\n\n    if (!entry.argsComplete && entry.controller) {\n      // ToolExecutionStream parses the streamed prefix on close, so the close\n      // gates on the streamed content; a divergent snapshot (A.2) can be\n      // complete while the controller still holds an incomplete stale prefix.\n      const shouldClose = this._shouldCloseArgsStream({\n        toolName: content.toolName,\n        argsText: entry.argsText,\n        hasResult,\n      });\n      if (shouldClose) {\n        entry.controller.argsText.close();\n        entry.argsComplete = true;\n      }\n    }\n  }\n\n  private _processMessages(messages: readonly ThreadMessage[]): void {\n    const isRestore = this._pendingRestore;\n\n    for (const message of messages) {\n      if (!message || !Array.isArray((message as ThreadMessage).content)) {\n        continue;\n      }\n      for (const content of message.content as readonly ThreadMessage[\"content\"][number][]) {\n        if (!content || content.type !== \"tool-call\") continue;\n\n        const existing = this._entries.get(content.toolCallId);\n\n        if (isRestore) {\n          // Don't overwrite an already-active entry (e.g. live tool-call\n          // observed before this restore snapshot landed). Restore can\n          // only seed entries the runtime has never seen.\n          if (!existing?.controller) {\n            this._entries.set(content.toolCallId, {\n              toolName: content.toolName,\n              argsText: content.argsText,\n              hasResult: content.result !== undefined,\n            });\n          }\n          if (content.messages) this._processMessages(content.messages);\n          continue;\n        }\n\n        // Live snapshot.\n        let entry = existing;\n\n        if (entry && !entry.controller) {\n          // Restored entry observed in a live snapshot. Promote if its\n          // signature has changed; otherwise treat as still-historical.\n          const signatureChanged =\n            content.argsText !== entry.argsText ||\n            (content.result !== undefined) !== entry.hasResult;\n          if (!signatureChanged) {\n            if (content.messages) this._processMessages(content.messages);\n            continue;\n          }\n          this._entries.delete(content.toolCallId);\n          entry = undefined;\n        }\n\n        if (!entry) {\n          entry = this._startActiveEntry(\n            content.toolCallId,\n            content.toolName,\n            content.result !== undefined,\n          );\n        }\n\n        this._processArgsText(entry, content);\n\n        if (content.result !== undefined && !entry.hasResult) {\n          // `entry` is in active phase from this point — either just\n          // created by `_startActiveEntry`, or pre-existing with a live\n          // controller. Narrow once instead of asserting at every use.\n          const { controller: activeController } = entry;\n          if (!activeController) continue;\n          entry.hasResult = true;\n          entry.argsComplete = true;\n          activeController.setResponse(\n            new ToolResponse({\n              result: content.result as ReadonlyJSONValue,\n              artifact: content.artifact as ReadonlyJSONValue | undefined,\n              isError: content.isError,\n              ...(content.modelContent !== undefined\n                ? { modelContent: content.modelContent }\n                : {}),\n            }),\n          );\n          activeController.close();\n        }\n\n        if (content.messages) this._processMessages(content.messages);\n      }\n    }\n  }\n}\n\nexport namespace ToolInvocationTracker {\n  export type ExecutionStatus = ToolExecutionStatus;\n\n  export type Snapshot = {\n    readonly messages: readonly ThreadMessage[];\n    /** Whether the producing runtime is currently streaming new output. */\n    readonly isRunning: boolean;\n    /**\n     * Whether the producing runtime is still loading historical state.\n     * When `true`, every snapshot is treated as historical (no `streamCall` /\n     * `execute` fires). When `false`, processing resumes as live.\n     */\n    readonly isLoading?: boolean;\n  };\n\n  export type Callbacks = {\n    /**\n     * Invoked when a client-side `execute()` returns a result and the runtime\n     * needs to feed it back into the conversation.\n     */\n    onResult: (command: AddToolResultCommand) => void;\n    /**\n     * Invoked whenever the per-tool-call status map changes (executing /\n     * interrupt / cleared). The callback receives a fresh map; mutating the\n     * argument is not supported.\n     */\n    onStatusesChange: (\n      statuses: ReadonlyMap<string, ToolExecutionStatus>,\n    ) => void;\n  };\n}\n"],"mappings":"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"}

package/dist/store/clients/suggestions.js

@@ -91,8 +91,8 @@ function _temp2(s) {
 }
 function _temp3(s) {
 	return {
-		title: s.prompt,
-		label: "",
+		title: s.title ?? s.prompt,
+		label: s.label ?? "",
 		prompt: s.prompt
 	};
 }

package/dist/store/clients/suggestions.js.map

@@ -1 +1 @@
-{"version":3,"file":"suggestions.js","names":["useMemo","useState","resource","withKey","ClientOutput","useClientLookup","SuggestionsState","SuggestionState","ThreadSuggestion","SuggestionConfig","title","label","prompt","useSuggestionClient","state","getState","SuggestionClient","useSuggestionsClient","$","_c","t0","suggestions","map","_temp","suggestionClients","t1","t2","t3","index","index_0","get","suggestion","useStaticSuggestions","normalizedSuggestions","_temp2","Suggestions","useThreadSuggestions","_temp3","ThreadSuggestions","s"],"sources":["../../../src/store/clients/suggestions.ts"],"sourcesContent":["import { useMemo, useState } from \"react\";\nimport { resource, withKey } from \"@assistant-ui/tap\";\nimport type { ClientOutput } from \"@assistant-ui/store\";\nimport { useClientLookup } from \"@assistant-ui/store/client\";\nimport type { SuggestionsState } from \"../scopes/suggestions\";\nimport type { SuggestionState } from \"../scopes/suggestion\";\nimport type { ThreadSuggestion } from \"../../runtime/interfaces/thread-runtime-core\";\n\nexport type SuggestionConfig =\n  | string\n  | { title: string; label: string; prompt: string };\n\nconst useSuggestionClient = (\n  state: SuggestionState,\n): ClientOutput<\"suggestion\"> => {\n  return {\n    getState: () => state,\n  };\n};\n\nconst SuggestionClient = resource(useSuggestionClient);\n\nconst useSuggestionsClient = (\n  state: SuggestionsState,\n): ClientOutput<\"suggestions\"> => {\n  const suggestionClients = useClientLookup(\n    state.suggestions.map((suggestion, index) =>\n      withKey(index, SuggestionClient(suggestion), [suggestion]),\n    ),\n  );\n\n  return {\n    getState: () => state,\n    suggestion: ({ index }: { index: number }) => {\n      return suggestionClients.get({ index });\n    },\n  };\n};\n\nconst useStaticSuggestions = (\n  suggestions?: SuggestionConfig[],\n): ClientOutput<\"suggestions\"> => {\n  const [state] = useState<SuggestionsState>(() => {\n    const normalizedSuggestions = (suggestions ?? []).map((s) => {\n      if (typeof s === \"string\") {\n        return {\n          title: s,\n          label: \"\",\n          prompt: s,\n        };\n      }\n      return {\n        title: s.title,\n        label: s.label,\n        prompt: s.prompt,\n      };\n    });\n\n    return {\n      suggestions: normalizedSuggestions,\n    };\n  });\n\n  return useSuggestionsClient(state);\n};\n\nexport const Suggestions = resource(useStaticSuggestions);\n\nconst useThreadSuggestions = (\n  suggestions: readonly ThreadSuggestion[],\n): ClientOutput<\"suggestions\"> => {\n  const state = useMemo<SuggestionsState>(\n    () => ({\n      suggestions: suggestions.map((s) => ({\n        title: s.prompt,\n        label: \"\",\n        prompt: s.prompt,\n      })),\n    }),\n    [suggestions],\n  );\n\n  return useSuggestionsClient(state);\n};\n\nexport const ThreadSuggestions = resource(useThreadSuggestions);\n"],"mappings":";;;;;AAYA,MAAMa,uBACJC,UAC+B;CAC/B,OAAO,EACLC,gBAAgBD,MAClB;AACF;AAEA,MAAME,mBAAmBd,SAASW,mBAAmB;AAErD,MAAMI,wBAAuBH,UAAA;CAAA,MAAAI,IAAAC,EAAA,CAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAJ,MAAAO,aAAA;EAIzBD,KAAAN,MAAKO,YAAYC,IAAKC,KAEtB;EAACL,EAAA,KAAAJ,MAAAO;EAAAH,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAHH,MAAAM,oBAA0BnB,gBACxBe,EAGF;CAAE,IAAAK;CAAA,IAAAP,EAAA,OAAAJ,OAAA;EAGUW,WAAMX;EAAKI,EAAA,KAAAJ;EAAAI,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAAA,IAAAQ;CAAA,IAAAR,EAAA,OAAAM,mBAAA;EACTE,MAAAC,OAAA;GAAC,MAAA,EAAAC,OAAAC,YAAAF;GAA4B,OAChCH,kBAAiBM,IAAK,EAAAF,OAAEA,QAAM,CAAC;EAAC;EACxCV,EAAA,KAAAM;EAAAN,EAAA,KAAAQ;CAAA,OAAAA,KAAAR,EAAA;CAAA,IAAAS;CAAA,IAAAT,EAAA,OAAAO,MAAAP,EAAA,OAAAQ,IAAA;EAJIC,KAAA;GAAAZ,UACKU;GAAWM,YACTL;EAGd;EAACR,EAAA,KAAAO;EAAAP,EAAA,KAAAQ;EAAAR,EAAA,KAAAS;CAAA,OAAAA,KAAAT,EAAA;CAAA,OALMS;AAKN;AAGH,MAAMK,wBAAuBX,gBAAA;CAAA,MAAAH,IAAAC,EAAA,CAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAG,aAAA;EAGgBD,WAAA;GActC,OAEI,EAAAC,cAfwBA,eAAA,CAAA,EAAA,CAAiBC,IAAMY,MAgBvCD,EACf;EAAC;EACFf,EAAA,KAAAG;EAAAH,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAnBD,MAAA,CAAAJ,SAAgBb,SAA2BmB,EAmB1C;CAAE,OAEIH,qBAAqBH,KAAK;AAAC;AAGpC,MAAaqB,cAAcjC,SAAS8B,oBAAoB;AAExD,MAAMI,wBAAuBf,gBAAA;CAAA,MAAAH,IAAAC,EAAA,CAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAG,aAAA;EAKVD,KAAAC,YAAWC,IAAKe,MAI3B;EAACnB,EAAA,KAAAG;EAAAH,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAAA,IAAAO;CAAA,IAAAP,EAAA,OAAAE,IAAA;EALEK,KAAA,EAAAJ,aACQD,GAKf;EAACF,EAAA,KAAAE;EAAAF,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAED,OAEKD,qBAAqBH,EAAK;AAAC;AAGpC,MAAawB,oBAAoBpC,SAASkC,oBAAoB;AA/DjC,SAAAb,MAAAQ,YAAAH,OAAA;CAAA,OAKvBzB,QAAQyB,OAAOZ,iBAAiBe,UAAU,GAAG,CAACA,UAAU,CAAC;AAAC;AAYnC,SAAAG,OAAAK,GAAA;CAKvB,IAAI,OAAOA,MAAM,UAAQ,OAChB;EAAA7B,OACE6B;EAAC5B,OACD;EAAEC,QACD2B;CACV;CACD,OACM;EAAA7B,OACE6B,EAAC7B;EAAMC,OACP4B,EAAC5B;EAAMC,QACN2B,EAAC3B;CACX;AAAC;AAasB,SAAAyB,OAAAE,GAAA;CAAA,OAKc;EAAA7B,OAC5B6B,EAAC3B;EAAOD,OACR;EAAEC,QACD2B,EAAC3B;CACX;AAAC"}
+{"version":3,"file":"suggestions.js","names":["useMemo","useState","resource","withKey","ClientOutput","useClientLookup","SuggestionsState","SuggestionState","ThreadSuggestion","SuggestionConfig","title","label","prompt","useSuggestionClient","state","getState","SuggestionClient","useSuggestionsClient","$","_c","t0","suggestions","map","_temp","suggestionClients","t1","t2","t3","index","index_0","get","suggestion","useStaticSuggestions","normalizedSuggestions","_temp2","Suggestions","useThreadSuggestions","_temp3","ThreadSuggestions","s"],"sources":["../../../src/store/clients/suggestions.ts"],"sourcesContent":["import { useMemo, useState } from \"react\";\nimport { resource, withKey } from \"@assistant-ui/tap\";\nimport type { ClientOutput } from \"@assistant-ui/store\";\nimport { useClientLookup } from \"@assistant-ui/store/client\";\nimport type { SuggestionsState } from \"../scopes/suggestions\";\nimport type { SuggestionState } from \"../scopes/suggestion\";\nimport type { ThreadSuggestion } from \"../../runtime/interfaces/thread-runtime-core\";\n\nexport type SuggestionConfig =\n  | string\n  | { title: string; label: string; prompt: string };\n\nconst useSuggestionClient = (\n  state: SuggestionState,\n): ClientOutput<\"suggestion\"> => {\n  return {\n    getState: () => state,\n  };\n};\n\nconst SuggestionClient = resource(useSuggestionClient);\n\nconst useSuggestionsClient = (\n  state: SuggestionsState,\n): ClientOutput<\"suggestions\"> => {\n  const suggestionClients = useClientLookup(\n    state.suggestions.map((suggestion, index) =>\n      withKey(index, SuggestionClient(suggestion), [suggestion]),\n    ),\n  );\n\n  return {\n    getState: () => state,\n    suggestion: ({ index }: { index: number }) => {\n      return suggestionClients.get({ index });\n    },\n  };\n};\n\nconst useStaticSuggestions = (\n  suggestions?: SuggestionConfig[],\n): ClientOutput<\"suggestions\"> => {\n  const [state] = useState<SuggestionsState>(() => {\n    const normalizedSuggestions = (suggestions ?? []).map((s) => {\n      if (typeof s === \"string\") {\n        return {\n          title: s,\n          label: \"\",\n          prompt: s,\n        };\n      }\n      return {\n        title: s.title,\n        label: s.label,\n        prompt: s.prompt,\n      };\n    });\n\n    return {\n      suggestions: normalizedSuggestions,\n    };\n  });\n\n  return useSuggestionsClient(state);\n};\n\nexport const Suggestions = resource(useStaticSuggestions);\n\nconst useThreadSuggestions = (\n  suggestions: readonly ThreadSuggestion[],\n): ClientOutput<\"suggestions\"> => {\n  const state = useMemo<SuggestionsState>(\n    () => ({\n      suggestions: suggestions.map((s) => ({\n        title: s.title ?? s.prompt,\n        label: s.label ?? \"\",\n        prompt: s.prompt,\n      })),\n    }),\n    [suggestions],\n  );\n\n  return useSuggestionsClient(state);\n};\n\nexport const ThreadSuggestions = resource(useThreadSuggestions);\n"],"mappings":";;;;;AAYA,MAAMa,uBACJC,UAC+B;CAC/B,OAAO,EACLC,gBAAgBD,MAClB;AACF;AAEA,MAAME,mBAAmBd,SAASW,mBAAmB;AAErD,MAAMI,wBAAuBH,UAAA;CAAA,MAAAI,IAAAC,EAAA,CAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAJ,MAAAO,aAAA;EAIzBD,KAAAN,MAAKO,YAAYC,IAAKC,KAEtB;EAACL,EAAA,KAAAJ,MAAAO;EAAAH,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAHH,MAAAM,oBAA0BnB,gBACxBe,EAGF;CAAE,IAAAK;CAAA,IAAAP,EAAA,OAAAJ,OAAA;EAGUW,WAAMX;EAAKI,EAAA,KAAAJ;EAAAI,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAAA,IAAAQ;CAAA,IAAAR,EAAA,OAAAM,mBAAA;EACTE,MAAAC,OAAA;GAAC,MAAA,EAAAC,OAAAC,YAAAF;GAA4B,OAChCH,kBAAiBM,IAAK,EAAAF,OAAEA,QAAM,CAAC;EAAC;EACxCV,EAAA,KAAAM;EAAAN,EAAA,KAAAQ;CAAA,OAAAA,KAAAR,EAAA;CAAA,IAAAS;CAAA,IAAAT,EAAA,OAAAO,MAAAP,EAAA,OAAAQ,IAAA;EAJIC,KAAA;GAAAZ,UACKU;GAAWM,YACTL;EAGd;EAACR,EAAA,KAAAO;EAAAP,EAAA,KAAAQ;EAAAR,EAAA,KAAAS;CAAA,OAAAA,KAAAT,EAAA;CAAA,OALMS;AAKN;AAGH,MAAMK,wBAAuBX,gBAAA;CAAA,MAAAH,IAAAC,EAAA,CAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAG,aAAA;EAGgBD,WAAA;GActC,OAEI,EAAAC,cAfwBA,eAAA,CAAA,EAAA,CAAiBC,IAAMY,MAgBvCD,EACf;EAAC;EACFf,EAAA,KAAAG;EAAAH,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAnBD,MAAA,CAAAJ,SAAgBb,SAA2BmB,EAmB1C;CAAE,OAEIH,qBAAqBH,KAAK;AAAC;AAGpC,MAAaqB,cAAcjC,SAAS8B,oBAAoB;AAExD,MAAMI,wBAAuBf,gBAAA;CAAA,MAAAH,IAAAC,EAAA,CAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAG,aAAA;EAKVD,KAAAC,YAAWC,IAAKe,MAI3B;EAACnB,EAAA,KAAAG;EAAAH,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAAA,IAAAO;CAAA,IAAAP,EAAA,OAAAE,IAAA;EALEK,KAAA,EAAAJ,aACQD,GAKf;EAACF,EAAA,KAAAE;EAAAF,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAED,OAEKD,qBAAqBH,EAAK;AAAC;AAGpC,MAAawB,oBAAoBpC,SAASkC,oBAAoB;AA/DjC,SAAAb,MAAAQ,YAAAH,OAAA;CAAA,OAKvBzB,QAAQyB,OAAOZ,iBAAiBe,UAAU,GAAG,CAACA,UAAU,CAAC;AAAC;AAYnC,SAAAG,OAAAK,GAAA;CAKvB,IAAI,OAAOA,MAAM,UAAQ,OAChB;EAAA7B,OACE6B;EAAC5B,OACD;EAAEC,QACD2B;CACV;CACD,OACM;EAAA7B,OACE6B,EAAC7B;EAAMC,OACP4B,EAAC5B;EAAMC,QACN2B,EAAC3B;CACX;AAAC;AAasB,SAAAyB,OAAAE,GAAA;CAAA,OAKc;EAAA7B,OAC5B6B,EAAC7B,SAAU6B,EAAC3B;EAAOD,OACnB4B,EAAC5B,SAAD;EAAaC,QACZ2B,EAAC3B;CACX;AAAC"}

package/dist/store/clients/thread-selection-events.d.ts

@@ -0,0 +1,10 @@
+//#region src/store/clients/thread-selection-events.d.ts
+/**
+ * Emits `threads.selectionChanged` whenever the main thread selection changes.
+ * Does not emit for the initially selected thread on mount. Every `threads`
+ * client whose selection can change calls this with its current main thread id.
+ */
+declare const useThreadSelectionEvents: (mainThreadId: string) => void;
+//#endregion
+export { useThreadSelectionEvents };
+//# sourceMappingURL=thread-selection-events.d.ts.map

package/dist/store/clients/thread-selection-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-selection-events.d.ts","names":[],"sources":["../../../src/store/clients/thread-selection-events.ts"],"mappings":";;;;;;cAQa,2BAA4B"}

package/dist/store/clients/thread-selection-events.js

@@ -0,0 +1,40 @@
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { useEffect, useRef } from "@assistant-ui/tap/react-shim";
+import { useAssistantEmit } from "@assistant-ui/store/client";
+//#region src/store/clients/thread-selection-events.ts
+/**
+* Emits `threads.selectionChanged` whenever the main thread selection changes.
+* Does not emit for the initially selected thread on mount. Every `threads`
+* client whose selection can change calls this with its current main thread id.
+*/
+const useThreadSelectionEvents = (mainThreadId) => {
+	const $ = c(4);
+	const emit = useAssistantEmit();
+	const previousMainThreadIdRef = useRef(mainThreadId);
+	let t0;
+	let t1;
+	if ($[0] !== emit || $[1] !== mainThreadId) {
+		t0 = () => {
+			const previousThreadId = previousMainThreadIdRef.current;
+			if (previousThreadId === mainThreadId) return;
+			previousMainThreadIdRef.current = mainThreadId;
+			emit("threads.selectionChanged", {
+				threadId: mainThreadId,
+				previousThreadId
+			});
+		};
+		t1 = [mainThreadId, emit];
+		$[0] = emit;
+		$[1] = mainThreadId;
+		$[2] = t0;
+		$[3] = t1;
+	} else {
+		t0 = $[2];
+		t1 = $[3];
+	}
+	useEffect(t0, t1);
+};
+//#endregion
+export { useThreadSelectionEvents };
+
+//# sourceMappingURL=thread-selection-events.js.map

package/dist/store/clients/thread-selection-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-selection-events.js","names":["useEffect","useRef","useAssistantEmit","useThreadSelectionEvents","mainThreadId","$","_c","emit","previousMainThreadIdRef","t0","t1","previousThreadId","current","threadId"],"sources":["../../../src/store/clients/thread-selection-events.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { useAssistantEmit } from \"@assistant-ui/store/client\";\n\n/**\n * Emits `threads.selectionChanged` whenever the main thread selection changes.\n * Does not emit for the initially selected thread on mount. Every `threads`\n * client whose selection can change calls this with its current main thread id.\n */\nexport const useThreadSelectionEvents = (mainThreadId: string) => {\n  const emit = useAssistantEmit();\n  const previousMainThreadIdRef = useRef(mainThreadId);\n  useEffect(() => {\n    const previousThreadId = previousMainThreadIdRef.current;\n    if (previousThreadId === mainThreadId) return;\n    previousMainThreadIdRef.current = mainThreadId;\n    emit(\"threads.selectionChanged\", {\n      threadId: mainThreadId,\n      previousThreadId,\n    });\n  }, [mainThreadId, emit]);\n};\n"],"mappings":";;;;;;;;;AAQA,MAAaG,4BAA2BC,iBAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACtC,MAAAC,OAAaL,iBAAiB;CAC9B,MAAAM,0BAAgCP,OAAOG,YAAY;CAAE,IAAAK;CAAA,IAAAC;CAAA,IAAAL,EAAA,OAAAE,QAAAF,EAAA,OAAAD,cAAA;EAC3CK,WAAA;GACR,MAAAE,mBAAyBH,wBAAuBI;GAChD,IAAID,qBAAqBP,cAAY;GACrCI,wBAAuBI,UAAWR;GAClCG,KAAK,4BAA4B;IAAAM,UACrBT;IAAYO;GAExB,CAAC;EAAC;EACDD,KAAA,CAACN,cAAcG,IAAI;EAACF,EAAA,KAAAE;EAAAF,EAAA,KAAAD;EAAAC,EAAA,KAAAI;EAAAJ,EAAA,KAAAK;CAAA,OAAA;EAAAD,KAAAJ,EAAA;EAAAK,KAAAL,EAAA;CAAA;CARvBL,UAAUS,IAQPC,EAAoB;AAAC"}

package/dist/store/env.d.ts

@@ -0,0 +1,5 @@
+//#region src/store/env.d.ts
+declare const isDevelopment: boolean;
+//#endregion
+export { isDevelopment };
+//# sourceMappingURL=env.d.ts.map

package/dist/store/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","names":[],"sources":["../../src/store/env.ts"],"mappings":";cAEa"}

package/dist/store/env.js

@@ -0,0 +1,12 @@
+//#region src/store/env.ts
+const isDevelopment = (() => {
+	try {
+		return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+	} catch {
+		return false;
+	}
+})();
+//#endregion
+export { isDevelopment };
+
+//# sourceMappingURL=env.js.map

package/dist/store/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","names":["isDevelopment","process","env","NODE_ENV"],"sources":["../../src/store/env.ts"],"sourcesContent":["// Bundlers replace the process.env.NODE_ENV literal statically (Vite, webpack,\n// Metro); the try covers hosts where no process binding exists at runtime.\nexport const isDevelopment = (() => {\n  try {\n    return (\n      process.env.NODE_ENV === \"development\" || process.env.NODE_ENV === \"test\"\n    );\n  } catch {\n    return false;\n  }\n})();\n"],"mappings":";AAEA,MAAaA,uBAAuB;CAClC,IAAI;EACF,OACEC,QAAQC,IAAIC,aAAa,iBAAiBF,QAAQC,IAAIC,aAAa;CAEvE,QAAQ;EACN,OAAO;CACT;AACF,EAAA,CAAG"}

package/dist/store/index.d.ts

@@ -9,10 +9,12 @@ import { MessageClientSchema, MessageMeta, MessageMethods, MessageState } from "
 import { SuggestionClientSchema, SuggestionMeta, SuggestionMethods, SuggestionState } from "./scopes/suggestion.js";
 import { Suggestion, SuggestionsClientSchema, SuggestionsMethods, SuggestionsState } from "./scopes/suggestions.js";
 import { ThreadClientSchema, ThreadEvents, ThreadMeta, ThreadMethods, ThreadState } from "./scopes/thread.js";
-import { ThreadsClientSchema, ThreadsMethods, ThreadsState } from "./scopes/threads.js";
+import { ThreadsClientSchema, ThreadsEvents, ThreadsMethods, ThreadsState } from "./scopes/threads.js";
 import { ModelContextClientSchema, ModelContextMethods, ModelContextState } from "./scopes/model-context.js";
 import { ChainOfThoughtClientSchema, ChainOfThoughtMeta, ChainOfThoughtMethods, ChainOfThoughtPart, ChainOfThoughtState } from "./scopes/chain-of-thought.js";
-import { RuntimeAdapter } from "../react/RuntimeAdapter.js";
+import { RuntimeAdapter, runtimeAdapterTransformScopes } from "../react/RuntimeAdapter.js";
+import { InMemoryThreadList, InMemoryThreadListProps, inMemoryThreadListTransformScopes } from "../react/client/InMemoryThreadList.js";
+import { RemoteThreadList, RemoteThreadListProps } from "../react/client/RemoteThreadList.js";
 import { JoinStrategy, convertExternalMessages, useExternalMessageConverter } from "../react/runtimes/external-message-converter.js";
 import { StreamingTimingAccessors, StreamingTimingOptions, StreamingTimingState } from "../runtime/utils/streaming-timing.js";
 import { useStreamingTiming } from "../react/runtimes/useStreamingTiming.js";
@@ -27,4 +29,4 @@ import { SuggestionConfig, Suggestions } from "./clients/suggestions.js";
 import { ChainOfThoughtClient } from "./clients/chain-of-thought-client.js";
 import { ThreadMessageClient, ThreadMessageClientProps } from "./clients/thread-message-client.js";
 import { ModelContext } from "./clients/model-context-client.js";
-export { type AttachmentClientSchema, type AttachmentMeta, type AttachmentMethods, type AttachmentState, ChainOfThoughtClient, type ChainOfThoughtClientSchema, type ChainOfThoughtMeta, type ChainOfThoughtMethods, type ChainOfThoughtPart, type ChainOfThoughtState, type ComposerClientSchema, type ComposerEvents, type ComposerMeta, type ComposerMethods, type ComposerSendOptions, type ComposerState, ExternalThread, type ExternalThreadMessage, type ExternalThreadProps, type JoinStrategy, type McpToolkitDefinition, type McpToolkitEntry, type McpToolkitToolConfig, type MessageClientSchema, type MessageMeta, type MessageMethods, type MessageState, ModelContext, type ModelContextClientSchema, type ModelContextMethods, type ModelContextState, NoOpComposerClient, type PartClientSchema, type PartMeta, type PartMethods, type PartState, type QueueItemClientSchema, type QueueItemMeta, type QueueItemMethods, type QueueItemState, RuntimeAdapter, type RuntimeExtrasBrand, SingleThreadList, type StreamingTimingAccessors, type StreamingTimingOptions, type StreamingTimingState, type Suggestion, type SuggestionClientSchema, type SuggestionConfig, type SuggestionMeta, type SuggestionMethods, type SuggestionState, Suggestions, type SuggestionsClientSchema, type SuggestionsMethods, type SuggestionsState, type ThreadClientSchema, type ThreadEvents, type ThreadListItemClientSchema, type ThreadListItemEvents, type ThreadListItemMeta, type ThreadListItemMethods, type ThreadListItemState, ThreadMessageClient, type ThreadMessageClientProps, type ThreadMeta, type ThreadMethods, type ThreadState, type ThreadsClientSchema, type ThreadsMethods, type ThreadsState, type Toolkit, type ToolkitDefinition, type ToolkitDefinitionEntry, convertExternalMessages, createRuntimeExtrasBrand, defineMcpToolkit, defineToolkit, useExternalMessageConverter, useStreamingTiming };
+export { type AttachmentClientSchema, type AttachmentMeta, type AttachmentMethods, type AttachmentState, ChainOfThoughtClient, type ChainOfThoughtClientSchema, type ChainOfThoughtMeta, type ChainOfThoughtMethods, type ChainOfThoughtPart, type ChainOfThoughtState, type ComposerClientSchema, type ComposerEvents, type ComposerMeta, type ComposerMethods, type ComposerSendOptions, type ComposerState, ExternalThread, type ExternalThreadMessage, type ExternalThreadProps, InMemoryThreadList, type InMemoryThreadListProps, type JoinStrategy, type McpToolkitDefinition, type McpToolkitEntry, type McpToolkitToolConfig, type MessageClientSchema, type MessageMeta, type MessageMethods, type MessageState, ModelContext, type ModelContextClientSchema, type ModelContextMethods, type ModelContextState, NoOpComposerClient, type PartClientSchema, type PartMeta, type PartMethods, type PartState, type QueueItemClientSchema, type QueueItemMeta, type QueueItemMethods, type QueueItemState, RemoteThreadList, type RemoteThreadListProps, RuntimeAdapter, type RuntimeExtrasBrand, SingleThreadList, type StreamingTimingAccessors, type StreamingTimingOptions, type StreamingTimingState, type Suggestion, type SuggestionClientSchema, type SuggestionConfig, type SuggestionMeta, type SuggestionMethods, type SuggestionState, Suggestions, type SuggestionsClientSchema, type SuggestionsMethods, type SuggestionsState, type ThreadClientSchema, type ThreadEvents, type ThreadListItemClientSchema, type ThreadListItemEvents, type ThreadListItemMeta, type ThreadListItemMethods, type ThreadListItemState, ThreadMessageClient, type ThreadMessageClientProps, type ThreadMeta, type ThreadMethods, type ThreadState, type ThreadsClientSchema, type ThreadsEvents, type ThreadsMethods, type ThreadsState, type Toolkit, type ToolkitDefinition, type ToolkitDefinitionEntry, convertExternalMessages, createRuntimeExtrasBrand, defineMcpToolkit, defineToolkit, inMemoryThreadListTransformScopes, runtimeAdapterTransformScopes, useExternalMessageConverter, useStreamingTiming };

package/dist/store/index.js

@@ -1,8 +1,10 @@
 import { Suggestions } from "./clients/suggestions.js";
 import { ModelContext } from "./clients/model-context-client.js";
-import { RuntimeAdapter } from "../react/RuntimeAdapter.js";
+import { RuntimeAdapter, runtimeAdapterTransformScopes } from "../react/RuntimeAdapter.js";
 import { defineToolkit } from "../react/model-context/define-toolkit.js";
 import { defineMcpToolkit } from "../react/model-context/define-mcp-toolkit.js";
+import { InMemoryThreadList, inMemoryThreadListTransformScopes } from "../react/client/InMemoryThreadList.js";
+import { RemoteThreadList } from "../react/client/RemoteThreadList.js";
 import { convertExternalMessages, useExternalMessageConverter } from "../react/runtimes/external-message-converter.js";
 import { useStreamingTiming } from "../react/runtimes/useStreamingTiming.js";
 import { createRuntimeExtrasBrand } from "../runtime/utils/runtime-extras-brand.js";
@@ -11,4 +13,4 @@ import { ExternalThread } from "./clients/external-thread.js";
 import { NoOpComposerClient } from "./clients/no-op-composer-client.js";
 import { ChainOfThoughtClient } from "./clients/chain-of-thought-client.js";
 import { ThreadMessageClient } from "./clients/thread-message-client.js";
-export { ChainOfThoughtClient, ExternalThread, ModelContext, NoOpComposerClient, RuntimeAdapter, SingleThreadList, Suggestions, ThreadMessageClient, convertExternalMessages, createRuntimeExtrasBrand, defineMcpToolkit, defineToolkit, useExternalMessageConverter, useStreamingTiming };
+export { ChainOfThoughtClient, ExternalThread, InMemoryThreadList, ModelContext, NoOpComposerClient, RemoteThreadList, RuntimeAdapter, SingleThreadList, Suggestions, ThreadMessageClient, convertExternalMessages, createRuntimeExtrasBrand, defineMcpToolkit, defineToolkit, inMemoryThreadListTransformScopes, runtimeAdapterTransformScopes, useExternalMessageConverter, useStreamingTiming };

package/dist/store/internal.d.ts

@@ -1,4 +1,6 @@
 import { baseRuntimeAdapterTransformScopes } from "./clients/runtime-adapter.js";
+import { useThreadSelectionEvents } from "./clients/thread-selection-events.js";
+import { isDevelopment } from "./env.js";
 import { AttachmentRuntimeClient } from "./runtime-clients/attachment-runtime-client.js";
 import { MessagePartClient } from "./runtime-clients/message-part-runtime-client.js";
 import { ComposerClient } from "./runtime-clients/composer-runtime-client.js";
@@ -6,4 +8,5 @@ import { MessageClient } from "./runtime-clients/message-runtime-client.js";
 import { ThreadClient } from "./runtime-clients/thread-runtime-client.js";
 import { ThreadListItemClient } from "./runtime-clients/thread-list-item-runtime-client.js";
 import { ThreadListClient } from "./runtime-clients/thread-list-runtime-client.js";
-export { AttachmentRuntimeClient, ComposerClient, MessageClient, MessagePartClient, ThreadClient, ThreadListClient, ThreadListItemClient, baseRuntimeAdapterTransformScopes };
+import { actionBarCopyDisabled, actionBarEditDisabled, actionBarReloadDisabled, branchPickerNextDisabled, branchPickerPreviousDisabled, composerCancelDisabled, composerInputDisabled, composerSendDisabled, suggestionTriggerDisabled } from "./primitive-predicates.js";
+export { AttachmentRuntimeClient, ComposerClient, MessageClient, MessagePartClient, ThreadClient, ThreadListClient, ThreadListItemClient, actionBarCopyDisabled, actionBarEditDisabled, actionBarReloadDisabled, baseRuntimeAdapterTransformScopes, branchPickerNextDisabled, branchPickerPreviousDisabled, composerCancelDisabled, composerInputDisabled, composerSendDisabled, isDevelopment, suggestionTriggerDisabled, useThreadSelectionEvents };

package/dist/store/internal.js

@@ -4,6 +4,9 @@ import { ComposerClient } from "./runtime-clients/composer-runtime-client.js";
 import { MessageClient } from "./runtime-clients/message-runtime-client.js";
 import { ThreadClient } from "./runtime-clients/thread-runtime-client.js";
 import { ThreadListItemClient } from "./runtime-clients/thread-list-item-runtime-client.js";
+import { useThreadSelectionEvents } from "./clients/thread-selection-events.js";
 import { ThreadListClient } from "./runtime-clients/thread-list-runtime-client.js";
 import { baseRuntimeAdapterTransformScopes } from "./clients/runtime-adapter.js";
-export { AttachmentRuntimeClient, ComposerClient, MessageClient, MessagePartClient, ThreadClient, ThreadListClient, ThreadListItemClient, baseRuntimeAdapterTransformScopes };
+import { actionBarCopyDisabled, actionBarEditDisabled, actionBarReloadDisabled, branchPickerNextDisabled, branchPickerPreviousDisabled, composerCancelDisabled, composerInputDisabled, composerSendDisabled, suggestionTriggerDisabled } from "./primitive-predicates.js";
+import { isDevelopment } from "./env.js";
+export { AttachmentRuntimeClient, ComposerClient, MessageClient, MessagePartClient, ThreadClient, ThreadListClient, ThreadListItemClient, actionBarCopyDisabled, actionBarEditDisabled, actionBarReloadDisabled, baseRuntimeAdapterTransformScopes, branchPickerNextDisabled, branchPickerPreviousDisabled, composerCancelDisabled, composerInputDisabled, composerSendDisabled, isDevelopment, suggestionTriggerDisabled, useThreadSelectionEvents };