@assistant-ui/core 0.1.14 → 0.1.16

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

@@ -0,0 +1,312 @@
+import { describe, expect, it, vi } from "vitest";
+import { DefaultEditComposerRuntimeCore } from "../runtime/base/default-edit-composer-runtime-core";
+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 append = vi.fn();
+  const runtime = {
+    append,
+    composer: { runConfig: {} },
+  } as unknown as ThreadRuntimeCore & { adapters?: undefined };
+  return { runtime, append };
+};
+
+const makeUserMessage = (overrides?: Partial<ThreadMessage>): ThreadMessage =>
+  ({
+    id: "msg-1",
+    role: "user",
+    createdAt: new Date(),
+    content: [{ type: "text", text: "hello" }],
+    attachments: [],
+    metadata: { custom: {} },
+    ...overrides,
+  }) as ThreadMessage;
+
+const makeCompleteAttachment = (
+  id: string,
+  name = "file.pdf",
+): CompleteAttachment => ({
+  id,
+  type: "document",
+  name,
+  contentType: "application/pdf",
+  content: [
+    { type: "file", data: "blob", mimeType: "application/pdf", filename: name },
+  ],
+  status: { type: "complete" },
+});
+
+describe("DefaultEditComposerRuntimeCore", () => {
+  describe("construction", () => {
+    it("seeds composer text from the edited message", () => {
+      const { runtime } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: makeUserMessage({
+          content: [{ type: "text", text: "original" }],
+        }),
+      });
+      expect(composer.text).toBe("original");
+    });
+
+    it("seeds attachments from message.attachments", () => {
+      const { runtime } = makeRuntime();
+      const attachment = makeCompleteAttachment("att-1");
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: makeUserMessage({ attachments: [attachment] }),
+      });
+      expect(composer.attachments).toEqual([attachment]);
+    });
+
+    it("lifts non-text content parts into attachments", () => {
+      const { runtime } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: makeUserMessage({
+          content: [
+            { type: "text", text: "here is a file" },
+            {
+              type: "file",
+              data: "blob",
+              mimeType: "application/pdf",
+              filename: "report.pdf",
+            },
+          ],
+        }),
+      });
+      expect(composer.attachments).toHaveLength(1);
+      expect(composer.attachments[0]).toMatchObject({
+        type: "document",
+        name: "report.pdf",
+        contentType: "application/pdf",
+        status: { type: "complete" },
+      });
+    });
+
+    it("merges message.attachments with lifted content parts", () => {
+      const { runtime } = makeRuntime();
+      const attachment = makeCompleteAttachment("att-1", "existing.pdf");
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: makeUserMessage({
+          attachments: [attachment],
+          content: [
+            { type: "text", text: "x" },
+            {
+              type: "file",
+              data: "b",
+              mimeType: "application/pdf",
+              filename: "inline.pdf",
+            },
+          ],
+        }),
+      });
+      expect(composer.attachments).toHaveLength(2);
+      expect(composer.attachments[0]).toBe(attachment);
+      expect(composer.attachments[1]).toMatchObject({ name: "inline.pdf" });
+    });
+
+    it("exposes parentId and sourceId", () => {
+      const { runtime } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: "parent-7",
+        message: makeUserMessage(),
+      });
+      expect(composer.parentId).toBe("parent-7");
+      expect(composer.sourceId).toBe("msg-1");
+    });
+  });
+
+  describe("send behavior", () => {
+    it("does not call append when nothing changed", async () => {
+      const { runtime, append } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: "p1",
+        message: makeUserMessage({
+          content: [{ type: "text", text: "same" }],
+        }),
+      });
+      await composer.send();
+      expect(append).not.toHaveBeenCalled();
+    });
+
+    it("calls append when text changes", async () => {
+      const { runtime, append } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: "p1",
+        message: makeUserMessage({
+          content: [{ type: "text", text: "old" }],
+        }),
+      });
+      composer.setText("new");
+      await composer.send();
+      expect(append).toHaveBeenCalledTimes(1);
+      const appended = append.mock.calls[0]![0] as AppendMessage;
+      expect(appended.content).toEqual([{ type: "text", text: "new" }]);
+      expect(appended.parentId).toBe("p1");
+      expect(appended.sourceId).toBe("msg-1");
+    });
+
+    it("drops a removed attachment from the sent message", async () => {
+      const { runtime, append } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: makeUserMessage({
+          content: [
+            { type: "text", text: "original" },
+            {
+              type: "file",
+              data: "blob",
+              mimeType: "application/pdf",
+              filename: "doc.pdf",
+            },
+          ],
+        }),
+      });
+      expect(composer.attachments).toHaveLength(1);
+      await composer.removeAttachment(composer.attachments[0]!.id);
+      await composer.send();
+      expect(append).toHaveBeenCalledTimes(1);
+      const appended = append.mock.calls[0]![0] as AppendMessage;
+      expect(appended.attachments).toHaveLength(0);
+      expect(appended.content).toEqual([{ type: "text", text: "original" }]);
+    });
+
+    it("preserves the attachment without duplicating it when only text changes", async () => {
+      const { runtime, append } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: makeUserMessage({
+          content: [
+            { type: "text", text: "old" },
+            {
+              type: "file",
+              data: "blob",
+              mimeType: "application/pdf",
+              filename: "doc.pdf",
+            },
+          ],
+        }),
+      });
+      composer.setText("new text");
+      await composer.send();
+      const appended = append.mock.calls[0]![0] as AppendMessage;
+      expect(appended.content).toEqual([{ type: "text", text: "new text" }]);
+      expect(appended.attachments).toHaveLength(1);
+      expect(appended.attachments![0]).toMatchObject({ name: "doc.pdf" });
+    });
+
+    it("forwards startRun even when text and attachments are unchanged", async () => {
+      const { runtime, append } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: makeUserMessage({
+          content: [{ type: "text", text: "same" }],
+        }),
+      });
+      await composer.send({ startRun: true });
+      expect(append).toHaveBeenCalledTimes(1);
+      const appended = append.mock.calls[0]![0] as AppendMessage;
+      expect(appended.startRun).toBe(true);
+    });
+  });
+
+  describe("non-user messages", () => {
+    it("does not lift non-text parts for assistant messages", () => {
+      const { runtime } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: {
+          id: "msg-a",
+          role: "assistant",
+          createdAt: new Date(),
+          content: [
+            { type: "text", text: "answer" },
+            {
+              type: "file",
+              data: "blob",
+              mimeType: "application/pdf",
+              filename: "doc.pdf",
+            },
+          ],
+          status: { type: "complete", reason: "stop" },
+          metadata: {
+            unstable_state: null,
+            unstable_annotations: [],
+            unstable_data: [],
+            steps: [],
+            custom: {},
+          },
+        } as ThreadMessage,
+      });
+      expect(composer.attachments).toHaveLength(0);
+    });
+
+    it("preserves non-text content parts of assistant messages on send", async () => {
+      const { runtime, append } = makeRuntime();
+      const fileParts = [
+        {
+          type: "file" as const,
+          data: "blob",
+          mimeType: "application/pdf",
+          filename: "doc.pdf",
+        },
+        { type: "reasoning" as const, text: "chain of thought" },
+      ];
+      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+        parentId: null,
+        message: {
+          id: "msg-a",
+          role: "assistant",
+          createdAt: new Date(),
+          content: [{ type: "text", text: "old answer" }, ...fileParts],
+          status: { type: "complete", reason: "stop" },
+          metadata: {
+            unstable_state: null,
+            unstable_annotations: [],
+            unstable_data: [],
+            steps: [],
+            custom: {},
+          },
+        } as ThreadMessage,
+      });
+      composer.setText("new answer");
+      await composer.send();
+      expect(append).toHaveBeenCalledTimes(1);
+      const appended = append.mock.calls[0]![0] as AppendMessage;
+      expect(appended.content).toEqual([
+        { type: "text", text: "new answer" },
+        ...fileParts,
+      ]);
+      expect(appended.attachments ?? []).toHaveLength(0);
+    });
+  });
+
+  describe("lifecycle", () => {
+    it("invokes endEditCallback after send", async () => {
+      const endEdit = vi.fn();
+      const { runtime } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, endEdit, {
+        parentId: null,
+        message: makeUserMessage(),
+      });
+      composer.setText("changed");
+      await composer.send();
+      expect(endEdit).toHaveBeenCalledTimes(1);
+    });
+
+    it("invokes endEditCallback on cancel", () => {
+      const endEdit = vi.fn();
+      const { runtime } = makeRuntime();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, endEdit, {
+        parentId: null,
+        message: makeUserMessage(),
+      });
+      composer.cancel();
+      expect(endEdit).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/tests/{mention-formatter.test.ts → directive-formatter.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { unstable_defaultDirectiveFormatter } from "../adapters/mention";
+import { unstable_defaultDirectiveFormatter } from "../adapters/directive-formatter";
 
 describe("unstable_defaultDirectiveFormatter", () => {
   describe("serialize", () => {
@@ -109,4 +109,29 @@ describe("unstable_defaultDirectiveFormatter", () => {
       ]);
     });
   });
+
+  describe("unicode support", () => {
+    it("serializes a directive with a CJK label", () => {
+      expect(
+        unstable_defaultDirectiveFormatter.serialize({
+          id: "天气",
+          type: "tool",
+          label: "天气",
+        }),
+      ).toBe(":tool[天气]");
+    });
+
+    it("parses a directive with a CJK label and name attr", () => {
+      expect(
+        unstable_defaultDirectiveFormatter.parse(":tool[天气]{name=w1}"),
+      ).toEqual([
+        {
+          kind: "mention",
+          type: "tool",
+          label: "天气",
+          id: "w1",
+        },
+      ]);
+    });
+  });
 });

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

@@ -0,0 +1,212 @@
+import { describe, expect, it, vi } from "vitest";
+import { ExternalStoreThreadListRuntimeCore } from "../runtimes/external-store/external-store-thread-list-runtime-core";
+import type { ExternalStoreThreadRuntimeCore } from "../runtimes/external-store/external-store-thread-runtime-core";
+import type { ExternalStoreThreadListAdapter } from "../runtimes/external-store/external-store-adapter";
+import { ThreadListRuntimeImpl } from "../runtime/api/thread-list-runtime";
+
+const makeFactory = () =>
+  vi.fn(
+    () =>
+      ({
+        subscribe: () => () => {},
+      }) as unknown as ExternalStoreThreadRuntimeCore,
+  );
+
+const makeAdapter = (
+  overrides: Partial<ExternalStoreThreadListAdapter> = {},
+): ExternalStoreThreadListAdapter => ({ ...overrides });
+
+describe("ExternalStoreThreadListRuntimeCore - construction", () => {
+  it("assigns a resolvable fallback mainThreadId when adapter has no threadId", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter(),
+      makeFactory(),
+    );
+    expect(typeof core.mainThreadId).toBe("string");
+    expect(core.mainThreadId.length).toBeGreaterThan(0);
+    expect(core.getItemById(core.mainThreadId)).toBeDefined();
+  });
+
+  it("picks up mainThreadId from adapter.threadId on construction (regression: #2577)", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      makeFactory(),
+    );
+    expect(core.mainThreadId).toBe("thread-alpha");
+  });
+
+  it("exposes threadIds from adapter.threads on construction", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({
+        threadId: "thread-alpha",
+        threads: [
+          { id: "thread-alpha", status: "regular" },
+          { id: "thread-beta", status: "regular" },
+        ],
+      }),
+      makeFactory(),
+    );
+    expect(core.threadIds).toEqual(["thread-alpha", "thread-beta"]);
+    expect(core.mainThreadId).toBe("thread-alpha");
+  });
+
+  it("creates the main thread instance exactly once on construction", () => {
+    const factory = makeFactory();
+    new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      factory,
+    );
+    expect(factory).toHaveBeenCalledTimes(1);
+  });
+
+  it("creates the main thread instance exactly once when adapter has no threadId", () => {
+    const factory = makeFactory();
+    new ExternalStoreThreadListRuntimeCore(makeAdapter(), factory);
+    expect(factory).toHaveBeenCalledTimes(1);
+  });
+
+  it("binds getMainThreadRuntimeCore() to the instance produced by the factory", () => {
+    const instance = {
+      subscribe: () => () => {},
+    } as unknown as ExternalStoreThreadRuntimeCore;
+    const factory = vi.fn(() => instance);
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      factory,
+    );
+    expect(core.getMainThreadRuntimeCore()).toBe(instance);
+  });
+
+  it("preserves the frozen threadItems default when the adapter has no threads", () => {
+    const a = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter(),
+      makeFactory(),
+    );
+    const b = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter(),
+      makeFactory(),
+    );
+    // Two empty-adapter constructions should share the frozen DEFAULT_THREAD_DATA
+    // singleton rather than each getting a fresh `{ ... }` clone.
+    expect(a.threadItems).toBe(b.threadItems);
+  });
+});
+
+describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
+  it("updates mainThreadId when adapter.threadId changes", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      makeFactory(),
+    );
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+    expect(core.mainThreadId).toBe("thread-beta");
+  });
+
+  it("rebuilds the main thread instance when threadId changes", () => {
+    const factory = makeFactory();
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      factory,
+    );
+    const constructionCalls = factory.mock.calls.length;
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+    expect(factory.mock.calls.length).toBe(constructionCalls + 1);
+  });
+
+  it("does not rebuild the main thread when only threads array changes", () => {
+    const factory = makeFactory();
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({
+        threadId: "thread-alpha",
+        threads: [{ id: "thread-alpha", status: "regular" }],
+      }),
+      factory,
+    );
+    const constructionCalls = factory.mock.calls.length;
+    core.__internal_setAdapter(
+      makeAdapter({
+        threadId: "thread-alpha",
+        threads: [
+          { id: "thread-alpha", status: "regular" },
+          { id: "thread-beta", status: "regular" },
+        ],
+      }),
+    );
+    expect(factory.mock.calls.length).toBe(constructionCalls);
+    expect(core.threadIds).toEqual(["thread-alpha", "thread-beta"]);
+  });
+
+  it("notifies subscribers on threadId change", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      makeFactory(),
+    );
+    const callback = vi.fn();
+    core.subscribe(callback);
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+    expect(callback).toHaveBeenCalled();
+  });
+});
+
+describe("ExternalStoreThreadListRuntimeCore - isMain via ThreadListRuntimeImpl", () => {
+  // Stub to avoid constructing the full ThreadRuntimeImpl graph when we only
+  // care about ThreadListItemRuntime.getState().isMain.
+  class NoopThreadRuntime {}
+
+  const buildImpl = (adapter: ExternalStoreThreadListAdapter) => {
+    const core = new ExternalStoreThreadListRuntimeCore(adapter, makeFactory());
+    return new ThreadListRuntimeImpl(
+      core,
+      NoopThreadRuntime as unknown as Parameters<
+        typeof ThreadListRuntimeImpl
+      >[1],
+    );
+  };
+
+  it("reports isMain=true for adapter.threadId on construction (user-visible regression: #2577)", () => {
+    const impl = buildImpl({
+      threadId: "thread-alpha",
+      threads: [
+        { id: "thread-alpha", status: "regular" },
+        { id: "thread-beta", status: "regular" },
+      ],
+    });
+    expect(impl.getItemById("thread-alpha").getState().isMain).toBe(true);
+    expect(impl.getItemById("thread-beta").getState().isMain).toBe(false);
+  });
+
+  it("reflects the main thread in the aggregated ThreadListState on construction", () => {
+    const impl = buildImpl({
+      threadId: "thread-alpha",
+      threads: [
+        { id: "thread-alpha", status: "regular" },
+        { id: "thread-beta", status: "regular" },
+      ],
+    });
+    const state = impl.getState();
+    expect(state.mainThreadId).toBe("thread-alpha");
+    expect(state.threadIds).toEqual(["thread-alpha", "thread-beta"]);
+  });
+});
+
+describe("ExternalStoreThreadListRuntimeCore - switchToThread", () => {
+  it("invokes onSwitchToThread when the target differs from mainThreadId", async () => {
+    const onSwitchToThread = vi.fn(async () => {});
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha", onSwitchToThread }),
+      makeFactory(),
+    );
+    await core.switchToThread("thread-beta");
+    expect(onSwitchToThread).toHaveBeenCalledWith("thread-beta");
+  });
+
+  it("early-returns without calling onSwitchToThread when target equals initial threadId (regression: #2577)", async () => {
+    const onSwitchToThread = vi.fn(async () => {});
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha", onSwitchToThread }),
+      makeFactory(),
+    );
+    await core.switchToThread("thread-alpha");
+    expect(onSwitchToThread).not.toHaveBeenCalled();
+  });
+});

