@assistant-ui/react 0.11.21 → 0.11.22

package/src/legacy-runtime/runtime/MessagePartRuntime.ts

@@ -30,6 +30,12 @@ export type MessagePartRuntime = {
    */
   addToolResult(result: any | ToolResponse<any>): void;
 
+  /**
+   * Resume an interrupted tool call with a payload.
+   * This is useful when a tool has interrupted its execution and is waiting for user input.
+   */
+  resumeToolCall(payload: unknown): void;
+
   readonly path: MessagePartRuntimePath;
   getState(): MessagePartState;
   subscribe(callback: () => void): Unsubscribe;
@@ -50,6 +56,7 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
 
   protected __internal_bindMethods() {
     this.addToolResult = this.addToolResult.bind(this);
+    this.resumeToolCall = this.resumeToolCall.bind(this);
     this.getState = this.getState.bind(this);
     this.subscribe = this.subscribe.bind(this);
   }
@@ -88,6 +95,22 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
     });
   }
 
+  public resumeToolCall(payload: unknown) {
+    const state = this.contentBinding.getState();
+    if (!state) throw new Error("Message part is not available");
+
+    if (state.type !== "tool-call")
+      throw new Error("Tried to resume tool call on non-tool message part");
+
+    if (!this.threadApi) throw new Error("Thread API is not available");
+
+    const toolCallId = state.toolCallId;
+    this.threadApi.getState().resumeToolCall({
+      toolCallId,
+      payload,
+    });
+  }
+
   public subscribe(callback: () => void) {
     return this.contentBinding.subscribe(callback);
   }

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

@@ -2,6 +2,7 @@ import { ReadonlyJSONValue } from "assistant-stream/utils";
 import { ThreadMessage } from "../../../types";
 import { AttachmentAdapter, ThreadHistoryAdapter } from "..";
 import { UserCommands } from "../../../augmentations";
+import type { ToolExecutionStatus } from "./useToolInvocations";
 
 // Message part types
 export type TextPart = {
@@ -56,6 +57,7 @@ export type AssistantTransportState = {
 export type AssistantTransportConnectionMetadata = {
   pendingCommands: AssistantTransportCommand[];
   isSending: boolean;
+  toolStatuses: Record<string, ToolExecutionStatus>;
 };
 
 export type AssistantTransportStateConverter<T> = (

package/src/legacy-runtime/runtime-cores/assistant-transport/useAssistantTransportRuntime.tsx

@@ -1,8 +1,8 @@
 "use client";
 
 import {
-  ReadonlyJSONObject,
-  ReadonlyJSONValue,
+  type ReadonlyJSONObject,
+  type ReadonlyJSONValue,
   asAsyncIterableStream,
 } from "assistant-stream/utils";
 import { AppendMessage } from "../../../types";
@@ -26,7 +26,7 @@ import {
 import { useCommandQueue } from "./commandQueue";
 import { useRunManager } from "./runManager";
 import { useConvertedState } from "./useConvertedState";
-import { useToolInvocations } from "./useToolInvocations";
+import { ToolExecutionStatus, useToolInvocations } from "./useToolInvocations";
 import { toAISDKTools, getEnabledTools, createRequestHeaders } from "./utils";
 import { useRemoteThreadListRuntime } from "../remote-thread-list/useRemoteThreadListRuntime";
 import { InMemoryThreadListAdapter } from "../remote-thread-list/adapter/in-memory";
@@ -177,6 +177,11 @@ const useAssistantTransportThreadRuntime = <T,>(
     },
   });
 
+  // Tool execution status state
+  const [toolStatuses, setToolStatuses] = useState<
+    Record<string, ToolExecutionStatus>
+  >({});
+
   // Reactive conversion of agent state + connection metadata → UI state
   const pendingCommands = useMemo(
     () => [...commandQueue.state.inTransit, ...commandQueue.state.queued],
@@ -187,6 +192,7 @@ const useAssistantTransportThreadRuntime = <T,>(
     agentStateRef.current,
     pendingCommands,
     runManager.isRunning,
+    toolStatuses,
   );
 
   // Create runtime
@@ -266,6 +272,7 @@ const useAssistantTransportThreadRuntime = <T,>(
     state: converted,
     getTools: () => runtime.thread.getModelContext().tools,
     onResult: commandQueue.enqueue,
+    setToolStatuses,
   });
 
   return runtime;

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

@@ -4,15 +4,17 @@ import type {
   AssistantTransportState,
   AssistantTransportStateConverter,
 } from "./types";
+import type { ToolExecutionStatus } from "./useToolInvocations";
 
 export function useConvertedState<T>(
   converter: AssistantTransportStateConverter<T>,
   agentState: T,
   pendingCommands: AssistantTransportCommand[],
   isSending: boolean,
+  toolStatuses: Record<string, ToolExecutionStatus>,
 ): AssistantTransportState {
   return useMemo(
-    () => converter(agentState, { pendingCommands, isSending }),
-    [converter, agentState, pendingCommands, isSending],
+    () => converter(agentState, { pendingCommands, isSending, toolStatuses }),
+    [converter, agentState, pendingCommands, isSending, toolStatuses],
   );
 }

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";
@@ -33,6 +33,11 @@ export type AddToolResultOptions = {
   artifact?: ReadonlyJSONValue | undefined;
 };
 
+export type ResumeToolCallOptions = {
+  toolCallId: string;
+  payload: unknown;
+};
+
 export type SubmitFeedbackOptions = {
   messageId: string;
   type: "negative" | "positive";
@@ -86,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";
@@ -161,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 &&
@@ -309,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,
@@ -463,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;
   },

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