@assistant-ui/core 0.2.18 → 0.2.19

package/src/tests/default-edit-composer-runtime-core.test.ts

@@ -4,11 +4,20 @@ import type { AppendMessage, ThreadMessage } from "../types/message";
 import type { CompleteAttachment } from "../types/attachment";
 import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
 
-const makeRuntime = () => {
+const makeRuntime = (options?: {
+  messages?: ThreadMessage[];
+  composerMetadata?: Record<string, unknown>;
+}) => {
   const append = vi.fn();
   const runtime = {
     append,
     composer: { runConfig: {} },
+    messages: options?.messages ?? [],
+    getModelContext: () => ({
+      ...(options?.composerMetadata
+        ? { unstable_composerMetadata: options.composerMetadata }
+        : {}),
+    }),
   } as unknown as ThreadRuntimeCore & { adapters?: undefined };
   return { runtime, append };
 };
@@ -214,6 +223,74 @@ describe("DefaultEditComposerRuntimeCore", () => {
     });
   });
 
+  describe("interactables snapshot gating", () => {
+    const live = (state: unknown) => ({
+      interactables: [{ id: "n1", name: "note", state }],
+    });
+    const snapshotMessage = (id: string, state: unknown): ThreadMessage =>
+      makeUserMessage({
+        id,
+        metadata: {
+          custom: { interactables: [{ id: "n1", name: "note", state }] },
+        },
+      } as Partial<ThreadMessage>);
+
+    it("re-stamps the baseline when the edited message carried the only snapshot", async () => {
+      // The new branch's prefix (before the edited message) has no snapshot,
+      // so the live (unchanged) state becomes the branch's baseline.
+      const edited = snapshotMessage("msg-1", { v: 1 });
+      const { runtime, append } = makeRuntime({
+        messages: [edited],
+        composerMetadata: live({ v: 1 }),
+      });
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: edited,
+      });
+      composer.setText("new");
+      await composer.send();
+      const appended = append.mock.calls[0]![0] as AppendMessage;
+      expect(appended.metadata?.custom?.interactables).toEqual([
+        { id: "n1", name: "note", state: { v: 1 } },
+      ]);
+    });
+
+    it("stamps the newest live state when the interactable was edited after the original message", async () => {
+      const edited = snapshotMessage("msg-1", { v: 1 });
+      const { runtime, append } = makeRuntime({
+        messages: [edited],
+        composerMetadata: live({ v: 2 }),
+      });
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: edited,
+      });
+      composer.setText("new");
+      await composer.send();
+      const appended = append.mock.calls[0]![0] as AppendMessage;
+      expect(appended.metadata?.custom?.interactables).toEqual([
+        { id: "n1", name: "note", state: { v: 2 } },
+      ]);
+    });
+
+    it("stamps nothing when the branch prefix already carries the live state", async () => {
+      const parent = snapshotMessage("parent-1", { v: 1 });
+      const edited = makeUserMessage({ id: "msg-1" });
+      const { runtime, append } = makeRuntime({
+        messages: [parent, edited],
+        composerMetadata: live({ v: 1 }),
+      });
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: "parent-1",
+        message: edited,
+      });
+      composer.setText("new");
+      await composer.send();
+      const appended = append.mock.calls[0]![0] as AppendMessage;
+      expect(appended.metadata?.custom?.interactables).toBeUndefined();
+    });
+  });
+
   describe("non-user messages", () => {
     it("does not lift non-text parts for assistant messages", () => {
       const { runtime } = makeRuntime();

package/src/tests/default-thread-composer-runtime-core.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it, vi } from "vitest";
+import { DefaultThreadComposerRuntimeCore } from "../runtime/base/default-thread-composer-runtime-core";
+import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
+import type { AppendMessage, ThreadMessage } from "../types/message";
+
+const makeRuntime = (options?: {
+  messages?: ThreadMessage[];
+  composerMetadata?: Record<string, unknown>;
+}) => {
+  const append = vi.fn();
+  const runtime = {
+    append,
+    getModelContext: () => ({
+      ...(options?.composerMetadata
+        ? { unstable_composerMetadata: options.composerMetadata }
+        : {}),
+    }),
+    subscribe: () => () => {},
+    capabilities: { cancel: false },
+    messages: options?.messages ?? [],
+    isSendDisabled: false,
+    composer: { runConfig: {} },
+  } as unknown as Omit<ThreadRuntimeCore, "composer">;
+  return { runtime, append };
+};
+
+const snapshotMessage = (id: string, state: unknown): ThreadMessage =>
+  ({
+    id,
+    role: "user",
+    createdAt: new Date(),
+    content: [{ type: "text", text: "old" }],
+    attachments: [],
+    metadata: {
+      custom: { interactables: [{ id: "n1", name: "note", state }] },
+    },
+  }) as ThreadMessage;
+
+const live = (state: unknown) => ({
+  interactables: [{ id: "n1", name: "note", state }],
+});
+
+const send = async (runtime: Omit<ThreadRuntimeCore, "composer">) => {
+  const composer = new DefaultThreadComposerRuntimeCore(runtime);
+  composer.setText("hello");
+  await composer.send();
+};
+
+describe("DefaultThreadComposerRuntimeCore interactables snapshot gating", () => {
+  it("stamps a baseline on the first send of the thread", async () => {
+    const { runtime, append } = makeRuntime({
+      composerMetadata: live({ v: 1 }),
+    });
+    await send(runtime);
+    const appended = append.mock.calls[0]![0] as AppendMessage;
+    expect(appended.metadata?.custom?.interactables).toEqual([
+      { id: "n1", name: "note", state: { v: 1 } },
+    ]);
+  });
+
+  it("stamps nothing when the history already carries the live state", async () => {
+    const { runtime, append } = makeRuntime({
+      messages: [snapshotMessage("msg-1", { v: 1 })],
+      composerMetadata: live({ v: 1 }),
+    });
+    await send(runtime);
+    const appended = append.mock.calls[0]![0] as AppendMessage;
+    expect(appended.metadata?.custom?.interactables).toBeUndefined();
+  });
+
+  it("stamps the new state when it diverged from the latest snapshot", async () => {
+    const { runtime, append } = makeRuntime({
+      messages: [snapshotMessage("msg-1", { v: 1 })],
+      composerMetadata: live({ v: 2 }),
+    });
+    await send(runtime);
+    const appended = append.mock.calls[0]![0] as AppendMessage;
+    expect(appended.metadata?.custom?.interactables).toEqual([
+      { id: "n1", name: "note", state: { v: 2 } },
+    ]);
+  });
+});

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

@@ -355,6 +355,343 @@ describe("ExternalStoreThreadRuntimeCore - optimistic message reconciliation", (
   });
 });
 
+describe("ExternalStoreThreadRuntimeCore - branch change callback", () => {
+  type Raw = {
+    id: string;
+    role: "user" | "assistant";
+    text: string;
+    optimistic?: boolean;
+  };
+
+  const convertMessage = (m: Raw): ThreadMessageLike => ({
+    id: m.id,
+    role: m.role,
+    content: [{ type: "text", text: m.text }],
+    ...(m.optimistic && { metadata: { isOptimistic: true } }),
+  });
+
+  const u: Raw = { id: "u", role: "user", text: "hi" };
+
+  // Build a runtime whose repository holds two sibling assistant branches
+  // (a1, a2) under the user message, with a2 the currently visible head.
+  const makeBranched = (extra?: Record<string, unknown>) => {
+    const base = { convertMessage, setMessages: vi.fn(), ...extra };
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({
+        ...base,
+        messages: [u, { id: "a1", role: "assistant", text: "first" }],
+      }),
+    );
+    runtime.__internal_setAdapter(
+      makeStore({
+        ...base,
+        messages: [u, { id: "a2", role: "assistant", text: "second" }],
+      }),
+    );
+    return runtime;
+  };
+
+  it("fires on explicit switchToBranch with head and visible path", () => {
+    const onBranchChange = vi.fn();
+    const runtime = makeBranched({
+      unstable_onBranchChange: onBranchChange,
+    });
+
+    runtime.switchToBranch("a1");
+
+    expect(onBranchChange).toHaveBeenCalledTimes(1);
+    expect(onBranchChange).toHaveBeenCalledWith({
+      headId: "a1",
+      visibleMessageIds: ["u", "a1"],
+    });
+  });
+
+  it("dedupes consecutive switches that resolve to the same head", () => {
+    const onBranchChange = vi.fn();
+    const runtime = makeBranched({
+      unstable_onBranchChange: onBranchChange,
+    });
+
+    runtime.switchToBranch("a1");
+    runtime.switchToBranch("a1");
+    expect(onBranchChange).toHaveBeenCalledTimes(1);
+
+    runtime.switchToBranch("a2");
+    expect(onBranchChange).toHaveBeenCalledTimes(2);
+    expect(onBranchChange).toHaveBeenLastCalledWith({
+      headId: "a2",
+      visibleMessageIds: ["u", "a2"],
+    });
+  });
+
+  it("does not fire on adapter resync", () => {
+    const onBranchChange = vi.fn();
+    // makeBranched performs construction + one resync via __internal_setAdapter.
+    makeBranched({ unstable_onBranchChange: onBranchChange });
+    expect(onBranchChange).not.toHaveBeenCalled();
+  });
+
+  it("does not fire on messageRepository resync (resetHead)", () => {
+    const onBranchChange = vi.fn();
+    const source = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({
+        messages: [u, { id: "a", role: "assistant", text: "x" }],
+        convertMessage,
+      }),
+    );
+    const exported = source.export();
+
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({
+        messageRepository: exported,
+        unstable_onBranchChange: onBranchChange,
+      }),
+    );
+    runtime.__internal_setAdapter(
+      makeStore({
+        messageRepository: { ...exported },
+        unstable_onBranchChange: onBranchChange,
+      }),
+    );
+
+    expect(onBranchChange).not.toHaveBeenCalled();
+  });
+
+  it("does not fire on append, edit, or content-only resync", async () => {
+    const onBranchChange = vi.fn();
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({
+        messages: [u, { id: "a1", role: "assistant", text: "first" }],
+        convertMessage,
+        onNew: vi.fn(),
+        onEdit: vi.fn(),
+        setMessages: vi.fn(),
+        unstable_onBranchChange: onBranchChange,
+      }),
+    );
+
+    // append to the tail (onNew)
+    await runtime.append({
+      role: "user",
+      content: [{ type: "text", text: "again" }],
+      attachments: [],
+      createdAt: new Date(0),
+      parentId: "a1",
+      sourceId: null,
+      runConfig: {},
+      metadata: { custom: {} },
+    });
+
+    // edit a non-tail message (onEdit)
+    await runtime.append({
+      role: "user",
+      content: [{ type: "text", text: "edited" }],
+      attachments: [],
+      createdAt: new Date(0),
+      parentId: null,
+      sourceId: null,
+      runConfig: {},
+      metadata: { custom: {} },
+    });
+
+    // content-only resync of the same structure
+    runtime.__internal_setAdapter(
+      makeStore({
+        messages: [u, { id: "a1", role: "assistant", text: "first edited" }],
+        convertMessage,
+        onNew: vi.fn(),
+        onEdit: vi.fn(),
+        setMessages: vi.fn(),
+        unstable_onBranchChange: onBranchChange,
+      }),
+    );
+
+    expect(onBranchChange).not.toHaveBeenCalled();
+  });
+
+  it("fires again when a resync moved the head away before switching back", () => {
+    const onBranchChange = vi.fn();
+    const runtime = makeBranched({
+      unstable_onBranchChange: onBranchChange,
+    });
+
+    runtime.switchToBranch("a1");
+    expect(onBranchChange).toHaveBeenCalledTimes(1);
+
+    // Adapter resync moves the visible head back to a2 (does not fire).
+    runtime.__internal_setAdapter(
+      makeStore({
+        messages: [u, { id: "a2", role: "assistant", text: "second" }],
+        convertMessage,
+        setMessages: vi.fn(),
+        unstable_onBranchChange: onBranchChange,
+      }),
+    );
+    expect(onBranchChange).toHaveBeenCalledTimes(1);
+
+    // Switching back to a1 must fire — the dedupe compares the head observed
+    // just before the switch, not the last emitted head.
+    runtime.switchToBranch("a1");
+    expect(onBranchChange).toHaveBeenCalledTimes(2);
+    expect(onBranchChange).toHaveBeenLastCalledWith({
+      headId: "a1",
+      visibleMessageIds: ["u", "a1"],
+    });
+  });
+
+  it("does not fire while the thread is running", () => {
+    const onBranchChange = vi.fn();
+    const runtime = makeBranched({
+      unstable_onBranchChange: onBranchChange,
+    });
+
+    // Flip into a running state without adding a trailing placeholder.
+    runtime.__internal_setAdapter(
+      makeStore({
+        messages: [u, { id: "a2", role: "assistant", text: "second" }],
+        convertMessage,
+        setMessages: vi.fn(),
+        isRunning: true,
+        unstable_onBranchChange: onBranchChange,
+      }),
+    );
+
+    runtime.switchToBranch("a1");
+
+    expect(onBranchChange).not.toHaveBeenCalled();
+  });
+
+  it("emits the persisted canonical head, not an optimistic id", () => {
+    const onBranchChange = vi.fn();
+
+    // Build a repository whose visible head is the persisted a1, with an
+    // optimistic sibling a2 also present under the user message.
+    const source = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({
+        messages: [u, { id: "a1", role: "assistant", text: "first" }],
+        convertMessage,
+      }),
+    );
+    const exported = source.export();
+    const a1Item = exported.messages.find((m) => m.message.id === "a1")!;
+    const optimisticRepo = {
+      headId: "a1",
+      messages: [
+        ...exported.messages,
+        {
+          parentId: "u",
+          message: {
+            ...a1Item.message,
+            id: "a2",
+            metadata: { ...a1Item.message.metadata, isOptimistic: true },
+          },
+        },
+      ],
+    };
+
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({
+        messageRepository: optimisticRepo,
+        setMessages: vi.fn(),
+        unstable_onBranchChange: onBranchChange,
+      }),
+    );
+
+    // Switch onto the optimistic leaf: the canonical head changes (a1 -> the
+    // persisted ancestor) so the callback fires.
+    runtime.switchToBranch("a2");
+
+    const event = onBranchChange.mock.calls.at(-1)![0];
+    // export() walks up from the optimistic a2 to its persisted ancestor.
+    expect(event.headId).toBe("u");
+    // The visible path still reflects the optimistic leaf.
+    expect(event.visibleMessageIds).toEqual(["u", "a2"]);
+  });
+
+  it("is a no-op when no callback is provided", () => {
+    const runtime = makeBranched();
+    expect(() => runtime.switchToBranch("a1")).not.toThrow();
+  });
+
+  it("does not read canonical heads when no callback is provided", () => {
+    const runtime = makeBranched();
+    const repository = (
+      runtime as unknown as { repository: { canonicalHeadId: string | null } }
+    ).repository;
+    const canonicalHeadIdSpy = vi.spyOn(repository, "canonicalHeadId", "get");
+
+    runtime.switchToBranch("a1");
+
+    expect(canonicalHeadIdSpy).not.toHaveBeenCalled();
+  });
+
+  it("does not export snapshots when emitting branch changes", () => {
+    const onBranchChange = vi.fn();
+    const runtime = makeBranched({ unstable_onBranchChange: onBranchChange });
+    const repository = (
+      runtime as unknown as { repository: { export: () => unknown } }
+    ).repository;
+    const exportSpy = vi.spyOn(repository, "export");
+
+    runtime.switchToBranch("a1");
+
+    expect(onBranchChange).toHaveBeenCalledTimes(1);
+    expect(exportSpy).not.toHaveBeenCalled();
+  });
+
+  it("uses the initiating adapter callback if setMessages swaps adapters synchronously", () => {
+    const initialOnBranchChange = vi.fn();
+    const swappedOnBranchChange = vi.fn();
+    let runtime!: ExternalStoreThreadRuntimeCore;
+    const setMessages = vi.fn(() => {
+      runtime.__internal_setAdapter(
+        makeStore({
+          messages: [u, { id: "a1", role: "assistant", text: "first" }],
+          convertMessage,
+          setMessages: vi.fn(),
+          unstable_onBranchChange: swappedOnBranchChange,
+        }),
+      );
+    });
+
+    runtime = makeBranched({
+      setMessages,
+      unstable_onBranchChange: initialOnBranchChange,
+    });
+
+    runtime.switchToBranch("a1");
+
+    expect(setMessages).toHaveBeenCalledTimes(1);
+    expect(initialOnBranchChange).toHaveBeenCalledTimes(1);
+    expect(initialOnBranchChange).toHaveBeenCalledWith({
+      headId: "a1",
+      visibleMessageIds: ["u", "a1"],
+    });
+    expect(swappedOnBranchChange).not.toHaveBeenCalled();
+  });
+
+  it("still calls setMessages on branch switch", () => {
+    const setMessages = vi.fn();
+    const runtime = makeBranched({
+      setMessages,
+      unstable_onBranchChange: vi.fn(),
+    });
+
+    runtime.switchToBranch("a1");
+
+    expect(setMessages).toHaveBeenCalledWith([
+      expect.objectContaining({ id: "u" }),
+      expect.objectContaining({ id: "a1" }),
+    ]);
+  });
+});
+
 describe("ExternalStoreThreadRuntimeCore - initialize event replay", () => {
   const message = { id: "m", role: "assistant" as const, content: [] };
   const flushMicrotasks = () => Promise.resolve();

package/src/tests/groupParts.test.ts

@@ -190,6 +190,38 @@ describe("groupPartByType", () => {
     expect(fn(standalone, inlineCtx)).toEqual(["group-tool"]);
   });
 
+  it("leaves regular and standalone tool calls ungrouped when both map to []", () => {
+    const fn = groupPartByType({
+      reasoning: ["group-chainOfThought", "group-reasoning"],
+      "tool-call": [],
+      "standalone-tool-call": [],
+    });
+    const regularTool = part({
+      type: "tool-call",
+      toolName: "search",
+    } as Partial<PartState>);
+    const standaloneTool = part({
+      type: "tool-call",
+      toolName: "ask_user",
+    } as Partial<PartState>);
+
+    const paths = [
+      fn(part({ type: "reasoning" })),
+      fn(regularTool),
+      fn(standaloneTool, standaloneContext("ask_user")),
+    ];
+
+    // reasoning groups into the chain-of-thought; both tool kinds stay flat.
+    expect(paths).toEqual([
+      ["group-chainOfThought", "group-reasoning"],
+      [],
+      [],
+    ]);
+    expect(dump(buildGroupTree(paths))).toBe(
+      "G:group-chainOfThought#0[0]{G:group-reasoning#0.0[0]{P:#0.0.0(0)}},P:#1(1),P:#2(2)",
+    );
+  });
+
   it("routes MCP-app parts through 'standalone-tool-call' from the part alone", () => {
     const fn = groupPartByType({
       "tool-call": ["group-tool"],

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

@@ -1,4 +1,6 @@
 import { describe, it, expect, vi } from "vitest";
+import type { RemoteThreadListAdapter } from "../runtimes/remote-thread-list/types";
+import { createCore, makeAdapter } from "./remote-thread-list-test-helpers";
 
 /**
  * Tests for the reactive threadId useEffect logic in useRemoteThreadListRuntime.
@@ -91,3 +93,91 @@ describe("threadId reactive effect", () => {
     expect(switchToThread).toHaveBeenCalledTimes(3);
   });
 });
+
+/**
+ * Tests for onThreadIdChange, driving the real
+ * RemoteThreadListThreadListRuntimeCore via a mock adapter (no React). These
+ * exercise the actual _notifyThreadIdChange / _mainThreadRemoteId path and the
+ * subscription + switchToThread wiring that invokes it.
+ */
+function createCoreWithCallback(
+  onThreadIdChange: (id: string | undefined) => void,
+  adapterOverrides: Partial<RemoteThreadListAdapter> = {},
+) {
+  const adapter = makeAdapter(adapterOverrides);
+  const core = createCore(adapter, undefined, onThreadIdChange);
+  return { core, adapter };
+}
+
+// Let the constructor's in-flight switchToNewThread settle.
+const flush = () => new Promise((resolve) => setTimeout(resolve));
+
+describe("onThreadIdChange", () => {
+  it("does not emit while the active thread is still optimistic", async () => {
+    const cb = vi.fn();
+    createCoreWithCallback(cb);
+    await flush();
+
+    expect(cb).not.toHaveBeenCalled();
+  });
+
+  it("emits the remote ID once a new thread is initialized", async () => {
+    const cb = vi.fn();
+    const { core } = createCoreWithCallback(cb, {
+      initialize: vi.fn(async () => ({
+        remoteId: "remote-1",
+        externalId: "ext-1",
+      })),
+    });
+    await flush();
+
+    const newThreadId = core.newThreadId!;
+    expect(newThreadId).toBeDefined();
+    expect(cb).not.toHaveBeenCalled(); // still optimistic, no remote ID
+
+    await core.initialize(newThreadId);
+
+    expect(cb).toHaveBeenLastCalledWith("remote-1");
+  });
+
+  it("emits the remote ID when switching to an existing thread", async () => {
+    const cb = vi.fn();
+    const { core } = createCoreWithCallback(cb);
+    await flush();
+
+    await core.switchToThread("existing-1");
+
+    expect(cb).toHaveBeenLastCalledWith("existing-1");
+  });
+
+  it("dedupes: switching to the already-active thread does not re-emit", async () => {
+    const cb = vi.fn();
+    const { core } = createCoreWithCallback(cb);
+    await flush();
+
+    await core.switchToThread("existing-1");
+    const callsAfterFirstSwitch = cb.mock.calls.length;
+
+    await core.switchToThread("existing-1");
+
+    expect(cb).toHaveBeenCalledTimes(callsAfterFirstSwitch);
+  });
+
+  it("never surfaces the transient local ID", async () => {
+    const cb = vi.fn();
+    const { core } = createCoreWithCallback(cb, {
+      initialize: vi.fn(async () => ({
+        remoteId: "remote-1",
+        externalId: "ext-1",
+      })),
+    });
+    await flush();
+
+    const localId = core.newThreadId!;
+    await core.initialize(localId);
+
+    for (const [emitted] of cb.mock.calls) {
+      expect(emitted).not.toBe(localId);
+    }
+  });
+});

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

@@ -52,9 +52,10 @@ export function makeAdapter(
 export function createCore(
   adapter: RemoteThreadListAdapter,
   threadId?: string,
+  onThreadIdChange?: (threadId: string | undefined) => void,
 ): RemoteThreadListThreadListRuntimeCore {
   const core = new RemoteThreadListThreadListRuntimeCore(
-    { adapter, runtimeHook: () => ({}) as never, threadId },
+    { adapter, runtimeHook: () => ({}) as never, threadId, onThreadIdChange },
     contextProvider,
   );
   // `startThreadRuntime` blocks until a React component attaches a runtime;