package/src/tests/get-thread-state-isRunning.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest";
+import { getThreadState } from "../runtime/api/thread-runtime";
+import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
+import type { ThreadMessage } from "../types/message";
+import type { ThreadListItemState } from "../runtime/api/thread-list-item-runtime";
+
+const listItem = { id: "t1" } as unknown as ThreadListItemState;
+
+const baseRuntime = (
+  overrides: Partial<ThreadRuntimeCore>,
+): ThreadRuntimeCore =>
+  ({
+    messages: [],
+    isDisabled: false,
+    isLoading: false,
+    capabilities: {} as any,
+    state: null,
+    suggestions: [],
+    extras: undefined,
+    speech: undefined,
+    voice: undefined,
+    ...overrides,
+  }) as unknown as ThreadRuntimeCore;
+
+const userMessage: ThreadMessage = {
+  id: "u1",
+  role: "user",
+  content: [],
+  createdAt: new Date(),
+  attachments: [],
+  metadata: { custom: {} },
+} as unknown as ThreadMessage;
+
+const completeAssistant: ThreadMessage = {
+  id: "a1",
+  role: "assistant",
+  content: [],
+  createdAt: new Date(),
+  status: { type: "complete", reason: "stop" },
+  metadata: { unstable_state: null, custom: {}, steps: [] },
+} as unknown as ThreadMessage;
+
+const runningAssistant: ThreadMessage = {
+  ...completeAssistant,
+  id: "a2",
+  status: { type: "running" },
+} as unknown as ThreadMessage;
+
+describe("getThreadState.isRunning", () => {
+  it("falls back to last-message heuristic when runtime.isRunning is undefined", () => {
+    expect(
+      getThreadState(baseRuntime({ messages: [runningAssistant] }), listItem)
+        .isRunning,
+    ).toBe(true);
+
+    expect(
+      getThreadState(baseRuntime({ messages: [completeAssistant] }), listItem)
+        .isRunning,
+    ).toBe(false);
+
+    expect(
+      getThreadState(baseRuntime({ messages: [userMessage] }), listItem)
+        .isRunning,
+    ).toBe(false);
+  });
+
+  it("prefers explicit runtime.isRunning=true even when last message is complete", () => {
+    expect(
+      getThreadState(
+        baseRuntime({ isRunning: true, messages: [completeAssistant] }),
+        listItem,
+      ).isRunning,
+    ).toBe(true);
+  });
+
+  it("prefers explicit runtime.isRunning=true when last message is a user message", () => {
+    expect(
+      getThreadState(
+        baseRuntime({ isRunning: true, messages: [userMessage] }),
+        listItem,
+      ).isRunning,
+    ).toBe(true);
+  });
+
+  it("prefers explicit runtime.isRunning=false even when last message is running", () => {
+    expect(
+      getThreadState(
+        baseRuntime({ isRunning: false, messages: [runningAssistant] }),
+        listItem,
+      ).isRunning,
+    ).toBe(false);
+  });
+});