@assistant-ui/core 0.3.14 → 0.3.15

package/src/react/runtimes/assistant-transport/useAssistantTransportRuntime.test.tsx

@@ -4,6 +4,7 @@ import { act, render, waitFor } from "@testing-library/react";
 import type { FC } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { useAui } from "@assistant-ui/store";
+import { ToolResponse } from "assistant-stream";
 import { AssistantRuntimeProvider } from "../../AssistantRuntimeProvider";
 import {
   useAssistantTransportRuntime,
@@ -145,6 +146,63 @@ afterEach(() => {
 });
 
 describe("useAssistantTransportRuntime", () => {
+  it.each([false, 0, "", null])(
+    "preserves the falsy tool artifact %j",
+    async (artifact) => {
+      const fetchMock = installFetch();
+      const { aui } = mountRuntime({
+        converter: (_state, meta) => ({
+          messages: [
+            {
+              id: "a1",
+              role: "assistant",
+              content: [
+                {
+                  type: "tool-call",
+                  toolCallId: "tc1",
+                  toolName: "probe",
+                  args: {},
+                  argsText: "{}",
+                },
+              ],
+              createdAt: new Date(0),
+              status: { type: "requires-action", reason: "tool-calls" },
+              metadata: { custom: {} },
+            },
+          ],
+          isRunning: meta.isSending,
+        }),
+      });
+
+      await waitFor(() =>
+        expect(
+          aui()
+            .thread.message({ id: "a1" })
+            .part({ toolCallId: "tc1" })
+            .getState().type,
+        ).toBe("tool-call"),
+      );
+
+      act(() => {
+        aui()
+          .thread.message({ id: "a1" })
+          .part({ toolCallId: "tc1" })
+          .addToolResult(new ToolResponse({ result: "ok", artifact }));
+      });
+
+      await waitFor(() => expect(fetchMock.requests).toHaveLength(1));
+      expect(fetchMock.requests[0]!.body["commands"][0]).toHaveProperty(
+        "artifact",
+        artifact,
+      );
+
+      act(() => fetchMock.servers[0]!.close());
+      await waitFor(() =>
+        expect(aui().thread.getState().isRunning).toBe(false),
+      );
+    },
+  );
+
   it.each(["throws", "rejects"] as const)(
     "cancels the response body when onResponse %s",
     async (failureMode) => {

package/src/react/runtimes/assistant-transport/useAssistantTransportRuntime.ts

@@ -447,7 +447,9 @@ const useAssistantTransportThreadRuntime = <T>(
         result: toolOptions.result as ReadonlyJSONObject,
         toolName: toolOptions.toolName,
         isError: toolOptions.isError,
-        ...(toolOptions.artifact && { artifact: toolOptions.artifact }),
+        ...(toolOptions.artifact !== undefined && {
+          artifact: toolOptions.artifact,
+        }),
         ...(toolOptions.modelContent !== undefined && {
           modelContent: toolOptions.modelContent,
         }),

package/src/react/runtimes/cloud/useCloudThreadListAdapter.test.tsx

@@ -19,7 +19,38 @@ const makeThread = (id: string) => ({
 });
 
 describe("useCloudThreadListAdapter", () => {
-  it("exposes full Cloud pages through the remote thread cursor", async () => {
+  it("loads archived Cloud threads alongside regular threads", async () => {
+    const activeThreads = [makeThread("active-1")];
+    const archivedThreads = [
+      { ...makeThread("archived-1"), is_archived: true },
+    ];
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce({ threads: activeThreads })
+      .mockResolvedValueOnce({ threads: archivedThreads });
+    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
+
+    const page = await result.current.list();
+
+    expect(list).toHaveBeenNthCalledWith(1, { limit: 20 });
+    expect(list).toHaveBeenNthCalledWith(2, {
+      is_archived: true,
+      limit: 20,
+    });
+    expect(page.threads.map((thread) => thread.remoteId)).toEqual([
+      "active-1",
+      "archived-1",
+    ]);
+    expect(
+      page.threads.find((thread) => thread.remoteId === "active-1")?.status,
+    ).toBe("regular");
+    expect(
+      page.threads.find((thread) => thread.remoteId === "archived-1")?.status,
+    ).toBe("archived");
+  });
+
+  it("continues the active list once the archived list is exhausted", async () => {
     const firstPage = Array.from({ length: 20 }, (_, index) =>
       makeThread(`thread-${index + 1}`),
     );
@@ -27,17 +58,20 @@ describe("useCloudThreadListAdapter", () => {
     const list = vi
       .fn()
       .mockResolvedValueOnce({ threads: firstPage })
+      .mockResolvedValueOnce({ threads: [] })
       .mockResolvedValueOnce({ threads: secondPage });
     const cloud = { threads: { list } } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const first = await result.current.list();
     expect(list).toHaveBeenNthCalledWith(1, { limit: 20 });
+    expect(list).toHaveBeenNthCalledWith(2, { is_archived: true, limit: 20 });
     expect(first.threads).toHaveLength(20);
-    expect(first.nextCursor).toBe("thread-20");
+    expect(JSON.parse(first.nextCursor!)).toEqual({ a: "thread-20", re: true });
 
     const second = await result.current.list({ after: first.nextCursor });
-    expect(list).toHaveBeenNthCalledWith(2, {
+    expect(list).toHaveBeenCalledTimes(3);
+    expect(list).toHaveBeenNthCalledWith(3, {
       limit: 20,
       after: "thread-20",
     });
@@ -46,4 +80,65 @@ describe("useCloudThreadListAdapter", () => {
     ]);
     expect(second.nextCursor).toBeUndefined();
   });
+
+  it("paginates both legs without dropping or duplicating items", async () => {
+    const activePage1 = Array.from({ length: 20 }, (_, index) =>
+      makeThread(`a-${index + 1}`),
+    );
+    const archivedPage1 = Array.from({ length: 20 }, (_, index) => ({
+      ...makeThread(`r-${index + 1}`),
+      is_archived: true,
+    }));
+    const activePage2 = [makeThread("a-21")];
+    const archivedPage2 = [{ ...makeThread("r-21"), is_archived: true }];
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce({ threads: activePage1 })
+      .mockResolvedValueOnce({ threads: archivedPage1 })
+      .mockResolvedValueOnce({ threads: activePage2 })
+      .mockResolvedValueOnce({ threads: archivedPage2 });
+    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
+
+    const page1 = await result.current.list();
+    expect(page1.threads).toHaveLength(40);
+    expect(JSON.parse(page1.nextCursor!)).toEqual({ a: "a-20", r: "r-20" });
+
+    const page2 = await result.current.list({ after: page1.nextCursor });
+    expect(list).toHaveBeenNthCalledWith(3, { limit: 20, after: "a-20" });
+    expect(list).toHaveBeenNthCalledWith(4, {
+      is_archived: true,
+      limit: 20,
+      after: "r-20",
+    });
+    expect(page2.threads.map((thread) => thread.remoteId)).toEqual([
+      "a-21",
+      "r-21",
+    ]);
+    expect(page2.nextCursor).toBeUndefined();
+  });
+
+  it("accepts a legacy bare-id cursor for the active list", async () => {
+    const activeThreads = [makeThread("thread-21")];
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce({ threads: activeThreads })
+      .mockResolvedValueOnce({ threads: [] });
+    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
+
+    const page = await result.current.list({ after: "thread-20" });
+
+    expect(list).toHaveBeenNthCalledWith(1, {
+      limit: 20,
+      after: "thread-20",
+    });
+    expect(list).toHaveBeenNthCalledWith(2, {
+      is_archived: true,
+      limit: 20,
+    });
+    expect(page.threads.map((thread) => thread.remoteId)).toEqual([
+      "thread-21",
+    ]);
+  });
 });

package/src/react/runtimes/cloud/useCloudThreadListAdapter.tsx

@@ -44,6 +44,35 @@ const autoCloud = baseUrl
 
 const CLOUD_THREAD_PAGE_SIZE = 20;
 
+type CloudListCursor = {
+  activeCursor: string | undefined;
+  archivedCursor: string | undefined;
+  activeExhausted: boolean;
+  archivedExhausted: boolean;
+};
+
+const parseListCursor = (after: string | undefined): CloudListCursor => {
+  const fallback: CloudListCursor = {
+    activeCursor: after,
+    archivedCursor: undefined,
+    activeExhausted: false,
+    archivedExhausted: false,
+  };
+  if (!after || !after.startsWith("{")) return fallback;
+  try {
+    const parsed = JSON.parse(after);
+    if (!isRecord(parsed)) return fallback;
+    return {
+      activeCursor: typeof parsed.a === "string" ? parsed.a : undefined,
+      archivedCursor: typeof parsed.r === "string" ? parsed.r : undefined,
+      activeExhausted: parsed.ae === true,
+      archivedExhausted: parsed.re === true,
+    };
+  } catch {
+    return fallback;
+  }
+};
+
 const useCloudThreadListAdapters = (
   adapterRef: RefObject<CloudThreadListAdapterOptions>,
 ): RuntimeAdapters => {
@@ -105,10 +134,38 @@ export const useCloudThreadListAdapter = (
 
     return {
       list: async ({ after } = {}) => {
-        const { threads } = await cloud.threads.list({
-          limit: CLOUD_THREAD_PAGE_SIZE,
-          ...(after ? { after } : {}),
-        });
+        const {
+          activeCursor,
+          archivedCursor,
+          activeExhausted,
+          archivedExhausted,
+        } = parseListCursor(after);
+        const [{ threads: activeThreads }, { threads: archivedThreads }] =
+          await Promise.all([
+            activeExhausted
+              ? Promise.resolve({ threads: [] })
+              : cloud.threads.list({
+                  limit: CLOUD_THREAD_PAGE_SIZE,
+                  ...(activeCursor ? { after: activeCursor } : {}),
+                }),
+            archivedExhausted
+              ? Promise.resolve({ threads: [] })
+              : cloud.threads.list({
+                  is_archived: true,
+                  limit: CLOUD_THREAD_PAGE_SIZE,
+                  ...(archivedCursor ? { after: archivedCursor } : {}),
+                }),
+          ]);
+        const activeNext =
+          !activeExhausted && activeThreads.length === CLOUD_THREAD_PAGE_SIZE
+            ? activeThreads.at(-1)?.id
+            : undefined;
+        const archivedNext =
+          !archivedExhausted &&
+          archivedThreads.length === CLOUD_THREAD_PAGE_SIZE
+            ? archivedThreads.at(-1)?.id
+            : undefined;
+        const threads = [...activeThreads, ...archivedThreads];
         return {
           threads: threads.map((t) => ({
             status: t.is_archived ? "archived" : "regular",
@@ -121,8 +178,13 @@ export const useCloudThreadListAdapter = (
             custom: toCustom(t.metadata),
           })),
           nextCursor:
-            threads.length === CLOUD_THREAD_PAGE_SIZE
-              ? threads.at(-1)?.id
+            activeNext || archivedNext
+              ? JSON.stringify({
+                  a: activeNext,
+                  r: archivedNext,
+                  ...(activeNext === undefined ? { ae: true } : {}),
+                  ...(archivedNext === undefined ? { re: true } : {}),
+                })
               : undefined,
         };
       },

package/src/react/runtimes/useLocalRuntime.test.tsx

@@ -83,17 +83,17 @@ describe("useLocalRuntime", () => {
     const { rerender } = render(<App cloud={firstCloud} label="first" />);
 
     await waitFor(() => {
-      expect(firstCloud.threads.list).toHaveBeenCalledOnce();
+      expect(firstCloud.threads.list).toHaveBeenCalledTimes(2);
     });
 
     rerender(<App cloud={firstCloud} label="second" />);
-    expect(firstCloud.threads.list).toHaveBeenCalledOnce();
+    expect(firstCloud.threads.list).toHaveBeenCalledTimes(2);
 
     rerender(<App cloud={secondCloud} label="third" />);
     await waitFor(() => {
-      expect(secondCloud.threads.list).toHaveBeenCalledOnce();
+      expect(secondCloud.threads.list).toHaveBeenCalledTimes(2);
     });
-    expect(firstCloud.threads.list).toHaveBeenCalledOnce();
+    expect(firstCloud.threads.list).toHaveBeenCalledTimes(2);
   });
 
   it("uses the current Cloud client for attachment uploads", async () => {
@@ -118,7 +118,7 @@ describe("useLocalRuntime", () => {
     const { rerender } = render(<App cloud={firstCloud} />);
 
     await waitFor(() => {
-      expect(firstCloud.threads.list).toHaveBeenCalledOnce();
+      expect(firstCloud.threads.list).toHaveBeenCalledTimes(2);
     });
 
     rerender(<App cloud={secondCloud} />);

package/src/runtime/utils/message-repository.ts

@@ -81,9 +81,9 @@ type RepositoryMessage = RepositoryParent & {
 const findHead = (
   message: RepositoryMessage | RepositoryParent,
 ): RepositoryMessage | null => {
-  if (message.next) return findHead(message.next);
-  if ("current" in message) return message;
-  return null;
+  let current = message;
+  while (current.next) current = current.next;
+  return "current" in current ? current : null;
 };
 
 class CachedValue<T> {
@@ -116,11 +116,17 @@ export class MessageRepository {
   };
 
   private updateLevels(message: RepositoryMessage, newLevel: number) {
-    message.level = newLevel;
-    for (const childId of message.children) {
-      const childMessage = this.messages.get(childId);
-      if (childMessage) {
-        this.updateLevels(childMessage, newLevel + 1);
+    const pending = [{ message, level: newLevel }];
+
+    while (pending.length > 0) {
+      const current = pending.pop()!;
+      current.message.level = current.level;
+
+      for (const childId of current.message.children) {
+        const childMessage = this.messages.get(childId);
+        if (childMessage) {
+          pending.push({ message: childMessage, level: current.level + 1 });
+        }
       }
     }
   }
@@ -135,7 +141,8 @@ export class MessageRepository {
 
     if (operation === "relink" && parentOrRoot === newParentOrRoot) return;
 
-    if (operation !== "cut") {
+    // `link` receives a fresh ID from `addOrUpdateMessage`; only `relink` can introduce a cycle.
+    if (operation === "relink") {
       for (
         let current: RepositoryMessage | null = newParent;
         current;
@@ -143,7 +150,7 @@ export class MessageRepository {
       ) {
         if (current.current.id === child.current.id) {
           throw new Error(
-            "MessageRepository(performOp/link): A message with the same id already exists in the parent tree. This error occurs if the same message id is found multiple times. This is likely an internal bug in assistant-ui.",
+            "MessageRepository(performOp/relink): A message with the same id already exists in the parent tree. This error occurs if the same message id is found multiple times. This is likely an internal bug in assistant-ui.",
           );
         }
       }
@@ -396,16 +403,17 @@ export class MessageRepository {
     const previousHead = this.head;
 
     if (message.children.length > 0) {
-      const deleteDescendants = (msg: RepositoryMessage) => {
-        for (const childId of msg.children) {
-          const childMessage = this.messages.get(childId);
-          if (childMessage) {
-            deleteDescendants(childMessage);
-            this.messages.delete(childId);
+      const pending = [...message.children];
+      while (pending.length > 0) {
+        const childId = pending.pop()!;
+        const childMessage = this.messages.get(childId);
+        if (childMessage) {
+          for (const descendantId of childMessage.children) {
+            pending.push(descendantId);
           }
+          this.messages.delete(childId);
         }
-      };
-      deleteDescendants(message);
+      }
 
       message.children = [];
       message.next = null;

package/src/runtimes/external-store/external-store-thread-runtime-core.ts

@@ -674,6 +674,8 @@ export class ExternalStoreThreadRuntimeCore
     if (!this._store.onCancel)
       throw new Error("Runtime does not support cancelling runs.");
 
+    const generation = captureThreadRuntimeGeneration(this);
+
     // Abort any in-flight client-side tool executions. Fire-and-forget —
     // the abort resolves once executions settle, but we don't gate the
     // cancel on it.
@@ -731,6 +733,8 @@ export class ExternalStoreThreadRuntimeCore
     // tick. Read the repository at flush time and re-apply the rollbacks to
     // it, instead of stamping a snapshot captured above over the newer state.
     setTimeout(() => {
+      if (!isThreadRuntimeGenerationCurrent(this, generation)) return;
+
       this.dropEmptyOptimisticHead();
       if (movedLeaf) {
         const current = this.repository.getMessages();

package/src/runtimes/inert/InertThreadRuntimeCore.test.ts

@@ -0,0 +1,253 @@
+import { describe, expect, it } from "vitest";
+import { BaseSubscribable } from "../../subscribable/subscribable";
+import { ReadonlyThreadRuntimeCore } from "../readonly/ReadonlyThreadRuntimeCore";
+import { EMPTY_THREAD_CORE } from "../remote-thread-list/empty-thread-core";
+
+const READONLY_ERROR = /readonly thread/;
+const EMPTY_ERROR = /empty thread/;
+
+const SHARED_THROWING_METHODS = [
+  "switchToBranch",
+  "append",
+  "deleteMessage",
+  "startRun",
+  "resumeRun",
+  "unstable_notifySessionReset",
+  "addToolResult",
+  "resumeToolCall",
+  "respondToToolApproval",
+  "speak",
+  "connectVoice",
+  "muteVoice",
+  "unmuteVoice",
+  "submitFeedback",
+  "exportExternalState",
+  "importExternalState",
+  "beginEdit",
+  "import",
+  "reset",
+] as const;
+
+const SHARED_THROWING_COMPOSER_METHODS = [
+  "setText",
+  "setRole",
+  "setRunConfig",
+  "send",
+  "startDictation",
+  "setQuote",
+] as const;
+
+const SHARED_NOOP_COMPOSER_METHODS = [
+  "cancel",
+  "stopDictation",
+  "moveQueueItem",
+  "removeQueueItem",
+] as const;
+
+type AnyCore = Record<string, any>;
+
+const cores = [
+  [
+    "ReadonlyThreadRuntimeCore",
+    () => new ReadonlyThreadRuntimeCore() as unknown as AnyCore,
+    READONLY_ERROR,
+  ],
+  [
+    "EMPTY_THREAD_CORE",
+    () => EMPTY_THREAD_CORE as unknown as AnyCore,
+    EMPTY_ERROR,
+  ],
+] as const;
+
+describe.each(cores)("%s shared inert surface", (_name, makeCore, error) => {
+  it.each(SHARED_THROWING_METHODS)("%s throws the core's error", (method) => {
+    expect(() => makeCore()[method]!()).toThrow(error);
+  });
+
+  it.each(SHARED_THROWING_COMPOSER_METHODS)(
+    "composer.%s throws the core's error",
+    (method) => {
+      expect(() => makeCore().composer[method]!()).toThrow(error);
+    },
+  );
+
+  it.each(["addAttachment", "removeAttachment"] as const)(
+    "composer.%s rejects with the core's error",
+    async (method) => {
+      await expect(makeCore().composer[method]!()).rejects.toThrow(error);
+    },
+  );
+
+  it.each(SHARED_NOOP_COMPOSER_METHODS)("composer.%s is a no-op", (method) => {
+    expect(() => makeCore().composer[method]!()).not.toThrow();
+  });
+
+  it("composer.reset and composer.clearAttachments resolve without throwing", async () => {
+    const core = makeCore();
+    await expect(core.composer.reset()).resolves.toBeUndefined();
+    await expect(core.composer.clearAttachments()).resolves.toBeUndefined();
+  });
+
+  it("reports every capability as disabled", () => {
+    expect(makeCore().capabilities).toEqual({
+      switchToBranch: false,
+      switchBranchDuringRun: false,
+      edit: false,
+      delete: false,
+      reload: false,
+      refetchThread: false,
+      cancel: false,
+      unstable_copy: false,
+      speech: false,
+      dictation: false,
+      voice: false,
+      attachments: false,
+      feedback: false,
+      queue: false,
+    });
+  });
+
+  it("exposes inert read-only state", () => {
+    const core = makeCore();
+    expect(core.getModelContext()).toEqual({});
+    expect(core.getEditComposer()).toBeUndefined();
+    expect(core.getVoiceVolume()).toBe(0);
+    expect(core.speech).toBeUndefined();
+    expect(core.voice).toBeUndefined();
+    expect(core.state).toBeNull();
+    expect(core.suggestions).toEqual([]);
+    expect(core.extras).toBeUndefined();
+    expect(core.isDisabled).toBe(false);
+    expect(core.isSendDisabled).toBe(false);
+  });
+
+  it("exposes an empty composer that accepts everything and holds nothing", () => {
+    const composer = makeCore().composer;
+    expect(composer.attachmentAccept).toBe("*");
+    expect(composer.attachments).toEqual([]);
+    expect(composer.text).toBe("");
+    expect(composer.role).toBe("user");
+    expect(composer.runConfig).toEqual({});
+    expect(composer.queue).toEqual([]);
+    expect(composer.dictation).toBeUndefined();
+    expect(composer.quote).toBeUndefined();
+    expect(composer.isEmpty).toBe(true);
+    expect(composer.canSend).toBe(false);
+    expect(composer.canCancel).toBe(false);
+  });
+
+  it("throws one stable error object from every mutator", () => {
+    const core = makeCore();
+    const thrown = SHARED_THROWING_METHODS.map((method) => {
+      try {
+        core[method]!();
+        return undefined;
+      } catch (e) {
+        return e;
+      }
+    });
+
+    expect(thrown[0]).toBeInstanceOf(Error);
+    expect(thrown.every((e) => e === thrown[0])).toBe(true);
+  });
+
+  it("throws a receiver TypeError when a mutator is detached", () => {
+    const detached = makeCore().append!;
+    expect(() => detached()).toThrow(TypeError);
+  });
+
+  it("subscribeVoiceVolume and unstable_on hand back no-op unsubscribers", () => {
+    const core = makeCore();
+    expect(() => core.subscribeVoiceVolume(() => {})()).not.toThrow();
+    expect(() => core.unstable_on("runStart", () => {})()).not.toThrow();
+  });
+});
+
+describe("no-op versus throw divergences", () => {
+  it.each(["cancelRun", "stopSpeaking", "disconnectVoice"] as const)(
+    "%s is a no-op on the readonly core but throws on the empty core",
+    (method) => {
+      const readonly = new ReadonlyThreadRuntimeCore() as unknown as AnyCore;
+      expect(() => readonly[method]!()).not.toThrow();
+      expect(() =>
+        (EMPTY_THREAD_CORE as unknown as AnyCore)[method]!(),
+      ).toThrow(EMPTY_ERROR);
+    },
+  );
+
+  it("readonly is not loading; empty is loading so it is not read as an empty conversation", () => {
+    expect(new ReadonlyThreadRuntimeCore().isLoading).toBe(false);
+    expect(EMPTY_THREAD_CORE.isLoading).toBe(true);
+  });
+
+  it("readonly composer is not editing; empty composer is", () => {
+    expect(new ReadonlyThreadRuntimeCore().composer.isEditing).toBe(false);
+    expect(EMPTY_THREAD_CORE.composer.isEditing).toBe(true);
+  });
+
+  it("the two cores carry distinct error objects and messages", () => {
+    const grab = (fn: () => void) => {
+      try {
+        fn();
+        return undefined;
+      } catch (e) {
+        return e as Error;
+      }
+    };
+
+    const readonlyError = grab(() => new ReadonlyThreadRuntimeCore().append());
+    const emptyError = grab(() =>
+      (EMPTY_THREAD_CORE as unknown as AnyCore).append!(),
+    );
+
+    expect(readonlyError).not.toBe(emptyError);
+    expect(readonlyError?.message).toBe(
+      "This is a readonly thread. You cannot perform mutations on readonly threads.",
+    );
+    expect(emptyError?.message).toMatch(/placeholder for the main thread/);
+  });
+});
+
+describe("readonly notifications", () => {
+  it("notifies subscribers and settles waitForUpdate when messages change", async () => {
+    const core = new ReadonlyThreadRuntimeCore();
+    const seen: number[] = [];
+    const unsubscribe = core.subscribe(() => {
+      seen.push(core.messages.length);
+    });
+    const update = core.waitForUpdate();
+
+    core.setMessages([
+      {
+        id: "m1",
+        role: "user",
+        content: [{ type: "text", text: "hi" }],
+        createdAt: new Date(0),
+        status: { type: "complete", reason: "stop" },
+        metadata: { custom: {} },
+      } as any,
+    ]);
+
+    await expect(update).resolves.toBeUndefined();
+    expect(seen).toEqual([1]);
+    unsubscribe();
+  });
+});
+
+describe("empty singleton", () => {
+  it("does not retain subscribe callbacks", () => {
+    const subscribers = (
+      EMPTY_THREAD_CORE as unknown as Record<string, unknown>
+    )._subscribers as Set<unknown>;
+    const before = subscribers.size;
+    const unsubscribe = EMPTY_THREAD_CORE.subscribe(() => undefined);
+    expect(subscribers.size).toBe(before);
+    expect(() => unsubscribe()).not.toThrow();
+  });
+
+  it("rejects waitForUpdate instead of hanging", async () => {
+    await expect(
+      (EMPTY_THREAD_CORE as unknown as BaseSubscribable).waitForUpdate(),
+    ).rejects.toThrow(EMPTY_ERROR);
+  });
+});