@assistant-ui/core 0.3.17 → 0.3.19

package/src/tests/external-store-thread-runtime-core-adapter.test.ts

@@ -4,6 +4,7 @@ import {
   hasUpcomingMessage,
 } from "../runtimes/external-store/external-store-thread-runtime-core";
 import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
+import type { RealtimeVoiceAdapter } from "../adapters/voice";
 import type { ModelContextProvider } from "../model-context/types";
 import type { AppendMessage, ThreadMessage } from "../types/message";
 import { createMessageQueue } from "../runtime/queue/message-queue";
@@ -160,26 +161,35 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       expect(onNew).not.toHaveBeenCalled();
     });
 
-    it("throws when adapter has no onEdit and parentId differs from head", async () => {
-      const messages = [createUserMessage("u1"), createAssistantMessage("a1")];
-      const adapter = createBaseAdapter({ messages });
-      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+    it.each(["u1", null])(
+      "rejects parent %s without onEdit",
+      async (parentId) => {
+        const messages = [
+          createUserMessage("u1"),
+          createAssistantMessage("a1"),
+        ];
+        const adapter = createBaseAdapter({ messages });
+        const core = new ExternalStoreThreadRuntimeCore(
+          contextProvider,
+          adapter,
+        );
 
-      const appendMessage: AppendMessage = {
-        role: "user",
-        content: [{ type: "text", text: "Edit" }],
-        attachments: [],
-        createdAt: new Date(),
-        parentId: "u1",
-        sourceId: null,
-        runConfig: undefined,
-        metadata: { custom: {} },
-      } as AppendMessage;
+        const appendMessage: AppendMessage = {
+          role: "user",
+          content: [{ type: "text", text: "Edit" }],
+          attachments: [],
+          createdAt: new Date(),
+          parentId,
+          sourceId: null,
+          runConfig: undefined,
+          metadata: { custom: {} },
+        } as AppendMessage;
 
-      await expect(core.append(appendMessage)).rejects.toThrow(
-        "Runtime does not support editing messages.",
-      );
-    });
+        await expect(core.append(appendMessage)).rejects.toThrow(
+          "Runtime does not support editing messages.",
+        );
+      },
+    );
   });
 
   describe("startRun", () => {
@@ -1108,6 +1118,44 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       ).resolves.toBeUndefined();
     });
 
+    it("emits a decision after an approval callback accepts", async () => {
+      const message: ThreadMessage = {
+        ...createAssistantMessage("assistant-1"),
+        status: { type: "requires-action", reason: "tool-calls" },
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "tool-1",
+            toolName: "review",
+            args: {},
+            argsText: "{}",
+            approval: { id: "approval-1" },
+          },
+        ],
+      } as ThreadMessage;
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        createBaseAdapter({
+          messages: [message],
+          onRespondToToolApproval: () => {},
+        }),
+      );
+      const answered = vi.fn();
+      core.unstable_on("toolApprovalAnswered", answered);
+
+      await core.respondToToolApproval({
+        approvalId: "approval-1",
+        approved: true,
+      });
+
+      expect(answered).toHaveBeenCalledWith({
+        messageId: "assistant-1",
+        toolCallId: "tool-1",
+        toolName: "review",
+        approved: true,
+      });
+    });
+
     it("handles rejected onCancel callbacks", async () => {
       const error = new Error("cancel failed");
       const consoleError = vi
@@ -1253,3 +1301,115 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
     });
   });
 });
