@assistant-ui/core 0.3.18 → 0.3.20

package/dist/runtimes/remote-thread-list/title-generation.d.ts

@@ -1,5 +1,5 @@
 //#region src/runtimes/remote-thread-list/title-generation.d.ts
-type ThreadTitleClaim = {
+export type ThreadTitleClaim = {
   readonly title: string;
   readonly order: number;
   readonly settled: Promise<boolean>;
@@ -14,7 +14,7 @@ type ThreadTitleGeneration = {
   readonly persisted: Promise<string | undefined>;
   readonly settlePersisted: (title: string | undefined) => void;
 };
-type ThreadTitleState = {
+export type ThreadTitleState = {
   generations: Set<ThreadTitleGeneration>;
   pendingClaim: ThreadTitleClaim | null;
   inFlightClaims: Set<ThreadTitleClaim>;
@@ -22,7 +22,7 @@ type ThreadTitleState = {
   latestExplicit: ThreadTitleGeneration | null;
   nextOrder: number;
 };
-type ThreadTitleGenerationRun = {
+export type ThreadTitleGenerationRun = {
   states: Map<string, ThreadTitleState>;
   threadId: string;
   automatic: boolean;
@@ -30,9 +30,9 @@ type ThreadTitleGenerationRun = {
   rename: (title: string) => Promise<void>;
   applyTitle: (title: string | undefined) => Promise<void>;
 };
-declare function startThreadTitleRename(states: Map<string, ThreadTitleState>, threadId: string, title: string): ThreadTitleClaim;
-declare function finishThreadTitleRename(states: Map<string, ThreadTitleState>, threadId: string, claim: ThreadTitleClaim, renamed: boolean): void;
-declare function clearThreadTitleState(states: Map<string, ThreadTitleState>, threadId: string): void;
+export declare function startThreadTitleRename(states: Map<string, ThreadTitleState>, threadId: string, title: string): ThreadTitleClaim;
+export declare function finishThreadTitleRename(states: Map<string, ThreadTitleState>, threadId: string, claim: ThreadTitleClaim, renamed: boolean): void;
+export declare function clearThreadTitleState(states: Map<string, ThreadTitleState>, threadId: string): void;
 /**
  * Runs one title generation under the per-thread rename claims and generation
  * ordering, so the title that wins locally is also the title left on the
@@ -43,7 +43,6 @@ declare function clearThreadTitleState(states: Map<string, ThreadTitleState>, th
  * only after `generate` has resolved. Reasserting mid-stream would race the
  * run's own write and lose the winning title on the server.
  */
-declare function runThreadTitleGeneration({ states, threadId, automatic, generate, rename, applyTitle }: ThreadTitleGenerationRun): Promise<void>;
+export declare function runThreadTitleGeneration({ states, threadId, automatic, generate, rename, applyTitle }: ThreadTitleGenerationRun): Promise<void>;
 //#endregion
-export { ThreadTitleClaim, ThreadTitleGenerationRun, ThreadTitleState, clearThreadTitleState, finishThreadTitleRename, runThreadTitleGeneration, startThreadTitleRename };
 //# sourceMappingURL=title-generation.d.ts.map

package/dist/runtimes/remote-thread-list/title-generation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"title-generation.d.ts","names":[],"sources":["../../../src/runtimes/remote-thread-list/title-generation.ts"],"mappings":";KAAY;WACD;WACA;WACA,SAAS;WACT,SAAS;;KAGf;WACM;WACA;EACT,OAAO;EACP,iCAAiC;EACjC;WACS,WAAW;WACX,kBAAkB;;KAGjB;EACV,aAAa,IAAI;EACjB,cAAc;EACd,gBAAgB,IAAI;EACpB;EACA,gBAAgB;EAChB;;KAGU;EACV,QAAQ,YAAY;EACpB;EACA;EACA,WACE,UAAU,8BAA8B,kBACrC;EACL,SAAS,kBAAkB;EAC3B,aAAa,8BAA8B;;iBAuD7B,uBACd,QAAQ,YAAY,mBACpB,kBACA,gBACC;iBAoBa,wBACd,QAAQ,YAAY,mBACpB,kBACA,OAAO,kBACP;iBA2Bc,sBACd,QAAQ,YAAY,mBACpB;;;;;;;;;;;iBAsDoB,2BACpB,QACA,UACA,WACA,UACA,QACA,cACC,2BAA2B"}
+{"version":3,"file":"title-generation.d.ts","names":[],"sources":["../../../src/runtimes/remote-thread-list/title-generation.ts"],"mappings":";YAAY;WACD;WACA;WACA,SAAS;WACT,SAAS;;KAGf;WACM;WACA;EACT,OAAO;EACP,iCAAiC;EACjC;WACS,WAAW;WACX,kBAAkB;;YAGjB;EACV,aAAa,IAAI;EACjB,cAAc;EACd,gBAAgB,IAAI;EACpB;EACA,gBAAgB;EAChB;;YAGU;EACV,QAAQ,YAAY;EACpB;EACA;EACA,WACE,UAAU,8BAA8B,kBACrC;EACL,SAAS,kBAAkB;EAC3B,aAAa,8BAA8B;;wBAuD7B,uBACd,QAAQ,YAAY,mBACpB,kBACA,gBACC;wBAoBa,wBACd,QAAQ,YAAY,mBACpB,kBACA,OAAO,kBACP;wBA2Bc,sBACd,QAAQ,YAAY,mBACpB;;;;;;;;;;;wBAsDoB,2BACpB,QACA,UACA,WACA,UACA,QACA,cACC,2BAA2B"}

package/dist/runtimes/remote-thread-list/title.d.ts

@@ -1,11 +1,10 @@
 import { AssistantMessageStream } from "assistant-stream";
 //#region src/runtimes/remote-thread-list/title.d.ts
-declare const isTitleSourceMessage: (message: {
+export declare const isTitleSourceMessage: (message: {
   status?: {
     type: string;
   } | undefined;
 }) => boolean;
-declare const applyTitleStream: (stream: Parameters<typeof AssistantMessageStream.fromAssistantStream>[0], onTitle: (title: string | undefined) => Promise<void>) => Promise<void>;
+export declare const applyTitleStream: (stream: Parameters<typeof AssistantMessageStream.fromAssistantStream>[0], onTitle: (title: string | undefined) => Promise<void>) => Promise<void>;
 //#endregion
-export { applyTitleStream, isTitleSourceMessage };
 //# sourceMappingURL=title.d.ts.map

package/dist/runtimes/remote-thread-list/title.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"title.d.ts","names":[],"sources":["../../../src/runtimes/remote-thread-list/title.ts"],"mappings":";;cAEa,uBAAwB;EACnC;IAAW;;;cAGA,mBACX,QAAQ,kBAAkB,uBAAuB,yBACjD,UAAU,8BAA8B,kBAAa"}
+{"version":3,"file":"title.d.ts","names":[],"sources":["../../../src/runtimes/remote-thread-list/title.ts"],"mappings":";;qBAEa,uBAAwB;EACnC;IAAW;;;qBAGA,mBACX,QAAQ,kBAAkB,uBAAuB,yBACjD,UAAU,8BAA8B,kBAAa"}

package/dist/runtimes/remote-thread-list/types.d.ts

@@ -9,12 +9,12 @@ import { AssistantStream } from "assistant-stream";
 type RemoteThreadListProviderProps = {
   children?: any;
 };
-type RemoteThreadListProviderComponent = ((props: RemoteThreadListProviderProps) => any) | (new (props: RemoteThreadListProviderProps) => any);
-type RemoteThreadInitializeResponse = {
+export type RemoteThreadListProviderComponent = ((props: RemoteThreadListProviderProps) => any) | (new (props: RemoteThreadListProviderProps) => any);
+export type RemoteThreadInitializeResponse = {
   remoteId: string;
   externalId?: string | undefined;
 };
-type RemoteThreadMetadata = {
+export type RemoteThreadMetadata = {
   readonly status: "regular" | "archived";
   readonly remoteId: string;
   readonly externalId?: string | undefined;
@@ -22,20 +22,20 @@ type RemoteThreadMetadata = {
   readonly lastMessageAt?: Date | undefined;
   readonly custom?: Record<string, unknown> | undefined;
 };
-type RemoteThreadListResponse = {
+export type RemoteThreadListResponse = {
   threads: RemoteThreadMetadata[];
   nextCursor?: string | undefined;
 };
-type RemoteThreadListPageOptions = {
+export type RemoteThreadListPageOptions = {
   after?: string | undefined;
 };
-type RuntimeAdapters = {
+export type RuntimeAdapters = {
   modelContext?: ModelContextProvider | undefined;
   history?: ThreadHistoryAdapter | undefined;
   attachments?: AttachmentAdapter | undefined;
   feedback?: FeedbackAdapter | undefined;
 };
-type RemoteThreadListAdapter = {
+export type RemoteThreadListAdapter = {
   list(params?: RemoteThreadListPageOptions): Promise<RemoteThreadListResponse>;
   rename(remoteId: string, newTitle: string): Promise<void>;
   updateCustom?(remoteId: string, custom: Record<string, unknown> | undefined): Promise<void>;
@@ -86,7 +86,7 @@ type RemoteThreadListAdapter = {
    */
   unstable_useAdapters?: (() => RuntimeAdapters | null | undefined) | undefined;
 };
-type RemoteThreadListOptions = {
+export type RemoteThreadListOptions = {
   runtimeHook: () => AssistantRuntime;
   /**
    * The adapter reference should remain stable across renders. Replacing it reloads the list and drops cached threads that are not in the replacement page. In-flight mutations from the previous adapter are cancelled.
@@ -127,5 +127,4 @@ type RemoteThreadListOptions = {
   allowNesting?: boolean | undefined;
 };
 //#endregion
-export { RemoteThreadInitializeResponse, RemoteThreadListAdapter, RemoteThreadListOptions, RemoteThreadListPageOptions, RemoteThreadListProviderComponent, RemoteThreadListResponse, RemoteThreadMetadata, RuntimeAdapters };
 //# sourceMappingURL=types.d.ts.map

package/dist/runtimes/remote-thread-list/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/runtimes/remote-thread-list/types.ts"],"mappings":";;;;;;;;KASK;EAAkC;;KAE3B,sCACN,OAAO,+CACH,OAAO;KAGL;EACV;EACA;;KAGU;WACD;WACA;WACA;WACA;WACA,gBAAgB;WAChB,SAAS;;KAGR;EACV,SAAS;EACT;;KAGU;EACV;;KAGU;EACV,eAAe;EACf,UAAU;EACV,cAAc;EACd,WAAW;;KAGD;EACV,KAAK,SAAS,8BAA8B,QAAQ;EAEpD,OAAO,kBAAkB,mBAAmB;EAC5C,cACE,kBACA,QAAQ,sCACP;EACH,QAAQ,mBAAmB;EAC3B,UAAU,mBAAmB;EAC7B,OAAO,mBAAmB;EAC1B,WAAW,mBAAmB,QAAQ;;;;;;;;;EAStC,cACE,kBACA,4BAA4B,kBAC3B,QAAQ;EACX,MAAM,mBAAmB,QAAQ;;;;;;;;;;;;;;;;EAiBjC,oBAAoB;;;;;;;;;;;;;;;;EAiBpB,8BAA8B;;KAGpB;EACV,mBAAmB;;;;EAKnB,SAAS;;;;;;;;EAST;;;;;;EAOA;;;;;;;;;;;;;EAcA,qBAAqB;;;;;;EAOrB"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/runtimes/remote-thread-list/types.ts"],"mappings":";;;;;;;;KASK;EAAkC;;YAE3B,sCACN,OAAO,+CACH,OAAO;YAGL;EACV;EACA;;YAGU;WACD;WACA;WACA;WACA;WACA,gBAAgB;WAChB,SAAS;;YAGR;EACV,SAAS;EACT;;YAGU;EACV;;YAGU;EACV,eAAe;EACf,UAAU;EACV,cAAc;EACd,WAAW;;YAGD;EACV,KAAK,SAAS,8BAA8B,QAAQ;EAEpD,OAAO,kBAAkB,mBAAmB;EAC5C,cACE,kBACA,QAAQ,sCACP;EACH,QAAQ,mBAAmB;EAC3B,UAAU,mBAAmB;EAC7B,OAAO,mBAAmB;EAC1B,WAAW,mBAAmB,QAAQ;;;;;;;;;EAStC,cACE,kBACA,4BAA4B,kBAC3B,QAAQ;EACX,MAAM,mBAAmB,QAAQ;;;;;;;;;;;;;;;;EAiBjC,oBAAoB;;;;;;;;;;;;;;;;EAiBpB,8BAA8B;;YAGpB;EACV,mBAAmB;;;;EAKnB,SAAS;;;;;;;;EAST;;;;;;EAOA;;;;;;;;;;;;;EAcA,qBAAqB;;;;;;EAOrB"}

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

@@ -5,7 +5,7 @@ import { ReadonlyJSONValue } from "assistant-stream/utils";
 /**
  * Streaming execution state for a frontend tool.
  */
-type ToolExecutionStatus = {
+export type ToolExecutionStatus = {
   type: "executing";
 } | {
   type: "interrupt";
@@ -14,7 +14,7 @@ type ToolExecutionStatus = {
     payload: unknown;
   };
 };
-type AddToolResultCommand = {
+export type AddToolResultCommand = {
   readonly type: "add-tool-result";
   readonly toolCallId: string;
   readonly toolName: string;
@@ -45,7 +45,7 @@ type AddToolResultCommand = {
  *
  * @deprecated Internal — for framework bindings; not a public API. May change without notice.
  */
-declare class ToolInvocationTracker {
+export declare class ToolInvocationTracker {
   private readonly _getTools;
   private readonly _callbacks;
   private readonly _isClientToolCall;
@@ -153,7 +153,7 @@ declare class ToolInvocationTracker {
   private _processArgsText;
   private _processMessages;
 }
-declare namespace ToolInvocationTracker {
+export declare namespace ToolInvocationTracker {
   type ExecutionStatus = ToolExecutionStatus;
   type Snapshot = {
     readonly messages: readonly ThreadMessage[];
@@ -181,5 +181,4 @@ declare namespace ToolInvocationTracker {
   };
 }
 //#endregion
-export { AddToolResultCommand, ToolExecutionStatus, ToolInvocationTracker };
 //# sourceMappingURL=ToolInvocationTracker.d.ts.map

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":";;;;;;;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"}
+{"version":3,"file":"ToolInvocationTracker.d.ts","names":[],"sources":["../../../src/runtimes/tool-invocations/ToolInvocationTracker.ts"],"mappings":";;;;;;;YAwBY;EACN;;EAEA;EACA;IAAW;IAAe;;;YAGpB;WACD;WACA;WACA;WACA,QAAQ;WACR;WACA,WAAW;WACX,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;qBA+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;;yBAuFO;OACH,kBAAkB;OAElB;aACD,mBAAmB;;aAEnB;;;;;;aAMA;;OAGC;;;;;IAKV,WAAW,SAAS;;;;;;IAMpB,mBACE,UAAU,oBAAoB"}

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

@@ -487,7 +487,8 @@ var ToolInvocationTracker = class {
 			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;
+				if (entry.hasResult) continue;
+				if (!(content.argsText !== entry.argsText && !(isArgsTextComplete(entry.argsText) && isArgsTextComplete(content.argsText) && isEquivalentCompleteArgsText(entry.argsText, content.argsText))) && content.result === void 0) continue;
 				this._entries.delete(content.toolCallId);
 				entry = void 0;
 			}

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","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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"}
+{"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","argsChanged","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        // A restored entry with a result remains historical.\n        if (entry.hasResult) continue;\n        const argsChanged =\n          content.argsText !== entry.argsText &&\n          !(\n            isArgsTextComplete(entry.argsText) &&\n            isArgsTextComplete(content.argsText) &&\n            isEquivalentCompleteArgsText(entry.argsText, content.argsText)\n          );\n        if (!argsChanged && content.result === undefined) 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/chain-of-thought-client.d.ts

@@ -2,12 +2,11 @@ import { PartMethods } from "../scopes/part.js";
 import { ChainOfThoughtPart } from "../scopes/chain-of-thought.js";
 import { ClientOutput } from "@assistant-ui/store";
 //#region src/store/clients/chain-of-thought-client.d.ts
-declare const ChainOfThoughtClient: import("@assistant-ui/tap").Resource<ClientOutput<"chainOfThought">, [{
+export declare const ChainOfThoughtClient: import("@assistant-ui/tap").Resource<ClientOutput<"chainOfThought">, [{
   parts: readonly ChainOfThoughtPart[];
   getMessagePart: (selector: {
     index: number;
   }) => PartMethods;
 }]>;
 //#endregion
-export { ChainOfThoughtClient };
 //# sourceMappingURL=chain-of-thought-client.d.ts.map

package/dist/store/clients/chain-of-thought-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain-of-thought-client.d.ts","names":[],"sources":["../../../src/store/clients/chain-of-thought-client.ts"],"mappings":";;;;cAmCa,kDAAoB,SAAA;EArBxB,gBAAS;EACA,iBAAC;IAAY;QAAoB"}
+{"version":3,"file":"chain-of-thought-client.d.ts","names":[],"sources":["../../../src/store/clients/chain-of-thought-client.ts"],"mappings":";;;;qBAmCa,kDAAoB,SAAA;EArBxB,gBAAS;EACA,iBAAC;IAAY;QAAoB"}

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

@@ -8,10 +8,10 @@ import { ExternalThreadBranchAdapter } from "../../runtime/branch/external-threa
 import { ReadonlyJSONValue } from "assistant-stream/utils";
 import { ClientOutput } from "@assistant-ui/store";
 //#region src/store/clients/external-thread.d.ts
-type ExternalThreadMessage = ThreadMessage & {
+export type ExternalThreadMessage = ThreadMessage & {
   id: string;
 };
-type ExternalThreadProps = {
+export type ExternalThreadProps = {
   messages: readonly ExternalThreadMessage[];
   isRunning?: boolean;
   isLoading?: boolean | undefined;
@@ -55,7 +55,6 @@ type ExternalThreadProps = {
   /** Callback for tool approval decisions. Absent: responding to an approval throws a capability error. */
   onRespondToToolApproval?: (options: RespondToToolApprovalOptions) => void | Promise<void>;
 };
-declare const ExternalThread: import("@assistant-ui/tap").Resource<ClientOutput<"thread">, [ExternalThreadProps]>;
+export declare const ExternalThread: import("@assistant-ui/tap").Resource<ClientOutput<"thread">, [ExternalThreadProps]>;
 //#endregion
-export { ExternalThread, ExternalThreadMessage, ExternalThreadProps };
 //# sourceMappingURL=external-thread.d.ts.map

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":";;;;;;;;;;KAiEY,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;;cAikCD,4CAAc,SAAA,yBAAA"}
+{"version":3,"file":"external-thread.d.ts","names":[],"sources":["../../../src/store/clients/external-thread.ts"],"mappings":";;;;;;;;;;YAkEY,wBAAwB;EAClC;;YAgBU;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;;qBAumCD,4CAAc,SAAA,yBAAA"}