@assistant-ui/react-ag-ui 0.0.64 → 0.0.66

package/src/runtime/adapter/run-aggregator.ts

@@ -3,6 +3,7 @@
 import {
   isMcpAppUri,
   type ChatModelRunResult,
+  type MessagePartTiming,
   type MessageStatus,
   type MessageTiming,
   type ThreadAssistantMessagePart,
@@ -12,19 +13,24 @@ import {
 } from "@assistant-ui/core";
 import {
   applyA2uiOperations,
-  convertSurfaceToUISpec,
-  surfaceToOperations,
+  surfaceToPresentToolCall,
   type A2uiState,
   type A2uiSurfaceState,
-} from "@assistant-ui/react-generative-ui/a2ui";
+} from "@assistant-ui/generative-ui/a2ui";
 import jsonpatch, { type Operation } from "fast-json-patch";
 import { readMcpAppResourceUri } from "../mcp-tool-result";
 import { projectAgUiToolApprovals } from "./tool-approval";
-import type { AgUiEvent, AgUiInterrupt } from "../types";
+import {
+  AG_UI_METADATA_NAMESPACE,
+  A2UI_SURFACE_ACTIVITY_TYPE,
+  MCP_APPS_ACTIVITY_TYPE,
+  type AgUiCustomMetadata,
+  type AgUiEvent,
+  type AgUiInterrupt,
+  type AgUiOpaqueReasoning,
+} from "../types";
 import type { Logger } from "../logger";
 
-export const AG_UI_METADATA_NAMESPACE = "agui";
-
 const ROOT_SCOPE = "";
 
 // Defensive guard against a malformed or cyclic parentToolCallId /
@@ -69,20 +75,6 @@ type BuildContext = {
   };
 };
 
