@assistant-ui/react 0.15.4 → 0.15.6

package/src/tests/local-runtime-queue.test.tsx

@@ -34,7 +34,14 @@ const userTexts = (aui: ReturnType<typeof useAui>) =>
       m.content.map((p) => (p.type === "text" ? p.text : "")).join(""),
     );
 
-const renderWithRuntime = (adapter: ChatModelAdapter, enableQueue: boolean) => {
+const renderWithRuntime = (
+  adapter: ChatModelAdapter,
+  enableQueue: boolean,
+  options?: {
+    unstable_queueClearOnRewind?: boolean;
+    unstable_queueClearOnCancel?: boolean;
+  },
+) => {
   const captured: { aui?: ReturnType<typeof useAui> } = {};
   const Capture: FC = () => {
     captured.aui = useAui();
@@ -43,6 +50,7 @@ const renderWithRuntime = (adapter: ChatModelAdapter, enableQueue: boolean) => {
   const App: FC = () => {
     const runtime = useLocalRuntime(adapter, {
       unstable_enableMessageQueue: enableQueue,
+      ...options,
     });
     return (
       <AssistantRuntimeProvider runtime={runtime}>
@@ -114,6 +122,43 @@ describe("local runtime message queue", () => {
     ).toEqual(["b"]);
   });
 
+  it("defaults a mid-run send to steer, ahead of an explicitly queued item", async () => {
+    const { adapter, releases, getRunCount } = createCountingAdapter();
+    const aui = renderWithRuntime(adapter, true);
+
+    await send(aui, "first");
+    expect(getRunCount()).toBe(1);
+
+    await act(async () => {
+      aui.thread.composer().setText("behind");
+      aui.thread.composer().send({ steer: false });
+      await flush();
+    });
+    await send(aui, "next");
+    expect(
+      aui.thread
+        .composer()
+        .getState()
+        .queue.map((q) => q.prompt),
+    ).toEqual(["next", "behind"]);
+
+    await act(async () => {
+      releases[0]!();
+      await flush();
+      await flush();
+    });
+    expect(getRunCount()).toBe(2);
+    expect(userTexts(aui)).toEqual(["first", "next"]);
+
+    await act(async () => {
+      releases[1]!();
+      await flush();
+      await flush();
+    });
+    expect(getRunCount()).toBe(3);
+    expect(userTexts(aui)).toEqual(["first", "next", "behind"]);
+  });
+
   it("queueItem(index).remove() drops a queued message", async () => {
     const { adapter } = createCountingAdapter();
     const aui = renderWithRuntime(adapter, true);
@@ -132,7 +177,7 @@ describe("local runtime message queue", () => {
     expect(queue[0]!.prompt).toBe("b");
   });
 
-  it("clears the queue when the run is cancelled, without flushing", async () => {
+  it("clears queued items when the user cancels the run", async () => {
     const { adapter, getRunCount } = createCountingAdapter();
     const aui = renderWithRuntime(adapter, true);
 
@@ -147,13 +192,50 @@ describe("local runtime message queue", () => {
       await flush();
     });
 
+    // Stop means stop: nothing pending, nothing dispatched
+    expect(getRunCount()).toBe(1);
     expect(aui.thread.composer().getState().queue).toEqual([]);
-    // cancelling must not start the next queued message
+  });
+
+  it("keeps queued items on cancel when unstable_queueClearOnCancel is false", async () => {
+    const { adapter, getRunCount } = createCountingAdapter();
+    const aui = renderWithRuntime(adapter, true, {
+      unstable_queueClearOnCancel: false,
+    });
+
+    await send(aui, "first");
+    await send(aui, "a");
+    await send(aui, "b");
+    expect(aui.thread.composer().getState().queue).toHaveLength(2);
+
+    await act(async () => {
+      aui.thread.cancelRun();
+      await flush();
+      await flush();
+    });
+
+    // cancel pauses the queue: items survive, nothing auto-dispatches
     expect(getRunCount()).toBe(1);
+    expect(
+      aui.thread
+        .composer()
+        .getState()
+        .queue.map((q) => q.prompt),
+    ).toEqual(["a", "b"]);
+
+    // the next explicit send drains the head
+    await send(aui, "c");
+    expect(getRunCount()).toBe(2);
+    expect(
+      aui.thread
+        .composer()
+        .getState()
+        .queue.map((q) => q.prompt),
+    ).toEqual(["b", "c"]);
   });
 
-  it("applies an edit instead of queuing it, dropping pending items", async () => {
-    const { adapter, releases } = createCountingAdapter();
+  it("applies an edit instead of queuing it and clears the pending items", async () => {
+    const { adapter, releases, getRunCount } = createCountingAdapter();
     const aui = renderWithRuntime(adapter, true);
 
     await send(aui, "first");
@@ -174,10 +256,52 @@ describe("local runtime message queue", () => {
       message.composer().setText("edited");
       message.composer().send();
       await flush();
+      await flush();
+    });
+
+    // the edit is applied (branches the thread); the rewind clears the queue,
+    // so nothing pending dispatches against the new branch
+    expect(aui.thread.composer().getState().queue).toEqual([]);
+    expect(getRunCount()).toBe(3); // first, second, edit — not "queued"
+  });
+
+  it("keeps the queue across an edit when unstable_queueClearOnRewind is false", async () => {
+    const { adapter, releases, getRunCount } = createCountingAdapter();
+    const aui = renderWithRuntime(adapter, true, {
+      unstable_queueClearOnRewind: false,
+    });
+
+    await send(aui, "first");
+    await act(async () => {
+      releases[0]!();
+      await flush();
+    });
+
+    await send(aui, "second");
+    await send(aui, "queued");
+    expect(aui.thread.composer().getState().queue).toHaveLength(1);
+
+    await act(async () => {
+      const message = aui.thread.message({ index: 0 });
+      message.composer().beginEdit();
+      message.composer().setText("edited");
+      message.composer().send();
+      await flush();
+    });
+
+    // the edit's rerun survives; the queued item waits for it to settle
+    expect(getRunCount()).toBe(3);
+    expect(aui.thread.composer().getState().queue).toHaveLength(1);
+
+    await act(async () => {
+      releases[2]!();
+      await flush();
     });
 
-    // the edit is applied (branches the thread) and the stale queue is cleared
+    // the surviving queue drains after the edit's run completes
+    expect(getRunCount()).toBe(4);
     expect(aui.thread.composer().getState().queue).toEqual([]);
+    expect(userTexts(aui)).toEqual(["edited", "queued"]);
   });
 
   it("buffers a send during a regenerate instead of interrupting it", async () => {
@@ -214,6 +338,75 @@ describe("local runtime message queue", () => {
     ).toEqual(["Y"]);
   });
 
+  it("drains the pending head after a regenerate started inside the cancellation window", async () => {
+    const { adapter, releases, getRunCount } = createCountingAdapter();
+    const aui = renderWithRuntime(adapter, true, {
+      unstable_queueClearOnCancel: false,
+    });
+
+    await send(aui, "first");
+    await act(async () => {
+      releases[0]!();
+      await flush();
+    });
+
+    // regenerate, buffer a send, then cancel and regenerate again before
+    // the cancelled settle lands
+    await act(async () => {
+      aui.thread.message({ index: 1 }).reload();
+      await flush();
+    });
+    await send(aui, "pending");
+    await act(async () => {
+      aui.thread.cancelRun();
+      aui.thread.message({ index: 1 }).reload();
+      await flush();
+    });
+    expect(getRunCount()).toBe(3);
+    expect(aui.thread.composer().getState().queue).toHaveLength(1);
+
+    // the cancelled settle must not eat the replacement's: once the
+    // replacement settles, the pending head drains exactly once
+    await act(async () => {
+      releases[2]!();
+      await flush();
+    });
+    expect(getRunCount()).toBe(4);
+    expect(aui.thread.composer().getState().queue).toEqual([]);
+  });
+
+  it("keeps a second regenerate alive when the first one's settle arrives", async () => {
+    const { adapter, releases, getRunCount } = createCountingAdapter();
+    const aui = renderWithRuntime(adapter, true);
+
+    await send(aui, "first");
+    await act(async () => {
+      releases[0]!();
+      await flush();
+    });
+
+    await act(async () => {
+      aui.thread.message({ index: 1 }).reload();
+      await flush();
+    });
+    await send(aui, "Y");
+
+    // the second regenerate aborts the first; its settle must not dispatch
+    await act(async () => {
+      aui.thread.message({ index: 1 }).reload();
+      await flush();
+    });
+    expect(getRunCount()).toBe(3);
+    expect(aui.thread.composer().getState().queue).toHaveLength(1);
+
+    await act(async () => {
+      releases[2]!();
+      await flush();
+    });
+    expect(getRunCount()).toBe(4);
+    expect(aui.thread.composer().getState().queue).toEqual([]);
+  });
+
   it("advances exactly once after a failed run, without deadlocking", async () => {
     const releases: Array<() => void> = [];
     let runCount = 0;

package/src/utils/createActionButton.test.tsx

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { renderToStaticMarkup } from "react-dom/server";
+import { createActionButton } from "./createActionButton";
+
+const TestButton = createActionButton("TestButton", () => () => {});
+
+describe("createActionButton", () => {
+  it("defaults to type=button", () => {
+    const html = renderToStaticMarkup(<TestButton />);
+    expect(html).toContain('type="button"');
+  });
+
+  it("allows the caller to override type", () => {
+    const html = renderToStaticMarkup(<TestButton type="submit" />);
+    expect(html).toContain('type="submit"');
+    expect(html).not.toContain('type="button"');
+  });
+});

package/src/utils/createActionButton.tsx

@@ -41,8 +41,8 @@ export const createActionButton = <TProps,>(
     const callback = useActionButton(forwardedProps as TProps) ?? undefined;
     return (
       <Primitive.button
-        {...primitiveProps}
         type="button"
+        {...primitiveProps}
         ref={forwardedRef}
         disabled={primitiveProps.disabled || !callback}
         onClick={composeEventHandlers(primitiveProps.onClick, callback)}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 AgentbaseAI Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.