@assistant-ui/react 0.15.9 → 0.15.11

package/src/tests/external-thread-parity.test.tsx

@@ -322,6 +322,130 @@ describe("ExternalThread composer", () => {
     expect(steer).not.toHaveBeenCalled();
   });
 
+  it("dispatches a same-tick beginEdit + setText + send sequence", async () => {
+    const onEdit = vi.fn();
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: false,
+      onEdit,
+    });
+
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+    composer().beginEdit();
+    composer().setText("edited");
+    composer().send();
+
+    await waitFor(() => expect(onEdit).toHaveBeenCalledTimes(1));
+    expect(onEdit.mock.calls[0]![0]).toMatchObject({
+      sourceId: "u1",
+      content: [{ type: "text", text: "edited" }],
+    });
+    await waitFor(() => expect(composer().getState().isEditing).toBe(false));
+  });
+
+  it("prefills the edit composer from the message on beginEdit", async () => {
+    const onEdit = vi.fn();
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "a1",
+          role: "assistant",
+          content: [{ type: "text", text: "original answer" }],
+          createdAt: new Date(0),
+          attachments: [
+            {
+              id: "att1",
+              type: "file",
+              name: "a.txt",
+              contentType: "text/plain",
+              status: { type: "complete" },
+              content: [],
+            },
+          ],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: false,
+      onEdit,
+    });
+
+    const composer = () => aui().thread.message({ id: "a1" }).composer();
+    composer().beginEdit();
+    await waitFor(() => {
+      const state = composer().getState();
+      expect(state.text).toBe("original answer");
+      expect(state.role).toBe("assistant");
+      expect(state.attachments).toHaveLength(1);
+    });
+    expect(() => composer().beginEdit()).toThrow("Edit already in progress");
+
+    composer().send();
+    await waitFor(() => expect(onEdit).toHaveBeenCalledTimes(1));
+    expect(onEdit.mock.calls[0]![0]).toMatchObject({
+      sourceId: "a1",
+      content: [{ type: "text", text: "original answer" }],
+    });
+  });
+
+  it("throws on edit-composer send before beginEdit", () => {
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: false,
+      onEdit: vi.fn(),
+    });
+
+    expect(() => aui().thread.message({ id: "u1" }).composer().send()).toThrow(
+      "Composer is not available",
+    );
+  });
+
+  it("throws on beginEdit when the runtime has no edit handler", () => {
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: false,
+      queue: {
+        items: [],
+        steerItems: [],
+        enqueue: vi.fn(),
+        steer: vi.fn(),
+        move: vi.fn(),
+        edit: vi.fn(),
+        remove: vi.fn(),
+      },
+    });
+
+    expect(() =>
+      aui().thread.message({ id: "u1" }).composer().beginEdit(),
+    ).toThrow("Runtime does not support editing.");
+  });
+
   it("still refuses to send an empty composer synchronously after a send", async () => {
     const onNew = vi.fn();
     const { aui } = renderThread({ messages: [], isRunning: false, onNew });

package/src/tests/in-memory-thread-list.test.tsx

@@ -0,0 +1,55 @@
+// @vitest-environment jsdom
+
+import { render, waitFor } from "@testing-library/react";
+import type { FC } from "react";
+import { describe, it, expect } from "vitest";
+import { useAui, AuiProvider } from "@assistant-ui/store";
+import { InMemoryThreadList } from "../client/InMemoryThreadList";
+import { ExternalThread } from "../client/ExternalThread";
+
+const renderThreads = () => {
+  const captured: { aui?: ReturnType<typeof useAui> } = {};
+  const Capture: FC = () => {
+    captured.aui = useAui();
+    return null;
+  };
+  const App: FC = () => {
+    const aui = useAui({
+      threads: InMemoryThreadList({
+        thread: () => ExternalThread({ messages: [] }),
+      }),
+    });
+    return (
+      <AuiProvider value={aui}>
+        <Capture />
+      </AuiProvider>
+    );
+  };
+  render(<App />);
+  return { aui: () => captured.aui! };
+};
+
+describe("InMemoryThreadList delete", () => {
+  it("falls back to a live thread when the switch target is deleted in the same tick", async () => {
+    const { aui } = renderThreads();
+
+    aui().threads.switchToNewThread();
+    await waitFor(() =>
+      expect(aui().threads.getState().mainThreadId).not.toBe("main"),
+    );
+    const newId = aui().threads.getState().mainThreadId;
+    aui().threads.switchToThread("main");
+    await waitFor(() =>
+      expect(aui().threads.getState().mainThreadId).toBe("main"),
+    );
+
+    aui().threads.switchToThread(newId);
+    aui().threads.item({ id: newId }).delete();
+
+    await waitFor(() => {
+      const state = aui().threads.getState();
+      expect(state.mainThreadId).toBe("main");
+      expect(state.threadIds).not.toContain(newId);
+    });
+  });
+});