@assistant-ui/core 0.2.6 → 0.2.8

package/src/tests/groupParts.test.ts

@@ -160,6 +160,76 @@ describe("groupPartByType", () => {
     expect(fn(notMcp)).toEqual(["group-tool"]);
   });
 
+  const standaloneContext = (...names: string[]) => ({
+    toolUIs: Object.fromEntries(
+      names.map((name) => [name, [{ render: () => null, standalone: true }]]),
+    ),
+  });
+
+  it("routes context-standalone tool calls through the 'standalone-tool-call' entry", () => {
+    const fn = groupPartByType({
+      "tool-call": ["group-tool"],
+      "standalone-tool-call": [],
+    });
+    const standalone = part({
+      type: "tool-call",
+      toolName: "ask_user",
+    } as Partial<PartState>);
+    const regular = part({
+      type: "tool-call",
+      toolName: "search",
+    } as Partial<PartState>);
+    expect(fn(standalone, standaloneContext("ask_user"))).toEqual([]);
+    expect(fn(regular, standaloneContext("ask_user"))).toEqual(["group-tool"]);
+    // No context → not standalone, falls through to "tool-call".
+    expect(fn(standalone)).toEqual(["group-tool"]);
+    // Registered but not standalone → also falls through to "tool-call".
+    const inlineCtx = {
+      toolUIs: { ask_user: [{ render: () => null, standalone: false }] },
+    };
+    expect(fn(standalone, inlineCtx)).toEqual(["group-tool"]);
+  });
+
+  it("routes MCP-app parts through 'standalone-tool-call' from the part alone", () => {
+    const fn = groupPartByType({
+      "tool-call": ["group-tool"],
+      "standalone-tool-call": [],
+    });
+    const mcpApp = part({
+      type: "tool-call",
+      toolName: "render",
+      mcp: { app: { resourceUri: "ui://my-app" } },
+    } as Partial<PartState>);
+    expect(fn(mcpApp)).toEqual([]);
+  });
+
+  it("routes MCP-app parts through the deprecated 'mcp-app' entry", () => {
+    const fn = groupPartByType({
+      "tool-call": ["group-tool"],
+      "mcp-app": ["group-mcp"],
+    });
+    const mcpApp = part({
+      type: "tool-call",
+      toolName: "render",
+      mcp: { app: { resourceUri: "ui://my-app" } },
+    } as Partial<PartState>);
+    expect(fn(mcpApp)).toEqual(["group-mcp"]);
+  });
+
+  it("prefers 'standalone-tool-call' over the deprecated 'mcp-app' entry", () => {
+    const fn = groupPartByType({
+      "tool-call": ["group-tool"],
+      "standalone-tool-call": ["group-standalone"],
+      "mcp-app": ["group-mcp"],
+    });
+    const mcpApp = part({
+      type: "tool-call",
+      toolName: "render",
+      mcp: { app: { resourceUri: "ui://x" } },
+    } as Partial<PartState>);
+    expect(fn(mcpApp)).toEqual(["group-standalone"]);
+  });
+
   it("tags the function with a GROUPBY_MEMO_KEY fingerprint", () => {
     const fn = groupPartByType({ reasoning: ["group-r"] });
     const memoKey = (fn as unknown as { [GROUPBY_MEMO_KEY]: string })[

package/src/tests/no-unsafe-process-env.test.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { describe, expect, it } from "vitest";
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { resolve, relative, join } from "node:path";

package/src/tests/remote-thread-list-isLoading.test.ts

@@ -26,6 +26,8 @@ type ListResult = {
 
 const INITIAL_STATE: RemoteThreadState = {
   isLoading: true,
+  isLoadingMore: false,
+  cursor: undefined,
   newThreadId: undefined,
   threadIds: [],
   archivedThreadIds: [],
@@ -84,7 +86,6 @@ describe("RemoteThreadList isLoading lifecycle", () => {
     state.optimisticUpdate({
       execute: () => d.promise,
       loading: (s) => ({ ...s, isLoading: true }),
-      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -98,7 +99,6 @@ describe("RemoteThreadList isLoading lifecycle", () => {
     const promise = state.optimisticUpdate({
       execute: () => d.promise,
       loading: (s) => ({ ...s, isLoading: true }),
-      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -115,7 +115,6 @@ describe("RemoteThreadList isLoading lifecycle", () => {
     const promise = state.optimisticUpdate({
       execute: () => d.promise,
       loading: (s) => ({ ...s, isLoading: true }),
-      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -140,7 +139,6 @@ describe("RemoteThreadList isLoading lifecycle", () => {
     const promise = state.optimisticUpdate({
       execute: () => d.promise,
       loading: (s) => ({ ...s, isLoading: true }),
-      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -164,7 +162,6 @@ describe("RemoteThreadList isLoading error path", () => {
       .optimisticUpdate({
         execute: () => d.promise,
         loading: (s) => ({ ...s, isLoading: true }),
-        // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
         then: applyListResult,
       })
       .catch(() => {

package/src/tests/thread-message-like.test.ts

@@ -2,7 +2,10 @@ import { describe, expect, it } from "vitest";
 import { fromThreadMessageLike } from "../runtime/utils/thread-message-like";
 
 const fallbackId = "test-id";
-const fallbackStatus = { type: "complete" as const };
+const fallbackStatus = {
+  type: "complete" as const,
+  reason: "stop" as const,
+};
 
 describe("fromThreadMessageLike", () => {
   describe("data-* prefixed types", () => {

package/src/types/index.ts

@@ -49,7 +49,4 @@ export type {
   Unstable_DirectiveFormatter,
 } from "./directive";
 
-export type {
-  Unstable_TriggerItem,
-  Unstable_TriggerCategory,
-} from "./trigger";
+export type { Unstable_TriggerItem, Unstable_TriggerCategory } from "./trigger";

package/src/types/message.ts

@@ -314,6 +314,11 @@ export type ThreadAssistantMessage = MessageCommonProps & {
     readonly steps: readonly ThreadStep[];
     readonly submittedFeedback?: { readonly type: "positive" | "negative" };
     readonly timing?: MessageTiming;
+    /**
+     * Marks a client-side optimistic placeholder. Such messages are evicted
+     * once off the head branch and are never persisted.
+     */
+    readonly isOptimistic?: boolean;
     readonly custom: Record<string, unknown>;
   };
 };
@@ -327,6 +332,7 @@ type BaseThreadMessage = {
     readonly steps?: readonly ThreadStep[];
     readonly submittedFeedback?: { readonly type: "positive" | "negative" };
     readonly timing?: MessageTiming;
+    readonly isOptimistic?: boolean;
     readonly custom: Record<string, unknown>;
   };
   readonly attachments?: ThreadUserMessage["attachments"];

package/src/utils/id.ts

@@ -5,10 +5,6 @@ export const generateId = customAlphabet(
   7,
 );
 
-const optimisticPrefix = "__optimistic__";
-export const generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
-export const isOptimisticId = (id: string) => id.startsWith(optimisticPrefix);
-
 const errorPrefix = "__error__";
 export const generateErrorMessageId = () => `${errorPrefix}${generateId()}`;
 export const isErrorMessageId = (id: string) => id.startsWith(errorPrefix);

package/dist/react/runtimes/useToolInvocations.d.ts

@@ -1,53 +0,0 @@
-import { ThreadMessage } from "../../types/message.js";
-import { Tool, ToolModelContentPart } from "assistant-stream";
-import { ReadonlyJSONValue } from "assistant-stream/utils";
-
-//#region src/react/runtimes/useToolInvocations.d.ts
-type AssistantTransportState = {
-  readonly messages: readonly ThreadMessage[];
-  readonly state?: ReadonlyJSONValue;
-  readonly isRunning: boolean;
-};
-type AddToolResultCommand = {
-  readonly type: "add-tool-result";
-  readonly toolCallId: string;
-  readonly toolName: string;
-  readonly result: ReadonlyJSONValue;
-  readonly isError: boolean;
-  readonly artifact?: ReadonlyJSONValue;
-  readonly modelContent?: readonly ToolModelContentPart[];
-};
-type UseToolInvocationsParams = {
-  state: AssistantTransportState;
-  getTools: () => Record<string, Tool> | undefined;
-  onResult: (command: AddToolResultCommand) => void;
-  setToolStatuses: (updater: Record<string, ToolExecutionStatus> | ((prev: Record<string, ToolExecutionStatus>) => Record<string, ToolExecutionStatus>)) => void;
-};
-/**
- * Streaming execution state for a frontend tool.
- *
- * Custom runtime integrations use this to mirror in-flight tool calls while
- * `useToolInvocations` executes tools in the browser.
- */
-type ToolExecutionStatus = {
-  /** The tool's execute function is currently running. */type: "executing";
-} | {
-  /** The tool is waiting for a human input payload before continuing. */type: "interrupt"; /** Human input request emitted by the tool execution context. */
-  payload: {
-    type: "human";
-    payload: unknown;
-  };
-};
-declare function useToolInvocations({
-  state,
-  getTools,
-  onResult,
-  setToolStatuses
-}: UseToolInvocationsParams): {
-  reset: () => void;
-  abort: () => Promise<void>;
-  resume: (toolCallId: string, payload: unknown) => void;
-};
-//#endregion
-export { AddToolResultCommand, AssistantTransportState, ToolExecutionStatus, useToolInvocations };
-//# sourceMappingURL=useToolInvocations.d.ts.map

package/dist/react/runtimes/useToolInvocations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useToolInvocations.d.ts","names":[],"sources":["../../../src/react/runtimes/useToolInvocations.ts"],"mappings":";;;;;KAkBY,uBAAA;EAAA,SACD,QAAA,WAAmB,aAAA;EAAA,SACnB,KAAA,GAAQ,iBAAiB;EAAA,SACzB,SAAA;AAAA;AAAA,KAGC,oBAAA;EAAA,SACD,IAAA;EAAA,SACA,UAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA,EAAQ,iBAAA;EAAA,SACR,OAAA;EAAA,SACA,QAAA,GAAW,iBAAA;EAAA,SACX,YAAA,YAAwB,oBAAA;AAAA;AAAA,KA2B9B,wBAAA;EACH,KAAA,EAAO,uBAAA;EACP,QAAA,QAAgB,MAAA,SAAe,IAAA;EAC/B,QAAA,GAAW,OAAA,EAAS,oBAAA;EACpB,eAAA,GACE,OAAA,EACI,MAAA,SAAe,mBAAA,MAEb,IAAA,EAAM,MAAA,SAAe,mBAAA,MAClB,MAAA,SAAe,mBAAA;AAAA;;;;;;;KAUhB,mBAAA;EA/CD,wDAkDL,IAAA;AAAA;EAjD6B,uEAqD7B,IAAA,eArDiD;EAuDjD,OAAA;IAAW,IAAA;IAAe,OAAA;EAAA;AAAA;AAAA,iBAyChB,kBAAA,CAAA;EACd,KAAA;EACA,QAAA;EACA,QAAA;EACA;AAAA,GACC,wBAAA;;eA+fiB,OAAA;+BAkCW,OAAA;AAAA"}

package/dist/react/runtimes/useToolInvocations.js

@@ -1,380 +0,0 @@
-import { isJSONValueEqual } from "../../utils/json/is-json-equal.js";
-import { ToolResponse, createAssistantStreamController, unstable_toolResultStream } from "assistant-stream";
-import { AssistantMetaTransformStream } from "assistant-stream/utils";
-import { useEffect, useRef, useState } from "react";
-//#region src/react/runtimes/useToolInvocations.ts
-const isArgsTextComplete = (argsText) => {
-	try {
-		JSON.parse(argsText);
-		return true;
-	} catch {
-		return false;
-	}
-};
-const parseArgsText = (argsText) => {
-	try {
-		return JSON.parse(argsText);
-	} catch {
-		return;
-	}
-};
-const isEquivalentCompleteArgsText = (previous, next) => {
-	const previousValue = parseArgsText(previous);
-	const nextValue = parseArgsText(next);
-	if (previousValue === void 0 || nextValue === void 0) return false;
-	return isJSONValueEqual(previousValue, nextValue);
-};
-function useToolInvocations({ state, getTools, onResult, setToolStatuses }) {
-	/**
-	* Single source of truth for per-tool-call lifecycle. Keyed by *logical*
-	* toolCallId (the id the host knows). Restored entries have no controller;
-	* active entries carry their stream id and rewrite/execution bookkeeping.
-	*/
-	const entriesRef = useRef(/* @__PURE__ */ new Map());
-	/**
-	* Reverse alias map populated only when a rewrite assigns a synthetic stream
-	* id to an entry. Identity mappings are implicit via the fallback in
-	* `getLogicalToolCallId`.
-	*/
-	const streamToLogicalRef = useRef(/* @__PURE__ */ new Map());
-	/**
-	* Stream ids whose `result` chunks must be dropped before reaching `onResult`.
-	* Populated when:
-	*   - an argsText rewrite supersedes a stream (the old stream's result, if
-	*     any, is no longer authoritative)
-	*   - `reset()` is called while a pre-resolved tool call has a never-settling
-	*     Promise pending in the executor — the eventual cancellation chunk
-	*     would otherwise be forwarded to a host that has already moved on.
-	*/
-	const abandonedStreamIdsRef = useRef(/* @__PURE__ */ new Set());
-	/**
-	* Stream ids whose `execute` should be short-circuited in the tool wrapper.
-	* Tracked by physical stream id (not logical id) so cleanup is keyed off
-	* the same id the wrapper sees in its context.
-	*/
-	const skipExecuteStreamIdsRef = useRef(/* @__PURE__ */ new Set());
-	const humanInputRef = useRef(/* @__PURE__ */ new Map());
-	/**
-	* In-flight `execute` invocations keyed by physical stream id. Lives outside
-	* `entriesRef` so `reset()` can drop tool-call state without orphaning the
-	* cleanup the cancellation `onExecutionEnd` still needs.
-	*/
-	const executingRef = useRef(/* @__PURE__ */ new Map());
-	const acRef = useRef(new AbortController());
-	const executingCountRef = useRef(0);
-	const settledResolversRef = useRef([]);
-	const rewriteCounterRef = useRef(0);
-	/**
-	* `true` until the first snapshot has been processed; `reset()` flips it
-	* back to `true`. Snapshots observed while this is `true` are treated as
-	* historical: their tool calls are recorded in `entriesRef` as restored
-	* but no streamCall/execute fires. The next snapshot is processed as live.
-	*/
-	const pendingRestoreRef = useRef(true);
-	const getLogicalToolCallId = (streamId) => streamToLogicalRef.current.get(streamId) ?? streamId;
-	const getWrappedTools = () => {
-		const tools = getTools();
-		if (!tools) return void 0;
-		return Object.fromEntries(Object.entries(tools).map(([name, tool]) => {
-			const execute = tool.execute;
-			const streamCall = tool.streamCall;
-			const toModelOutput = tool.toModelOutput;
-			return [name, {
-				...tool,
-				...execute !== void 0 && { execute: (...[args, context]) => {
-					if (skipExecuteStreamIdsRef.current.has(context.toolCallId)) return new Promise(() => {});
-					return execute(args, {
-						...context,
-						toolCallId: getLogicalToolCallId(context.toolCallId)
-					});
-				} },
-				...streamCall !== void 0 && { streamCall: (...[reader, context]) => streamCall(reader, {
-					...context,
-					toolCallId: getLogicalToolCallId(context.toolCallId)
-				}) },
-				...toModelOutput !== void 0 && { toModelOutput: (options) => toModelOutput({
-					...options,
-					toolCallId: getLogicalToolCallId(options.toolCallId)
-				}) }
-			}];
-		}));
-	};
-	const resolveAllSettledResolvers = () => {
-		const resolvers = settledResolversRef.current;
-		settledResolversRef.current = [];
-		resolvers.forEach((resolve) => resolve());
-	};
-	const [controller] = useState(() => {
-		const [stream, controller] = createAssistantStreamController();
-		const transform = unstable_toolResultStream(getWrappedTools, () => acRef.current?.signal ?? new AbortController().signal, (toolCallId, payload) => {
-			const logicalToolCallId = getLogicalToolCallId(toolCallId);
-			return new Promise((resolve, reject) => {
-				const previous = humanInputRef.current.get(logicalToolCallId);
-				if (previous) previous.reject(/* @__PURE__ */ new Error("Human input request was superseded by a new request"));
-				humanInputRef.current.set(logicalToolCallId, {
-					resolve,
-					reject
-				});
-				setToolStatuses((prev) => ({
-					...prev,
-					[logicalToolCallId]: {
-						type: "interrupt",
-						payload: {
-							type: "human",
-							payload
-						}
-					}
-				}));
-			});
-		}, {
-			onExecutionStart: (streamId) => {
-				if (skipExecuteStreamIdsRef.current.has(streamId)) return;
-				const logicalToolCallId = getLogicalToolCallId(streamId);
-				const abandoned = abandonedStreamIdsRef.current.has(streamId);
-				executingRef.current.set(streamId, {
-					logicalToolCallId,
-					abandoned
-				});
-				executingCountRef.current++;
-				if (!abandoned) setToolStatuses((prev) => ({
-					...prev,
-					[logicalToolCallId]: { type: "executing" }
-				}));
-			},
-			onExecutionEnd: (streamId) => {
-				const info = executingRef.current.get(streamId);
-				if (!info) return;
-				executingRef.current.delete(streamId);
-				executingCountRef.current--;
-				if (!info.abandoned) setToolStatuses((prev) => {
-					const next = { ...prev };
-					delete next[info.logicalToolCallId];
-					return next;
-				});
-				if (executingCountRef.current === 0) resolveAllSettledResolvers();
-			}
-		});
-		stream.pipeThrough(transform).pipeThrough(new AssistantMetaTransformStream()).pipeTo(new WritableStream({ write(chunk) {
-			if (chunk.type !== "result") return;
-			const streamId = chunk.meta.toolCallId;
-			const logicalToolCallId = getLogicalToolCallId(streamId);
-			const entry = entriesRef.current.get(logicalToolCallId);
-			if (abandonedStreamIdsRef.current.delete(streamId)) {
-				streamToLogicalRef.current.delete(streamId);
-				return;
-			}
-			if (!entry && skipExecuteStreamIdsRef.current.has(streamId)) return;
-			if (entry?.hasResult) return;
-			if (streamId !== logicalToolCallId) streamToLogicalRef.current.delete(streamId);
-			onResult({
-				type: "add-tool-result",
-				toolCallId: logicalToolCallId,
-				toolName: chunk.meta.toolName,
-				result: chunk.result,
-				isError: chunk.isError,
-				...chunk.artifact !== void 0 && { artifact: chunk.artifact },
-				...chunk.modelContent !== void 0 && { modelContent: chunk.modelContent }
-			});
-		} }));
-		return controller;
-	});
-	useEffect(() => {
-		const hasExecutableTool = (toolName) => {
-			const tool = getTools()?.[toolName];
-			return tool?.execute !== void 0 || tool?.streamCall !== void 0;
-		};
-		const shouldCloseArgsStream = ({ toolName, argsText, hasResult }) => {
-			if (hasResult) return true;
-			if (!hasExecutableTool(toolName)) return !state.isRunning && isArgsTextComplete(argsText);
-			return isArgsTextComplete(argsText);
-		};
-		const startActiveEntry = (toolCallId, toolName, skipExecute) => {
-			const toolCallController = controller.addToolCallPart({
-				toolName,
-				toolCallId
-			});
-			if (skipExecute) skipExecuteStreamIdsRef.current.add(toolCallId);
-			const entry = {
-				toolName,
-				controller: toolCallController,
-				streamId: toolCallId,
-				argsText: "",
-				hasResult: false,
-				argsComplete: false
-			};
-			entriesRef.current.set(toolCallId, entry);
-			return entry;
-		};
-		const restartArgsStream = (entry, toolCallId) => {
-			if (!entry.controller) return;
-			abandonedStreamIdsRef.current.add(entry.streamId);
-			const wasSkipExecute = skipExecuteStreamIdsRef.current.has(entry.streamId);
-			entry.controller.argsText.close();
-			const newStreamId = `${toolCallId}:rewrite:${rewriteCounterRef.current++}`;
-			streamToLogicalRef.current.set(newStreamId, toolCallId);
-			const newController = controller.addToolCallPart({
-				toolName: entry.toolName,
-				toolCallId: newStreamId
-			});
-			if (wasSkipExecute) skipExecuteStreamIdsRef.current.add(newStreamId);
-			if (process.env.NODE_ENV !== "production") console.warn("started replacement stream tool call", {
-				toolCallId,
-				streamToolCallId: newStreamId
-			});
-			entry.controller = newController;
-			entry.streamId = newStreamId;
-			entry.argsText = "";
-			entry.argsComplete = false;
-		};
-		const processArgsText = (entry, content) => {
-			if (!entry.controller) return;
-			const hasResult = content.result !== void 0;
-			if (content.argsText !== entry.argsText) {
-				let shouldWriteArgsText = true;
-				if (entry.argsComplete) if (isEquivalentCompleteArgsText(entry.argsText, content.argsText)) {
-					entry.argsText = content.argsText;
-					shouldWriteArgsText = false;
-				} else {
-					const canRestart = !entry.hasResult && !executingRef.current.has(entry.streamId);
-					if (process.env.NODE_ENV !== "production") console.warn(canRestart ? "argsText updated after controller was closed, restarting tool args stream:" : "argsText updated after controller was closed:", {
-						previous: entry.argsText,
-						next: content.argsText
-					});
-					if (!canRestart) {
-						entry.argsText = content.argsText;
-						shouldWriteArgsText = false;
-					} else restartArgsStream(entry, content.toolCallId);
-				}
-				else if (!content.argsText.startsWith(entry.argsText)) if (isArgsTextComplete(entry.argsText) && isArgsTextComplete(content.argsText) && isEquivalentCompleteArgsText(entry.argsText, content.argsText)) {
-					const shouldClose = shouldCloseArgsStream({
-						toolName: content.toolName,
-						argsText: content.argsText,
-						hasResult
-					});
-					if (shouldClose) entry.controller.argsText.close();
-					entry.argsText = content.argsText;
-					entry.argsComplete = shouldClose;
-					shouldWriteArgsText = false;
-				} else {
-					if (process.env.NODE_ENV !== "production") console.warn("argsText rewrote previous snapshot, restarting tool args stream:", {
-						previous: entry.argsText,
-						next: content.argsText,
-						toolCallId: content.toolCallId
-					});
-					restartArgsStream(entry, content.toolCallId);
-				}
-				if (shouldWriteArgsText) {
-					const delta = content.argsText.slice(entry.argsText.length);
-					entry.controller.argsText.append(delta);
-					const shouldClose = shouldCloseArgsStream({
-						toolName: content.toolName,
-						argsText: content.argsText,
-						hasResult
-					});
-					if (shouldClose) entry.controller.argsText.close();
-					entry.argsText = content.argsText;
-					entry.argsComplete = shouldClose;
-				}
-			}
-			if (!entry.argsComplete) {
-				if (shouldCloseArgsStream({
-					toolName: content.toolName,
-					argsText: content.argsText,
-					hasResult
-				})) {
-					entry.controller.argsText.close();
-					entry.argsText = content.argsText;
-					entry.argsComplete = true;
-				}
-			}
-		};
-		const processMessages = (messages) => {
-			const isRestore = pendingRestoreRef.current;
-			messages.forEach((message) => {
-				message.content.forEach((content) => {
-					if (content.type !== "tool-call") return;
-					const existing = entriesRef.current.get(content.toolCallId);
-					if (isRestore) {
-						if (!existing?.controller) entriesRef.current.set(content.toolCallId, {
-							toolName: content.toolName,
-							argsText: content.argsText,
-							hasResult: content.result !== void 0
-						});
-						if (content.messages) processMessages(content.messages);
-						return;
-					}
-					let entry = existing;
-					if (entry && !entry.controller) {
-						if (!(content.argsText !== entry.argsText || content.result !== void 0 !== entry.hasResult)) {
-							if (content.messages) processMessages(content.messages);
-							return;
-						}
-						entriesRef.current.delete(content.toolCallId);
-						entry = void 0;
-					}
-					if (!entry) entry = startActiveEntry(content.toolCallId, content.toolName, content.result !== void 0);
-					processArgsText(entry, content);
-					if (content.result !== void 0 && !entry.hasResult) {
-						const { controller: activeController } = entry;
-						if (!activeController) return;
-						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) processMessages(content.messages);
-				});
-			});
-		};
-		processMessages(state.messages);
-		pendingRestoreRef.current = false;
-	}, [
-		state,
-		controller,
-		getTools
-	]);
-	const abort = () => {
-		humanInputRef.current.forEach(({ reject }) => {
-			reject(/* @__PURE__ */ new Error("Tool execution aborted"));
-		});
-		humanInputRef.current.clear();
-		acRef.current.abort();
-		acRef.current = new AbortController();
-		if (executingCountRef.current === 0) return Promise.resolve();
-		return new Promise((resolve) => {
-			settledResolversRef.current.push(resolve);
-		});
-	};
-	return {
-		reset: () => {
-			pendingRestoreRef.current = true;
-			entriesRef.current.clear();
-			abort().finally(() => {
-				executingRef.current.clear();
-				streamToLogicalRef.current.clear();
-				rewriteCounterRef.current = 0;
-			});
-		},
-		abort,
-		resume: (toolCallId, payload) => {
-			const handlers = humanInputRef.current.get(toolCallId);
-			if (handlers) {
-				humanInputRef.current.delete(toolCallId);
-				setToolStatuses((prev) => ({
-					...prev,
-					[toolCallId]: { type: "executing" }
-				}));
-				handlers.resolve(payload);
-			} else throw new Error(`Tool call ${toolCallId} is not waiting for human input`);
-		}
-	};
-}
-//#endregion
-export { useToolInvocations };
-
-//# sourceMappingURL=useToolInvocations.js.map