+
+describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
+  const createVoiceAdapter = () => {
+    let transcriptCallback:
+      | ((transcript: RealtimeVoiceAdapter.TranscriptItem) => void)
+      | undefined;
+    const session: RealtimeVoiceAdapter.Session = {
+      status: { type: "running" },
+      isMuted: false,
+      disconnect: vi.fn(),
+      mute: vi.fn(),
+      unmute: vi.fn(),
+      onStatusChange: () => () => {},
+      onTranscript: (callback) => {
+        transcriptCallback = callback;
+        return () => {
+          transcriptCallback = undefined;
+        };
+      },
+      onModeChange: () => () => {},
+      onVolumeChange: () => () => {},
+    };
+    return {
+      adapter: { connect: () => session } satisfies RealtimeVoiceAdapter,
+      emitTranscript: (transcript: RealtimeVoiceAdapter.TranscriptItem) =>
+        transcriptCallback?.(transcript),
+    };
+  };
+
+  const createVoiceCore = () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onNew = vi.fn(async () => {});
+    const onEdit = vi.fn(async () => {});
+    const onReload = vi.fn(async () => {});
+    const onResume = vi.fn(async () => {});
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        onNew,
+        onEdit,
+        onReload,
+        onResume,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+    voiceAdapter.emitTranscript({
+      role: "assistant",
+      text: "Hello",
+      isFinal: true,
+    });
+    return {
+      core,
+      onNew,
+      onEdit,
+      onReload,
+      onResume,
+      transcriptId: core.messages[0]!.id,
+    };
+  };
+
+  it("rejects an edit resubmission of a transcript before reaching the store", async () => {
+    const { core, onNew, onEdit, transcriptId } = createVoiceCore();
+    try {
+      const edit: AppendMessage = {
+        parentId: null,
+        sourceId: transcriptId,
+        role: "user",
+        content: [{ type: "text", text: "again" }],
+        attachments: [],
+        metadata: { custom: {} },
+        createdAt: new Date(),
+        runConfig: {},
+      };
+
+      await expect(core.append(edit)).rejects.toThrow(
+        "Voice transcript messages cannot be edited",
+      );
+      await expect(core.append({ ...edit, startRun: false })).rejects.toThrow(
+        "Voice transcript messages cannot be edited",
+      );
+      expect(onNew).not.toHaveBeenCalled();
+      expect(onEdit).not.toHaveBeenCalled();
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+
+  it("rejects reloading a transcript before reaching the store", async () => {
+    const { core, onReload, onResume, transcriptId } = createVoiceCore();
+    try {
+      await expect(
+        core.startRun({
+          parentId: null,
+          sourceId: transcriptId,
+          runConfig: {},
+        }),
+      ).rejects.toThrow("Voice transcript messages cannot be reloaded");
+      await expect(
+        core.resumeRun({
+          parentId: null,
+          sourceId: transcriptId,
+          runConfig: {},
+        }),
+      ).rejects.toThrow("Voice transcript messages cannot be reloaded");
+      expect(onReload).not.toHaveBeenCalled();
+      expect(onResume).not.toHaveBeenCalled();
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+});

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

@@ -4,6 +4,7 @@ import { act, render, waitFor } from "@testing-library/react";
 import type { FC } from "react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { AuiProvider, useAui } from "@assistant-ui/store";
+import { CompositeAttachmentAdapter } from "../adapters/attachment";
 import type {
   ExternalThreadMessage,
   ExternalThreadProps,
@@ -75,6 +76,75 @@ const renderThread = () => {
 };
 
 describe("ExternalThread attachments", () => {
+  describe.each(["clearAttachments", "reset"] as const)(
+    "%s cleanup",
+    (method) => {
+      it.each(["first throw", "later throw", "rejection", "multiple failures"])(
+        "attempts all pending removals after %s and still rejects",
+        async (failure) => {
+          const error = new Error("removal failed");
+          const remove = vi.fn((attachment: PendingAttachment) => {
+            const fails =
+              attachment.id === (failure === "later throw" ? "two" : "one");
+            if (fails) {
+              if (failure === "rejection") return Promise.reject(error);
+              throw error;
+            }
+            if (failure === "multiple failures" && attachment.id === "two") {
+              return Promise.reject(new Error("another failure"));
+            }
+            return Promise.resolve();
+          });
+          const aui = renderThreadWithProps({
+            attachmentAdapter: {
+              accept: "*",
+              add: async ({ file }) => ({
+                id: file.name,
+                type: "file",
+                name: file.name,
+                contentType: "text/plain",
+                file,
+                status: { type: "requires-action", reason: "composer-send" },
+              }),
+              send: vi.fn(),
+              remove,
+            },
+          });
+          const composer = () => aui().thread().composer();
+          await act(async () => {
+            await composer().addAttachment(
+              new File(["data"], "one", { type: "text/plain" }),
+            );
+            await composer().addAttachment({
+              id: "complete",
+              name: "saved.txt",
+              contentType: "text/plain",
+              content: [],
+            });
+            await composer().addAttachment(
+              new File(["data"], "two", { type: "text/plain" }),
+            );
+            await composer().addAttachment(
+              new File(["data"], "three", { type: "text/plain" }),
+            );
+          });
+          await waitFor(() =>
+            expect(composer().getState().attachments).toHaveLength(4),
+          );
+
+          await act(async () => {
+            await expect(composer()[method]()).rejects.toBe(error);
+          });
+
+          expect(
+            remove.mock.calls.map(([attachment]) => attachment.id),
+          ).toEqual(["one", "two", "three"]);
+          expect(composer().getState().attachments).toEqual([]);
+        },
+      );
+    },
+  );
+
   it("uses generated IDs unless a prepared attachment supplies one", async () => {
     const aui = renderThread();
     mockGenerateId
@@ -404,6 +474,53 @@ describe("ExternalThread attachments", () => {
     },
   );
 
+  it("preserves pending attachments when adapter removal fails", async () => {
+    const error = new Error("remove failed");
+    const remove = vi.fn(async () => {
+      throw error;
+    });
+    const file = new File(["data"], "notes.txt", { type: "text/plain" });
+    const adapter = {
+      accept: "*",
+      add: async () => ({
+        id: "att-1",
+        type: "file" as const,
+        name: file.name,
+        contentType: file.type,
+        file,
+        status: {
+          type: "requires-action" as const,
+          reason: "composer-send" as const,
+        },
+      }),
+      send: async () => ({}) as never,
+      remove,
+    };
+    const aui = renderThreadWithProps({ attachmentAdapter: adapter });
+    const composer = () => aui().thread.composer();
+
+    await act(() => composer().addAttachment(file));
+    await waitFor(() =>
+      expect(composer().getState().attachments).toHaveLength(1),
+    );
+
+    await expect(
+      act(() => composer().attachment({ id: "att-1" }).remove()),
+    ).rejects.toBe(error);
+
+    expect(remove).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "att-1" }),
+    );
+    expect(composer().getState().attachments).toHaveLength(1);
+    await waitFor(() =>
+      expect(composer().getState().attachments[0]?.status).toEqual({
+        type: "incomplete",
+        reason: "error",
+        message: "remove failed",
+      }),
+    );
+  });
+
   it.each([
     [
       "clearAttachments",
@@ -610,6 +727,97 @@ describe("ExternalThread attachments", () => {
     });
   });
 
+  it("removes complete edit attachments without adapter cleanup", async () => {
+    const remove = vi.fn(async () => {});
+    const completeAttachment = {
+      id: "image-1",
+      type: "image",
+      name: "image",
+      content: [{ type: "image", image: "data:image/png;base64,data" }],
+      status: { type: "complete" },
+    } as unknown as CompleteAttachment;
+    const aui = renderThreadWithProps({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [completeAttachment],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      onEdit: () => {},
+      attachmentAdapter: new CompositeAttachmentAdapter([
+        {
+          accept: "image/*",
+          add: async () => {
+            throw new Error("not used");
+          },
+          send: async () => {
+            throw new Error("not used");
+          },
+          remove,
+        },
+      ]),
+    });
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+
+    await act(async () => composer().beginEdit());
+    await waitFor(() =>
+      expect(composer().getState().attachments).toHaveLength(1),
+    );
+    await act(() => composer().attachment({ id: "image-1" }).remove());
+
+    expect(remove).not.toHaveBeenCalled();
+    expect(composer().getState().attachments).toEqual([]);
+  });
+
+  it("calls adapter.remove for pending edit attachments", async () => {
+    const remove = vi.fn(async () => {});
+    const file = new File(["data"], "notes.txt", { type: "text/plain" });
+    const aui = renderThreadWithProps({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      onEdit: () => {},
+      attachmentAdapter: {
+        accept: "*",
+        add: async () => ({
+          id: "pending-1",
+          type: "document" as const,
+          name: file.name,
+          contentType: file.type,
+          file,
+          status: {
+            type: "requires-action" as const,
+            reason: "composer-send" as const,
+          },
+        }),
+        send: async () => ({}) as never,
+        remove,
+      },
+    });
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+
+    await act(async () => composer().beginEdit());
+    await act(() => composer().addAttachment(file));
+    await act(() => composer().attachment({ id: "pending-1" }).remove());
+
+    expect(remove).toHaveBeenCalledTimes(1);
+    expect(remove).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "pending-1" }),
+    );
+    expect(composer().getState().attachments).toEqual([]);
+  });
+
   it("merges the failed send into a draft the user already modified", async () => {
     vi.spyOn(console, "error").mockImplementation(() => {});
     let rejectSend!: (reason: unknown) => void;

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

@@ -203,6 +203,40 @@ describe("ExternalThread part status", () => {
   });
 });
 
+describe("ExternalThread tasks", () => {
+  it("derives nested conversations and resolves their task scope", () => {
+    const { aui } = renderThread({
+      messages: [
+        assistantMessageWithContent({ type: "running" }, [
+          {
+            type: "tool-call",
+            toolCallId: "delegate-1",
+            toolName: "delegate",
+            args: {},
+            argsText: "{}",
+            messages: [
+              assistantMessageWithContent(
+                { type: "running" },
+                [],
+                "nested-message-1",
+              ),
+            ],
+          },
+        ]),
+      ],
+      isRunning: true,
+    });
+
+    const [task] = aui().thread.getState().tasks;
+    expect(task).toMatchObject({
+      id: "delegate-1",
+      toolName: "delegate",
+      messageId: "a1",
+    });
+    expect(aui().thread.task({ id: "delegate-1" }).getState()).toBe(task);
+  });
+});
+
 describe("ExternalThread unset optional callbacks", () => {
   it("throws a capability error when the callback prop is not set", () => {
     const { aui } = renderThread({
@@ -229,6 +263,29 @@ describe("ExternalThread unset optional callbacks", () => {
   });
 });
 
+describe("ExternalThread append parent selection", () => {
+  it("passes an explicit null parent to the host", () => {
+    const onNew = vi.fn();
+    const { aui } = renderThread({
+      messages: [assistantMessage({ type: "complete", reason: "stop" })],
+      onNew,
+    });
+
+    aui().thread.append({
+      parentId: null,
+      content: [{ type: "text", text: "new root" }],
+      startRun: false,
+    });
+
+    expect(onNew).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({
+        parentId: null,
+        content: [{ type: "text", text: "new root" }],
+      }),
+    );
+  });
+});
+
 describe("ExternalThread composer", () => {
   it("dispatches a synchronous setText + send sequence", async () => {
     const onNew = vi.fn();

package/src/tests/groupParts.test.ts

@@ -114,6 +114,53 @@ describe("groupPartByType", () => {
     ]);
   });
 
+  it("routes a tool call by name through its tool-call:<name> entry", () => {
+    const fn = groupPartByType({
+      "tool-call:task": ["group-subagents"],
+      "tool-call": ["group-tool"],
+    });
+
+    expect(
+      fn(
+        part({
+          type: "tool-call",
+          toolName: "task",
+        } as Partial<PartState>),
+      ),
+    ).toEqual(["group-subagents"]);
+  });
+
+  it("falls back to the plain tool-call entry for other tool names", () => {
+    const fn = groupPartByType({
+      "tool-call:task": ["group-subagents"],
+      "tool-call": ["group-tool"],
+    });
+
+    expect(
+      fn(
+        part({
+          type: "tool-call",
+          toolName: "search",
+        } as Partial<PartState>),
+      ),
+    ).toEqual(["group-tool"]);
+  });
+
+  it("routes standalone tool calls before matching a tool name entry", () => {
+    const fn = groupPartByType({
+      "standalone-tool-call": ["group-standalone"],
+      "tool-call:task": ["group-subagents"],
+      "tool-call": ["group-tool"],
+    });
+    const standaloneTask = part({
+      type: "tool-call",
+      toolName: "task",
+      mcp: { app: { resourceUri: "ui://task" } },
+    } as Partial<PartState>);
+
+    expect(fn(standaloneTask)).toEqual(["group-standalone"]);
+  });
+
   it("returns [] for part types not in the map", () => {
     const fn = groupPartByType({ reasoning: ["group-r"] });
     expect(fn(part({ type: "text" }))).toEqual([]);
@@ -254,6 +301,30 @@ describe("groupPartByType", () => {
     ];
     expect(keyA).not.toBe(keyB);
   });
+
+  it("includes tool-call name entries in an order-insensitive fingerprint", () => {
+    const withoutName = groupPartByType({ "tool-call": ["group-tool"] });
+    const a = groupPartByType({
+      "tool-call:task": ["group-subagents"],
+      "tool-call": ["group-tool"],
+    });
+    const b = groupPartByType({
+      "tool-call": ["group-tool"],
+      "tool-call:task": ["group-subagents"],
+    });
+    const withoutNameKey = (
+      withoutName as unknown as { [GROUPBY_MEMO_KEY]: string }
+    )[GROUPBY_MEMO_KEY];
+    const keyA = (a as unknown as { [GROUPBY_MEMO_KEY]: string })[
+      GROUPBY_MEMO_KEY
+    ];
+    const keyB = (b as unknown as { [GROUPBY_MEMO_KEY]: string })[
+      GROUPBY_MEMO_KEY
+    ];
+
+    expect(keyA).not.toBe(withoutNameKey);
+    expect(keyA).toBe(keyB);
+  });
 });
 
 describe("buildGroupTree idKey", () => {