@assistant-ui/core 0.3.15 → 0.3.17

package/dist/runtimes/tool-invocations/ToolInvocationTracker.d.ts

@@ -1,4 +1,4 @@
-import { ThreadMessage } from "../../types/message.js";
+import { ThreadMessage, ToolCallMessagePart } from "../../types/message.js";
 import { Tool, ToolModelContentPart } from "assistant-stream";
 import { ReadonlyJSONValue } from "assistant-stream/utils";
 //#region src/runtimes/tool-invocations/ToolInvocationTracker.d.ts
@@ -48,9 +48,17 @@ type AddToolResultCommand = {
 declare class ToolInvocationTracker {
   private readonly _getTools;
   private readonly _callbacks;
+  private readonly _isClientToolCall;
   private readonly _entries;
   private readonly _humanInput;
   private readonly _executing;
+  /**
+   * Tool calls whose turn ended before they reached the executor. Held here
+   * rather than on the entry because an entry is rebuilt whenever a snapshot
+   * re-creates the call, and this is the one reason to skip that no later
+   * snapshot carries.
+   */
+  private readonly _discardedToolCallIds;
   private readonly _settledResolvers;
   private _statuses;
   private _ac;
@@ -62,14 +70,16 @@ declare class ToolInvocationTracker {
   /**
    * Set when the assistant-stream pipeline has died (errored out via
    * `.pipeTo(...).catch(...)`). The next `setState` re-initializes the
-   * pipeline and demotes all active entries to restored so they survive
-   * across the restart without re-firing `streamCall` (preserves the
-   * "exactly once" contract). Capped at a single auto-restart per session
-   * — repeated failures keep the tracker dead with a more visible error.
+   * pipeline and demotes each active entry that reached the executor to
+   * restored, so it survives the restart without re-firing `streamCall`.
+   * A restart is an execution boundary like `reset()`: an entry that had
+   * not reached it starts over and fires once there (F.4). Capped at a
+   * single auto-restart per session — repeated failures keep the tracker
+   * dead with a more visible error.
    */
   private _pipelineDead;
   private _pipelineRestartUsed;
-  constructor(getTools: () => Record<string, Tool> | undefined, callbacks: ToolInvocationTracker.Callbacks);
+  constructor(getTools: () => Record<string, Tool> | undefined, callbacks: ToolInvocationTracker.Callbacks, isClientToolCall?: (toolCall: ToolCallMessagePart) => boolean | undefined);
   /**
    * Build the assistant-stream pipeline. Called once from the constructor
    * and at most once again if `_pipelineDead` is set (see F.4 in
@@ -90,8 +100,15 @@ declare class ToolInvocationTracker {
   /**
    * Abort any in-flight `execute()` invocations. Resolves once all of them
    * have settled (or immediately if none are running).
+   *
+   * `discardPending` additionally kills the calls that never reached the
+   * executor, for a caller ending the turn rather than interrupting it. The
+   * signal cannot reach those: they are waiting on the run to settle (A.10),
+   * and the settled snapshot arrives after this installs a fresh controller.
    */
-  abort(): Promise<void>;
+  abort(options?: {
+    discardPending?: boolean;
+  }): Promise<void>;
   /**
    * Resolve a pending human-input request for the given tool call. Returns
    * `true` if a pending request was resumed, `false` if the tracker has no
@@ -116,7 +133,13 @@ declare class ToolInvocationTracker {
   private _invokeOnStatusesChange;
   private _setStatus;
   private _deleteStatus;
-  private _hasExecutableTool;
+  private _warnProviderOwnedSkip;
+  /**
+   * Closing the args stream hands the call to the client executor, so it may
+   * only happen once the provider can no longer speak about that call. The run
+   * ending is the only universal signal for that; an adapter that reports the
+   * call as client-owned has said it earlier, per call.
+   */
   private _shouldCloseArgsStream;
   private _startActiveEntry;
   /**

package/dist/runtimes/tool-invocations/ToolInvocationTracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolInvocationTracker.d.ts","names":[],"sources":["../../../src/runtimes/tool-invocations/ToolInvocationTracker.ts"],"mappings":";;;;;;;KAuBY;EACN;;EAEA;EACA;IAAW;IAAe;;;KAGpB;WACD;WACA;WACA;WACA,QAAQ;WACR;WACA,WAAW;WACX,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;cA8EtB;mBACM;mBACA;mBAEA;mBACA;mBAQA;mBACA;UAET;UAEA;UACA;;UAGA;UACA;UAEA;;;;;;;;;UAUA;UACA;EAGN,YAAA,gBAAgB,eAAe,mBAC/B,WAAW,sBAAsB;;;;;;UAa3B;;;;;EAsDD,SAAS,UAAU,sBAAsB;;;;;;EAmEzC;;;;;EAwBA,SAAS;;;;;;;EAkCT,OAAO,oBAAoB;;;;;;;EAoB3B,eAAe,oBAAoB;UAMlC;UA6CA;UAaA;UAmCA;UAYA;UA0BA;UAiCA;UAWA;UAaA;UAOA;UAUA;UAKA;UAgBA;;;;;;;;UA4BA;UAWA;UA0GA;;kBAiFO;OACH,kBAAkB;OAElB;aACD,mBAAmB;;aAEnB;;;;;;aAMA;;OAGC;;;;;IAKV,WAAW,SAAS;;;;;;IAMpB,mBACE,UAAU,oBAAoB"}
+{"version":3,"file":"ToolInvocationTracker.d.ts","names":[],"sources":["../../../src/runtimes/tool-invocations/ToolInvocationTracker.ts"],"mappings":";;;;;;;KAwBY;EACN;;EAEA;EACA;IAAW;IAAe;;;KAGpB;WACD;WACA;WACA;WACA,QAAQ;WACR;WACA,WAAW;WACX,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;cA+EtB;mBACM;mBACA;mBACA;mBAIA;mBACA;mBAQA;;;;;;;mBAOA;mBACA;UAET;UAEA;UACA;;UAGA;UACA;UAEA;;;;;;;;;;;UAYA;UACA;EAGN,YAAA,gBAAgB,eAAe,mBAC/B,WAAW,sBAAsB,WACjC,oBAAoB,UAAU;;;;;;UAcxB;;;;;EAsDD,SAAS,UAAU,sBAAsB;;;;;;EAmEzC;;;;;;;;;;EA8BA,MAAM;IAAY;MAA6B;;;;;;;EA2C/C,OAAO,oBAAoB;;;;;;;EAoB3B,eAAe,oBAAoB;UAMlC;UA6CA;UAaA;UAmCA;UAcA;UA0BA;UAkCA;UAWA;UAaA;UAOA;UAUA;;;;;;;UAeA;UAcA;;;;;;;;UA8BA;UAqBA;UA0GA;;kBAmFO;OACH,kBAAkB;OAElB;aACD,mBAAmB;;aAEnB;;;;;;aAMA;;OAGC;;;;;IAKV,WAAW,SAAS;;;;;;IAMpB,mBACE,UAAU,oBAAoB"}

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

@@ -1,4 +1,5 @@
 import { isJSONValueEqual } from "../../utils/json/is-json-equal.js";
+import { walkToolCallTree } from "../../runtime/utils/tool-call-tree.js";
 import { ToolResponse, createAssistantStreamController, unstable_toolResultStream } from "assistant-stream";
 import { AssistantMetaTransformStream } from "assistant-stream/utils";
 //#region src/runtimes/tool-invocations/ToolInvocationTracker.ts
@@ -50,9 +51,17 @@ const getToolExecutionId = (value) => value[TOOL_EXECUTION_ID];
 var ToolInvocationTracker = class {
 	_getTools;
 	_callbacks;
+	_isClientToolCall;
 	_entries = /* @__PURE__ */ new Map();
 	_humanInput = /* @__PURE__ */ new Map();
 	_executing = /* @__PURE__ */ new Set();
+	/**
+	* Tool calls whose turn ended before they reached the executor. Held here
+	* rather than on the entry because an entry is rebuilt whenever a snapshot
+	* re-creates the call, and this is the one reason to skip that no later
+	* snapshot carries.
+	*/
+	_discardedToolCallIds = /* @__PURE__ */ new Set();
 	_settledResolvers = [];
 	_statuses = /* @__PURE__ */ new Map();
 	_ac = new AbortController();
@@ -64,16 +73,19 @@ var ToolInvocationTracker = class {
 	/**
 	* Set when the assistant-stream pipeline has died (errored out via
 	* `.pipeTo(...).catch(...)`). The next `setState` re-initializes the
-	* pipeline and demotes all active entries to restored so they survive
-	* across the restart without re-firing `streamCall` (preserves the
-	* "exactly once" contract). Capped at a single auto-restart per session
-	* — repeated failures keep the tracker dead with a more visible error.
+	* pipeline and demotes each active entry that reached the executor to
+	* restored, so it survives the restart without re-firing `streamCall`.
+	* A restart is an execution boundary like `reset()`: an entry that had
+	* not reached it starts over and fires once there (F.4). Capped at a
+	* single auto-restart per session — repeated failures keep the tracker
+	* dead with a more visible error.
 	*/
 	_pipelineDead = false;
 	_pipelineRestartUsed = false;
-	constructor(getTools, callbacks) {
+	constructor(getTools, callbacks, isClientToolCall) {
 		this._getTools = getTools;
 		this._callbacks = callbacks;
+		this._isClientToolCall = isClientToolCall;
 		this._initPipeline();
 	}
 	/**
@@ -141,6 +153,7 @@ var ToolInvocationTracker = class {
 		try {
 			this._pendingRestore = true;
 			this._entries.clear();
+			this._discardedToolCallIds.clear();
 			this._lastSnapshot = null;
 			this.abort();
 			if (this._statuses.size > 0) {
@@ -154,8 +167,13 @@ var ToolInvocationTracker = class {
 	/**
 	* Abort any in-flight `execute()` invocations. Resolves once all of them
 	* have settled (or immediately if none are running).
+	*
+	* `discardPending` additionally kills the calls that never reached the
+	* executor, for a caller ending the turn rather than interrupting it. The
+	* signal cannot reach those: they are waiting on the run to settle (A.10),
+	* and the settled snapshot arrives after this installs a fresh controller.
 	*/
-	abort() {
+	abort(options) {
 		try {
 			this._humanInput.forEach(({ reject }) => {
 				try {
@@ -163,6 +181,12 @@ var ToolInvocationTracker = class {
 				} catch {}
 			});
 			this._humanInput.clear();
+			if (options?.discardPending) for (const [toolCallId, entry] of this._entries) {
+				if (!entry.controller) continue;
+				if (entry.argsComplete || entry.hasResult) continue;
+				this._discardedToolCallIds.add(toolCallId);
+				entry.skipExecute = true;
+			}
 			this._ac.abort();
 			this._ac = new AbortController();
 			if (this._executing.size === 0) return Promise.resolve();
@@ -265,6 +289,7 @@ var ToolInvocationTracker = class {
 		if (!this._captureExecution(toolCallId, executionId)) return;
 		if (this._entries.get(toolCallId).skipExecute) return;
 		this._executing.add(executionId);
+		if (this._humanInput.get(toolCallId)?.executionId === executionId) return;
 		this._setStatus(toolCallId, { type: "executing" });
 	}
 	_onExecutionEnd(toolCallId, executionId) {
@@ -292,6 +317,7 @@ var ToolInvocationTracker = class {
 		const entry = this._entries.get(toolCallId);
 		if (!entry || entry.executionId !== executionId) return;
 		if (entry?.hasResult) return;
+		if (entry.skipExecute) return;
 		this._invokeOnResult({
 			type: "add-tool-result",
 			toolCallId,
@@ -329,16 +355,26 @@ var ToolInvocationTracker = class {
 		this._statuses = next;
 		this._invokeOnStatusesChange();
 	}
-	_hasExecutableTool(toolName) {
-		const tool = this._getTools()?.[toolName];
-		return tool?.execute !== void 0 || tool?.streamCall !== void 0;
+	_warnProviderOwnedSkip(toolName, toolCallId) {
+		if (process.env.NODE_ENV === "production") return;
+		if (this._getTools()?.[toolName]?.execute === void 0) return;
+		console.warn("[ToolInvocationTracker] the runtime reports this tool call as provider-owned, so the registered execute is skipped; the provider has to hand the call to the client for it to run (see EDGE_CASES.md A.9)", {
+			toolCallId,
+			toolName
+		});
 	}
-	_shouldCloseArgsStream({ toolName, argsText, hasResult }) {
+	/**
+	* Closing the args stream hands the call to the client executor, so it may
+	* only happen once the provider can no longer speak about that call. The run
+	* ending is the only universal signal for that; an adapter that reports the
+	* call as client-owned has said it earlier, per call.
+	*/
+	_shouldCloseArgsStream({ argsText, hasResult, clientOwned }) {
 		if (hasResult) return true;
-		if (!this._hasExecutableTool(toolName)) return !this._isRunning && isArgsTextComplete(argsText);
-		return isArgsTextComplete(argsText);
+		if (!isArgsTextComplete(argsText)) return false;
+		return clientOwned || !this._isRunning;
 	}
-	_startActiveEntry(toolCallId, toolName, skipExecute) {
+	_startActiveEntry(toolCallId, toolName, skipExecute, clientOwned) {
 		const entry = {
 			toolName,
 			controller: this._controller.addToolCallPart({
@@ -348,7 +384,8 @@ var ToolInvocationTracker = class {
 			argsText: "",
 			hasResult: false,
 			skipExecute,
-			argsComplete: false
+			argsComplete: false,
+			clientOwned
 		};
 		this._entries.set(toolCallId, entry);
 		return entry;
@@ -363,6 +400,10 @@ var ToolInvocationTracker = class {
 	_demoteEntriesToRestored() {
 		for (const [toolCallId, entry] of this._entries) {
 			if (!entry.controller) continue;
+			if (!entry.argsComplete && !entry.hasResult) {
+				this._entries.delete(toolCallId);
+				continue;
+			}
 			this._entries.set(toolCallId, {
 				toolName: entry.toolName,
 				argsText: entry.argsText,
@@ -390,9 +431,9 @@ var ToolInvocationTracker = class {
 			} else if (!content.argsText.startsWith(entry.argsText)) {
 				if (isArgsTextComplete(entry.argsText) && isArgsTextComplete(content.argsText) && isEquivalentCompleteArgsText(entry.argsText, content.argsText)) {
 					const shouldClose = this._shouldCloseArgsStream({
-						toolName: content.toolName,
 						argsText: content.argsText,
-						hasResult
+						hasResult,
+						clientOwned: entry.clientOwned
 					});
 					if (shouldClose) entry.controller.argsText.close();
 					entry.argsText = content.argsText;
@@ -411,9 +452,9 @@ var ToolInvocationTracker = class {
 				const delta = content.argsText.slice(entry.argsText.length);
 				entry.controller.argsText.append(delta);
 				const shouldClose = this._shouldCloseArgsStream({
-					toolName: content.toolName,
 					argsText: content.argsText,
-					hasResult
+					hasResult,
+					clientOwned: entry.clientOwned
 				});
 				if (shouldClose) entry.controller.argsText.close();
 				entry.argsText = content.argsText;
@@ -422,9 +463,9 @@ var ToolInvocationTracker = class {
 		}
 		if (!entry.argsComplete && entry.controller) {
 			if (this._shouldCloseArgsStream({
-				toolName: content.toolName,
 				argsText: entry.argsText,
-				hasResult
+				hasResult,
+				clientOwned: entry.clientOwned
 			})) {
 				entry.controller.argsText.close();
 				entry.argsComplete = true;
@@ -433,45 +474,43 @@ var ToolInvocationTracker = class {
 	}
 	_processMessages(messages) {
 		const isRestore = this._pendingRestore;
-		for (const message of messages) {
-			if (!message || !Array.isArray(message.content)) continue;
-			for (const content of message.content) {
-				if (!content || content.type !== "tool-call") continue;
-				const existing = this._entries.get(content.toolCallId);
-				if (isRestore) {
-					if (!existing?.controller) this._entries.set(content.toolCallId, {
-						toolName: content.toolName,
-						argsText: content.argsText,
-						hasResult: content.result !== void 0
-					});
-					if (content.messages) this._processMessages(content.messages);
-					continue;
-				}
-				let entry = existing;
-				if (entry && !entry.controller) {
-					if (!(content.argsText !== entry.argsText || content.result !== void 0 !== entry.hasResult)) {
-						if (content.messages) this._processMessages(content.messages);
-						continue;
-					}
-					this._entries.delete(content.toolCallId);
-					entry = void 0;
-				}
-				if (!entry) entry = this._startActiveEntry(content.toolCallId, content.toolName, content.result !== void 0);
-				this._processArgsText(entry, content);
-				if (content.result !== void 0 && !entry.hasResult) {
-					const { controller: activeController } = entry;
-					if (!activeController) continue;
-					entry.hasResult = true;
-					entry.argsComplete = true;
-					activeController.setResponse(new ToolResponse({
-						result: content.result,
-						artifact: content.artifact,
-						isError: content.isError,
-						...content.modelContent !== void 0 ? { modelContent: content.modelContent } : {}
-					}));
-					activeController.close();
-				}
-				if (content.messages) this._processMessages(content.messages);
+		for (const { part: content } of walkToolCallTree(messages)) {
+			const existing = this._entries.get(content.toolCallId);
+			if (isRestore) {
+				if (!existing?.controller) this._entries.set(content.toolCallId, {
+					toolName: content.toolName,
+					argsText: content.argsText,
+					hasResult: content.result !== void 0
+				});
+				continue;
+			}
+			let entry = existing;
+			if (content.result !== void 0) this._discardedToolCallIds.delete(content.toolCallId);
+			if (entry && !entry.controller) {
+				if (!(content.argsText !== entry.argsText || content.result !== void 0 !== entry.hasResult)) continue;
+				this._entries.delete(content.toolCallId);
+				entry = void 0;
+			}
+			if (!entry) {
+				const ownership = this._isClientToolCall?.(content);
+				const providerOwned = content.result === void 0 && ownership === false;
+				if (providerOwned) this._warnProviderOwnedSkip(content.toolName, content.toolCallId);
+				entry = this._startActiveEntry(content.toolCallId, content.toolName, content.result !== void 0 || providerOwned || this._discardedToolCallIds.has(content.toolCallId), ownership === true);
+			}
+			if (content.approval !== void 0) entry.skipExecute = true;
+			this._processArgsText(entry, content);
+			if (content.result !== void 0 && !entry.hasResult) {
+				const { controller: activeController } = entry;
+				if (!activeController) continue;
+				entry.hasResult = true;
+				entry.argsComplete = true;
+				activeController.setResponse(new ToolResponse({
+					result: content.result,
+					artifact: content.artifact,
+					isError: content.isError,
+					...content.modelContent !== void 0 ? { modelContent: content.modelContent } : {}
+				}));
+				activeController.close();
 			}
 		}
 	}

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","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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"}
+{"version":3,"file":"ToolInvocationTracker.js","names":["process","env","NODE_ENV","createAssistantStreamController","ToolCallStreamController","ToolResponse","unstable_toolResultStream","Tool","ToolModelContentPart","ToolResultStreamOptions","AssistantMetaTransformStream","ReadonlyJSONValue","isJSONValueEqual","ThreadMessage","ToolCallMessagePart","walkToolCallTree","TOOL_EXECUTION_ID","Symbol","for","ToolExecutionStatus","type","payload","AddToolResultCommand","toolCallId","toolName","result","isError","artifact","modelContent","ToolCallEntry","argsText","hasResult","executionId","skipExecute","controller","argsComplete","clientOwned","SettledResolver","executionIds","ReadonlySet","resolve","isArgsTextComplete","JSON","parse","parseArgsText","undefined","isEquivalentCompleteArgsText","previous","next","previousValue","nextValue","getToolExecutionId","value","Record","PropertyKey","ToolInvocationTracker","_getTools","_callbacks","Callbacks","_isClientToolCall","toolCall","_entries","Map","_humanInput","reject","reason","_executing","Set","_discardedToolCallIds","_settledResolvers","_statuses","_ac","AbortController","_pendingRestore","_lastSnapshot","Snapshot","_isRunning","_controller","ReturnType","_pipelineDead","_pipelineRestartUsed","constructor","getTools","callbacks","isClientToolCall","_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","options","discardPending","Promise","forEach","Error","entry","add","push","resume","handlers","get","delete","_setStatus","getStatuses","ReadonlyMap","tools","Object","fromEntries","entries","map","name","tool","execute","streamCall","wrappedTool","args","context","Parameters","_captureExecution","reader","set","_deleteStatus","pending","some","has","length","meta","_invokeOnResult","command","onResult","onStatusesChange","status","_warnProviderOwnedSkip","warn","_shouldCloseArgsStream","_startActiveEntry","toolCallController","addToolCallPart","_processArgsText","content","shouldWriteArgsText","startsWith","shouldClose","close","delta","slice","append","isRestore","part","existing","signatureChanged","ownership","providerOwned","approval","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, ToolCallMessagePart } from \"../../types/message\";\nimport { walkToolCallTree } from \"../../runtime/utils/tool-call-tree\";\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      clientOwned: 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  private readonly _isClientToolCall:\n    | ((toolCall: ToolCallMessagePart) => boolean | undefined)\n    | undefined;\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  /**\n   * Tool calls whose turn ended before they reached the executor. Held here\n   * rather than on the entry because an entry is rebuilt whenever a snapshot\n   * re-creates the call, and this is the one reason to skip that no later\n   * snapshot carries.\n   */\n  private readonly _discardedToolCallIds = new Set<string>();\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 each active entry that reached the executor to\n   * restored, so it survives the restart without re-firing `streamCall`.\n   * A restart is an execution boundary like `reset()`: an entry that had\n   * not reached it starts over and fires once there (F.4). Capped at a\n   * single auto-restart per session — repeated failures keep the tracker\n   * 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    isClientToolCall?: (toolCall: ToolCallMessagePart) => boolean | undefined,\n  ) {\n    this._getTools = getTools;\n    this._callbacks = callbacks;\n    this._isClientToolCall = isClientToolCall;\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. Entries\n      // that reached the executor are demoted to \"restored\" so the rebuilt\n      // pipeline does not re-fire `streamCall` for them; the rest start over\n      // across the boundary the restart opens (F.4).\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._discardedToolCallIds.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   * `discardPending` additionally kills the calls that never reached the\n   * executor, for a caller ending the turn rather than interrupting it. The\n   * signal cannot reach those: they are waiting on the run to settle (A.10),\n   * and the settled snapshot arrives after this installs a fresh controller.\n   */\n  public abort(options?: { discardPending?: boolean }): 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      if (options?.discardPending) {\n        for (const [toolCallId, entry] of this._entries) {\n          if (!entry.controller) continue;\n          if (entry.argsComplete || entry.hasResult) continue;\n          this._discardedToolCallIds.add(toolCallId);\n          entry.skipExecute = true;\n        }\n      }\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    // execute can park human() before onExecutionStart; preserve this execution's interrupt.\n    if (this._humanInput.get(toolCallId)?.executionId === executionId) return;\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    if (entry.skipExecute) 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 _warnProviderOwnedSkip(toolName: string, toolCallId: string): void {\n    if (process.env.NODE_ENV === \"production\") return;\n    if (this._getTools()?.[toolName]?.execute === undefined) return;\n    console.warn(\n      \"[ToolInvocationTracker] the runtime reports this tool call as provider-owned, so the registered execute is skipped; the provider has to hand the call to the client for it to run (see EDGE_CASES.md A.9)\",\n      { toolCallId, toolName },\n    );\n  }\n\n  /**\n   * Closing the args stream hands the call to the client executor, so it may\n   * only happen once the provider can no longer speak about that call. The run\n   * ending is the only universal signal for that; an adapter that reports the\n   * call as client-owned has said it earlier, per call.\n   */\n  private _shouldCloseArgsStream({\n    argsText,\n    hasResult,\n    clientOwned,\n  }: {\n    argsText: string;\n    hasResult: boolean;\n    clientOwned: boolean;\n  }): boolean {\n    if (hasResult) return true;\n    if (!isArgsTextComplete(argsText)) return false;\n    return clientOwned || !this._isRunning;\n  }\n\n  private _startActiveEntry(\n    toolCallId: string,\n    toolName: string,\n    skipExecute: boolean,\n    clientOwned: 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      clientOwned,\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      if (!entry.argsComplete && !entry.hasResult) {\n        // The call never reached the executor. A restored entry is promoted\n        // only when its signature changes, and a call waiting on the run to\n        // settle already holds its final args, so demoting it would strand it\n        // unexecuted. Dropping it lets the next snapshot start it over; a call\n        // whose turn was discarded is held by `_discardedToolCallIds`, not by\n        // the entry, so starting over does not revive it.\n        this._entries.delete(toolCallId);\n        continue;\n      }\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            argsText: content.argsText,\n            hasResult,\n            clientOwned: entry.clientOwned,\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          argsText: content.argsText,\n          hasResult,\n          clientOwned: entry.clientOwned,\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        argsText: entry.argsText,\n        hasResult,\n        clientOwned: entry.clientOwned,\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 { part: content } of walkToolCallTree(messages)) {\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        continue;\n      }\n\n      // Live snapshot.\n      let entry = existing;\n\n      // A discarded id is remembered only until the call is answered, which\n      // bounds the set to the open calls of a discarded turn.\n      if (content.result !== undefined)\n        this._discardedToolCallIds.delete(content.toolCallId);\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) continue;\n        this._entries.delete(content.toolCallId);\n        entry = undefined;\n      }\n\n      if (!entry) {\n        const ownership = this._isClientToolCall?.(content);\n        const providerOwned =\n          content.result === undefined && ownership === false;\n        if (providerOwned)\n          this._warnProviderOwnedSkip(content.toolName, content.toolCallId);\n        entry = this._startActiveEntry(\n          content.toolCallId,\n          content.toolName,\n          content.result !== undefined ||\n            providerOwned ||\n            this._discardedToolCallIds.has(content.toolCallId),\n          ownership === true,\n        );\n      }\n\n      if (content.approval !== undefined) entry.skipExecute = true;\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  }\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/external-thread.d.ts

@@ -53,7 +53,7 @@ type ExternalThreadProps = {
   /** Branch adapter for runtimes that track sibling variants of messages. */
   branches?: ExternalThreadBranchAdapter;
   /** Callback for tool approval decisions. Absent: responding to an approval throws a capability error. */
-  onRespondToToolApproval?: (options: RespondToToolApprovalOptions) => void;
+  onRespondToToolApproval?: (options: RespondToToolApprovalOptions) => void | Promise<void>;
 };
 declare const ExternalThread: import("@assistant-ui/tap").Resource<ClientOutput<"thread">, [ExternalThreadProps]>;
 //#endregion

package/dist/store/clients/external-thread.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"external-thread.d.ts","names":[],"sources":["../../../src/store/clients/external-thread.ts"],"mappings":";;;;;;;;;;KAyDY,wBAAwB;EAClC;;KAgBU;EACV,mBAAmB;EACnB;EACA;EACA,QAAQ;EACR;;;;;;;EAOA;;;;;EAKA,SAAS,SAAS;EAClB,UAAU,SAAS;EACnB,YAAY;EACZ;EACA;EACA;;;;;;;EAOA,yBAAyB;EACzB,oBAAoB,SAAS;;EAE7B,qBAAqB,SAAS;EAC9B,wBAAwB;EACxB,oBAAoB;EACpB,kBAAkB;EAClB,gBAAgB;;EAEhB,QAAQ;;EAER,WAAW;;EAEX,2BAA2B,SAAS;;cAqkCzB,4CAAc,SAAA,yBAAA"}
+{"version":3,"file":"external-thread.d.ts","names":[],"sources":["../../../src/store/clients/external-thread.ts"],"mappings":";;;;;;;;;;KA8DY,wBAAwB;EAClC;;KAgBU;EACV,mBAAmB;EACnB;EACA;EACA,QAAQ;EACR;;;;;;;EAOA;;;;;EAKA,SAAS,SAAS;EAClB,UAAU,SAAS;EACnB,YAAY;EACZ;EACA;EACA;;;;;;;EAOA,yBAAyB;EACzB,oBAAoB,SAAS;;EAE7B,qBAAqB,SAAS;EAC9B,wBAAwB;EACxB,oBAAoB;EACpB,kBAAkB;EAClB,gBAAgB;;EAEhB,QAAQ;;EAER,WAAW;;EAEX,2BACE,SAAS,wCACC;;cAuhCD,4CAAc,SAAA,yBAAA"}