@assistant-ui/react 0.11.20 → 0.11.22

package/src/legacy-runtime/runtime-cores/assistant-transport/useToolInvocations.ts

@@ -12,7 +12,7 @@ import type {
 } from "./types";
 import {
   AssistantMetaTransformStream,
-  ReadonlyJSONValue,
+  type ReadonlyJSONValue,
 } from "assistant-stream/utils";
 
 const isArgsTextComplete = (argsText: string) => {
@@ -28,12 +28,24 @@ type UseToolInvocationsParams = {
   state: AssistantTransportState;
   getTools: () => Record<string, Tool> | undefined;
   onResult: (command: AssistantTransportCommand) => void;
+  setToolStatuses: (
+    updater:
+      | Record<string, ToolExecutionStatus>
+      | ((
+          prev: Record<string, ToolExecutionStatus>,
+        ) => Record<string, ToolExecutionStatus>),
+  ) => void;
 };
 
+export type ToolExecutionStatus =
+  | { type: "executing" }
+  | { type: "interrupt"; payload: unknown };
+
 export function useToolInvocations({
   state,
   getTools,
   onResult,
+  setToolStatuses,
 }: UseToolInvocationsParams) {
   const lastToolStates = useRef<
     Record<
@@ -46,12 +58,39 @@ export function useToolInvocations({
     >
   >({});
 
+  const interruptedToolsRef = useRef<
+    Map<
+      string,
+      {
+        resolve: (payload: unknown) => void;
+        reject: (reason: unknown) => void;
+      }
+    >
+  >(new Map());
+
   const acRef = useRef<AbortController>(new AbortController());
   const [controller] = useState(() => {
     const [stream, controller] = createAssistantStreamController();
     const transform = unstable_toolResultStream(
       getTools,
       () => acRef.current?.signal ?? new AbortController().signal,
+      (toolCallId: string, payload: unknown) => {
+        return new Promise<unknown>((resolve, reject) => {
+          // Reject previous interrupt if it exists
+          const previous = interruptedToolsRef.current.get(toolCallId);
+          if (previous) {
+            previous.reject(
+              new Error("Interrupt was superseded by a new interrupt"),
+            );
+          }
+
+          interruptedToolsRef.current.set(toolCallId, { resolve, reject });
+          setToolStatuses((prev) => ({
+            ...prev,
+            [toolCallId]: { type: "interrupt", payload },
+          }));
+        });
+      },
     );
     stream
       .pipeThrough(transform)
@@ -72,6 +111,13 @@ export function useToolInvocations({
                 isError: chunk.isError,
                 ...(chunk.artifact && { artifact: chunk.artifact }),
               });
+
+              // Clear status when result is set
+              setToolStatuses((prev) => {
+                const next = { ...prev };
+                delete next[chunk.meta.toolCallId];
+                return next;
+              });
             }
           },
         }),
@@ -159,15 +205,36 @@ export function useToolInvocations({
     }
   }, [state, controller, onResult]);
 
+  const abort = () => {
+    interruptedToolsRef.current.forEach(({ reject }) => {
+      reject(new Error("Tool execution aborted"));
+    });
+    interruptedToolsRef.current.clear();
+    setToolStatuses({});
+
+    acRef.current.abort();
+    acRef.current = new AbortController();
+  };
+
   return {
     reset: () => {
-      acRef.current.abort();
-      acRef.current = new AbortController();
+      abort();
       isInititialState.current = true;
     },
-    abort: () => {
-      acRef.current.abort();
-      acRef.current = new AbortController();
+    abort,
+    resume: (toolCallId: string, payload: unknown) => {
+      const handlers = interruptedToolsRef.current.get(toolCallId);
+      if (handlers) {
+        interruptedToolsRef.current.delete(toolCallId);
+        setToolStatuses((prev) => {
+          const next = { ...prev };
+          delete next[toolCallId];
+          return next;
+        });
+        handlers.resolve(payload);
+      } else {
+        throw new Error(`Tool call ${toolCallId} is not interrupted`);
+      }
     },
   };
 }

package/src/legacy-runtime/runtime-cores/core/BaseThreadRuntimeCore.tsx

@@ -6,6 +6,7 @@ import {
 import { DefaultThreadComposerRuntimeCore } from "../composer/DefaultThreadComposerRuntimeCore";
 import {
   AddToolResultOptions,
+  ResumeToolCallOptions,
   ThreadSuggestion,
   SubmitFeedbackOptions,
   ThreadRuntimeCore,
@@ -46,6 +47,7 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
   public abstract startRun(config: StartRunConfig): void;
   public abstract resumeRun(config: ResumeRunConfig): void;
   public abstract addToolResult(options: AddToolResultOptions): void;
+  public abstract resumeToolCall(options: ResumeToolCallOptions): void;
   public abstract cancelRun(): void;
   public abstract unstable_loadExternalState(state: any): void;
 

package/src/legacy-runtime/runtime-cores/core/ThreadRuntimeCore.tsx

@@ -1,4 +1,4 @@
-import { ReadonlyJSONValue } from "assistant-stream/utils";
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import { ModelContext } from "../../../model-context";
 import { AppendMessage, ThreadMessage } from "../../../types";
 import { RunConfig } from "../../../types/AssistantTypes";
@@ -14,6 +14,7 @@ import {
 
 export type RuntimeCapabilities = {
   readonly switchToBranch: boolean;
+  readonly switchBranchDuringRun: boolean;
   readonly edit: boolean;
   readonly reload: boolean;
   readonly cancel: boolean;
@@ -32,6 +33,11 @@ export type AddToolResultOptions = {
   artifact?: ReadonlyJSONValue | undefined;
 };
 
+export type ResumeToolCallOptions = {
+  toolCallId: string;
+  payload: unknown;
+};
+
 export type SubmitFeedbackOptions = {
   messageId: string;
   type: "negative" | "positive";
@@ -85,6 +91,7 @@ export type ThreadRuntimeCore = Readonly<{
   cancelRun: () => void;
 
   addToolResult: (options: AddToolResultOptions) => void;
+  resumeToolCall: (options: ResumeToolCallOptions) => void;
 
   speak: (messageId: string) => void;
   stopSpeaking: () => void;

package/src/legacy-runtime/runtime-cores/external-store/ExternalStoreAdapter.tsx

@@ -10,7 +10,7 @@ import { FeedbackAdapter } from "../adapters/feedback/FeedbackAdapter";
 import { SpeechSynthesisAdapter } from "../adapters/speech/SpeechAdapterTypes";
 import { ThreadMessageLike } from "./ThreadMessageLike";
 import { ExportedMessageRepository } from "../utils/MessageRepository";
-import { ReadonlyJSONValue } from "assistant-stream/utils";
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
 
 export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
   status: TState;
@@ -77,6 +77,9 @@ type ExternalStoreAdapterBase<T> = {
   onAddToolResult?:
     | ((options: AddToolResultOptions) => Promise<void> | void)
     | undefined;
+  onResumeToolCall?:
+    | ((options: { toolCallId: string; payload: unknown }) => void)
+    | undefined;
   convertMessage?: ExternalStoreMessageConverter<T> | undefined;
   adapters?:
     | {

package/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadRuntimeCore.tsx

@@ -1,6 +1,7 @@
 import {
   AddToolResultOptions,
   ResumeRunConfig,
+  ResumeToolCallOptions,
   StartRunConfig,
   ThreadSuggestion,
 } from "../core/ThreadRuntimeCore";
@@ -43,6 +44,7 @@ export class ExternalStoreThreadRuntimeCore
 
   private _capabilities: RuntimeCapabilities = {
     switchToBranch: false,
+    switchBranchDuringRun: false,
     edit: false,
     reload: false,
     cancel: false,
@@ -108,6 +110,7 @@ export class ExternalStoreThreadRuntimeCore
     this.suggestions = store.suggestions ?? EMPTY_ARRAY;
     this._capabilities = {
       switchToBranch: this._store.setMessages !== undefined,
+      switchBranchDuringRun: false, // External store never supports branch switching during run
       edit: this._store.onEdit !== undefined,
       reload: this._store.onReload !== undefined,
       cancel: this._store.onCancel !== undefined,
@@ -159,7 +162,7 @@ export class ExternalStoreThreadRuntimeCore
             if (!store.convertMessage) return m;
 
             const isLast = idx === store.messages!.length - 1;
-            const autoStatus = getAutoStatus(isLast, isRunning, false);
+            const autoStatus = getAutoStatus(isLast, isRunning, false, false);
 
             if (
               cache &&
@@ -228,6 +231,11 @@ export class ExternalStoreThreadRuntimeCore
     if (!this._store.setMessages)
       throw new Error("Runtime does not support switching branches.");
 
+    // Silently ignore branch switches while running
+    if (this._store.isRunning) {
+      return;
+    }
+
     this.repository.switchToBranch(branchId);
     this.updateMessages(this.repository.getMessages());
   }
@@ -302,6 +310,12 @@ export class ExternalStoreThreadRuntimeCore
     this._store.onAddToolResult?.(options);
   }
 
+  public resumeToolCall(options: ResumeToolCallOptions) {
+    if (!this._store.onResumeToolCall)
+      throw new Error("Runtime does not support resuming tool calls.");
+    this._store.onResumeToolCall(options);
+  }
+
   public override reset(initialMessages?: readonly ThreadMessageLike[]) {
     const repo = new MessageRepository();
     repo.import(ExportedMessageRepository.fromArray(initialMessages ?? []));

package/src/legacy-runtime/runtime-cores/external-store/auto-status.tsx

@@ -11,16 +11,24 @@ const AUTO_STATUS_PENDING = Object.freeze({
   reason: "tool-calls",
 });
 
+const AUTO_STATUS_SUSPENDED = Object.freeze({
+  type: "requires-action",
+  reason: "interrupt",
+});
+
 export const isAutoStatus = (status: MessageStatus) =>
   status === AUTO_STATUS_RUNNING || status === AUTO_STATUS_COMPLETE;
 
 export const getAutoStatus = (
   isLast: boolean,
   isRunning: boolean,
+  hasSuspendedToolCalls: boolean,
   hasPendingToolCalls: boolean,
 ) =>
   isLast && isRunning
     ? AUTO_STATUS_RUNNING
-    : hasPendingToolCalls
-      ? AUTO_STATUS_PENDING
-      : AUTO_STATUS_COMPLETE;
+    : hasSuspendedToolCalls
+      ? AUTO_STATUS_SUSPENDED
+      : hasPendingToolCalls
+        ? AUTO_STATUS_PENDING
+        : AUTO_STATUS_COMPLETE;

package/src/legacy-runtime/runtime-cores/external-store/createMessageConverter.tsx

@@ -16,20 +16,27 @@ export const createMessageConverter = <T extends object>(
       messages,
       isRunning,
       joinStrategy,
+      metadata,
     }: {
       messages: T[];
       isRunning: boolean;
       joinStrategy?: "concat-content" | "none" | undefined;
+      metadata?: useExternalMessageConverter.Metadata;
     }) => {
       return useExternalMessageConverter<T>({
         callback,
         messages,
         isRunning,
         joinStrategy,
+        metadata,
       });
     },
-    toThreadMessages: (messages: T[], isRunning = false) => {
-      return convertExternalMessages(messages, callback, isRunning);
+    toThreadMessages: (
+      messages: T[],
+      isRunning = false,
+      metadata: useExternalMessageConverter.Metadata = {},
+    ) => {
+      return convertExternalMessages(messages, callback, isRunning, metadata);
     },
     toOriginalMessages: (
       input: ThreadState | ThreadMessage | ThreadMessage["content"][number],

package/src/legacy-runtime/runtime-cores/external-store/external-message-converter.tsx

@@ -9,6 +9,7 @@ import {
 import { fromThreadMessageLike, ThreadMessageLike } from "./ThreadMessageLike";
 import { getAutoStatus, isAutoStatus } from "./auto-status";
 import { ToolCallMessagePart } from "../../../types";
+import { ToolExecutionStatus } from "../assistant-transport/useToolInvocations";
 
 export namespace useExternalMessageConverter {
   export type Message =
@@ -26,7 +27,14 @@ export namespace useExternalMessageConverter {
         isError?: boolean;
       };
 
-  export type Callback<T> = (message: T) => Message | Message[];
+  export type Metadata = {
+    readonly toolStatuses?: Record<string, ToolExecutionStatus>;
+  };
+
+  export type Callback<T> = (
+    message: T,
+    metadata: Metadata,
+  ) => Message | Message[];
 }
 
 type CallbackResult<T> = {
@@ -218,10 +226,11 @@ export const convertExternalMessages = <T extends WeakKey>(
   messages: T[],
   callback: useExternalMessageConverter.Callback<T>,
   isRunning: boolean,
+  metadata: useExternalMessageConverter.Metadata,
 ) => {
   const callbackResults: CallbackResult<T>[] = [];
   for (const message of messages) {
-    const output = callback(message);
+    const output = callback(message, metadata);
     const outputs = Array.isArray(output) ? output : [output];
     const result = { input: message, outputs };
     callbackResults.push(result);
@@ -232,12 +241,22 @@ export const convertExternalMessages = <T extends WeakKey>(
   return chunks.map((message, idx) => {
     const isLast = idx === chunks.length - 1;
     const joined = joinExternalMessages(message.outputs);
+    const hasSuspendedToolCalls =
+      typeof joined.content === "object" &&
+      joined.content.some(
+        (c) => c.type === "tool-call" && c.result === undefined,
+      );
     const hasPendingToolCalls =
       typeof joined.content === "object" &&
       joined.content.some(
         (c) => c.type === "tool-call" && c.result === undefined,
       );
-    const autoStatus = getAutoStatus(isLast, isRunning, hasPendingToolCalls);
+    const autoStatus = getAutoStatus(
+      isLast,
+      isRunning,
+      hasSuspendedToolCalls,
+      hasPendingToolCalls,
+    );
     const newMessage = fromThreadMessageLike(
       joined,
       idx.toString(),
@@ -253,14 +272,17 @@ export const useExternalMessageConverter = <T extends WeakKey>({
   messages,
   isRunning,
   joinStrategy,
+  metadata,
 }: {
   callback: useExternalMessageConverter.Callback<T>;
   messages: T[];
   isRunning: boolean;
   joinStrategy?: "concat-content" | "none" | undefined;
+  metadata?: useExternalMessageConverter.Metadata | undefined;
 }) => {
   const state = useMemo(
     () => ({
+      metadata: metadata ?? {},
       callback,
       callbackCache: new WeakMap<T, CallbackResult<T>>(),
       chunkCache: new WeakMap<
@@ -269,7 +291,7 @@ export const useExternalMessageConverter = <T extends WeakKey>({
       >(),
       converterCache: new ThreadMessageConverter(),
     }),
-    [callback],
+    [callback, metadata],
   );
 
   return useMemo(() => {
@@ -277,7 +299,7 @@ export const useExternalMessageConverter = <T extends WeakKey>({
     for (const message of messages) {
       let result = state.callbackCache.get(message);
       if (!result) {
-        const output = state.callback(message);
+        const output = state.callback(message, state.metadata);
         const outputs = Array.isArray(output) ? output : [output];
         result = { input: message, outputs };
         state.callbackCache.set(message, result);
@@ -304,6 +326,11 @@ export const useExternalMessageConverter = <T extends WeakKey>({
         const isLast = idx === chunks.length - 1;
 
         const joined = joinExternalMessages(message.outputs);
+        const hasSuspendedToolCalls =
+          typeof joined.content === "object" &&
+          joined.content.some(
+            (c) => c.type === "tool-call" && c.result === undefined,
+          );
         const hasPendingToolCalls =
           typeof joined.content === "object" &&
           joined.content.some(
@@ -312,6 +339,7 @@ export const useExternalMessageConverter = <T extends WeakKey>({
         const autoStatus = getAutoStatus(
           isLast,
           isRunning,
+          hasSuspendedToolCalls,
           hasPendingToolCalls,
         );
 

package/src/legacy-runtime/runtime-cores/local/LocalThreadRuntimeCore.tsx

@@ -5,6 +5,7 @@ import { shouldContinue } from "./shouldContinue";
 import { LocalRuntimeOptionsBase } from "./LocalRuntimeOptions";
 import {
   AddToolResultOptions,
+  ResumeToolCallOptions,
   ThreadSuggestion,
   ThreadRuntimeCore,
   StartRunConfig,
@@ -30,6 +31,7 @@ export class LocalThreadRuntimeCore
 {
   public readonly capabilities = {
     switchToBranch: true,
+    switchBranchDuringRun: true,
     edit: true,
     reload: true,
     cancel: true,
@@ -462,4 +464,8 @@ export class LocalThreadRuntimeCore
       this.performRoundtrip(parentId, message, this._lastRunConfig);
     }
   }
+
+  public resumeToolCall(_options: ResumeToolCallOptions) {
+    throw new Error("Local runtime does not support resuming tool calls.");
+  }
 }

package/src/legacy-runtime/runtime-cores/remote-thread-list/EMPTY_THREAD_CORE.tsx

@@ -36,6 +36,10 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     throw EMPTY_THREAD_ERROR;
   },
 
+  resumeToolCall() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
   speak() {
     throw EMPTY_THREAD_ERROR;
   },
@@ -132,6 +136,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
 
   capabilities: {
     switchToBranch: false,
+    switchBranchDuringRun: false,
     edit: false,
     reload: false,
     cancel: false,

package/src/legacy-runtime/runtime-cores/remote-thread-list/RemoteThreadListHookInstanceManager.tsx

@@ -90,10 +90,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
         throw new Error("Thread not found. This is a bug in assistant-ui.");
 
       aliveThread.runtime = threadBinding.getState();
-
-      if (isMounted) {
-        this._notifySubscribers();
-      }
+      this._notifySubscribers();
     }, [threadId, threadBinding]);
 
     const isMounted = useRef(false);

package/src/legacy-runtime/runtime-cores/remote-thread-list/adapter/cloud.tsx

@@ -16,14 +16,14 @@ import { InMemoryThreadListAdapter } from "./in-memory";
 import { CloudFileAttachmentAdapter } from "../../adapters";
 
 type ThreadData = {
-  externalId: string;
+  externalId: string | undefined;
 };
 
 type CloudThreadListAdapterOptions = {
   cloud?: AssistantCloud | undefined;
 
-  create?(): Promise<ThreadData>;
-  delete?(threadId: string): Promise<void>;
+  create?: (() => Promise<ThreadData>) | undefined;
+  delete?: ((threadId: string) => Promise<void>) | undefined;
 };
 
 const baseUrl =

package/src/legacy-runtime/runtime-cores/remote-thread-list/useRemoteThreadListRuntime.tsx

@@ -6,6 +6,7 @@ import { RemoteThreadListThreadListRuntimeCore } from "./RemoteThreadListThreadL
 import { RemoteThreadListOptions } from "./types";
 import { AssistantRuntimeImpl } from "../../../internal";
 import { AssistantRuntimeCore } from "../core/AssistantRuntimeCore";
+import { AssistantRuntime } from "../../runtime/AssistantRuntime";
 
 class RemoteThreadListRuntimeCore
   extends BaseAssistantRuntimeCore
@@ -28,7 +29,7 @@ class RemoteThreadListRuntimeCore
 
 export const useRemoteThreadListRuntime = (
   options: RemoteThreadListOptions,
-) => {
+): AssistantRuntime => {
   const [runtime] = useState(() => new RemoteThreadListRuntimeCore(options));
   useEffect(() => {
     runtime.threads.__internal_setOptions(options);

package/src/legacy-runtime/runtime-cores/utils/MessageRepository.tsx

@@ -67,7 +67,7 @@ export const ExportedMessageRepository = {
       fromThreadMessageLike(
         m,
         generateId(),
-        getAutoStatus(false, false, false),
+        getAutoStatus(false, false, false, false),
       ),
     );
 

package/src/model-context/frame/AssistantFrameProvider.ts

@@ -133,6 +133,11 @@ export class AssistantFrameProvider {
           ? await tool.execute(message.args, {
               toolCallId: message.id,
               abortSignal: new AbortController().signal,
+              interrupt: async () => {
+                throw new Error(
+                  "Tool interrupt is not supported in frame context",
+                );
+              },
             })
           : undefined;
       } catch (e) {

package/src/primitives/branchPicker/BranchPickerNext.tsx

@@ -10,9 +10,17 @@ import { useAssistantState, useAssistantApi } from "../../context";
 
 const useBranchPickerNext = () => {
   const api = useAssistantApi();
-  const disabled = useAssistantState(
-    ({ message }) => message.branchNumber >= message.branchCount,
-  );
+  const disabled = useAssistantState(({ thread, message }) => {
+    // Disabled if no next branch
+    if (message.branchNumber >= message.branchCount) return true;
+
+    // Disabled if running and capability not supported
+    if (thread.isRunning && !thread.capabilities.switchBranchDuringRun) {
+      return true;
+    }
+
+    return false;
+  });
 
   const callback = useCallback(() => {
     api.message().switchToBranch({ position: "next" });

package/src/primitives/branchPicker/BranchPickerPrevious.tsx

@@ -31,9 +31,17 @@ import { useAssistantState, useAssistantApi } from "../../context";
  */
 const useBranchPickerPrevious = () => {
   const api = useAssistantApi();
-  const disabled = useAssistantState(
-    ({ message }) => message.branchNumber <= 1,
-  );
+  const disabled = useAssistantState(({ thread, message }) => {
+    // Disabled if no previous branch
+    if (message.branchNumber <= 1) return true;
+
+    // Disabled if running and capability not supported
+    if (thread.isRunning && !thread.capabilities.switchBranchDuringRun) {
+      return true;
+    }
+
+    return false;
+  });
 
   const callback = useCallback(() => {
     api.message().switchToBranch({ position: "previous" });

package/src/primitives/message/MessageParts.tsx

@@ -241,11 +241,19 @@ const MessagePartComponent: FC<MessagePartComponentProps> = ({
 
   const type = part.type;
   if (type === "tool-call") {
-    const addResult = (result: any) => api.part().addToolResult(result);
+    const addResult = api.part().addToolResult;
+    const resume = api.part().resumeToolCall;
     if ("Override" in tools)
-      return <tools.Override {...part} addResult={addResult} />;
+      return <tools.Override {...part} addResult={addResult} resume={resume} />;
     const Tool = tools.by_name?.[part.toolName] ?? tools.Fallback;
-    return <ToolUIDisplay {...part} Fallback={Tool} addResult={addResult} />;
+    return (
+      <ToolUIDisplay
+        {...part}
+        Fallback={Tool}
+        addResult={addResult}
+        resume={resume}
+      />
+    );
   }
 
   if (part.status?.type === "requires-action")

package/src/primitives/message/MessagePartsGrouped.tsx

@@ -267,10 +267,18 @@ const MessagePartComponent: FC<MessagePartComponentProps> = ({
   const type = part.type;
   if (type === "tool-call") {
     const addResult = (result: any) => api.part().addToolResult(result);
+    const resume = api.part().resumeToolCall;
     if ("Override" in tools)
-      return <tools.Override {...part} addResult={addResult} />;
+      return <tools.Override {...part} addResult={addResult} resume={resume} />;
     const Tool = tools.by_name?.[part.toolName] ?? tools.Fallback;
-    return <ToolUIDisplay {...part} Fallback={Tool} addResult={addResult} />;
+    return (
+      <ToolUIDisplay
+        {...part}
+        Fallback={Tool}
+        addResult={addResult}
+        resume={resume}
+      />
+    );
   }
 
   if (part.status?.type === "requires-action")

package/src/types/AssistantTypes.ts

@@ -64,7 +64,7 @@ export type MessagePartStatus =
 export type ToolCallMessagePartStatus =
   | {
       readonly type: "requires-action";
-      readonly reason: "tool-calls";
+      readonly reason: "interrupt";
     }
   | MessagePartStatus;
 
@@ -74,7 +74,7 @@ export type MessageStatus =
     }
   | {
       readonly type: "requires-action";
-      readonly reason: "tool-calls";
+      readonly reason: "tool-calls" | "interrupt";
     }
   | {
       readonly type: "complete";

package/src/types/MessagePartComponentTypes.tsx

@@ -44,6 +44,7 @@ export type ToolCallMessagePartProps<
 > = MessagePartState &
   ToolCallMessagePart<TArgs, TResult> & {
     addResult: (result: TResult | ToolResponse<TResult>) => void;
+    resume: (payload: unknown) => void;
   };
 
 export type ToolCallMessagePartComponent<

package/src/types/MessagePartTypes.ts

@@ -54,6 +54,7 @@ export type ToolCallMessagePart<
   readonly isError?: boolean | undefined;
   readonly argsText: string;
   readonly artifact?: unknown;
+  readonly interrupt?: unknown;
   readonly parentId?: string;
 };