@assistant-ui/react-ag-ui 0.0.50 → 0.0.51

package/dist/useAgUiRuntime.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAgUiRuntime.js","names":[],"sources":["../src/useAgUiRuntime.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\nimport {\n  useExternalStoreRuntime,\n  useExternalStoreSharedOptions,\n  useRuntimeAdapters,\n} from \"@assistant-ui/core/react\";\nimport type { ToolExecutionStatus } from \"@assistant-ui/core\";\nimport type {\n  AssistantRuntime,\n  AppendMessage,\n  ExternalStoreAdapter,\n  ThreadMessage,\n} from \"@assistant-ui/core\";\nimport type { ReadonlyJSONValue } from \"assistant-stream/utils\";\nimport { makeLogger } from \"./runtime/logger\";\nimport type {\n  AgUiInterrupt,\n  AgUiResumeEntry,\n  UseAgUiRuntimeOptions,\n} from \"./runtime/types\";\nimport { AgUiThreadRuntimeCore } from \"./runtime/AgUiThreadRuntimeCore\";\nimport { agUiExtras } from \"./agUiExtras\";\n\nconst EMPTY_INTERRUPTS: readonly AgUiInterrupt[] = [];\n\nexport type AgUiAssistantRuntime = AssistantRuntime & {\n  /**\n   * @deprecated Use the `useAgUiInterrupts()` hook instead. This method is kept\n   * for backward compatibility and will be removed in a future major release.\n   */\n  unstable_getPendingInterrupts: () => readonly AgUiInterrupt[];\n  /**\n   * @deprecated Use the `useAgUiSubmitInterruptResponses()` hook instead. This\n   * method is kept for backward compatibility and will be removed in a future\n   * major release.\n   */\n  unstable_submitInterruptResponses: (\n    responses: readonly AgUiResumeEntry[],\n  ) => Promise<void>;\n};\n\nexport function useAgUiRuntime(\n  options: UseAgUiRuntimeOptions,\n): AgUiAssistantRuntime {\n  const logger = useMemo(() => makeLogger(options.logger), [options.logger]);\n  const [_version, setVersion] = useState(0);\n  const notifyUpdate = useCallback(() => setVersion((v) => v + 1), []);\n  const coreRef = useRef<AgUiThreadRuntimeCore | null>(null);\n  const runtimeAdapters = useRuntimeAdapters();\n\n  const historyAdapter = options.adapters?.history ?? runtimeAdapters?.history;\n  const threadListAdapter = options.adapters?.threadList;\n\n  if (!coreRef.current) {\n    coreRef.current = new AgUiThreadRuntimeCore({\n      agent: options.agent,\n      logger,\n      showThinking: options.showThinking ?? true,\n      autoCancelPendingToolCalls: options.autoCancelPendingToolCalls,\n      ...(options.onError && { onError: options.onError }),\n      ...(options.onCancel && { onCancel: options.onCancel }),\n      ...(historyAdapter && { history: historyAdapter }),\n      notifyUpdate,\n    });\n  }\n\n  const core = coreRef.current;\n  core.updateOptions({\n    agent: options.agent,\n    logger,\n    showThinking: options.showThinking ?? true,\n    autoCancelPendingToolCalls: options.autoCancelPendingToolCalls,\n    ...(options.onError && { onError: options.onError }),\n    ...(options.onCancel && { onCancel: options.onCancel }),\n    ...(historyAdapter && { history: historyAdapter }),\n  });\n\n  const [toolStatuses, setToolStatuses] = useState<\n    Record<string, ToolExecutionStatus>\n  >({});\n\n  const hasExecutingTools = Object.values(toolStatuses).some(\n    (s) => s?.type === \"executing\",\n  );\n\n  const threadList = useMemo(() => {\n    if (!threadListAdapter) return undefined;\n\n    const { onSwitchToNewThread, onSwitchToThread, ...rest } =\n      threadListAdapter;\n\n    return {\n      ...rest,\n      onSwitchToNewThread: onSwitchToNewThread\n        ? async () => {\n            await onSwitchToNewThread();\n            core.applyExternalMessages([]);\n            core.resetState();\n          }\n        : undefined,\n      onSwitchToThread: onSwitchToThread\n        ? async (threadId: string) => {\n            // Clear before the thread id flips, or the old messages leak\n            // into the new thread as a sibling branch.\n            core.applyExternalMessages([]);\n            const result = await onSwitchToThread(threadId);\n            core.applyExternalMessages(result.messages);\n            if (result.state !== undefined) {\n              core.loadExternalState(result.state);\n            } else {\n              core.resetState();\n            }\n            if (result.unstable_resume) {\n              void core.resumeInFlightRun(result.messages);\n            }\n          }\n        : undefined,\n    };\n  }, [threadListAdapter, core]);\n\n  const adapters = options.adapters;\n  const adapterAdapters = useMemo(\n    () => ({\n      attachments: adapters?.attachments ?? runtimeAdapters?.attachments,\n      speech: adapters?.speech,\n      dictation: adapters?.dictation,\n      voice: adapters?.voice,\n      feedback: adapters?.feedback,\n      threadList,\n    }),\n    [adapters, runtimeAdapters, threadList],\n  );\n\n  const shared = useExternalStoreSharedOptions(options);\n  const store = useMemo(\n    () => {\n      void _version; // rerender on version change\n\n      return {\n        ...shared,\n        isLoading: core.isLoading,\n        messageRepository: core.getMessageRepository(),\n        state: core.getState(),\n        isRunning: core.isRunning() || hasExecutingTools,\n        extras: agUiExtras.provide({\n          interrupts:\n            core.getPendingInterrupts()?.interrupts ?? EMPTY_INTERRUPTS,\n          sendA2uiAction: (action) => core.sendA2uiAction(action),\n          submitInterruptResponses: (responses) =>\n            core.submitInterruptResponses(responses),\n          steerAway: (message, responses) => core.steerAway(message, responses),\n          state: core.getState(),\n          setState: (next) => core.setState(next),\n        }),\n        unstable_enableToolInvocations: true,\n        setToolStatuses,\n        onNew: (message: AppendMessage) => core.append(message),\n        onEdit: (message: AppendMessage) => core.edit(message),\n        onReload: (parentId: string | null, config: { runConfig?: any }) =>\n          core.reload(parentId, config),\n        onCancel: async () => {\n          core.cancel();\n        },\n        onAddToolResult: (options) => core.addToolResult(options),\n        onResume: (config) => core.resume(config),\n        setMessages: (messages: readonly ThreadMessage[]) =>\n          core.applyExternalMessages(messages),\n        onImport: (messages: readonly ThreadMessage[]) =>\n          core.applyExternalMessages(messages),\n        onLoadExternalState: (state: ReadonlyJSONValue) =>\n          core.loadExternalState(state),\n        adapters: adapterAdapters,\n      } satisfies ExternalStoreAdapter<ThreadMessage>;\n    },\n    // _version is intentionally included to trigger re-computation when core state changes via notifyUpdate\n    // toolInvocations intentionally excluded: abort/resume use refs internally and work with stale captures\n    [adapterAdapters, core, _version, hasExecutingTools, shared],\n  );\n\n  const baseRuntime = useExternalStoreRuntime(store);\n\n  const runtime = useMemo<AgUiAssistantRuntime>(() => {\n    const wrapper = Object.create(baseRuntime) as AgUiAssistantRuntime;\n    wrapper.unstable_getPendingInterrupts = () =>\n      core.getPendingInterrupts()?.interrupts ?? [];\n    wrapper.unstable_submitInterruptResponses = (responses) =>\n      core.submitInterruptResponses(responses);\n    return wrapper;\n  }, [baseRuntime, core]);\n\n  useEffect(() => {\n    core.attachRuntime(runtime);\n    return () => {\n      core.detachRuntime();\n    };\n  }, [core, runtime]);\n\n  useEffect(() => {\n    core.__internal_load();\n  }, [core]);\n\n  return runtime;\n}\n"],"mappings":"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"}
+{"version":3,"file":"useAgUiRuntime.js","names":[],"sources":["../src/useAgUiRuntime.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  useSyncExternalStore,\n} from \"react\";\nimport {\n  useExternalStoreRuntime,\n  useExternalStoreSharedOptions,\n  useRuntimeAdapters,\n} from \"@assistant-ui/core/react\";\nimport { createMessageQueue } from \"@assistant-ui/core\";\nimport type {\n  MessageQueueController,\n  ToolExecutionStatus,\n} from \"@assistant-ui/core\";\nimport type {\n  AssistantRuntime,\n  AppendMessage,\n  ExternalStoreAdapter,\n  ThreadMessage,\n} from \"@assistant-ui/core\";\nimport type { ReadonlyJSONValue } from \"assistant-stream/utils\";\nimport { makeLogger } from \"./runtime/logger\";\nimport type {\n  AgUiInterrupt,\n  AgUiResumeEntry,\n  UseAgUiRuntimeOptions,\n} from \"./runtime/types\";\nimport { AgUiThreadRuntimeCore } from \"./runtime/AgUiThreadRuntimeCore\";\nimport { agUiExtras } from \"./agUiExtras\";\nimport type { QueueItemState } from \"@assistant-ui/core/store\";\n\nconst EMPTY_INTERRUPTS: readonly AgUiInterrupt[] = [];\nconst EMPTY_QUEUE_ITEMS: readonly QueueItemState[] = Object.freeze([]);\nconst subscribeNoop = () => () => {};\n\nexport type AgUiAssistantRuntime = AssistantRuntime & {\n  /**\n   * @deprecated Use the `useAgUiInterrupts()` hook instead. This method is kept\n   * for backward compatibility and will be removed in a future major release.\n   */\n  unstable_getPendingInterrupts: () => readonly AgUiInterrupt[];\n  /**\n   * @deprecated Use the `useAgUiSubmitInterruptResponses()` hook instead. This\n   * method is kept for backward compatibility and will be removed in a future\n   * major release.\n   */\n  unstable_submitInterruptResponses: (\n    responses: readonly AgUiResumeEntry[],\n  ) => Promise<void>;\n};\n\nexport function useAgUiRuntime(\n  options: UseAgUiRuntimeOptions,\n): AgUiAssistantRuntime {\n  const logger = useMemo(() => makeLogger(options.logger), [options.logger]);\n  const [_version, setVersion] = useState(0);\n  const notifyUpdate = useCallback(() => setVersion((v) => v + 1), []);\n  const coreRef = useRef<AgUiThreadRuntimeCore | null>(null);\n  const runtimeAdapters = useRuntimeAdapters();\n\n  const historyAdapter = options.adapters?.history ?? runtimeAdapters?.history;\n  const threadListAdapter = options.adapters?.threadList;\n\n  if (!coreRef.current) {\n    coreRef.current = new AgUiThreadRuntimeCore({\n      agent: options.agent,\n      logger,\n      showThinking: options.showThinking ?? true,\n      autoCancelPendingToolCalls: options.autoCancelPendingToolCalls,\n      ...(options.onError && { onError: options.onError }),\n      ...(options.onCancel && { onCancel: options.onCancel }),\n      ...(historyAdapter && { history: historyAdapter }),\n      notifyUpdate,\n    });\n  }\n\n  const core = coreRef.current;\n  core.updateOptions({\n    agent: options.agent,\n    logger,\n    showThinking: options.showThinking ?? true,\n    autoCancelPendingToolCalls: options.autoCancelPendingToolCalls,\n    ...(options.onError && { onError: options.onError }),\n    ...(options.onCancel && { onCancel: options.onCancel }),\n    ...(historyAdapter && { history: historyAdapter }),\n  });\n\n  const [toolStatuses, setToolStatuses] = useState<\n    Record<string, ToolExecutionStatus>\n  >({});\n\n  const hasExecutingTools = Object.values(toolStatuses).some(\n    (s) => s?.type === \"executing\",\n  );\n  const isRunning = core.isRunning() || hasExecutingTools;\n\n  // The driver sends through the agent core rather than the runtime, because\n  // the runtime's append routes every tail append back into this queue.\n  const queueRef = useRef<MessageQueueController | null>(null);\n  // Counts rendered busy edges, whether a run start or an interrupt arriving.\n  // A dispatch whose count never moves was never observed as busy, so no\n  // falling edge is coming to release the queue.\n  const busyEdgesRef = useRef(0);\n  if (options.unstable_enableMessageQueue && !queueRef.current) {\n    queueRef.current = createMessageQueue({\n      run: (message) => {\n        const controller = queueRef.current;\n        const edgesAtDispatch = busyEdgesRef.current;\n        // The queue drops the item before dispatching and stays busy until an\n        // idle edge. An append observed as busy is released by that falling\n        // edge, and releasing again here would advance the queue twice; one\n        // that never runs (a pre-run rejection, or startRun false) has to be\n        // released here or every later send buffers forever. An interrupt is\n        // rechecked because a run that resolves without yielding to React\n        // reaches here before the effect below has seen either edge.\n        const releaseIfNoRun = () => {\n          if (\n            queueRef.current !== controller ||\n            busyEdgesRef.current !== edgesAtDispatch ||\n            core.getPendingInterrupts() !== null\n          )\n            return;\n          controller?.notifyIdle();\n        };\n        void core.append(message).then(releaseIfNoRun, (e: unknown) => {\n          releaseIfNoRun();\n          logger.error?.(\"[agui] queued message failed to send\", e);\n        });\n      },\n    });\n  } else if (!options.unstable_enableMessageQueue && queueRef.current) {\n    queueRef.current.clear();\n    queueRef.current = null;\n  }\n  const queueController = options.unstable_enableMessageQueue\n    ? queueRef.current\n    : null;\n\n  // Feeds the store memo below: the runtime core skips an adapter whose\n  // identity is unchanged, so queue items have to move the store reference or\n  // subscribers never see composer.queue change.\n  const queueItems = useSyncExternalStore(\n    queueController?.subscribe ?? subscribeNoop,\n    () => queueController?.adapter.items ?? EMPTY_QUEUE_ITEMS,\n    () => EMPTY_QUEUE_ITEMS,\n  );\n  const steerQueueItems = useSyncExternalStore(\n    queueController?.subscribe ?? subscribeNoop,\n    () => queueController?.adapter.steerItems ?? EMPTY_QUEUE_ITEMS,\n    () => EMPTY_QUEUE_ITEMS,\n  );\n\n  // Holds the queue while client-side tools are still executing, and while an\n  // interrupt is unanswered: `append` refuses a new run until it is resolved,\n  // and the queue drops an item before dispatching it, so draining into that\n  // refusal would lose the message instead of keeping it visible.\n  const queueBusy = isRunning || core.getPendingInterrupts() !== null;\n  useEffect(() => {\n    if (queueBusy) {\n      busyEdgesRef.current++;\n      queueController?.notifyBusy();\n    } else {\n      queueController?.notifyIdle();\n    }\n  }, [queueBusy, queueController]);\n\n  const threadList = useMemo(() => {\n    if (!threadListAdapter) return undefined;\n\n    const { onSwitchToNewThread, onSwitchToThread, ...rest } =\n      threadListAdapter;\n\n    return {\n      ...rest,\n      onSwitchToNewThread: onSwitchToNewThread\n        ? async () => {\n            await onSwitchToNewThread();\n            core.applyExternalMessages([]);\n            core.resetState();\n          }\n        : undefined,\n      onSwitchToThread: onSwitchToThread\n        ? async (threadId: string) => {\n            // Clear before the thread id flips, or the old messages leak\n            // into the new thread as a sibling branch.\n            core.applyExternalMessages([]);\n            const result = await onSwitchToThread(threadId);\n            core.applyExternalMessages(result.messages);\n            if (result.state !== undefined) {\n              core.loadExternalState(result.state);\n            } else {\n              core.resetState();\n            }\n            if (result.unstable_resume) {\n              void core.resumeInFlightRun(result.messages);\n            }\n          }\n        : undefined,\n    };\n  }, [threadListAdapter, core]);\n\n  const adapters = options.adapters;\n  const adapterAdapters = useMemo(\n    () => ({\n      attachments: adapters?.attachments ?? runtimeAdapters?.attachments,\n      speech: adapters?.speech,\n      dictation: adapters?.dictation,\n      voice: adapters?.voice,\n      feedback: adapters?.feedback,\n      threadList,\n    }),\n    [adapters, runtimeAdapters, threadList],\n  );\n\n  const shared = useExternalStoreSharedOptions(options);\n  const store = useMemo(\n    () => {\n      void _version; // rerender on version change\n\n      return {\n        ...shared,\n        isLoading: core.isLoading,\n        messageRepository: core.getMessageRepository(),\n        state: core.getState(),\n        isRunning,\n        extras: agUiExtras.provide({\n          interrupts:\n            core.getPendingInterrupts()?.interrupts ?? EMPTY_INTERRUPTS,\n          sendA2uiAction: (action) => core.sendA2uiAction(action),\n          submitInterruptResponses: (responses) =>\n            core.submitInterruptResponses(responses),\n          steerAway: (message, responses) => core.steerAway(message, responses),\n          state: core.getState(),\n          setState: (next) => core.setState(next),\n        }),\n        unstable_enableToolInvocations: true,\n        setToolStatuses,\n        onNew: (message: AppendMessage) => core.append(message),\n        onEdit: (message: AppendMessage) => {\n          queueController?.clear();\n          return core.edit(message);\n        },\n        onReload: (parentId: string | null, config: { runConfig?: any }) => {\n          queueController?.clear();\n          return core.reload(parentId, config);\n        },\n        onCancel: async () => {\n          queueController?.clear();\n          core.cancel();\n        },\n        onAddToolResult: (options) => core.addToolResult(options),\n        onResume: (config) => core.resume(config),\n        setMessages: (messages: readonly ThreadMessage[]) =>\n          core.applyExternalMessages(messages),\n        onImport: (messages: readonly ThreadMessage[]) =>\n          core.applyExternalMessages(messages),\n        onLoadExternalState: (state: ReadonlyJSONValue) =>\n          core.loadExternalState(state),\n        adapters: adapterAdapters,\n        ...(queueController && { queue: queueController.adapter }),\n      } satisfies ExternalStoreAdapter<ThreadMessage>;\n    },\n    // _version is intentionally included to trigger re-computation when core state changes via notifyUpdate\n    // toolInvocations intentionally excluded: abort/resume use refs internally and work with stale captures\n    [\n      adapterAdapters,\n      core,\n      _version,\n      isRunning,\n      queueController,\n      queueItems,\n      steerQueueItems,\n      shared,\n    ],\n  );\n\n  const baseRuntime = useExternalStoreRuntime(store);\n\n  const runtime = useMemo<AgUiAssistantRuntime>(() => {\n    const wrapper = Object.create(baseRuntime) as AgUiAssistantRuntime;\n    wrapper.unstable_getPendingInterrupts = () =>\n      core.getPendingInterrupts()?.interrupts ?? [];\n    wrapper.unstable_submitInterruptResponses = (responses) =>\n      core.submitInterruptResponses(responses);\n    return wrapper;\n  }, [baseRuntime, core]);\n\n  useEffect(() => {\n    core.attachRuntime(runtime);\n    return () => {\n      core.detachRuntime();\n    };\n  }, [core, runtime]);\n\n  useEffect(() => {\n    core.__internal_load();\n  }, [core]);\n\n  return runtime;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-ag-ui",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "description": "AG-UI protocol adapter for assistant-ui",
   "keywords": [
     "ag-ui",
@@ -30,10 +30,10 @@
   "sideEffects": false,
   "dependencies": {
     "@ag-ui/client": "^0.0.57",
-    "@assistant-ui/core": "^0.3.4",
-    "@assistant-ui/react-generative-ui": "^0.0.11",
-    "@assistant-ui/store": "^0.3.3",
-    "assistant-stream": "^0.3.32",
+    "@assistant-ui/core": "^0.3.6",
+    "@assistant-ui/react-generative-ui": "^0.0.12",
+    "@assistant-ui/store": "^0.3.4",
+    "assistant-stream": "^0.3.34",
     "fast-json-patch": "^3.1.1"
   },
   "peerDependencies": {
@@ -46,11 +46,14 @@
     }
   },
   "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
     "@types/react": "^19.2.17",
+    "jsdom": "^29.1.1",
     "react": "^19.2.8",
     "vitest": "^4.1.10",
     "zod": "^4.4.3",
-    "@assistant-ui/x-buildutils": "0.0.20"
+    "@assistant-ui/x-buildutils": "0.0.21"
   },
   "publishConfig": {
     "access": "public",

package/src/runtime/AgUiThreadRuntimeCore.ts

@@ -90,6 +90,9 @@ export class AgUiThreadRuntimeCore {
   private exportedRepository: ExportedMessageRepository | undefined;
   private isRunningFlag = false;
   private abortController: AbortController | null = null;
+  // The agent that started the active run. updateOptions can swap this.agent
+  // mid-run, and cancelling has to reach the agent holding the live request.
+  private activeRunAgent: AbstractAgent | null = null;
   private stateSnapshot: ReadonlyJSONValue | undefined;
   private pendingError: Error | null = null;
   private history: ThreadHistoryAdapter | undefined;
@@ -333,7 +336,16 @@ export class AgUiThreadRuntimeCore {
 
   async cancel(): Promise<void> {
     if (!this.abortController) return;
-    this.abortController.abort();
+    // Before the local abort, whose listener runs onCancel synchronously: a
+    // callback that starts another run replaces the agent's controller, and
+    // aborting afterwards would kill that replacement and leave this run live.
+    // The local abort is unconditional because abortRun is a user subclass's
+    // code, and a throw there would otherwise strand the thread as running.
+    try {
+      (this.activeRunAgent ?? this.agent).abortRun();
+    } finally {
+      this.abortController.abort();
+    }
   }
 
   async resume(config: ResumeRunConfig): Promise<void> {
@@ -978,6 +990,8 @@ export class AgUiThreadRuntimeCore {
     const abortController = new AbortController();
     const abortSignal = abortController.signal;
     this.abortController = abortController;
+    const runAgentInstance = this.agent;
+    this.activeRunAgent = runAgentInstance;
 
     let cancelRun = () => dispatch({ type: "RUN_CANCELLED" });
     abortSignal.addEventListener(
@@ -1021,18 +1035,22 @@ export class AgUiThreadRuntimeCore {
           runId,
           logger: this.logger,
           onRunFailed: (error) => {
+            if (abortSignal.aborted) return;
             this.pendingError = error;
             this.onError?.(error);
           },
         });
         try {
-          (this.agent as any).messages = input.messages;
-          (this.agent as any).threadId = input.threadId;
-          (this.agent as any).state = input.state ?? null;
+          (runAgentInstance as any).messages = input.messages;
+          (runAgentInstance as any).threadId = input.threadId;
+          (runAgentInstance as any).state = input.state ?? null;
         } catch {
           // ignore
         }
-        await (this.agent as any).runAgent(input, subscriber, {
+        // HttpAgent ignores this third argument and is cancelled through
+        // agent.abortRun(); it stays for subclasses that inherit the base
+        // no-op abortRun and have no other cancellation hook.
+        await (runAgentInstance as any).runAgent(input, subscriber, {
           signal: abortSignal,
         });
       }
@@ -1217,6 +1235,7 @@ export class AgUiThreadRuntimeCore {
   private finishRun(controller: AbortController | null) {
     if (this.abortController === controller) {
       this.abortController = null;
+      this.activeRunAgent = null;
     }
     this.setRunning(false);
   }

package/src/runtime/types.ts

@@ -71,6 +71,13 @@ export type UseAgUiRuntimeOptions = ExternalStoreSharedOptions & {
    * Defaults to `true`.
    */
   autoCancelPendingToolCalls?: boolean | undefined;
+  /**
+   * Buffer a message sent while a run is in flight and send it once the run
+   * 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.
+   */
+  unstable_enableMessageQueue?: boolean | undefined;
   onError?: (e: Error) => void;
   onCancel?: () => void;
   adapters?: UseAgUiRuntimeAdapters;

package/src/useAgUiRuntime.queue.test.tsx

@@ -0,0 +1,352 @@
+// @vitest-environment jsdom
+
+import { describe, it, expect, vi, afterEach } from "vitest";
+import {
+  act,
+  cleanup,
+  render,
+  renderHook,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import type { AssistantRuntime } from "@assistant-ui/core";
+import { AssistantRuntimeProvider } from "@assistant-ui/core/react";
+import { useAuiState } from "@assistant-ui/store";
+import type { HttpAgent } from "@ag-ui/client";
+import { useAgUiRuntime } from "./useAgUiRuntime";
+
+const gatedAgent = () => {
+  let release!: () => void;
+  const gate = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const runAgent = vi.fn(
+    async (_input: unknown, subscriber: { onRunFinalized?: () => void }) => {
+      if (runAgent.mock.calls.length === 1) await gate;
+      subscriber.onRunFinalized?.();
+    },
+  );
+  return {
+    agent: { runAgent } as unknown as HttpAgent,
+    runAgent,
+    release: () => release(),
+  };
+};
+
+// Asserts through a subscribed consumer rather than the runtime object, which
+// stays correct on read even when the store identity never moves.
+const QueuedPrompts = () => {
+  const prompts = useAuiState((s) =>
+    s.composer.queue.map((item) => item.prompt).join(","),
+  );
+  return <div data-testid="queued">{prompts}</div>;
+};
+
+const mount = (runtime: AssistantRuntime) =>
+  render(
+    <AssistantRuntimeProvider runtime={runtime}>
+      <QueuedPrompts />
+    </AssistantRuntimeProvider>,
+  );
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("useAgUiRuntime unstable_enableMessageQueue", () => {
+  it("buffers a send during a run and flushes it once the run settles", async () => {
+    const { agent, runAgent, release } = gatedAgent();
+
+    const { result } = renderHook(() =>
+      useAgUiRuntime({ agent, unstable_enableMessageQueue: true }),
+    );
+    mount(result.current);
+
+    await act(async () => {
+      await result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "first" }],
+      });
+    });
+    await waitFor(() => expect(runAgent).toHaveBeenCalledTimes(1));
+    expect(result.current.thread.getState().capabilities.queue).toBe(true);
+
+    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,
+      });
+    });
+
+    // buffered rather than starting a second run, and visible to subscribers
+    expect(runAgent).toHaveBeenCalledTimes(1);
+    await waitFor(() =>
+      expect(screen.getByTestId("queued").textContent).toBe("second"),
+    );
+
+    await act(async () => {
+      release();
+    });
+
+    await waitFor(() => expect(runAgent).toHaveBeenCalledTimes(2));
+    await waitFor(() =>
+      expect(screen.getByTestId("queued").textContent).toBe(""),
+    );
+  });
+
+  it("keeps accepting sends after a queued run fails", async () => {
+    const runAgent = vi.fn(
+      async (_input: unknown, subscriber: { onRunFinalized?: () => void }) => {
+        if (runAgent.mock.calls.length === 1) throw new Error("boom");
+        subscriber.onRunFinalized?.();
+      },
+    );
+    const agent = { runAgent } as unknown as HttpAgent;
+
+    const { result } = renderHook(() =>
+      useAgUiRuntime({
+        agent,
+        unstable_enableMessageQueue: true,
+        onError: () => {},
+      }),
+    );
+    mount(result.current);
+
+    await act(async () => {
+      await result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "first" }],
+      });
+    });
+    await waitFor(() => expect(runAgent).toHaveBeenCalledTimes(1));
+
+    // the failed run must not leave the queue permanently busy
+    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(runAgent).toHaveBeenCalledTimes(2));
+    await waitFor(() =>
+      expect(screen.getByTestId("queued").textContent).toBe(""),
+    );
+  });
+
+  it("advances one item at a time when a queued dispatch fails", async () => {
+    const gate = (() => {
+      let release!: () => void;
+      const promise = new Promise<void>((r) => {
+        release = r;
+      });
+      return { promise, release: () => release() };
+    })();
+    // every run is held, so a second concurrent dispatch is observable as a
+    // call count rather than being hidden by sequential draining
+    const held: Array<() => void> = [];
+    const runAgent = vi.fn(async () => {
+      if (runAgent.mock.calls.length === 1) {
+        await gate.promise;
+        throw new Error("boom");
+      }
+      await new Promise<void>((resolve) => held.push(resolve));
+    });
+    const agent = { runAgent } as unknown as HttpAgent;
+
+    const { result } = renderHook(() =>
+      useAgUiRuntime({
+        agent,
+        unstable_enableMessageQueue: true,
+        onError: () => {},
+      }),
+    );
+    mount(result.current);
+
+    const send = async (text: string) => {
+      await act(async () => {
+        await result.current.thread.append({
+          role: "user",
+          content: [{ type: "text", text }],
+          parentId:
+            result.current.thread.getState().messages.at(-1)?.id ?? null,
+        });
+      });
+    };
+
+    await send("first");
+    await waitFor(() => expect(runAgent).toHaveBeenCalledTimes(1));
+
+    // two behind the gated run, so a double release would drain both
+    await send("second");
+    await send("third");
+    await waitFor(() =>
+      expect(screen.getByTestId("queued").textContent).toBe("second,third"),
+    );
+
+    await act(async () => {
+      gate.release();
+    });
+
+    // exactly one item advances; a double release would have drained both
+    await waitFor(() => expect(runAgent).toHaveBeenCalledTimes(2));
+    await waitFor(() =>
+      expect(screen.getByTestId("queued").textContent).toBe("third"),
+    );
+    expect(runAgent).toHaveBeenCalledTimes(2);
+  });
+
+  it("holds a queued message when the run settles on an interrupt", async () => {
+    const gate = (() => {
+      let release!: () => void;
+      const promise = new Promise<void>((r) => {
+        release = r;
+      });
+      return { promise, release: () => release() };
+    })();
+    const runAgent = vi.fn(
+      async (
+        _input: unknown,
+        subscriber: {
+          onRunFinishedEvent?: (e: unknown) => void;
+          onRunFinalized?: () => void;
+        },
+      ) => {
+        if (runAgent.mock.calls.length === 1) {
+          await gate.promise;
+          subscriber.onRunFinishedEvent?.({
+            event: {
+              type: "RUN_FINISHED",
+              runId: "run",
+              outcome: {
+                type: "interrupt",
+                interrupts: [{ id: "int-1", reason: "tool_call" }],
+              },
+            },
+          });
+        }
+        subscriber.onRunFinalized?.();
+      },
+    );
+    const agent = { runAgent } as unknown as HttpAgent;
+
+    const { result } = renderHook(() =>
+      useAgUiRuntime({ agent, unstable_enableMessageQueue: true }),
+    );
+    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"),
+    );
+
+    await act(async () => {
+      gate.release();
+    });
+
+    // append refuses a new run until the interrupt is answered, so the queued
+    // message must stay visible rather than being dropped into that refusal
+    await waitFor(() =>
+      expect(
+        result.current.thread.getState().messages.at(-1)?.status?.type,
+      ).toBe("requires-action"),
+    );
+    expect(runAgent).toHaveBeenCalledTimes(1);
+    expect(screen.getByTestId("queued").textContent).toBe("second");
+  });
+
+  it("does not wedge on an append that starts no run", async () => {
+    const { agent, runAgent } = gatedAgent();
+
+    const { result } = renderHook(() =>
+      useAgUiRuntime({ agent, unstable_enableMessageQueue: true }),
+    );
+    mount(result.current);
+
+    // startRun false never reaches the agent, so it produces no falling edge
+    await act(async () => {
+      await result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "staged" }],
+        startRun: false,
+      });
+    });
+    expect(runAgent).toHaveBeenCalledTimes(0);
+
+    await act(async () => {
+      await result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "real" }],
+        parentId: result.current.thread.getState().messages.at(-1)?.id ?? null,
+      });
+    });
+
+    await waitFor(() => expect(runAgent).toHaveBeenCalledTimes(1));
+    await waitFor(() =>
+      expect(screen.getByTestId("queued").textContent).toBe(""),
+    );
+  });
+
+  it("clears queued items when the flag is turned off", async () => {
+    const { agent, runAgent } = gatedAgent();
+
+    const { result, rerender } = renderHook(
+      ({ enabled }: { enabled: boolean }) =>
+        useAgUiRuntime({ agent, unstable_enableMessageQueue: enabled }),
+      { initialProps: { enabled: true } },
+    );
+    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"),
+    );
+
+    await act(async () => {
+      rerender({ enabled: false });
+    });
+
+    expect(result.current.thread.getState().capabilities.queue).toBe(false);
+    await waitFor(() =>
+      expect(screen.getByTestId("queued").textContent).toBe(""),
+    );
+  });
+
+  it("leaves the queue capability off when the flag is not set", () => {
+    const { agent } = gatedAgent();
+
+    const { result } = renderHook(() => useAgUiRuntime({ agent }));
+
+    expect(result.current.thread.getState().capabilities.queue).toBe(false);
+  });
+});