@assistant-ui/core 0.3.13 → 0.3.14

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import {
   ExternalStoreThreadRuntimeCore,
   hasUpcomingMessage,
@@ -49,6 +49,23 @@ const createBaseAdapter = (
   ...overrides,
 });
 
+const captureUnhandledRejections = async (
+  run: () => Promise<void>,
+): Promise<unknown[]> => {
+  const rejections: unknown[] = [];
+  const onUnhandledRejection = (reason: unknown) => {
+    rejections.push(reason);
+  };
+  process.on("unhandledRejection", onUnhandledRejection);
+  try {
+    await run();
+    await new Promise((resolve) => setImmediate(resolve));
+  } finally {
+    process.removeListener("unhandledRejection", onUnhandledRejection);
+  }
+  return rejections;
+};
+
 describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
   let contextProvider: ModelContextProvider;
 
@@ -56,6 +73,10 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
     contextProvider = createContextProvider();
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   it("hasUpcomingMessage is true only while running without an assistant tail", () => {
     expect(hasUpcomingMessage(true, [createUserMessage("u1")])).toBe(true);
     expect(hasUpcomingMessage(true, [createAssistantMessage("a1")])).toBe(
@@ -760,6 +781,175 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
     });
   });
 
+  describe("tool callbacks", () => {
+    it("handles rejected automatic tool result callbacks", async () => {
+      const error = new Error("tool result failed");
+      const consoleError = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      const execute = vi.fn(async () => ({ forecast: "sunny" }));
+      let callbackCalls = 0;
+      const onAddToolResult = () => {
+        callbackCalls += 1;
+        return Promise.reject(error);
+      };
+      const core = new ExternalStoreThreadRuntimeCore(
+        {
+          getModelContext: () => ({
+            tools: {
+              weatherSearch: {
+                parameters: { type: "object", properties: {} },
+                execute,
+              },
+            },
+          }),
+        },
+        createBaseAdapter({
+          unstable_enableToolInvocations: true,
+          onAddToolResult,
+        }),
+      );
+
+      const rejections = await captureUnhandledRejections(async () => {
+        core.__internal_setAdapter(
+          createBaseAdapter({
+            unstable_enableToolInvocations: true,
+            isRunning: true,
+            messages: [
+              {
+                ...createAssistantMessage("a1"),
+                status: { type: "requires-action", reason: "tool-calls" },
+                content: [
+                  {
+                    type: "tool-call",
+                    toolCallId: "tc1",
+                    toolName: "weatherSearch",
+                    args: { city: "London" },
+                    argsText: '{"city":"London"}',
+                  },
+                ],
+              },
+            ],
+            onAddToolResult,
+          }),
+        );
+
+        await vi.waitFor(() =>
+          expect(consoleError).toHaveBeenCalledWith(
+            "[ExternalStoreThreadRuntimeCore] onAddToolResult callback rejected",
+            error,
+          ),
+        );
+      });
+
+      expect(execute).toHaveBeenCalledOnce();
+      expect(callbackCalls).toBe(1);
+      expect(rejections).toEqual([]);
+    });
+
+    it("handles rejected direct tool result callbacks", async () => {
+      const error = new Error("tool result failed");
+      const consoleError = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      let callbackCalls = 0;
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        createBaseAdapter({
+          onAddToolResult: () => {
+            callbackCalls += 1;
+            return Promise.reject(error);
+          },
+        }),
+      );
+
+      const rejections = await captureUnhandledRejections(async () => {
+        core.addToolResult({
+          messageId: "m1",
+          toolName: "weatherSearch",
+          toolCallId: "tc1",
+          result: { forecast: "sunny" },
+          isError: false,
+        });
+
+        await vi.waitFor(() =>
+          expect(consoleError).toHaveBeenCalledWith(
+            "[ExternalStoreThreadRuntimeCore] onAddToolResult callback rejected",
+            error,
+          ),
+        );
+      });
+
+      expect(callbackCalls).toBe(1);
+      expect(rejections).toEqual([]);
+    });
+
+    it("handles rejected onRespondToToolApproval callbacks", async () => {
+      const error = new Error("approval failed");
+      const consoleError = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      let callbackCalls = 0;
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        createBaseAdapter({
+          onRespondToToolApproval: () => {
+            callbackCalls += 1;
+            return Promise.reject(error);
+          },
+        }),
+      );
+
+      const rejections = await captureUnhandledRejections(async () => {
+        core.respondToToolApproval({
+          approvalId: "approval-1",
+          approved: true,
+        });
+
+        await vi.waitFor(() =>
+          expect(consoleError).toHaveBeenCalledWith(
+            "[ExternalStoreThreadRuntimeCore] onRespondToToolApproval callback rejected",
+            error,
+          ),
+        );
+      });
+
+      expect(callbackCalls).toBe(1);
+      expect(rejections).toEqual([]);
+    });
+
+    it("handles rejected onCancel callbacks", async () => {
+      const error = new Error("cancel failed");
+      const consoleError = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      let callbackCalls = 0;
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        createBaseAdapter({
+          onCancel: () => {
+            callbackCalls += 1;
+            return Promise.reject(error);
+          },
+        }),
+      );
+
+      const rejections = await captureUnhandledRejections(async () => {
+        core.cancelRun();
+
+        await vi.waitFor(() =>
+          expect(consoleError).toHaveBeenCalledWith(
+            "[ExternalStoreThreadRuntimeCore] onCancel callback rejected",
+            error,
+          ),
+        );
+      });
+
+      expect(callbackCalls).toBe(1);
+      expect(rejections).toEqual([]);
+    });
+  });
+
   describe("messageRepository incremental sync", () => {
     const u1 = createUserMessage("u1");
     const a1 = createAssistantMessage("a1");

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

@@ -4,6 +4,7 @@ import type { ExternalStoreAdapter } from "../runtimes/external-store/external-s
 import type { ModelContextProvider } from "../model-context/types";
 import type { ThreadMessageLike } from "../runtime/utils/thread-message-like";
 import type { AppendMessage } from "../types/message";
+import { invalidateThreadRuntime } from "../runtime/utils/thread-runtime-lifecycle";
 
 const mockContextProvider: ModelContextProvider = {
   getModelContext: () => ({}),
@@ -868,6 +869,129 @@ describe("ExternalStoreThreadRuntimeCore - message queue", () => {
     expect(withoutQueue.capabilities.queue).toBe(false);
   });
 
+  it("waits for thread initialization before enqueueing into the queue adapter", async () => {
+    let resolveInitialization!: () => void;
+    const initialization = new Promise<void>((resolve) => {
+      resolveInitialization = resolve;
+    });
+    const queue = makeQueue();
+    const onNew = vi.fn(async () => {});
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ onNew, queue }),
+    );
+    runtime.__internal_setGetInitializePromise(() => initialization);
+
+    const appendPromise = runtime.append(appendMessage());
+    await Promise.resolve();
+
+    expect(queue.enqueue).not.toHaveBeenCalled();
+
+    resolveInitialization();
+    await appendPromise;
+
+    expect(queue.enqueue).toHaveBeenCalledTimes(1);
+    expect(onNew).not.toHaveBeenCalled();
+  });
+
+  it("does not enqueue when the thread is invalidated during initialization", async () => {
+    let resolveInitialization!: () => void;
+    const initialization = new Promise<void>((resolve) => {
+      resolveInitialization = resolve;
+    });
+    const queue = makeQueue();
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ onNew: vi.fn(), queue }),
+    );
+    runtime.__internal_setGetInitializePromise(() => initialization);
+
+    const appendPromise = runtime.append(appendMessage());
+    await Promise.resolve();
+    invalidateThreadRuntime(runtime);
+    resolveInitialization();
+
+    await appendPromise;
+    expect(queue.enqueue).not.toHaveBeenCalled();
+    expect(queue.steer).not.toHaveBeenCalled();
+  });
+
+  it("dispatches an append without waiting for thread initialization", async () => {
+    const initialization = new Promise<void>(() => {});
+    const getInitializePromise = vi.fn(() => initialization);
+    const onNew = vi.fn(async () => {});
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ onNew }),
+    );
+    runtime.__internal_setGetInitializePromise(getInitializePromise);
+
+    await runtime.append(appendMessage());
+
+    expect(onNew).toHaveBeenCalledTimes(1);
+    expect(getInitializePromise).toHaveBeenCalledTimes(1);
+  });
+
+  it("dispatches concurrent appends without waiting for initialization", async () => {
+    const initialization = new Promise<void>(() => {});
+    const onNew = vi.fn(async () => {});
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ onNew }),
+    );
+    runtime.__internal_setGetInitializePromise(() => initialization);
+
+    await Promise.all([
+      runtime.append(appendMessage()),
+      runtime.append(appendMessage()),
+    ]);
+
+    expect(onNew).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not fail the append when thread initialization rejects", async () => {
+    const initialization = Promise.reject(new Error("initialization failed"));
+    const onNew = vi.fn(async () => {});
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ onNew }),
+    );
+    runtime.__internal_setGetInitializePromise(() => initialization);
+
+    await runtime.append(appendMessage());
+
+    expect(onNew).toHaveBeenCalledTimes(1);
+  });
+
+  it("drops an append disposed while aborting client-side tools", async () => {
+    let resolveAbort!: () => void;
+    const abortPromise = new Promise<void>((resolve) => {
+      resolveAbort = resolve;
+    });
+    const onNew = vi.fn(async () => {});
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ onNew }),
+    );
+    runtime.__internal_setGetInitializePromise(() => Promise.resolve());
+    const abort = vi.fn(() => abortPromise);
+    (
+      runtime as unknown as { _toolInvocations: { abort: typeof abort } }
+    )._toolInvocations = {
+      abort,
+    };
+
+    const appendPromise = runtime.append(appendMessage());
+    await Promise.resolve();
+    expect(abort).toHaveBeenCalledOnce();
+
+    invalidateThreadRuntime(runtime);
+    resolveAbort();
+
+    await appendPromise;
+    expect(onNew).not.toHaveBeenCalled();
+  });
+
   it("routes a tail append through the queue adapter instead of onNew", async () => {
     const queue = makeQueue();
     const onNew = vi.fn();

package/src/tests/interactables-toolui-migration.test.tsx

@@ -0,0 +1,66 @@
+// @vitest-environment jsdom
+
+import { act, cleanup, render } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { withKey } from "@assistant-ui/tap";
+import { useAui } from "@assistant-ui/store";
+import { Tools } from "../react/client/Tools";
+import { unstable_Interactables } from "../react/client/Interactables";
+
+type AnyClient = Record<string, any>;
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("interactables update-tool UI registration", () => {
+  it("migrates to a structurally replaced tools scope", async () => {
+    let aui!: AnyClient;
+    const Harness = ({ generation }: { generation: number }) => {
+      aui = useAui({
+        tools: withKey(String(generation), Tools({})),
+        unstable_interactables: unstable_Interactables({}),
+      } as never);
+      return null;
+    };
+    const view = render(<Harness generation={0} />);
+
+    const toolUIs = () =>
+      (aui.tools().getState().toolUIs ?? {}) as Record<string, unknown[]>;
+    // setToolUI lands after the tap scheduler drains its macrotask
+    await act(async () => {
+      aui.unstable_interactables.register({
+        id: "call-1",
+        name: "note",
+        description: "a note",
+        stateSchema: { type: "object", properties: {} },
+        initialState: {},
+        updateRender: () => null,
+      });
+      await vi.waitFor(() => expect(Object.keys(toolUIs())).toHaveLength(1));
+    });
+    const [toolName] = Object.keys(toolUIs());
+    const firstRegistration = toolUIs()[toolName!]![0];
+
+    // A rerender inside an outer act would not land until that act exits,
+    // so the swap happens first and only the scheduler wait is wrapped
+    view.rerender(<Harness generation={1} />);
+
+    // The remounted tools scope starts from fresh state; a registration
+    // object distinct from the pre-swap one proves the retained entry was
+    // re-applied on the replacement instance rather than read stale. It
+    // lands one scheduler macrotask after the swap, once the tap scheduler
+    // drains.
+    await act(async () => {
+      await vi.waitFor(() => {
+        const registration = toolUIs()[toolName!]?.[0];
+        expect(registration).toBeDefined();
+        expect(registration).not.toBe(firstRegistration);
+      });
+    });
+
+    // Post-settle cardinality: a duplicate re-apply would leave a second
+    // registration whose disposer was dropped
+    expect(toolUIs()[toolName!]).toHaveLength(1);
+  });
+});

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

@@ -612,6 +612,34 @@ describe("createMessageQueue", () => {
     expect(cb).toHaveBeenCalled();
   });
 
+  it("isolates subscriber errors while enqueueing", () => {
+    const run = vi.fn();
+    const { adapter, subscribe } = createMessageQueue({ run });
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    subscribe(() => {
+      throw error;
+    });
+    subscribe(laterSubscriber);
+
+    try {
+      expect(() => adapter.enqueue(msg("a"), { steer: false })).not.toThrow();
+      expect(run).toHaveBeenCalledTimes(1);
+      expect(adapter.items).toHaveLength(0);
+      expect(laterSubscriber).toHaveBeenCalledTimes(2);
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] Message queue listener threw an error",
+        error,
+      );
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+
   it("buffers when a run started outside the queue is marked busy", () => {
     const run = vi.fn();
     const { adapter, notifyBusy, notifyIdle } = createMessageQueue({ run });

package/src/tests/session-reset-notification.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, it, vi } from "vitest";
+import { ExternalStoreRuntimeCore } from "../runtimes/external-store/external-store-runtime-core";
+import { LocalRuntimeCore } from "../runtimes/local/local-runtime-core";
+import type { ChatModelAdapter } from "../runtime/utils/chat-model-adapter";
+import type { ThreadMessage } from "../types/message";
+
+async function waitFor(
+  predicate: () => unknown,
+  timeoutMs = 500,
+): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      await predicate();
+      return;
+    } catch {
+      // retry
+    }
+    await new Promise((r) => setTimeout(r, 5));
+  }
+  await predicate();
+}
+
+const trailingUserMessage = {
+  id: "u1",
+  role: "user",
+  createdAt: new Date(),
+  content: [{ type: "text", text: "draft in flight" }],
+  attachments: [],
+  metadata: { custom: {} },
+} as ThreadMessage;
+
+const toolCallMessage = {
+  id: "a1",
+  role: "assistant",
+  createdAt: new Date(),
+  status: { type: "requires-action", reason: "tool-calls" },
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+  content: [
+    {
+      type: "tool-call",
+      toolCallId: "tool-1",
+      toolName: "send_email",
+      args: { to: "dev@example.com" },
+      argsText: '{"to":"dev@example.com"}',
+    },
+  ],
+} as unknown as ThreadMessage;
+
+const externalThread = () => {
+  const setToolStatuses = vi.fn();
+  const setMessages = vi.fn();
+  const onCancel = vi.fn();
+  const notifyCancelled = vi.fn();
+  const store = {
+    messages: [trailingUserMessage] as ThreadMessage[],
+    onNew: vi.fn(async () => {}),
+    onCancel,
+    setMessages,
+    unstable_enableToolInvocations: true,
+    setToolStatuses,
+    queue: {
+      __internal_notifyCancelled: notifyCancelled,
+    } as never,
+  };
+  const core = new ExternalStoreRuntimeCore(store);
+  core.registerModelContextProvider({
+    getModelContext: () => ({
+      tools: {
+        send_email: {
+          parameters: { type: "object", properties: {} },
+          execute: vi.fn(() => new Promise(() => {})),
+        },
+      },
+    }),
+  });
+  return {
+    core,
+    store,
+    thread: core.threads.getMainThreadRuntimeCore(),
+    setToolStatuses,
+    setMessages,
+    onCancel,
+    notifyCancelled,
+  };
+};
+
+const driveExecutingTool = async (
+  harness: ReturnType<typeof externalThread>,
+) => {
+  harness.core.setAdapter({
+    ...harness.store,
+    messages: [trailingUserMessage, toolCallMessage],
+  });
+  await waitFor(() => {
+    const statuses = harness.setToolStatuses.mock.lastCall?.[0] as
+      | Record<string, { type: string }>
+      | undefined;
+    expect(statuses?.["tool-1"]?.type).toBe("executing");
+  });
+};
+
+describe("unstable_notifySessionReset", () => {
+  it("clears session-scoped tool state once and parks queued work", async () => {
+    const harness = externalThread();
+    await driveExecutingTool(harness);
+
+    harness.setToolStatuses.mockClear();
+    harness.thread.unstable_notifySessionReset();
+
+    expect(harness.setToolStatuses).toHaveBeenCalledTimes(1);
+    expect(harness.setToolStatuses).toHaveBeenLastCalledWith({});
+    expect(harness.notifyCancelled).toHaveBeenCalledTimes(1);
+  });
+
+  it("carries no run-cancel semantics", async () => {
+    const harness = externalThread();
+    await driveExecutingTool(harness);
+
+    harness.thread.unstable_notifySessionReset();
+
+    expect(harness.onCancel).not.toHaveBeenCalled();
+    expect(harness.setMessages).not.toHaveBeenCalled();
+    expect(harness.thread.messages.at(-1)?.id).toBe("a1");
+  });
+
+  it("throws on runtimes without a backing session", () => {
+    const local = new LocalRuntimeCore(
+      {
+        adapters: { chatModel: { async *run() {} } satisfies ChatModelAdapter },
+      },
+      undefined,
+    );
+
+    expect(() =>
+      local.threads.getMainThreadRuntimeCore().unstable_notifySessionReset(),
+    ).toThrow("Runtime does not support resetting sessions.");
+  });
+});