@assistant-ui/core 0.3.20 → 0.3.21

package/src/react/runtimes/useLocalRuntime.test.tsx

@@ -1,13 +1,15 @@
 // @vitest-environment jsdom
 
 import { act, render, waitFor } from "@testing-library/react";
-import { type FC, StrictMode } from "react";
+import { Activity, type FC, StrictMode, useEffect } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { AssistantCloud } from "assistant-cloud";
 import { useAui, useAuiState } from "@assistant-ui/store";
 import type { ChatModelAdapter } from "../../runtime/utils/chat-model-adapter";
 import { AssistantRuntimeProvider } from "../AssistantRuntimeProvider";
 import { useLocalRuntime } from "./useLocalRuntime";
+import type { RealtimeVoiceAdapter } from "../../adapters/voice";
+import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
 
 const chatModel: ChatModelAdapter = {
   run: async () => ({ content: [] }),
@@ -32,6 +34,148 @@ afterEach(() => {
 });
 
 describe("useLocalRuntime", () => {
+  const createVoiceApp = () => {
+    const disconnect = vi.fn();
+    let emitTranscript!: (item: RealtimeVoiceAdapter.TranscriptItem) => void;
+    const session: RealtimeVoiceAdapter.Session = {
+      status: { type: "running" },
+      isMuted: false,
+      disconnect,
+      mute: vi.fn(),
+      unmute: vi.fn(),
+      onStatusChange: () => () => {},
+      onTranscript: (callback) => {
+        emitTranscript = callback;
+        return () => {};
+      },
+      onModeChange: () => () => {},
+      onVolumeChange: () => () => {},
+    };
+    const capture: { runtime: AssistantRuntime | null } = { runtime: null };
+    let connected = false;
+    const App = () => {
+      const runtime = useLocalRuntime(chatModel, {
+        adapters: { voice: { connect: () => session } },
+      });
+      capture.runtime = runtime;
+      useEffect(() => {
+        if (connected) return;
+        connected = true;
+        runtime.thread.connectVoice();
+      }, [runtime]);
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <div />
+        </AssistantRuntimeProvider>
+      );
+    };
+    return {
+      App,
+      capture,
+      disconnect,
+      emitTranscript: (item: RealtimeVoiceAdapter.TranscriptItem) =>
+        emitTranscript(item),
+    };
+  };
+
+  it("keeps voice connected through StrictMode replay and disconnects on unmount", async () => {
+    const { App, disconnect } = createVoiceApp();
+
+    const view = render(
+      <StrictMode>
+        <App />
+      </StrictMode>,
+    );
+    await act(async () => Promise.resolve());
+    expect(disconnect).not.toHaveBeenCalled();
+
+    view.unmount();
+    await act(async () => Promise.resolve());
+    expect(disconnect).toHaveBeenCalledOnce();
+  });
+
+  it("keeps voice and the thread through Activity hide and reveal", async () => {
+    const { App, capture, disconnect, emitTranscript } = createVoiceApp();
+    const renderApp = (mode: "visible" | "hidden") => (
+      <Activity mode={mode}>
+        <App />
+      </Activity>
+    );
+
+    const view = render(renderApp("visible"));
+    await act(async () => Promise.resolve());
+    view.rerender(renderApp("hidden"));
+    await act(async () => Promise.resolve());
+    view.rerender(renderApp("visible"));
+    await act(async () => Promise.resolve());
+
+    expect(disconnect).not.toHaveBeenCalled();
+    expect(capture.runtime!.thread.getState().voice).toBeDefined();
+
+    act(() =>
+      emitTranscript({ role: "user", text: "after reveal", isFinal: true }),
+    );
+    expect(capture.runtime!.thread.getState().messages).toHaveLength(1);
+
+    view.unmount();
+    await act(async () => Promise.resolve());
+    expect(disconnect).toHaveBeenCalledOnce();
+  });
+
+  it("passes the remote id of a fresh Cloud thread to its first run", async () => {
+    const cloud = {
+      registerSdk: vi.fn(),
+      telemetry: { enabled: false },
+      threads: {
+        list: vi.fn().mockResolvedValue({ threads: [] }),
+        create: vi.fn().mockResolvedValue({ thread_id: "remote-thread" }),
+        messages: {
+          list: vi.fn().mockResolvedValue({ messages: [] }),
+          create: vi.fn().mockResolvedValue({ message_id: "message-1" }),
+          update: vi.fn().mockResolvedValue(undefined),
+        },
+      },
+      runs: {
+        stream: vi.fn().mockResolvedValue(
+          new ReadableStream({
+            start(controller) {
+              controller.close();
+            },
+          }),
+        ),
+      },
+    } as unknown as AssistantCloud;
+    const threadIds: (string | undefined)[] = [];
+    const run: ChatModelAdapter = {
+      run: async ({ unstable_threadId }) => {
+        threadIds.push(unstable_threadId);
+        return { content: [] };
+      },
+    };
+    let runtime: ReturnType<typeof useLocalRuntime> | null = null;
+    const App = () => {
+      runtime = useLocalRuntime(run, { cloud });
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <div />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(<App />);
+    await waitFor(() => {
+      expect(runtime!.threads.mainItem.getState().id).toBeDefined();
+    });
+
+    await runtime!.thread.append("hello");
+
+    await waitFor(() => {
+      expect(threadIds).toHaveLength(1);
+    });
+    expect(cloud.threads.create).toHaveBeenCalledTimes(1);
+    expect(threadIds).toEqual(["remote-thread"]);
+  });
+
   it("enables feedback for Cloud threads", async () => {
     const cloud = makeCloud();
     let runtime: ReturnType<typeof useLocalRuntime> | null = null;

package/src/react/runtimes/useLocalRuntime.ts

@@ -6,7 +6,7 @@ import type {
 } from "../../index";
 import type { LocalRuntimeOptionsBase } from "../../runtimes/local/local-runtime-options";
 import { AssistantRuntimeImpl, LocalRuntimeCore } from "../../internal";
-import { useAuiState } from "@assistant-ui/store";
+import { useAui } from "@assistant-ui/store";
 import { useRemoteThreadListRuntime } from "./useRemoteThreadListRuntime";
 import { useCloudThreadListAdapter } from "./cloud/useCloudThreadListAdapter";
 import { useRuntimeAdapters } from "./RuntimeAdapterProvider";
@@ -34,15 +34,18 @@ const useLocalThreadRuntime = (
 
   const [runtime] = useState(() => new LocalRuntimeCore(opt, initialMessages));
 
-  const threadIdRef = useRef<string | undefined>(undefined);
+  const aui = useAui();
   const historyLoadPromiseRef = useRef<Promise<void> | undefined>(undefined);
-  threadIdRef.current = useAuiState((s) => s.threadListItem.remoteId);
 
+  // A run reads the id in the microtask after the initialization barrier,
+  // before the store has flushed the remote id into React state.
   useEffect(() => {
     runtime.threads
       .getMainThreadRuntimeCore()
-      .__internal_setGetThreadId(() => threadIdRef.current);
-  }, [runtime]);
+      .__internal_setGetThreadId(
+        () => aui.threadListItem.__internal_getRuntime?.().getState().remoteId,
+      );
+  }, [aui, runtime]);
 
   useEffect(() => {
     return () => {

package/src/react/types/MessagePartComponentTypes.ts

@@ -12,6 +12,7 @@ import type {
   ToolApprovalResponse,
   ToolCallMessagePart,
   Unstable_AudioMessagePart,
+  Unstable_ToolInteractionInput,
   QuoteInfo,
 } from "../..";
 import type { MessagePartState } from "../..";
@@ -91,6 +92,15 @@ export type ToolCallMessagePartProps<
      * it could not be recorded, so the controls can stay retryable.
      */
     respondToApproval: (response: ToolApprovalResponse) => Promise<void>;
+    /**
+     * Records what the user did in this call's UI on the part, so a stored
+     * conversation keeps it. Resolves once recorded, and rejects when the
+     * payload is not plain JSON, is over the size limit, or the runtime
+     * cannot record interactions; the user's action itself is unaffected.
+     */
+    unstable_recordInteraction?:
+      | ((input: Unstable_ToolInteractionInput) => Promise<void>)
+      | undefined;
   };
 
 /** Component used to render a tool-call message part. */

package/src/react/types/scopes/interactables.ts

@@ -59,6 +59,9 @@ export type Unstable_InteractablePersistenceAdapter = {
    * Restores previously saved state. Called when the adapter is attached;
    * loaded state seeds app-scoped interactables that have not been locally
    * edited yet (a local edit always wins over a slow load).
+   *
+   * A different adapter instance represents a different persistence scope.
+   * Switching adapters resets app-scoped state before loading the replacement.
    */
   load?():
     | Unstable_InteractablePersistedState

package/src/runtime/api/attachment-runtime.ts

@@ -17,25 +17,30 @@ type EditComposerAttachmentState = Attachment & {
   readonly source: "edit-composer";
 };
 
-export type AttachmentState =
+export type AttachmentRuntimeState =
   | ThreadComposerAttachmentState
   | EditComposerAttachmentState
   | MessageAttachmentState;
 
+/**
+ * @deprecated Use `AttachmentRuntimeState`. From `@assistant-ui/react` 0.16, `AttachmentState` names the attachment state read through `useAuiState`.
+ */
+export type AttachmentState = AttachmentRuntimeState;
+
 type AttachmentSnapshotBinding<Source extends AttachmentRuntimeSource> =
   SubscribableWithState<
-    AttachmentState & { source: Source },
+    AttachmentRuntimeState & { source: Source },
     AttachmentRuntimePath & { attachmentSource: Source }
   >;
 
-type AttachmentRuntimeSource = AttachmentState["source"];
+type AttachmentRuntimeSource = AttachmentRuntimeState["source"];
 
 export type AttachmentRuntime<
   TSource extends AttachmentRuntimeSource = AttachmentRuntimeSource,
 > = {
   readonly path: AttachmentRuntimePath & { attachmentSource: TSource };
   readonly source: TSource;
-  getState(): AttachmentState & { source: TSource };
+  getState(): AttachmentRuntimeState & { source: TSource };
   remove(): Promise<void>;
   subscribe(callback: () => void): Unsubscribe;
 };
@@ -62,7 +67,7 @@ export abstract class AttachmentRuntimeImpl<
     this.subscribe = this.subscribe.bind(this);
   }
 
-  public getState(): AttachmentState & { source: Source } {
+  public getState(): AttachmentRuntimeState & { source: Source } {
     return this._core.getState();
   }
 

package/src/runtime/api/bindings.ts

@@ -35,7 +35,7 @@ export type MessageStateBinding = SubscribableWithState<
   MessageRuntimePath
 >;
 
-export type ThreadListItemState = {
+export type ThreadListItemRuntimeState = {
   readonly isMain: boolean;
   /**
    * Whether this thread has a run in progress, including a run that continues
@@ -50,3 +50,8 @@ export type ThreadListItemState = {
   readonly lastMessageAt?: Date | undefined;
   readonly custom?: Record<string, unknown> | undefined;
 };
+
+/**
+ * @deprecated Use `ThreadListItemRuntimeState`. From `@assistant-ui/react` 0.16, `ThreadListItemState` names the thread list item state read through `useAuiState`.
+ */
+export type ThreadListItemState = ThreadListItemRuntimeState;

package/src/runtime/api/composer-runtime.ts

@@ -16,6 +16,7 @@ import {
 import type {
   ComposerRuntimeEventCallback,
   ComposerRuntimeEventType,
+  ComposerSubmission,
   DictationState,
   EditComposerRuntimeCore,
   SendOptions,
@@ -30,7 +31,7 @@ import type { ComposerRuntimePath } from "./paths";
 
 import {
   type AttachmentRuntime,
-  type AttachmentState,
+  type AttachmentRuntimeState,
   EditComposerAttachmentRuntimeImpl,
   ThreadComposerAttachmentRuntimeImpl,
 } from "./attachment-runtime";
@@ -73,6 +74,19 @@ type BaseComposerState = {
 
   /** Messages waiting to be processed. Empty unless the `queue` capability is set. */
   readonly queue: readonly QueueItemState[];
+
+  /**
+   * The message this composer sent while its attachments are prepared.
+   * Undefined once the runtime has taken it.
+   */
+  readonly submission?: ComposerSubmission | undefined;
+
+  /**
+   * Messages this composer handed to the runtime that the thread does not
+   * show yet, oldest first. The thread keeps rendering each one until the
+   * runtime shows the message it became.
+   */
+  readonly inTransit?: readonly ComposerSubmission[] | undefined;
 };
 
 export type ThreadComposerState = BaseComposerState & {
@@ -85,7 +99,12 @@ export type EditComposerState = BaseComposerState & {
   readonly sourceId: string | null;
 };
 
-export type ComposerState = ThreadComposerState | EditComposerState;
+export type ComposerRuntimeState = ThreadComposerState | EditComposerState;
+
+/**
+ * @deprecated Use `ComposerRuntimeState`. From `@assistant-ui/react` 0.16, `ComposerState` names the composer state read through `useAuiState`.
+ */
+export type ComposerState = ComposerRuntimeState;
 
 const EMPTY_ARRAY = Object.freeze([]);
 const EMPTY_OBJECT = Object.freeze({});
@@ -108,6 +127,8 @@ const getThreadComposerState = (
     dictation: runtime?.dictation,
     quote: runtime?.quote,
     queue: runtime?.queue ?? EMPTY_ARRAY,
+    submission: runtime?.submission,
+    inTransit: runtime?.inTransit ?? EMPTY_ARRAY,
 
     value: runtime?.text ?? "",
   });
@@ -132,6 +153,8 @@ const getEditComposerState = (
     dictation: runtime?.dictation,
     quote: runtime?.quote,
     queue: runtime?.queue ?? EMPTY_ARRAY,
+    submission: runtime?.submission,
+    inTransit: runtime?.inTransit ?? EMPTY_ARRAY,
 
     parentId: runtime?.parentId ?? null,
     sourceId: runtime?.sourceId ?? null,
@@ -147,7 +170,7 @@ export type ComposerRuntime = {
   /**
    * Get the current state of the composer. Includes any data that has been added to the composer.
    */
-  getState(): ComposerState;
+  getState(): ComposerRuntimeState;
 
   /**
    * Add an attachment to the composer. Accepts either a standard File object
@@ -287,7 +310,7 @@ export abstract class ComposerRuntimeImpl implements ComposerRuntime {
     this.unstable_on = this.unstable_on.bind(this);
   }
 
-  public abstract getState(): ComposerState;
+  public abstract getState(): ComposerRuntimeState;
 
   public setText(text: string) {
     const core = this._core.getState();
@@ -464,7 +487,7 @@ export class ThreadComposerRuntimeImpl
           return {
             ...attachment,
             source: "thread-composer",
-          } satisfies AttachmentState & { source: "thread-composer" };
+          } satisfies AttachmentRuntimeState & { source: "thread-composer" };
         },
         subscribe: (callback) => this._core.subscribe(callback),
       }),
@@ -552,7 +575,7 @@ export class EditComposerRuntimeImpl
           return {
             ...attachment,
             source: "edit-composer",
-          } satisfies AttachmentState & { source: "edit-composer" };
+          } satisfies AttachmentRuntimeState & { source: "edit-composer" };
         },
         subscribe: (callback) => this._core.subscribe(callback),
       }),

package/src/runtime/api/message-part-runtime.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect, it, vi } from "vitest";
+import type { ThreadRuntimeCore } from "../interfaces/thread-runtime-core";
+import type { MessageStateBinding } from "./bindings";
+import type { MessagePartState } from "./message-part-runtime";
+import { MessagePartRuntimeImpl } from "./message-part-runtime";
+import type { ThreadRuntimeCoreBinding } from "./thread-runtime";
+
+const threadPath = {
+  ref: "threads.main",
+  threadSelector: { type: "main" as const },
+};
+
+const messagePath = {
+  ...threadPath,
+  ref: "threads.main.messages[0]",
+  messageSelector: { type: "index" as const, index: 0 },
+};
+
+const partPath = {
+  ...messagePath,
+  ref: "threads.main.messages[0].content[0]",
+  messagePartSelector: { type: "index" as const, index: 0 },
+};
+
+const toolPart: MessagePartState = {
+  type: "tool-call",
+  toolCallId: "call-1",
+  toolName: "weather",
+  args: {},
+  argsText: "{}",
+  status: { type: "requires-action", reason: "tool-calls" },
+};
+
+const textPart: MessagePartState = {
+  type: "text",
+  text: "hello",
+  status: { type: "complete" },
+};
+
+const message = {
+  id: "message-1",
+  role: "assistant" as const,
+  createdAt: new Date(0),
+  content: [toolPart],
+  status: { type: "requires-action" as const, reason: "tool-calls" as const },
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+  parentId: null,
+  index: 0,
+  isLast: true,
+  branchNumber: 1,
+  branchCount: 1,
+  speech: undefined,
+};
+
+const createRuntime = ({
+  part = toolPart,
+  core,
+}: {
+  part?: MessagePartState;
+  core: ThreadRuntimeCore;
+}) => {
+  const contentBinding = {
+    path: partPath,
+    getState: () => part,
+    subscribe: () => () => {},
+  };
+  const messageBinding: MessageStateBinding = {
+    path: messagePath,
+    getState: () => message,
+    subscribe: () => () => {},
+  };
+  const threadBinding: ThreadRuntimeCoreBinding = {
+    path: threadPath,
+    getState: () => core,
+    subscribe: () => () => {},
+    outerSubscribe: () => () => {},
+  };
+  return new MessagePartRuntimeImpl(
+    contentBinding,
+    messageBinding,
+    threadBinding,
+  );
+};
+
+describe("MessagePartRuntime interaction recording", () => {
+  it("rejects invalid inputs without throwing synchronously", async () => {
+    const core = {
+      unstable_recordToolInteraction: vi.fn(),
+    } as unknown as ThreadRuntimeCore;
+    const runtime = createRuntime({ core });
+
+    const recording = runtime.unstable_recordInteraction({
+      type: "action",
+      payload: "not an object",
+    });
+
+    await expect(recording).rejects.toThrow(
+      "An action interaction payload must be a JSON object.",
+    );
+    expect(core.unstable_recordToolInteraction).not.toHaveBeenCalled();
+  });
+
+  it("rejects recording on non-tool parts", async () => {
+    const core = {
+      unstable_recordToolInteraction: vi.fn(),
+    } as unknown as ThreadRuntimeCore;
+    const runtime = createRuntime({ core, part: textPart });
+
+    await expect(
+      runtime.unstable_recordInteraction({ type: "action", payload: {} }),
+    ).rejects.toThrow("Tried to record interaction on non-tool message part");
+  });
+
+  it("rejects when the core cannot record tool interactions", async () => {
+    const runtime = createRuntime({ core: {} as ThreadRuntimeCore });
+
+    await expect(
+      runtime.unstable_recordInteraction({ type: "action", payload: {} }),
+    ).rejects.toThrow("Runtime does not support recording tool interactions.");
+  });
+
+  it("delegates stamped interactions with the message and tool call ids", async () => {
+    const recordInteraction = vi.fn(async () => {});
+    const core = {
+      unstable_recordToolInteraction: recordInteraction,
+    } as unknown as ThreadRuntimeCore;
+    const runtime = createRuntime({ core });
+
+    await runtime.unstable_recordInteraction({
+      type: "action",
+      payload: { action: "toggle" },
+    });
+
+    expect(recordInteraction).toHaveBeenCalledExactlyOnceWith({
+      messageId: "message-1",
+      toolCallId: "call-1",
+      interaction: {
+        type: "action",
+        payload: { action: "toggle" },
+        occurredAt: expect.any(Number),
+      },
+    });
+  });
+});
+
+describe("MessagePartRuntime resumeToolCall", () => {
+  it("records the accepted human response", () => {
+    const resumeToolCall = vi.fn();
+    const recordInteraction = vi.fn(async () => {});
+    const runtime = createRuntime({
+      core: {
+        resumeToolCall,
+        unstable_recordToolInteraction: recordInteraction,
+      } as unknown as ThreadRuntimeCore,
+    });
+    const payload = { answer: "yes" };
+
+    runtime.resumeToolCall(payload);
+
+    expect(resumeToolCall).toHaveBeenCalledExactlyOnceWith({
+      toolCallId: "call-1",
+      payload,
+    });
+    expect(recordInteraction).toHaveBeenCalledExactlyOnceWith({
+      messageId: "message-1",
+      toolCallId: "call-1",
+      interaction: {
+        type: "human-response",
+        payload,
+        occurredAt: expect.any(Number),
+      },
+    });
+    expect(resumeToolCall.mock.invocationCallOrder[0]).toBeLessThan(
+      recordInteraction.mock.invocationCallOrder[0]!,
+    );
+  });
+
+  it("does not record a human response when resuming throws", () => {
+    const error = new Error("resume failed");
+    const recordInteraction = vi.fn(async () => {});
+    const runtime = createRuntime({
+      core: {
+        resumeToolCall: () => {
+          throw error;
+        },
+        unstable_recordToolInteraction: recordInteraction,
+      } as unknown as ThreadRuntimeCore,
+    });
+
+    expect(() => runtime.resumeToolCall({ answer: "yes" })).toThrow(error);
+    expect(recordInteraction).not.toHaveBeenCalled();
+  });
+
+  it("keeps an accepted resume successful when recording fails", async () => {
+    const resumeToolCall = vi.fn();
+    const runtime = createRuntime({
+      core: {
+        resumeToolCall,
+        unstable_recordToolInteraction: vi.fn(async () => {
+          throw new Error("recording failed");
+        }),
+      } as unknown as ThreadRuntimeCore,
+    });
+
+    expect(() => runtime.resumeToolCall({ answer: "yes" })).not.toThrow();
+    await Promise.resolve();
+    expect(resumeToolCall).toHaveBeenCalledOnce();
+  });
+});

package/src/runtime/api/message-part-runtime.ts

@@ -3,8 +3,10 @@ import type {
   ThreadUserMessagePart,
   ToolApprovalResponse,
   ToolCallMessagePartStatus,
+  Unstable_ToolInteractionInput,
 } from "../../types/message";
 import { resolveToolApprovalResponse } from "../utils/resolveToolApprovalResponse";
+import { createToolInteraction } from "../utils/tool-interactions";
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { MessagePartStatus } from "../../types/message";
 import type { SubscribableWithState } from "../../subscribable/subscribable";
@@ -29,6 +31,9 @@ export type MessagePartRuntime = {
   addToolResult(result: any | ToolResponse<any>): void;
   resumeToolCall(payload: unknown): void;
   respondToToolApproval(response: ToolApprovalResponse): Promise<void>;
+  unstable_recordInteraction?: (
+    input: Unstable_ToolInteractionInput,
+  ) => Promise<void>;
 
   readonly path: MessagePartRuntimePath;
   getState(): MessagePartState;
@@ -59,6 +64,8 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
     this.addToolResult = this.addToolResult.bind(this);
     this.resumeToolCall = this.resumeToolCall.bind(this);
     this.respondToToolApproval = this.respondToToolApproval.bind(this);
+    this.unstable_recordInteraction =
+      this.unstable_recordInteraction.bind(this);
     this.getState = this.getState.bind(this);
     this.subscribe = this.subscribe.bind(this);
   }
@@ -114,6 +121,10 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
       toolCallId,
       payload,
     });
+    void this.unstable_recordInteraction({
+      type: "human-response",
+      payload,
+    }).catch(() => {});
   }
 
   public respondToToolApproval(response: ToolApprovalResponse): Promise<void> {
@@ -141,6 +152,35 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
       );
   }
 
+  public async unstable_recordInteraction(
+    input: Unstable_ToolInteractionInput,
+  ): Promise<void> {
+    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 record interaction on non-tool message part");
+
+    if (!this.messageApi)
+      throw new Error(
+        "Message API is not available. This is likely a bug in assistant-ui.",
+      );
+    if (!this.threadApi) throw new Error("Thread API is not available");
+
+    const message = this.messageApi.getState();
+    if (!message) throw new Error("Message is not available");
+
+    const core = this.threadApi.getState();
+    if (!core.unstable_recordToolInteraction)
+      throw new Error("Runtime does not support recording tool interactions.");
+
+    await core.unstable_recordToolInteraction({
+      messageId: message.id,
+      toolCallId: state.toolCallId,
+      interaction: createToolInteraction(input),
+    });
+  }
+
   public subscribe(callback: () => void) {
     return this.contentBinding.subscribe(callback);
   }