@assistant-ui/core 0.3.19 → 0.3.21

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

@@ -1,7 +1,11 @@
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, 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 {
+  CompleteAttachment,
+  PendingAttachment,
+} from "../types/attachment";
+import type { AttachmentAdapter } from "../adapters/attachment";
 import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
 
 const makeRuntime = (
@@ -14,6 +18,8 @@ const makeRuntime = (
   const runtime = {
     append,
     composer: { runConfig: {} },
+    voice: undefined,
+    subscribe: () => () => {},
     messages: options?.messages ?? [],
     getModelContext: () => ({
       ...(options?.composerMetadata
@@ -50,6 +56,52 @@ const makeCompleteAttachment = (
 });
 
 describe("DefaultEditComposerRuntimeCore", () => {
+  it("disables send while a voice session is connected and re-notifies on the flip", () => {
+    const listeners = new Set<() => void>();
+    const { runtime } = makeRuntime();
+    const live = runtime as unknown as {
+      voice: unknown;
+      subscribe: (callback: () => void) => () => void;
+    };
+    live.voice = undefined;
+    live.subscribe = (callback) => {
+      listeners.add(callback);
+      return () => {
+        listeners.delete(callback);
+      };
+    };
+    const endEdit = vi.fn();
+    const composer = new DefaultEditComposerRuntimeCore(runtime, endEdit, {
+      parentId: null,
+      message: makeUserMessage(),
+    });
+    const notify = vi.fn();
+    composer.subscribe(notify);
+    expect(composer.canSend).toBe(true);
+
+    live.voice = {
+      status: { type: "running" },
+      isMuted: false,
+      mode: "listening",
+      canSendText: true,
+    };
+    for (const listener of listeners) listener();
+    expect(composer.canSend).toBe(false);
+    expect(notify).toHaveBeenCalledTimes(1);
+
+    for (const listener of listeners) listener();
+    expect(notify).toHaveBeenCalledTimes(1);
+
+    live.voice = undefined;
+    for (const listener of listeners) listener();
+    expect(composer.canSend).toBe(true);
+    expect(notify).toHaveBeenCalledTimes(2);
+
+    composer.cancel();
+    expect(endEdit).toHaveBeenCalledOnce();
+    expect(listeners.size).toBe(0);
+  });
+
   describe("construction", () => {
     it("seeds composer text from the edited message", () => {
       const { runtime } = makeRuntime();
@@ -361,3 +413,98 @@ describe("DefaultEditComposerRuntimeCore", () => {
     });
   });
 });
+
+describe("DefaultEditComposerRuntimeCore sending attachments", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const attachmentAdapter = (
+    overrides: Partial<AttachmentAdapter>,
+  ): AttachmentAdapter => ({
+    accept: "*",
+    add: async ({ file }): Promise<PendingAttachment> => ({
+      id: "f",
+      type: "file",
+      name: file.name,
+      contentType: file.type,
+      file,
+      status: { type: "requires-action", reason: "composer-send" },
+    }),
+    remove: async () => {},
+    send: () => new Promise(() => {}),
+    ...overrides,
+  });
+
+  const makeEditComposer = (attachments: AttachmentAdapter) => {
+    const runtime = {
+      append: vi.fn(),
+      composer: { runConfig: {} },
+      voice: undefined,
+      subscribe: () => () => {},
+      messages: [],
+      getModelContext: () => ({}),
+      adapters: { attachments },
+    } as unknown as ThreadRuntimeCore & {
+      adapters: { attachments: AttachmentAdapter };
+    };
+    return new DefaultEditComposerRuntimeCore(runtime, () => {}, {
+      parentId: null,
+      message: makeUserMessage(),
+    });
+  };
+
+  const file = () => new File(["content"], "f.txt", { type: "text/plain" });
+
+  it("removes a pending attachment once when the edit is reset while sending", async () => {
+    const remove = vi.fn(async () => {});
+    const composer = makeEditComposer(attachmentAdapter({ remove }));
+
+    await composer.addAttachment(file());
+    void composer.send();
+    await composer.reset();
+
+    expect(remove).toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps the upload an edit was sent with when the edit ends", async () => {
+    const remove = vi.fn(async () => {});
+    const composer = makeEditComposer(
+      attachmentAdapter({
+        remove,
+        send: async (attachment) => ({
+          ...attachment,
+          status: { type: "complete" },
+          content: [],
+        }),
+      }),
+    );
+
+    await composer.addAttachment(file());
+    await composer.send();
+    await Promise.resolve();
+
+    expect(remove).not.toHaveBeenCalled();
+  });
+
+  it("keeps the reason an upload failed on the edit's attachment", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const composer = makeEditComposer(
+      attachmentAdapter({
+        send: async () => {
+          throw new Error("upload failed");
+        },
+      }),
+    );
+
+    await composer.addAttachment(file());
+    await composer.send();
+
+    expect(composer.submission).toBeUndefined();
+    expect(composer.attachments.find(({ id }) => id === "f")?.status).toEqual({
+      type: "incomplete",
+      reason: "error",
+      message: "upload failed",
+    });
+  });
+});

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

@@ -6,6 +6,7 @@ import { ExternalStoreRuntimeCore } from "../runtimes/external-store/external-st
 import type { ExternalStoreThreadListAdapter } from "../runtimes/external-store/external-store-adapter";
 import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
 import type { ModelContextProvider } from "../model-context/types";
+import type { ThreadAssistantMessage, ThreadMessage } from "../types/message";
 import { ThreadListRuntimeImpl } from "../runtime/api/thread-list-runtime";
 
 const makeFactory = (overrides: Record<string, unknown> = {}) =>
@@ -180,6 +181,22 @@ describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
     expect(factory.mock.calls.length).toBe(constructionCalls + 1);
   });
 
+  it("disconnects voice on the thread replaced by a threadId change", () => {
+    const disconnectVoice = vi.fn();
+    const factory = makeFactory({
+      voice: { status: { type: "running" } },
+      disconnectVoice,
+    });
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      factory,
+    );
+
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+
+    expect(disconnectVoice).toHaveBeenCalledOnce();
+  });
+
   it("does not rebuild the main thread when only threads array changes", () => {
     const factory = makeFactory();
     const core = new ExternalStoreThreadListRuntimeCore(
@@ -466,3 +483,97 @@ describe("ExternalStoreThreadListRuntimeCore.reloadMainThread", () => {
     await expect(core.reloadMainThread()).rejects.toThrow("refetch failed");
   });
 });
+
+describe("ExternalStoreRuntimeCore - thread switch", () => {
+  const userMessage = (id: string): ThreadMessage => ({
+    id,
+    role: "user",
+    createdAt: new Date(0),
+    content: [{ type: "text", text: "hi" }],
+    attachments: [],
+    metadata: { custom: {} },
+  });
+
+  const assistantMessage = (
+    id: string,
+    content: ThreadAssistantMessage["content"] = [{ type: "text", text: "yo" }],
+  ): ThreadAssistantMessage => ({
+    id,
+    role: "assistant",
+    createdAt: new Date(0),
+    content,
+    status: { type: "complete", reason: "stop" },
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {},
+    },
+  });
+
+  it("builds the switched-to thread from the current store's messages", () => {
+    const runtime = new ExternalStoreRuntimeCore({
+      messages: [userMessage("A"), assistantMessage("B")],
+      onNew: async () => {},
+      adapters: { threadList: { threadId: "thread-alpha" } },
+    });
+
+    runtime.setAdapter({
+      messages: [userMessage("X"), assistantMessage("Y")],
+      onNew: async () => {},
+      adapters: { threadList: { threadId: "thread-beta" } },
+    });
+
+    const main = runtime.threads.getMainThreadRuntimeCore();
+    expect(main.messages.map((m) => m.id)).toEqual(["X", "Y"]);
+    expect(main.getBranches("X")).toEqual(["X"]);
+  });
+
+  it("does not execute a tool call from the switched-to thread's history", async () => {
+    const execute = vi.fn(async () => "sunny");
+    const store = (
+      threadId: string,
+      messages: readonly ThreadMessage[],
+    ): ExternalStoreAdapter => ({
+      messages,
+      isRunning: false,
+      onNew: async () => {},
+      unstable_enableToolInvocations: true,
+      onAddToolResult: vi.fn(),
+      adapters: { threadList: { threadId } },
+    });
+    const runtime = new ExternalStoreRuntimeCore(store("thread-alpha", []));
+    runtime.registerModelContextProvider({
+      getModelContext: () => ({
+        tools: {
+          weatherSearch: {
+            parameters: { type: "object", properties: {} },
+            execute,
+          },
+        },
+      }),
+    });
+
+    runtime.setAdapter(
+      store("thread-beta", [
+        userMessage("u1"),
+        {
+          ...assistantMessage("a1", [
+            {
+              type: "tool-call",
+              toolCallId: "tc1",
+              toolName: "weatherSearch",
+              args: {},
+              argsText: "{}",
+            },
+          ]),
+          status: { type: "requires-action", reason: "tool-calls" },
+        },
+      ]),
+    );
+    await new Promise((resolve) => setTimeout(resolve, 30));
+
+    expect(execute).not.toHaveBeenCalled();
+  });
+});