@assistant-ui/core 0.2.6 → 0.2.7

package/src/subscribable/subscribable.ts

@@ -207,9 +207,9 @@ export class LazyMemoizeSubject<TState extends object, TPath>
 }
 
 export class NestedSubscriptionSubject<
-    TState extends Subscribable | undefined,
-    TPath,
-  >
+  TState extends Subscribable | undefined,
+  TPath,
+>
   extends BaseSubject
   implements
     SubscribableWithState<TState, TPath>,

package/src/tests/OptimisticState-delete-crash.test.ts

@@ -24,6 +24,8 @@ const createThreadState = (
   const mappingId = createThreadMappingId(threadId);
   return {
     isLoading: false,
+    isLoadingMore: false,
+    cursor: undefined,
     newThreadId: undefined,
     threadIds: status === "regular" ? [threadId] : [],
     archivedThreadIds: status === "archived" ? [threadId] : [],

package/src/tests/OptimisticState-list-race.test.ts

@@ -22,6 +22,8 @@ import { deferred } from "./remote-thread-list-test-helpers";
 
 const EMPTY_STATE: RemoteThreadState = {
   isLoading: false,
+  isLoadingMore: false,
+  cursor: undefined,
   newThreadId: undefined,
   threadIds: [],
   archivedThreadIds: [],

package/src/tests/RemoteThreadListThreadListRuntimeCore-loadMore.test.ts

@@ -20,7 +20,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
 
   it("initial list response with nextCursor sets hasMore=true", async () => {
     const adapter = makeAdapter({
-      list: vi.fn(async () => ({
+      list: vi.fn<ListFn>(async () => ({
         threads: [
           {
             status: "regular",
@@ -41,7 +41,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
 
   it("absent nextCursor leaves hasMore=false", async () => {
     const adapter = makeAdapter({
-      list: vi.fn(async () => ({
+      list: vi.fn<ListFn>(async () => ({
         threads: [
           {
             status: "regular",
@@ -243,7 +243,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
 
   it("__internal_setOptions clears cursor and dedup handles on adapter swap, then refetches via the new adapter", async () => {
     const firstAdapter = makeAdapter({
-      list: vi.fn(async () => ({
+      list: vi.fn<ListFn>(async () => ({
         threads: [{ status: "regular", remoteId: "old", externalId: "old" }],
         nextCursor: "old-cursor",
       })),
@@ -253,7 +253,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
     expect(core.threadIds).toEqual(["old"]);
     expect(core.hasMore).toBe(true);
 
-    const secondList = vi.fn(async () => ({
+    const secondList = vi.fn<ListFn>(async () => ({
       threads: [{ status: "regular", remoteId: "new", externalId: "new" }],
     }));
     const secondAdapter = makeAdapter({ list: secondList });
@@ -290,7 +290,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
     const stale = core.loadMore();
 
     const secondAdapter = makeAdapter({
-      list: vi.fn(async () => ({
+      list: vi.fn<ListFn>(async () => ({
         threads: [{ status: "regular", remoteId: "ignored", externalId: "x" }],
       })),
     });

package/src/tests/auiV0Encode.test.ts

@@ -9,7 +9,7 @@ describe("auiV0Encode", () => {
       role: "assistant",
       status: { type: "complete", reason: "stop" },
       metadata: {
-        unstable_state: undefined,
+        unstable_state: null,
         unstable_annotations: [],
         unstable_data: [],
         steps: [],

package/src/tests/composer-can-send.test.ts

@@ -102,10 +102,14 @@ describe("BaseComposerRuntimeCore.send", () => {
 describe("DefaultEditComposerRuntimeCore.canSend", () => {
   it("ignores runtime.isSendDisabled (thread-scoped flag does not block edits)", () => {
     const stub = makeRuntimeStub({ isSendDisabled: true });
-    const composer = new DefaultEditComposerRuntimeCore(stub, () => {}, {
-      parentId: null,
-      message: makeUserMessage("seed"),
-    });
+    const composer = new DefaultEditComposerRuntimeCore(
+      stub as unknown as ThreadRuntimeCore,
+      () => {},
+      {
+        parentId: null,
+        message: makeUserMessage("seed"),
+      },
+    );
 
     expect(composer.canSend).toBe(true);
   });

package/src/tests/duplicate-detection.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { checkDuplicateCore } from "../internal/duplicate-detection";
+
+const KEY = Symbol.for("@assistant-ui/core.loaded");
+
+function reset(): void {
+  delete (globalThis as unknown as Record<symbol, unknown>)[KEY];
+}
+
+describe("checkDuplicateCore", () => {
+  let warn: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    reset();
+    warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warn.mockRestore();
+    reset();
+  });
+
+  it("does not warn on the first load", () => {
+    checkDuplicateCore();
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it("warns when a second copy registers in the same runtime", () => {
+    checkDuplicateCore();
+    checkDuplicateCore();
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0]![0]).toMatch(/npx assistant-ui doctor/);
+  });
+});

package/src/tests/external-store-thread-list-runtime-core.test.ts

@@ -184,7 +184,7 @@ describe("ExternalStoreThreadListRuntimeCore - isMain via ThreadListRuntimeImpl"
     const core = new ExternalStoreThreadListRuntimeCore(adapter, makeFactory());
     return new ThreadListRuntimeImpl(
       core,
-      NoopThreadRuntime as unknown as Parameters<
+      NoopThreadRuntime as unknown as ConstructorParameters<
         typeof ThreadListRuntimeImpl
       >[1],
     );

package/src/tests/external-store-thread-runtime-core.test.ts

@@ -8,12 +8,13 @@ const mockContextProvider: ModelContextProvider = {
 };
 
 const makeStore = (
-  overrides?: Partial<ExternalStoreAdapter>,
-): ExternalStoreAdapter => ({
-  messages: [],
-  onNew: vi.fn(),
-  ...overrides,
-});
+  overrides?: Partial<ExternalStoreAdapter> | Record<string, unknown>,
+): ExternalStoreAdapter =>
+  ({
+    messages: [],
+    onNew: vi.fn(),
+    ...overrides,
+  }) as ExternalStoreAdapter;
 
 describe("ExternalStoreThreadRuntimeCore - state reference stability", () => {
   describe("capabilities", () => {

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: [],

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/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