@assistant-ui/core 0.3.18 → 0.3.19

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", () => {

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-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/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/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"];

package/src/utils/abortable-iterable.test.ts

@@ -16,6 +16,121 @@ const collect = async <T>(iterable: AsyncIterable<T>) => {
 };
 
 describe("abortableIterable", () => {
+  it.each([false, true])(
+    "releases the opening abort listener on rejection=%s",
+    async (fails) => {
+      const controller = new AbortController();
+      const added = vi.spyOn(controller.signal, "addEventListener");
+      const removed = vi.spyOn(controller.signal, "removeEventListener");
+      const source: AsyncIterable<number> = {
+        async *[Symbol.asyncIterator]() {
+          yield 1;
+        },
+      };
+      const opening = openAbortableIterable(
+        fails ? Promise.reject(new Error("opening failed")) : source,
+        controller.signal,
+      );
+      if (fails) await expect(opening).rejects.toThrow("opening failed");
+      else await expect(opening).resolves.toBe(source);
+      expect(added).toHaveBeenCalledTimes(1);
+      expect(removed).toHaveBeenCalledWith("abort", added.mock.calls[0]![1]);
+    },
+  );
+
+  it("finalizes once when an aborted read later rejects", async () => {
+    let rejectRead!: (error: unknown) => void;
+    const read = new Promise<IteratorResult<number>>((_, reject) => {
+      rejectRead = reject;
+    });
+    const finalize = vi.fn(async () => ({
+      done: true as const,
+      value: undefined,
+    }));
+    const source: AsyncIterable<number> = {
+      [Symbol.asyncIterator]: () => ({ next: () => read, return: finalize }),
+    };
+    const controller = new AbortController();
+    const iterator = abortableIterable(source, controller.signal)[
+      Symbol.asyncIterator
+    ]();
+    const pending = iterator.next();
+    controller.abort();
+    await expect(pending).resolves.toEqual({ done: true, value: undefined });
+    expect(finalize).toHaveBeenCalledTimes(1);
+    rejectRead(new Error("late failure"));
+    await read.catch(() => {});
+    await iterator.return?.();
+    expect(finalize).toHaveBeenCalledTimes(1);
+  });
+
+  it("releases the listener and finalizes after a synchronous read failure", async () => {
+    const controller = new AbortController();
+    const added = vi.spyOn(controller.signal, "addEventListener");
+    const removed = vi.spyOn(controller.signal, "removeEventListener");
+    const error = new Error("read failed");
+    const finalize = vi.fn(async () => ({
+      done: true as const,
+      value: undefined,
+    }));
+    const source: AsyncIterable<number> = {
+      [Symbol.asyncIterator]: () => ({
+        next: () => {
+          throw error;
+        },
+        return: finalize,
+      }),
+    };
+    await expect(
+      collect(abortableIterable(source, controller.signal)),
+    ).rejects.toBe(error);
+    expect(removed).toHaveBeenCalledWith("abort", added.mock.calls[0]![1]);
+    expect(finalize).toHaveBeenCalledTimes(1);
+    controller.abort();
+    expect(finalize).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not read or finalize again after the consumer returns", async () => {
+    const next = vi.fn(async () => ({ done: false as const, value: 1 }));
+    const finalize = vi.fn(async () => ({
+      done: true as const,
+      value: undefined,
+    }));
+    const source: AsyncIterable<number> = {
+      [Symbol.asyncIterator]: () => ({ next, return: finalize }),
+    };
+    const iterator = abortableIterable(source, new AbortController().signal)[
+      Symbol.asyncIterator
+    ]();
+    await iterator.return?.();
+    await iterator.return?.();
+    await expect(iterator.next()).resolves.toEqual({
+      done: true,
+      value: undefined,
+    });
+    expect(next).not.toHaveBeenCalled();
+    expect(finalize).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not finalize a naturally exhausted source", async () => {
+    const next = vi.fn(async () => ({ done: true as const, value: undefined }));
+    const finalize = vi.fn(async () => ({
+      done: true as const,
+      value: undefined,
+    }));
+    const source: AsyncIterable<number> = {
+      [Symbol.asyncIterator]: () => ({ next, return: finalize }),
+    };
+    const iterator = abortableIterable(source, new AbortController().signal)[
+      Symbol.asyncIterator
+    ]();
+    await iterator.next();
+    await iterator.next();
+    await iterator.return?.();
+    expect(next).toHaveBeenCalledTimes(1);
+    expect(finalize).not.toHaveBeenCalled();
+  });
+
   it("settles an opening stream on abort and finalizes a late iterable", async () => {
     const opened = deferred<AsyncIterable<number>>();
     const finalize = vi.fn(async () => ({