@assistant-ui/react 0.12.10 → 0.12.12

package/src/tests/ExternalStoreThreadRuntimeCore.test.ts

@@ -0,0 +1,510 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import {
+  ExternalStoreThreadRuntimeCore,
+  hasUpcomingMessage,
+} from "../legacy-runtime/runtime-cores/external-store/ExternalStoreThreadRuntimeCore";
+import type { ExternalStoreAdapter } from "../legacy-runtime/runtime-cores/external-store/ExternalStoreAdapter";
+import type { ModelContextProvider } from "@assistant-ui/core";
+import type { AppendMessage, ThreadMessage } from "@assistant-ui/core";
+
+const createContextProvider = (): ModelContextProvider => ({
+  getModelContext: () => ({}),
+});
+
+const createUserMessage = (id: string, text = "Hello"): ThreadMessage =>
+  ({
+    id,
+    role: "user" as const,
+    createdAt: new Date(),
+    content: [{ type: "text" as const, text }],
+    attachments: [],
+    metadata: {
+      custom: {},
+    },
+  }) as ThreadMessage;
+
+const createAssistantMessage = (id: string, text = "Hi there"): ThreadMessage =>
+  ({
+    id,
+    role: "assistant" as const,
+    createdAt: new Date(),
+    content: [{ type: "text" as const, text }],
+    status: { type: "complete" as const, reason: "stop" as const },
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {},
+    },
+  }) as ThreadMessage;
+
+const createBaseAdapter = (
+  overrides: Partial<ExternalStoreAdapter<ThreadMessage>> = {},
+): ExternalStoreAdapter<ThreadMessage> => ({
+  messages: [],
+  onNew: vi.fn(async () => {}),
+  ...overrides,
+});
+
+describe("ExternalStoreThreadRuntimeCore", () => {
+  let contextProvider: ModelContextProvider;
+
+  beforeEach(() => {
+    contextProvider = createContextProvider();
+  });
+
+  describe("hasUpcomingMessage", () => {
+    it("returns true when running and last message is not assistant", () => {
+      const messages = [createUserMessage("u1")];
+      expect(hasUpcomingMessage(true, messages)).toBe(true);
+    });
+
+    it("returns false when running and last message is assistant", () => {
+      const messages = [createAssistantMessage("a1")];
+      expect(hasUpcomingMessage(true, messages)).toBe(false);
+    });
+
+    it("returns false when not running", () => {
+      const messages = [createUserMessage("u1")];
+      expect(hasUpcomingMessage(false, messages)).toBe(false);
+    });
+
+    it("returns true for empty messages when running", () => {
+      expect(hasUpcomingMessage(true, [])).toBe(true);
+    });
+  });
+
+  describe("capabilities derived from adapter", () => {
+    it("enables edit when onEdit is provided", () => {
+      const adapter = createBaseAdapter({
+        onEdit: vi.fn(async () => {}),
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.capabilities.edit).toBe(true);
+    });
+
+    it("disables edit when onEdit is not provided", () => {
+      const adapter = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.capabilities.edit).toBe(false);
+    });
+
+    it("enables reload when onReload is provided", () => {
+      const adapter = createBaseAdapter({
+        onReload: vi.fn(async () => {}),
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.capabilities.reload).toBe(true);
+    });
+
+    it("disables reload when onReload is not provided", () => {
+      const adapter = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.capabilities.reload).toBe(false);
+    });
+
+    it("enables cancel when onCancel is provided", () => {
+      const adapter = createBaseAdapter({
+        onCancel: vi.fn(async () => {}),
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.capabilities.cancel).toBe(true);
+    });
+
+    it("disables cancel when onCancel is not provided", () => {
+      const adapter = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.capabilities.cancel).toBe(false);
+    });
+
+    it("enables switchToBranch when setMessages is provided", () => {
+      const adapter = createBaseAdapter({
+        setMessages: vi.fn(),
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.capabilities.switchToBranch).toBe(true);
+    });
+
+    it("defaults unstable_copy to true", () => {
+      const adapter = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.capabilities.unstable_copy).toBe(true);
+    });
+
+    it("disables unstable_copy when explicitly set to false", () => {
+      const adapter = createBaseAdapter({
+        unstable_capabilities: { copy: false },
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.capabilities.unstable_copy).toBe(false);
+    });
+  });
+
+  describe("append", () => {
+    it("calls onNew when parentId matches last message id", async () => {
+      const onNew = vi.fn(async () => {});
+      const messages = [createUserMessage("u1"), createAssistantMessage("a1")];
+      const adapter = createBaseAdapter({ messages, onNew });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      const appendMessage: AppendMessage = {
+        role: "user",
+        content: [{ type: "text", text: "Follow up" }],
+        attachments: [],
+        createdAt: new Date(),
+        parentId: "a1",
+        sourceId: null,
+        runConfig: undefined,
+        metadata: { custom: {} },
+      } as AppendMessage;
+
+      await core.append(appendMessage);
+      expect(onNew).toHaveBeenCalledWith(appendMessage);
+    });
+
+    it("calls onEdit when parentId does not match last message id", async () => {
+      const onEdit = vi.fn(async () => {});
+      const onNew = vi.fn(async () => {});
+      const messages = [createUserMessage("u1"), createAssistantMessage("a1")];
+      const adapter = createBaseAdapter({ messages, onNew, onEdit });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      const appendMessage: AppendMessage = {
+        role: "user",
+        content: [{ type: "text", text: "Edit" }],
+        attachments: [],
+        createdAt: new Date(),
+        parentId: "u1",
+        sourceId: null,
+        runConfig: undefined,
+        metadata: { custom: {} },
+      } as AppendMessage;
+
+      await core.append(appendMessage);
+      expect(onEdit).toHaveBeenCalledWith(appendMessage);
+      expect(onNew).not.toHaveBeenCalled();
+    });
+
+    it("throws when adapter has no onEdit and parentId differs from head", async () => {
+      const messages = [createUserMessage("u1"), createAssistantMessage("a1")];
+      const adapter = createBaseAdapter({ messages });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      const appendMessage: AppendMessage = {
+        role: "user",
+        content: [{ type: "text", text: "Edit" }],
+        attachments: [],
+        createdAt: new Date(),
+        parentId: "u1",
+        sourceId: null,
+        runConfig: undefined,
+        metadata: { custom: {} },
+      } as AppendMessage;
+
+      await expect(core.append(appendMessage)).rejects.toThrow(
+        "Runtime does not support editing messages.",
+      );
+    });
+  });
+
+  describe("startRun", () => {
+    it("delegates to onReload", async () => {
+      const onReload = vi.fn(async () => {});
+      const adapter = createBaseAdapter({ onReload });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      await core.startRun({ parentId: "msg-1", sourceId: null, runConfig: {} });
+      expect(onReload).toHaveBeenCalledWith("msg-1", {
+        parentId: "msg-1",
+        sourceId: null,
+        runConfig: {},
+      });
+    });
+
+    it("throws when adapter has no onReload", async () => {
+      const adapter = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      await expect(
+        core.startRun({ parentId: "msg-1", sourceId: null, runConfig: {} }),
+      ).rejects.toThrow("Runtime does not support reloading messages.");
+    });
+  });
+
+  describe("cancelRun", () => {
+    it("delegates to onCancel", () => {
+      const onCancel = vi.fn();
+      const messages = [createUserMessage("u1"), createAssistantMessage("a1")];
+      const adapter = createBaseAdapter({
+        messages,
+        onCancel,
+        setMessages: vi.fn(),
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      core.cancelRun();
+      expect(onCancel).toHaveBeenCalled();
+    });
+
+    it("throws when adapter has no onCancel", () => {
+      const adapter = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      expect(() => core.cancelRun()).toThrow(
+        "Runtime does not support cancelling runs.",
+      );
+    });
+  });
+
+  describe("optimistic assistant message", () => {
+    it("adds optimistic assistant message when running with last user message", () => {
+      const userMsg = createUserMessage("u1");
+      const adapter = createBaseAdapter({
+        messages: [userMsg],
+        isRunning: true,
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      const messages = core.messages;
+      expect(messages.length).toBe(2);
+      expect(messages[0]!.id).toBe("u1");
+      expect(messages[1]!.role).toBe("assistant");
+      expect(messages[1]!.content).toEqual([]);
+    });
+
+    it("does not add optimistic message when last message is assistant", () => {
+      const adapter = createBaseAdapter({
+        messages: [createUserMessage("u1"), createAssistantMessage("a1")],
+        isRunning: true,
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      const messages = core.messages;
+      expect(messages.length).toBe(2);
+      expect(messages[1]!.role).toBe("assistant");
+      expect(messages[1]!.id).toBe("a1");
+    });
+
+    it("does not add optimistic message when not running", () => {
+      const adapter = createBaseAdapter({
+        messages: [createUserMessage("u1")],
+        isRunning: false,
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      expect(core.messages.length).toBe(1);
+    });
+  });
+
+  describe("adapter update via __internal_setAdapter", () => {
+    it("updates capabilities when adapter changes", () => {
+      const adapter1 = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        adapter1,
+      );
+      expect(core.capabilities.edit).toBe(false);
+
+      const adapter2 = createBaseAdapter({
+        onEdit: vi.fn(async () => {}),
+      });
+      core.__internal_setAdapter(adapter2);
+      expect(core.capabilities.edit).toBe(true);
+    });
+
+    it("updates isDisabled from adapter", () => {
+      const adapter = createBaseAdapter({ isDisabled: true });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.isDisabled).toBe(true);
+
+      core.__internal_setAdapter(createBaseAdapter({ isDisabled: false }));
+      expect(core.isDisabled).toBe(false);
+    });
+
+    it("updates suggestions from adapter", () => {
+      const suggestions = [{ prompt: "Tell me a joke" }];
+      const adapter = createBaseAdapter({ suggestions });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      expect(core.suggestions).toEqual(suggestions);
+    });
+
+    it("skips update when same adapter reference is passed", () => {
+      const adapter = createBaseAdapter({
+        messages: [createUserMessage("u1")],
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+      const spy = vi.fn();
+      core.subscribe(spy);
+      spy.mockClear();
+
+      // Same reference — should not notify
+      core.__internal_setAdapter(adapter);
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("switchToBranch", () => {
+    it("throws when setMessages is not provided", () => {
+      const adapter = createBaseAdapter({
+        messages: [createUserMessage("u1")],
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      expect(() => core.switchToBranch("u1")).toThrow(
+        "Runtime does not support switching branches.",
+      );
+    });
+
+    it("silently ignores branch switch while running", () => {
+      const setMessages = vi.fn();
+      const adapter = createBaseAdapter({
+        messages: [createUserMessage("u1"), createAssistantMessage("a1")],
+        isRunning: true,
+        setMessages,
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      // Should not throw, should silently return
+      core.switchToBranch("u1");
+      expect(setMessages).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("exportExternalState and importExternalState", () => {
+    it("delegates export to adapter", () => {
+      const state = { key: "value" };
+      const adapter = createBaseAdapter({
+        onExportExternalState: vi.fn(() => state),
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      expect(core.exportExternalState()).toEqual(state);
+    });
+
+    it("throws on export when adapter has no onExportExternalState", () => {
+      const adapter = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      expect(() => core.exportExternalState()).toThrow(
+        "Runtime does not support exporting external states.",
+      );
+    });
+
+    it("delegates import to adapter", () => {
+      const onLoadExternalState = vi.fn();
+      const adapter = createBaseAdapter({ onLoadExternalState });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      const state = { key: "value" };
+      core.importExternalState(state);
+      expect(onLoadExternalState).toHaveBeenCalledWith(state);
+    });
+
+    it("throws on import when adapter has no onLoadExternalState", () => {
+      const adapter = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      expect(() => core.importExternalState({})).toThrow(
+        "Runtime does not support importing external states.",
+      );
+    });
+  });
+
+  describe("beginEdit", () => {
+    it("throws when adapter has no onEdit", () => {
+      const adapter = createBaseAdapter({
+        messages: [createUserMessage("u1")],
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      expect(() => core.beginEdit("u1")).toThrow(
+        "Runtime does not support editing.",
+      );
+    });
+  });
+
+  describe("subscribe", () => {
+    it("notifies subscribers when adapter changes", () => {
+      const adapter1 = createBaseAdapter({
+        messages: [createUserMessage("u1")],
+      });
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        adapter1,
+      );
+
+      const callback = vi.fn();
+      core.subscribe(callback);
+      callback.mockClear();
+
+      const adapter2 = createBaseAdapter({
+        messages: [createUserMessage("u1"), createAssistantMessage("a1")],
+      });
+      core.__internal_setAdapter(adapter2);
+      expect(callback).toHaveBeenCalled();
+    });
+
+    it("returns unsubscribe function", () => {
+      const adapter = createBaseAdapter({
+        messages: [createUserMessage("u1")],
+      });
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      const callback = vi.fn();
+      const unsub = core.subscribe(callback);
+      callback.mockClear();
+
+      unsub();
+
+      core.__internal_setAdapter(
+        createBaseAdapter({
+          messages: [createUserMessage("u1"), createAssistantMessage("a1")],
+        }),
+      );
+      expect(callback).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("addToolResult", () => {
+    it("throws when adapter has no onAddToolResult", () => {
+      const adapter = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      expect(() =>
+        core.addToolResult({
+          messageId: "m1",
+          toolName: "tool",
+          toolCallId: "tc1",
+          result: {},
+          isError: false,
+        }),
+      ).toThrow("Runtime does not support tool results.");
+    });
+  });
+
+  describe("resumeRun", () => {
+    it("throws when adapter has no onResume", async () => {
+      const adapter = createBaseAdapter();
+      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+
+      await expect(
+        core.resumeRun({ parentId: "msg-1" } as any),
+      ).rejects.toThrow("Runtime does not support resuming runs.");
+    });
+  });
+
+  describe("adapter requires messages or messageRepository", () => {
+    it("throws when adapter has neither messages nor messageRepository", () => {
+      const adapter = {
+        onNew: vi.fn(async () => {}),
+      } as unknown as ExternalStoreAdapter<ThreadMessage>;
+
+      expect(
+        () => new ExternalStoreThreadRuntimeCore(contextProvider, adapter),
+      ).toThrow(
+        "ExternalStoreAdapter must provide either 'messages' or 'messageRepository'",
+      );
+    });
+  });
+});