-export type AgUiOpaqueReasoning = {
-  id: string;
-  encryptedValue: string;
-  after?: boolean;
-};
-
-export type AgUiCustomMetadata = {
-  /** Wire role restored on export for messages the internal model cannot
-   * represent (a developer record rides as a system message). */
-  role?: "developer";
-  interrupts?: AgUiInterrupt[];
-  opaqueReasoning?: AgUiOpaqueReasoning[];
-};
-
 type Emit = (update: ChatModelRunResult) => void;
 
 type ToolCallState = {
@@ -177,10 +169,6 @@ const scanJSONContainerDelta = (
   return completed && scanner.state === "complete";
 };
 
-export const MCP_APPS_ACTIVITY_TYPE = "mcp-apps";
-
-export const A2UI_SURFACE_ACTIVITY_TYPE = "a2ui-surface";
-
 export const isPlainObject = (
   value: unknown,
 ): value is Record<string, unknown> =>
@@ -217,7 +205,10 @@ export class RunAggregator {
   private interrupts: AgUiInterrupt[] | undefined;
   private readonly textParts = new Map<string, { buffer: string }>();
   private readonly activeTextMessageIdByScope = new Map<string, string>();
-  private readonly reasoningParts = new Map<string, string>(); // key → buffer
+  private readonly reasoningParts = new Map<
+    string,
+    { buffer: string; timing?: MessagePartTiming }
+  >();
   private readonly reasoningSignatures = new Map<string, string>();
   private readonly reasoningSignatureIds = new Map<string, string>();
   // Signatures captured while thinking is hidden have no block to live on;
@@ -255,6 +246,7 @@ export class RunAggregator {
   >();
   private readonly lastResolvedToolCallIdByScope = new Map<string, string>();
   private readonly partOrder: PartOrderEntry[] = [];
+  private lastReasoningBeforeToolCall: PartOrderEntry | undefined;
   private textPartCounter = 0;
   private serverMessageIdReported = false;
   private reportedServerMessageId: string | undefined;
@@ -396,6 +388,7 @@ export class RunAggregator {
           this.scopeOf("subagentRunId" in event ? event : {}),
           "messageId" in event ? event.messageId : undefined,
           event.type === "REASONING_MESSAGE_START",
+          event.timestamp,
         );
         break;
       case "REASONING_ENCRYPTED_VALUE":
@@ -454,11 +447,11 @@ export class RunAggregator {
         break;
       case "THINKING_TEXT_MESSAGE_END":
       case "THINKING_END":
-        this.handleReasoningEnd(ROOT_SCOPE);
+        this.handleReasoningEnd(ROOT_SCOPE, event.timestamp);
         break;
       case "REASONING_MESSAGE_END":
       case "REASONING_END":
-        this.handleReasoningEnd(this.scopeOf(event));
+        this.handleReasoningEnd(this.scopeOf(event), event.timestamp);
         break;
 
       case "TOOL_CALL_START": {
@@ -743,23 +736,27 @@ export class RunAggregator {
 
     const activeToolCallIds = new Set<string>();
     for (const [surfaceId, surface] of surfaces) {
-      const toolCallId = `a2ui:${surfaceId}`;
-      const { spec, warnings } = convertSurfaceToUISpec(surface);
+      const { toolCall, warnings } = surfaceToPresentToolCall(
+        surfaceId,
+        surface,
+      );
       for (const warning of warnings) {
         this.logger.debug("[agui] a2ui surface conversion warning", warning);
       }
-      if (!spec) continue;
+      if (!toolCall) continue;
+
+      const { toolCallId } = toolCall;
 
       activeToolCallIds.add(toolCallId);
 
       const entry: ToolCallState = {
-        toolCallId,
-        toolCallName: "present",
-        argsText: JSON.stringify(spec),
-        parsedArgs: spec,
-        result: {},
+        toolCallId: toolCall.toolCallId,
+        toolCallName: toolCall.toolName,
+        argsText: toolCall.argsText,
+        parsedArgs: toolCall.args,
+        result: toolCall.result,
         isError: undefined,
-        artifact: { a2ui: surfaceToOperations(surface) },
+        artifact: toolCall.artifact,
         snapshotResultApplied: false,
       };
       if (!this.toolCalls.has(toolCallId)) {
@@ -821,6 +818,7 @@ export class RunAggregator {
     this.activityParts.clear();
     this.lastResolvedToolCallIdByScope.clear();
     this.partOrder.length = 0;
+    this.lastReasoningBeforeToolCall = undefined;
     this.textPartCounter = 0;
     this.activeTextMessageIdByScope.clear();
     this.reportedServerMessageId = undefined;
@@ -854,8 +852,103 @@ export class RunAggregator {
     ) {
       return;
     }
+    const carried = this.takeTrailingReasoning();
+    if (carried.parts.length > 0 || carried.hiddenSignatures.length > 0) {
+      this.emit();
+    }
+    const reasoningPartCounter = this.reasoningPartCounter;
     this.resetMessageParts();
     this.onTextMessageStart(messageId);
+    this.reasoningPartCounter = reasoningPartCounter;
+    this.restoreReasoning(carried);
+  }
+
+  private takeTrailingReasoning() {
+    const parts: {
+      key: string;
+      entry: { buffer: string; timing?: MessagePartTiming };
+      signature: string | undefined;
+      signatureId: string | undefined;
+      reasoningId: string | undefined;
+      anonymous: boolean;
+    }[] = [];
+    let last = this.partOrder.at(-1);
+    while (
+      last?.kind === "reasoning" &&
+      last.subagentRunId === undefined &&
+      last !== this.lastReasoningBeforeToolCall
+    ) {
+      this.partOrder.pop();
+      parts.unshift({
+        key: last.key,
+        entry: this.reasoningParts.get(last.key) ?? { buffer: "" },
+        signature: this.reasoningSignatures.get(last.key),
+        signatureId: this.reasoningSignatureIds.get(last.key),
+        reasoningId: this.reasoningMessageIds.get(last.key),
+        anonymous: this.anonymousReasoningKeys.has(last.key),
+      });
+      last = this.partOrder.at(-1);
+    }
+    const cut = this.partOrder.length;
+    const hiddenSignatures = Array.from(this.hiddenSignatures).filter(
+      ([id]) => this.hiddenSignatureAnchors.get(id)! >= cut,
+    );
+    for (const [id] of hiddenSignatures) {
+      this.hiddenSignatures.delete(id);
+      this.hiddenSignatureAnchors.delete(id);
+    }
+    const hiddenBlockIds = Array.from(this.hiddenBlockAnchors)
+      .filter(([, anchor]) => anchor >= cut)
+      .map(([id]) => id);
+    const hiddenAnonymous =
+      this.hiddenAnonymousAnchor !== undefined &&
+      this.hiddenAnonymousAnchor >= cut;
+    const activeCarried =
+      (this.hiddenActiveReasoning === "identified" &&
+        hiddenBlockIds.length > 0) ||
+      (this.hiddenActiveReasoning === "anonymous" && hiddenAnonymous);
+    return {
+      parts,
+      activeKey: this.activeReasoningKeyByScope.get(ROOT_SCOPE),
+      hiddenSignatures,
+      hiddenBlockIds,
+      hiddenAnonymous,
+      hiddenActiveReasoning: activeCarried
+        ? this.hiddenActiveReasoning
+        : ("none" as const),
+    };
+  }
+
+  private restoreReasoning(
+    carried: ReturnType<RunAggregator["takeTrailingReasoning"]>,
+  ): void {
+    for (const part of carried.parts) {
+      this.partOrder.push({ kind: "reasoning", key: part.key });
+      this.reasoningParts.set(part.key, part.entry);
+      if (part.signature !== undefined)
+        this.reasoningSignatures.set(part.key, part.signature);
+      if (part.signatureId !== undefined)
+        this.reasoningSignatureIds.set(part.key, part.signatureId);
+      if (part.reasoningId !== undefined)
+        this.reasoningMessageIds.set(part.key, part.reasoningId);
+      if (part.anonymous) this.anonymousReasoningKeys.add(part.key);
+    }
+    if (
+      carried.activeKey !== undefined &&
+      this.reasoningParts.has(carried.activeKey)
+    ) {
+      this.activeReasoningKeyByScope.set(ROOT_SCOPE, carried.activeKey);
+    }
+    for (const [id, encryptedValue] of carried.hiddenSignatures) {
+      this.hiddenSignatures.set(id, encryptedValue);
+      this.hiddenSignatureAnchors.set(id, 0);
+    }
+    for (const id of carried.hiddenBlockIds) {
+      this.hiddenReasoningIds.add(id);
+      this.hiddenBlockAnchors.set(id, 0);
+    }
+    if (carried.hiddenAnonymous) this.hiddenAnonymousAnchor = 0;
+    this.hiddenActiveReasoning = carried.hiddenActiveReasoning;
   }
 
   private generateTextKey(): string {
@@ -927,6 +1020,13 @@ export class RunAggregator {
         (part) => part.kind === "tool-call" && part.toolCallId === id,
       )
     ) {
+      // Tool insertion can precede existing reasoning in display order.
+      if (scope === ROOT_SCOPE) {
+        this.lastReasoningBeforeToolCall = this.partOrder.findLast(
+          (part) =>
+            part.kind === "reasoning" && part.subagentRunId === undefined,
+        );
+      }
       this.insertToolPart(scope, id, parentMessageId);
     }
     const state: ToolCallState = {
@@ -1222,7 +1322,8 @@ export class RunAggregator {
 
       if (part.kind === "reasoning") {
         if (this.showThinking) {
-          const buffer = this.reasoningParts.get(part.key) ?? "";
+          const entry = this.reasoningParts.get(part.key);
+          const buffer = entry?.buffer ?? "";
           const isActive =
             this.activeReasoningKeyByScope.get(rawScope) === part.key;
           if (buffer.length > 0 || isActive) {
@@ -1235,6 +1336,7 @@ export class RunAggregator {
             snapshot.push({
               type: "reasoning",
               text: buffer,
+              ...(entry?.timing ? { timing: entry.timing } : {}),
               ...(Object.keys(meta).length > 0
                 ? { providerMetadata: { [AG_UI_METADATA_NAMESPACE]: meta } }
                 : {}),
@@ -1441,6 +1543,7 @@ export class RunAggregator {
     scope: string,
     messageId?: string,
     isMessageId = false,
+    timestamp?: number,
   ): void {
     if (!this.showThinking) {
       // Hidden-reasoning bookkeeping stays root-only for this task — a
@@ -1473,13 +1576,23 @@ export class RunAggregator {
       this.reasoningMessageIds.set(key, messageId);
     }
     if (!this.reasoningParts.has(key)) {
-      this.reasoningParts.set(key, "");
+      this.reasoningParts.set(key, { buffer: "" });
       this.partOrder.push(
         scope === ROOT_SCOPE
           ? { kind: "reasoning", key }
           : { kind: "reasoning", key, subagentRunId: scope },
       );
     }
+    const entry = this.reasoningParts.get(key);
+    if (entry?.timing) {
+      entry.timing = { startedAt: entry.timing.startedAt };
+    } else if (
+      entry &&
+      typeof timestamp === "number" &&
+      Number.isFinite(timestamp)
+    ) {
+      entry.timing = { startedAt: timestamp };
+    }
     this.activeReasoningKeyByScope.set(scope, key);
     this.emit();
   }
@@ -1506,15 +1619,25 @@ export class RunAggregator {
     }
     const key = this.activeReasoningKeyByScope.get(scope);
     if (!key) return;
-    this.reasoningParts.set(key, (this.reasoningParts.get(key) ?? "") + delta);
+    const entry = this.reasoningParts.get(key);
+    if (entry) entry.buffer += delta;
     this.emit();
   }
 
-  private handleReasoningEnd(scope: string): void {
+  private handleReasoningEnd(scope: string, timestamp?: number): void {
     if (!this.showThinking) {
       if (scope === ROOT_SCOPE) this.hiddenActiveReasoning = "none";
       return;
     }
+    const key = this.activeReasoningKeyByScope.get(scope);
+    const entry = key ? this.reasoningParts.get(key) : undefined;
+    if (
+      entry?.timing &&
+      typeof timestamp === "number" &&
+      Number.isFinite(timestamp)
+    ) {
+      entry.timing = { ...entry.timing, completedAt: timestamp };
+    }
     this.activeReasoningKeyByScope.delete(scope);
     this.emit();
   }

package/src/runtime/event-parser.ts

@@ -146,6 +146,10 @@ export const parseAgUiEvent = (
 
   const getString = (key: string) =>
     isString(payload[key]) ? (payload[key] as string) : undefined;
+  const timestamp =
+    typeof payload.timestamp === "number" && Number.isFinite(payload.timestamp)
+      ? payload.timestamp
+      : undefined;
 
   switch (typeValue) {
     case "RUN_STARTED": {
@@ -219,24 +223,31 @@ export const parseAgUiEvent = (
     case "THINKING_START":
       return withOptional(
         { type: "THINKING_START" as const },
-        { title: getString("title") },
+        { title: getString("title"), timestamp },
       );
     case "THINKING_TEXT_MESSAGE_START":
-      return { type: "THINKING_TEXT_MESSAGE_START" };
+      return withOptional(
+        { type: "THINKING_TEXT_MESSAGE_START" as const },
+        { timestamp },
+      );
     case "THINKING_TEXT_MESSAGE_CONTENT": {
       const delta = getString("delta") ?? "";
       return { type: "THINKING_TEXT_MESSAGE_CONTENT", delta };
     }
     case "THINKING_TEXT_MESSAGE_END":
-      return { type: "THINKING_TEXT_MESSAGE_END" };
+      return withOptional(
+        { type: "THINKING_TEXT_MESSAGE_END" as const },
+        { timestamp },
+      );
     case "THINKING_END":
-      return { type: "THINKING_END" };
+      return withOptional({ type: "THINKING_END" as const }, { timestamp });
     case "REASONING_START":
       return withOptional(
         { type: "REASONING_START" as const },
         {
           messageId: getString("messageId"),
           subagentRunId: getString("subagentRunId"),
+          timestamp,
         },
       );
     case "REASONING_MESSAGE_START":
@@ -245,6 +256,7 @@ export const parseAgUiEvent = (
         {
           messageId: getString("messageId"),
           subagentRunId: getString("subagentRunId"),
+          timestamp,
         },
       );
     case "REASONING_MESSAGE_CONTENT": {
@@ -263,6 +275,7 @@ export const parseAgUiEvent = (
         {
           messageId: getString("messageId"),
           subagentRunId: getString("subagentRunId"),
+          timestamp,
         },
       );
     case "REASONING_ENCRYPTED_VALUE": {
@@ -292,6 +305,7 @@ export const parseAgUiEvent = (
         {
           messageId: getString("messageId"),
           subagentRunId: getString("subagentRunId"),
+          timestamp,
         },
       );
     case "TOOL_CALL_START": {

package/src/runtime/types.ts

@@ -15,11 +15,29 @@ import type { Logger } from "./logger";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import type { McpToolCallResult } from "./mcp-tool-result";
 
+export const AG_UI_METADATA_NAMESPACE = "agui";
+export const MCP_APPS_ACTIVITY_TYPE = "mcp-apps";
+export const A2UI_SURFACE_ACTIVITY_TYPE = "a2ui-surface";
+
+export type AgUiOpaqueReasoning = {
+  id: string;
+  encryptedValue: string;
+  after?: boolean;
+};
+
+export type AgUiCustomMetadata = {
+  /** Wire role restored on export for messages the internal model cannot
+   * represent (a developer record rides as a system message). */
+  role?: "developer";
+  interrupts?: AgUiInterrupt[];
+  opaqueReasoning?: AgUiOpaqueReasoning[];
+};
+
 /**
- * @experimental This API is still under active development and might change without notice.
- *
  * Same as ExternalStoreThreadListAdapter, except `onSwitchToThread` returns
  * the messages (and optional state) to hydrate the thread with.
+ *
+ * @deprecated Experimental since 2026-06-13. Not scheduled for removal; the API may change in any release.
  */
 type SwitchToThreadResult = {
   messages: readonly ThreadMessage[];
@@ -28,6 +46,8 @@ type SwitchToThreadResult = {
    * Set when the thread has a run in flight. The runtime resumes the run
    * after hydrating, the same way `ThreadHistoryAdapter.load()` does when it
    * returns `unstable_resume: true`.
+   *
+   * @deprecated Experimental since 2025-03-31. Not scheduled for removal; the API may change in any release.
    */
   unstable_resume?: boolean;
 };
@@ -50,9 +70,7 @@ export type UseAgUiRuntimeAdapters = {
   voice?: RealtimeVoiceAdapter;
   feedback?: FeedbackAdapter;
   history?: ThreadHistoryAdapter;
-  /**
-   * @experimental This API is still under active development and might change without notice.
-   */
+  /** @deprecated Experimental since 2026-01-28. Not scheduled for removal; the API may change in any release. */
   threadList?: UseAgUiThreadListAdapter;
 };
 
@@ -102,6 +120,8 @@ export type UseAgUiRuntimeOptions = ExternalStoreSharedOptions & {
    * settles, exposing it on `composer.queue` for `ComposerPrimitive.Queue`.
    * The runtime owns the queue lifecycle because flushing needs the agent's
    * send path and the run's own busy and idle edges.
+   *
+   * @deprecated Experimental since 2026-06-04. Not scheduled for removal; the API may change in any release.
    */
   unstable_enableMessageQueue?: boolean | undefined;
   onError?: (e: Error) => void;
@@ -180,16 +200,22 @@ export type AgUiEvent =
       delta: string;
       subagentRunId?: string;
     }
-  | { type: "THINKING_START"; title?: string }
-  | { type: "THINKING_TEXT_MESSAGE_START" }
+  | { type: "THINKING_START"; title?: string; timestamp?: number }
+  | { type: "THINKING_TEXT_MESSAGE_START"; timestamp?: number }
   | { type: "THINKING_TEXT_MESSAGE_CONTENT"; delta: string }
-  | { type: "THINKING_TEXT_MESSAGE_END" }
-  | { type: "THINKING_END" }
-  | { type: "REASONING_START"; messageId?: string; subagentRunId?: string }
+  | { type: "THINKING_TEXT_MESSAGE_END"; timestamp?: number }
+  | { type: "THINKING_END"; timestamp?: number }
+  | {
+      type: "REASONING_START";
+      messageId?: string;
+      subagentRunId?: string;
+      timestamp?: number;
+    }
   | {
       type: "REASONING_MESSAGE_START";
       messageId?: string;
       subagentRunId?: string;
+      timestamp?: number;
     }
   | {
       type: "REASONING_MESSAGE_CONTENT";
@@ -201,6 +227,7 @@ export type AgUiEvent =
       type: "REASONING_MESSAGE_END";
       messageId?: string;
       subagentRunId?: string;
+      timestamp?: number;
     }
   | {
       type: "REASONING_ENCRYPTED_VALUE";
@@ -209,7 +236,12 @@ export type AgUiEvent =
       encryptedValue: string;
       subagentRunId?: string;
     }
-  | { type: "REASONING_END"; messageId?: string; subagentRunId?: string }
+  | {
+      type: "REASONING_END";
+      messageId?: string;
+      subagentRunId?: string;
+      timestamp?: number;
+    }
   | {
       type: "TOOL_CALL_START";
       toolCallId: string;

package/src/useAgUiRuntime.external-store.test.tsx

@@ -0,0 +1,51 @@
+// @vitest-environment jsdom
+
+import { act, cleanup, renderHook } from "@testing-library/react";
+import type { HttpAgent } from "@ag-ui/client";
+import { afterEach, expect, it, vi } from "vitest";
+import { useAgUiRuntime } from "./useAgUiRuntime";
+
+afterEach(cleanup);
+
+it("exposes the deprecated interrupt methods on the runtime facade", () => {
+  const agent = {
+    runAgent: vi.fn(),
+    abortRun: vi.fn(),
+  } as unknown as HttpAgent;
+  const { result } = renderHook(() => useAgUiRuntime({ agent }));
+
+  expect(Object.hasOwn(result.current, "unstable_getPendingInterrupts")).toBe(
+    true,
+  );
+  expect(
+    Object.hasOwn(result.current, "unstable_submitInterruptResponses"),
+  ).toBe(true);
+  expect(result.current.unstable_getPendingInterrupts()).toEqual([]);
+  expect(result.current.unstable_submitInterruptResponses).toEqual(
+    expect.any(Function),
+  );
+});
+
+it("re-renders when the core publishes a state change", () => {
+  const agent = {
+    runAgent: vi.fn(),
+    abortRun: vi.fn(),
+  } as unknown as HttpAgent;
+  let renders = 0;
+  const { result } = renderHook(() => {
+    renders++;
+    return useAgUiRuntime({ agent });
+  });
+  const initialRenders = renders;
+
+  act(() => {
+    result.current.thread.append({
+      role: "user",
+      content: [{ type: "text", text: "hello" }],
+      startRun: false,
+    });
+  });
+
+  expect(renders).toBeGreaterThan(initialRenders);
+  expect(result.current.thread.getState().messages).toHaveLength(1);
+});

package/src/useAgUiRuntime.queue.test.tsx

@@ -96,11 +96,67 @@ describe("useAgUiRuntime unstable_enableMessageQueue", () => {
     );
   });
 
+  it("holds queued sends while sending is disabled", async () => {
+    const { agent, runAgent, release } = gatedAgent();
+
+    const { result, rerender } = renderHook(
+      ({ isSendDisabled }) =>
+        useAgUiRuntime({
+          agent,
+          unstable_enableMessageQueue: true,
+          isSendDisabled,
+        }),
+      { initialProps: { isSendDisabled: false } },
+    );
+    mount(result.current);
+
+    await act(async () => {
+      await result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "first" }],
+      });
+    });
+    await waitFor(() => expect(runAgent).toHaveBeenCalledTimes(1));
+
+    await act(async () => {
+      await result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "second" }],
+        parentId: result.current.thread.getState().messages.at(-1)?.id ?? null,
+      });
+    });
+    await waitFor(() =>
+      expect(screen.getByTestId("queued").textContent).toBe("second"),
+    );
+    rerender({ isSendDisabled: true });
+
+    await act(async () => {
+      release();
+    });
+    await waitFor(() =>
+      expect(result.current.thread.getState().isRunning).toBe(false),
+    );
+    expect(runAgent).toHaveBeenCalledTimes(1);
+    expect(screen.getByTestId("queued").textContent).toBe("second");
+
+    rerender({ isSendDisabled: false });
+    await waitFor(() => expect(runAgent).toHaveBeenCalledTimes(2));
+    await waitFor(() =>
+      expect(screen.getByTestId("queued").textContent).toBe(""),
+    );
+  });
+
   it("preserves queued sends when the active run is cancelled", async () => {
     const { agent, runAgent, release } = gatedAgent();
 
-    const { result } = renderHook(() =>
-      useAgUiRuntime({ agent, unstable_enableMessageQueue: true }),
+    const { result, rerender } = renderHook(
+      ({ isSendDisabled }) =>
+        useAgUiRuntime({
+          agent,
+          unstable_enableMessageQueue: true,
+          isSendDisabled,
+        }),
+      { initialProps: { isSendDisabled: false } },
     );
     mount(result.current);
 
@@ -135,6 +191,11 @@ describe("useAgUiRuntime unstable_enableMessageQueue", () => {
       expect(screen.getByTestId("queued").textContent).toBe("second"),
     );
 
+    rerender({ isSendDisabled: true });
+    rerender({ isSendDisabled: false });
+    expect(runAgent).toHaveBeenCalledTimes(1);
+    expect(screen.getByTestId("queued").textContent).toBe("second");
+
     await act(async () => {
       await result.current.thread.append({
         role: "user",