@assistant-ui/core 0.3.17 → 0.3.19

package/src/tests/message-queue.test.ts

@@ -435,6 +435,259 @@ describe("createMessageQueue", () => {
     });
   });
 
+  describe("synchronous dispatch failures", () => {
+    it("restores a message when the driver throws", () => {
+      const error = new Error("dispatch failed");
+      const run = vi.fn(() => {
+        throw error;
+      });
+      const { adapter } = createMessageQueue({ run });
+
+      expect(() => adapter.enqueue(msg("first"))).toThrow(error);
+      expect(prompts(adapter.items)).toEqual(["first"]);
+
+      run.mockImplementation(() => undefined);
+      adapter.enqueue(msg("second"));
+
+      expect(run).toHaveBeenCalledTimes(2);
+      expect(run).toHaveBeenLastCalledWith(
+        expect.objectContaining({ content: [{ type: "text", text: "first" }] }),
+        { steer: false },
+      );
+      expect(prompts(adapter.items)).toEqual(["second"]);
+    });
+
+    it("does not restore work after the driver starts its run", () => {
+      const error = new Error("dispatch failed");
+      let fail = true;
+      let controller!: ReturnType<typeof createMessageQueue>;
+      const run = vi.fn(() => {
+        if (!fail) return;
+        controller.notifyBusy();
+        throw error;
+      });
+      controller = createMessageQueue({ run });
+
+      expect(() => controller.adapter.enqueue(msg("first"))).toThrow(error);
+      expect(prompts(controller.adapter.items)).toEqual([]);
+
+      fail = false;
+      controller.adapter.enqueue(msg("second"));
+      expect(run).toHaveBeenCalledOnce();
+
+      controller.notifyIdle();
+      expect(run).toHaveBeenCalledTimes(2);
+      expect(run).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          content: [{ type: "text", text: "second" }],
+        }),
+        { steer: false },
+      );
+      expect(prompts(controller.adapter.items)).toEqual([]);
+    });
+
+    it("restores a message when its dispatch transform throws", () => {
+      const error = new Error("transform failed");
+      const run = vi.fn();
+      const { adapter } = createMessageQueue({ run });
+      adapter.__internal_setDispatchTransform(() => {
+        throw error;
+      });
+
+      expect(() => adapter.enqueue(msg("first"))).toThrow(error);
+      expect(run).not.toHaveBeenCalled();
+      expect(prompts(adapter.items)).toEqual(["first"]);
+
+      adapter.__internal_setDispatchTransform((message) => message);
+      adapter.enqueue(msg("second"));
+
+      expect(run).toHaveBeenCalledWith(
+        expect.objectContaining({ content: [{ type: "text", text: "first" }] }),
+        { steer: false },
+      );
+      expect(prompts(adapter.items)).toEqual(["second"]);
+    });
+
+    it("restores a steer when cancellation throws", () => {
+      const error = new Error("cancel failed");
+      const run = vi.fn();
+      const cancel = vi.fn(() => {
+        throw error;
+      });
+      const { adapter, notifyIdle } = createMessageQueue({ run, cancel });
+
+      adapter.enqueue(msg("active"));
+      expect(() => adapter.steer(msg("urgent"))).toThrow(error);
+      expect(prompts(adapter.steerItems)).toEqual(["urgent"]);
+
+      notifyIdle();
+      expect(run).toHaveBeenCalledOnce();
+
+      cancel.mockImplementation(() => undefined);
+      adapter.enqueue(msg("later"));
+      expect(run).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          content: [{ type: "text", text: "urgent" }],
+        }),
+        { steer: false },
+      );
+      expect(prompts(adapter.items)).toEqual(["later"]);
+    });
+
+    it("restores a steer when its dispatch transform throws", () => {
+      const error = new Error("transform failed");
+      const run = vi.fn();
+      const cancel = vi.fn();
+      const { adapter, notifyIdle } = createMessageQueue({ run, cancel });
+
+      adapter.enqueue(msg("active"));
+      adapter.__internal_setDispatchTransform(() => {
+        throw error;
+      });
+
+      expect(() => adapter.steer(msg("urgent"))).toThrow(error);
+      expect(cancel).toHaveBeenCalledOnce();
+      expect(prompts(adapter.steerItems)).toEqual(["urgent"]);
+
+      notifyIdle();
+      adapter.__internal_setDispatchTransform((message) => message);
+      adapter.enqueue(msg("later"));
+
+      expect(run).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          content: [{ type: "text", text: "urgent" }],
+        }),
+        { steer: false },
+      );
+      expect(prompts(adapter.items)).toEqual(["later"]);
+    });
+
+    it("restores a steer when its replacement run throws", () => {
+      const error = new Error("steer failed");
+      let failSteer = true;
+      const run = vi.fn(
+        (_message: AppendMessage, options: { steer: boolean }) => {
+          if (options.steer && failSteer) throw error;
+        },
+      );
+      const { adapter, notifyIdle } = createMessageQueue({
+        run,
+        cancel: vi.fn(),
+      });
+
+      adapter.enqueue(msg("active"));
+      expect(() => adapter.steer(msg("urgent"))).toThrow(error);
+      expect(prompts(adapter.steerItems)).toEqual(["urgent"]);
+
+      failSteer = false;
+      notifyIdle();
+      expect(run).toHaveBeenCalledTimes(2);
+
+      adapter.enqueue(msg("later"));
+      expect(run).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          content: [{ type: "text", text: "urgent" }],
+        }),
+        { steer: false },
+      );
+      expect(prompts(adapter.items)).toEqual(["later"]);
+    });
+
+    it("recovers when cancellation settles before the replacement throws", () => {
+      const error = new Error("steer failed");
+      let failSteer = true;
+      let controller!: ReturnType<typeof createMessageQueue>;
+      controller = createMessageQueue({
+        run: (_message, options) => {
+          if (options.steer && failSteer) throw error;
+        },
+        cancel: () => controller.notifyIdle(),
+      });
+
+      controller.adapter.enqueue(msg("active"));
+      expect(() => controller.adapter.steer(msg("urgent"))).toThrow(error);
+      expect(prompts(controller.adapter.steerItems)).toEqual(["urgent"]);
+
+      failSteer = false;
+      controller.adapter.enqueue(msg("later"));
+
+      expect(prompts(controller.adapter.steerItems)).toEqual([]);
+      expect(prompts(controller.adapter.items)).toEqual(["later"]);
+    });
+
+    it("does not restore a steer after its replacement run starts", () => {
+      const error = new Error("steer failed");
+      let failSteer = true;
+      let controller!: ReturnType<typeof createMessageQueue>;
+      const run = vi.fn(
+        (_message: AppendMessage, options: { steer: boolean }) => {
+          if (!options.steer || !failSteer) return;
+          controller.notifyBusy();
+          throw error;
+        },
+      );
+      controller = createMessageQueue({
+        run,
+        cancel: () => controller.notifyIdle(),
+      });
+
+      controller.adapter.enqueue(msg("active"));
+      expect(() => controller.adapter.steer(msg("urgent"))).toThrow(error);
+      expect(prompts(controller.adapter.steerItems)).toEqual([]);
+
+      failSteer = false;
+      controller.adapter.enqueue(msg("later"));
+      expect(run).toHaveBeenCalledTimes(2);
+
+      controller.notifyIdle();
+      expect(run).toHaveBeenCalledTimes(3);
+      expect(run).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          content: [{ type: "text", text: "later" }],
+        }),
+        { steer: false },
+      );
+      expect(prompts(controller.adapter.items)).toEqual([]);
+    });
+
+    it("restores an unanchored move when its replacement run throws", () => {
+      const error = new Error("steer failed");
+      let failSteer = true;
+      const run = vi.fn(
+        (_message: AppendMessage, options: { steer: boolean }) => {
+          if (options.steer && failSteer) throw error;
+        },
+      );
+      const { adapter, notifyIdle } = createMessageQueue({
+        run,
+        cancel: vi.fn(),
+      });
+
+      adapter.enqueue(msg("active"));
+      adapter.enqueue(msg("first"));
+      adapter.enqueue(msg("second"));
+      adapter.enqueue(msg("moved"));
+      const movedId = adapter.items[2]!.id;
+
+      expect(() => adapter.move(movedId, { lane: "steer" })).toThrow(error);
+      expect(adapter.steerItems).toHaveLength(0);
+      expect(prompts(adapter.items)).toEqual(["first", "second", "moved"]);
+      expect(adapter.items[2]?.id).toBe(movedId);
+
+      failSteer = false;
+      notifyIdle();
+      adapter.enqueue(msg("later"));
+
+      expect(run).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          content: [{ type: "text", text: "first" }],
+        }),
+        { steer: false },
+      );
+      expect(prompts(adapter.items)).toEqual(["second", "moved", "later"]);
+    });
+  });
+
   it("notifyCancelled keeps items and pauses advance until the next send", () => {
     const run = vi.fn();
     const { adapter, notifyIdle, notifyCancelled } = createMessageQueue({

package/src/tests/remote-thread-list-isLoading.test.ts

@@ -26,6 +26,7 @@ type ListResult = {
 
 const INITIAL_STATE: RemoteThreadState = {
   isLoading: true,
+  loadError: undefined,
   isLoadingMore: false,
   cursor: undefined,
   newThreadId: undefined,

package/src/tests/remote-thread-list-reactive-threadId.test.ts

@@ -88,4 +88,55 @@ describe("onThreadIdChange", () => {
       expect(emitted).not.toBe(localId);
     }
   });
+
+  it("does not reject a completed switch when the callback throws", async () => {
+    const callbackError = new Error("host callback failed");
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const cb = vi.fn(() => {
+        throw callbackError;
+      });
+      const { core } = createCoreWithCallback(cb);
+      await flush();
+
+      await expect(core.switchToThread("existing-1")).resolves.toBeUndefined();
+
+      expect(core.mainThreadId).toBe("existing-1");
+      expect(cb).toHaveBeenCalledExactlyOnceWith("existing-1");
+      expect(errorSpy).toHaveBeenCalledWith(
+        "[assistant-ui] onThreadIdChange callback threw an error",
+        callbackError,
+      );
+
+      await expect(core.switchToThread("existing-2")).resolves.toBeUndefined();
+      expect(core.mainThreadId).toBe("existing-2");
+      expect(cb).toHaveBeenLastCalledWith("existing-2");
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it("contains a rejected callback promise", async () => {
+    const callbackError = new Error("async host callback failed");
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const cb = vi.fn(async () => {
+        throw callbackError;
+      });
+      const { core } = createCoreWithCallback(cb);
+      await flush();
+
+      await expect(core.switchToThread("existing-1")).resolves.toBeUndefined();
+      await vi.waitFor(() => {
+        expect(errorSpy).toHaveBeenCalledWith(
+          "[assistant-ui] onThreadIdChange callback threw an error",
+          callbackError,
+        );
+      });
+
+      expect(core.mainThreadId).toBe("existing-1");
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
 });

package/src/tests/thread-list-runtime-getLoadThreadsPromise.test.ts

@@ -9,6 +9,7 @@ const createMockCore = (
   loadPromise: Promise<void> = Promise.resolve(),
 ): ThreadListRuntimeCore => ({
   isLoading: false,
+  loadError: undefined,
   mainThreadId: MAIN_THREAD_ID,
   newThreadId: undefined,
   threadIds: [MAIN_THREAD_ID],

package/src/tests/thread-switch-events.test.tsx

@@ -352,6 +352,84 @@ const switchTo = async (runtime: AssistantRuntime, remoteId: string) => {
   });
 };
 
+describe("ThreadListRuntime.getById", () => {
+  it("keeps background messages and metadata bound to the requested thread", async () => {
+    const harness = renderRemoteList(listAdapter(), async () => ({
+      content: [],
+    }));
+    const runtime = harness.getRuntime();
+    await waitFor(() => {
+      expect(runtime.threads.mainItem.getState().remoteId).toBe("thread-a");
+    });
+    await act(async () => {
+      runtime.thread.reset([
+        {
+          id: "message-a",
+          role: "user",
+          content: [{ type: "text", text: "A" }],
+        },
+      ]);
+    });
+    await switchTo(runtime, "thread-b");
+    await act(async () => {
+      runtime.thread.reset([
+        {
+          id: "message-b",
+          role: "user",
+          content: [{ type: "text", text: "B" }],
+        },
+      ]);
+    });
+    const threadBId = runtime.threads.mainItem.getState().id;
+    await switchTo(runtime, "thread-a");
+
+    const threadB = runtime.threads.getById(threadBId);
+    expect(threadB.getState()).toMatchObject({
+      threadId: threadBId,
+      messages: [{ id: "message-b" }],
+      metadata: {
+        id: threadBId,
+        remoteId: "thread-b",
+        title: "B",
+        isMain: false,
+      },
+    });
+    expect(runtime.thread.getState()).toMatchObject({
+      messages: [{ id: "message-a" }],
+      metadata: { remoteId: "thread-a", isMain: true },
+    });
+
+    let observed = threadB.getState();
+    const unsubscribe = threadB.subscribe(() => {
+      observed = threadB.getState();
+    });
+    try {
+      await act(async () => {
+        await runtime.threads.getItemById(threadBId).rename("Renamed B");
+      });
+      expect(observed).toMatchObject({
+        threadId: threadBId,
+        messages: [{ id: "message-b" }],
+        metadata: { title: "Renamed B", isMain: false },
+      });
+
+      await switchTo(runtime, "thread-b");
+      expect(observed.metadata).toMatchObject({
+        title: "Renamed B",
+        isMain: true,
+      });
+      await switchTo(runtime, "thread-a");
+      expect(observed).toMatchObject({
+        threadId: threadBId,
+        messages: [{ id: "message-b" }],
+        metadata: { title: "Renamed B", isMain: false },
+      });
+    } finally {
+      unsubscribe();
+    }
+  });
+});
+
 describe("background thread run events", () => {
   it("delivers runEnd globally after the running thread is switched away", async () => {
     const runA = deferred<{ content: [] }>();

package/src/tests/tools-scope-migration.test.tsx

@@ -23,6 +23,34 @@ afterEach(() => {
 });
 
 describe("Tools model-context registration", () => {
+  it("registers and removes a tool UI named __proto__", async () => {
+    let aui!: AnyClient;
+    const Harness = () => {
+      aui = useAui({ tools: Tools({}) } as never);
+      return null;
+    };
+    render(<Harness />);
+
+    let remove!: () => void;
+    await act(async () => {
+      remove = aui.tools().setToolUI("__proto__", () => null);
+      await vi.waitFor(() => {
+        const toolUIs = aui.tools().getState().toolUIs;
+        expect(Object.hasOwn(toolUIs, "__proto__")).toBe(true);
+        expect(toolUIs.__proto__).toHaveLength(1);
+      });
+    });
+
+    await act(async () => {
+      remove();
+      await vi.waitFor(() =>
+        expect(Object.hasOwn(aui.tools().getState().toolUIs, "__proto__")).toBe(
+          false,
+        ),
+      );
+    });
+  });
+
   it("migrates to a structurally replaced modelContext scope", async () => {
     let aui!: AnyClient;
     const Harness = ({ generation }: { generation: number }) => {

package/src/tests/useRemoteThreadListRuntime-controlled.test.tsx

@@ -269,6 +269,49 @@ describe("useRemoteThreadListRuntime controlled threadId", () => {
     expect(onThreadIdChange).toHaveBeenLastCalledWith(undefined);
   });
 
+  it("contains rejected callback promises on runtime-initiated switches", async () => {
+    const callbackError = new Error("async host callback failed");
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const adapter = makeAdapter();
+    const onThreadIdChange = vi.fn(async () => {
+      throw callbackError;
+    });
+    const runtimeRef: RuntimeRef = { current: null };
+
+    const { unmount } = render(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId="thread-a"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    try {
+      await waitForRemoteThread(runtimeRef, "thread-a");
+
+      await act(async () => {
+        await expect(
+          runtimeRef.current!.threads.switchToThread("thread-b"),
+        ).resolves.toBeUndefined();
+      });
+
+      await waitFor(() => {
+        expect(errorSpy).toHaveBeenCalledWith(
+          "[assistant-ui] onThreadIdChange callback threw an error",
+          callbackError,
+        );
+      });
+      expect(onThreadIdChange).toHaveBeenCalledExactlyOnceWith("thread-b");
+      expect(runtimeRef.current!.threads.mainItem.getState().remoteId).toBe(
+        "thread-b",
+      );
+    } finally {
+      unmount();
+      errorSpy.mockRestore();
+    }
+  });
+
   it("does not retain suppression after an initial switch fails", async () => {
     let threadAFetchCount = 0;
     const adapter = makeAdapter({

package/src/types/attachment.ts

@@ -57,3 +57,7 @@ export const isCreateAttachment = (
   attachment: File | CreateAttachment,
 ): attachment is CreateAttachment =>
   "content" in attachment && !("lastModified" in attachment);
+
+export const isAttachmentComplete = (
+  attachment: Attachment,
+): attachment is CompleteAttachment => attachment.status.type === "complete";

package/src/types/index.ts

@@ -23,6 +23,7 @@ export type {
   MessageStatus,
   // Thread messages
   MessageTiming,
+  MessageModality,
   ThreadStep,
   ThreadSystemMessage,
   ThreadUserMessage,

package/src/types/message.ts

@@ -395,6 +395,8 @@ export type MessageTiming = {
   readonly toolCallCount: number;
 };
 
+export type MessageModality = "voice";
+
 export type ThreadStep = {
   readonly messageId?: string;
   readonly usage?:
@@ -420,6 +422,7 @@ export type ThreadSystemMessage = MessageCommonProps & {
     readonly steps?: undefined;
     readonly submittedFeedback?: undefined;
     readonly timing?: undefined;
+    readonly modality?: undefined;
     readonly custom: Record<string, unknown>;
   };
 };
@@ -436,6 +439,8 @@ export type ThreadUserMessage = MessageCommonProps & {
     readonly submittedFeedback?: undefined;
     readonly timing?: undefined;
     readonly isOptimistic?: boolean;
+    /** Set when the message was produced by a voice session rather than typed. */
+    readonly modality?: MessageModality;
     readonly custom: Record<string, unknown>;
   };
 };
@@ -456,6 +461,8 @@ export type ThreadAssistantMessage = MessageCommonProps & {
      * once off the head branch and are never persisted.
      */
     readonly isOptimistic?: boolean;
+    /** Set when the message was produced by a voice session rather than typed. */
+    readonly modality?: MessageModality;
     readonly custom: Record<string, unknown>;
   };
 };
@@ -470,6 +477,7 @@ type BaseThreadMessage = {
     readonly submittedFeedback?: { readonly type: "positive" | "negative" };
     readonly timing?: MessageTiming;
     readonly isOptimistic?: boolean;
+    readonly modality?: MessageModality;
     readonly custom: Record<string, unknown>;
   };
   readonly attachments?: ThreadUserMessage["attachments"];