@assistant-ui/core 0.3.12 → 0.3.13

package/src/tests/external-thread-refetch.test.tsx

@@ -0,0 +1,117 @@
+// @vitest-environment jsdom
+
+import { cleanup, render, waitFor } from "@testing-library/react";
+import type { FC } from "react";
+import { useState } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AuiProvider, useAui } from "@assistant-ui/store";
+import { ExternalThread } from "../store/clients/external-thread";
+import type { ThreadMessage } from "../types/message";
+
+const message = (id: string, role: "user" | "assistant"): ThreadMessage =>
+  ({
+    id,
+    role,
+    content: [{ type: "text", text: `text of ${id}` }],
+    createdAt: new Date(1718000000000),
+    ...(role === "assistant"
+      ? { status: { type: "complete", reason: "stop" } }
+      : { attachments: [] }),
+    metadata: { custom: {} },
+  }) as ThreadMessage;
+
+let aui!: ReturnType<typeof useAui>;
+
+const Capture: FC = () => {
+  aui = useAui();
+  return null;
+};
+
+const renderThread = (props: Parameters<typeof ExternalThread>[0]) => {
+  const App: FC = () => {
+    const value = useAui({ thread: ExternalThread(props) });
+    return (
+      <AuiProvider value={value}>
+        <Capture />
+      </AuiProvider>
+    );
+  };
+  render(<App />);
+};
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("ExternalThread refetch", () => {
+  it("routes reloadMainThread to onRefetchThread and reports the capability", async () => {
+    const onRefetchThread = vi.fn(async () => {});
+    renderThread({ messages: [], onRefetchThread });
+
+    await waitFor(() =>
+      expect(
+        aui.threads.thread("main").getState().capabilities.refetchThread,
+      ).toBe(true),
+    );
+
+    await aui.threads.reloadMainThread();
+    expect(onRefetchThread).toHaveBeenCalledTimes(1);
+  });
+
+  it("resolves reloadMainThread without a callback and reports the capability off", async () => {
+    renderThread({ messages: [] });
+
+    await waitFor(() =>
+      expect(
+        aui.threads.thread("main").getState().capabilities.refetchThread,
+      ).toBe(false),
+    );
+
+    await expect(aui.threads.reloadMainThread()).resolves.toBeUndefined();
+  });
+
+  it("propagates a refetch rejection to the caller", async () => {
+    const onRefetchThread = vi.fn(async () => {
+      throw new Error("refetch failed");
+    });
+    renderThread({ messages: [], onRefetchThread });
+
+    await waitFor(() =>
+      expect(
+        aui.threads.thread("main").getState().capabilities.refetchThread,
+      ).toBe(true),
+    );
+
+    await expect(aui.threads.reloadMainThread()).rejects.toThrow(
+      "refetch failed",
+    );
+  });
+
+  it("applies refetched messages in place with the composer draft intact", async () => {
+    const App: FC = () => {
+      const [messages, setMessages] = useState<readonly ThreadMessage[]>([]);
+      const value = useAui({
+        thread: ExternalThread({
+          messages,
+          onRefetchThread: async () => {
+            setMessages([message("a1", "assistant")]);
+          },
+        }),
+      });
+      return (
+        <AuiProvider value={value}>
+          <Capture />
+        </AuiProvider>
+      );
+    };
+    render(<App />);
+
+    aui.thread.composer().setText("draft");
+    await aui.threads.reloadMainThread();
+
+    await waitFor(() =>
+      expect(aui.thread.getState().messages.map((m) => m.id)).toEqual(["a1"]),
+    );
+    expect(aui.thread.composer().getState().text).toBe("draft");
+  });
+});

package/src/tests/external-thread-suggestions.test.tsx

@@ -0,0 +1,59 @@
+// @vitest-environment jsdom
+
+import { cleanup, render } from "@testing-library/react";
+import type { FC, ReactNode } from "react";
+import { afterEach, describe, expect, it } from "vitest";
+import { AuiProvider, useAui } from "@assistant-ui/store";
+import { ExternalThread } from "../store/clients/external-thread";
+import { SingleThreadList } from "../store/clients/single-thread-list";
+
+let childAui!: ReturnType<typeof useAui>;
+
+const CaptureChild: FC = () => {
+  childAui = useAui();
+  return null;
+};
+
+const Child: FC = () => {
+  const aui = useAui({ thread: ExternalThread({ messages: [] }) });
+  return (
+    <AuiProvider value={aui}>
+      <CaptureChild />
+    </AuiProvider>
+  );
+};
+
+const Parent: FC<{ children: ReactNode }> = ({ children }) => {
+  const aui = useAui({
+    threads: SingleThreadList({ thread: ExternalThread({ messages: [] }) }),
+  });
+  return <AuiProvider value={aui}>{children}</AuiProvider>;
+};
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("ExternalThread suggestions scope", () => {
+  it("derives the scope from its own thread when standalone", () => {
+    render(<Child />);
+
+    expect(childAui.suggestions.getState()).toEqual({ suggestions: [] });
+    expect(childAui.suggestions.getState()).toBe(
+      childAui.thread.suggestions().getState(),
+    );
+  });
+
+  it("derives the scope from its own thread when nested under a threads parent", () => {
+    render(
+      <Parent>
+        <Child />
+      </Parent>,
+    );
+
+    expect(childAui.suggestions.getState()).toEqual({ suggestions: [] });
+    expect(childAui.suggestions.getState()).toBe(
+      childAui.thread.suggestions().getState(),
+    );
+  });
+});

package/src/tests/message-queue.test.ts

@@ -626,3 +626,29 @@ describe("createMessageQueue", () => {
     expect(adapter.items).toHaveLength(0);
   });
 });
+
+describe("createMessageQueue interrupt with a runtime-routed cancel", () => {
+  it("keeps draining when the driver's cancel notifies back", () => {
+    const runs: string[] = [];
+    const controller = createMessageQueue({
+      run: (message) => {
+        runs.push(
+          message.content[0]!.type === "text" ? message.content[0].text : "",
+        );
+      },
+      cancel: () => controller.notifyCancelled(),
+    });
+
+    controller.adapter.enqueue(msg("first"));
+    controller.adapter.enqueue(msg("second"));
+    controller.adapter.steer(msg("steered"));
+
+    expect(runs).toEqual(["first", "steered"]);
+
+    // the interrupted run and the steer run each settle once
+    controller.notifyIdle();
+    controller.notifyIdle();
+
+    expect(runs).toEqual(["first", "steered", "second"]);
+  });
+});

package/src/tests/thread-message-like.test.ts

@@ -382,3 +382,42 @@ describe("fromThreadMessageLike", () => {
     });
   });
 });
+
+describe("fromThreadMessageLike provider metadata", () => {
+  it("keeps it on image and file parts", () => {
+    const result = fromThreadMessageLike(
+      {
+        role: "user",
+        content: [
+          {
+            type: "image",
+            image: "https://example.com/cat.png",
+            providerMetadata: { agui: { file_id: "f_1" } },
+          },
+          {
+            type: "file",
+            data: "https://example.com/spec.pdf",
+            mimeType: "application/pdf",
+            providerMetadata: { agui: { file_id: "f_2" } },
+          },
+        ],
+      },
+      fallbackId,
+      fallbackStatus,
+    );
+
+    expect(result.content).toEqual([
+      {
+        type: "image",
+        image: "https://example.com/cat.png",
+        providerMetadata: { agui: { file_id: "f_1" } },
+      },
+      {
+        type: "file",
+        data: "https://example.com/spec.pdf",
+        mimeType: "application/pdf",
+        providerMetadata: { agui: { file_id: "f_2" } },
+      },
+    ]);
+  });
+});

package/src/tests/thread-switch-events.test.tsx

@@ -0,0 +1,136 @@
+// @vitest-environment jsdom
+
+import { act, render } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { AuiProvider, useAui, useAuiEvent } from "@assistant-ui/store";
+import { RuntimeAdapter } from "../react/RuntimeAdapter";
+import { AssistantRuntimeImpl } from "../runtime/api/assistant-runtime";
+import { ExternalStoreRuntimeCore } from "../runtimes/external-store/external-store-runtime-core";
+import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
+
+type DemoMessage = { id: string; role: "user" | "assistant"; text: string };
+
+const createRuntime = () => {
+  const threads = [
+    {
+      id: "t1",
+      title: "one",
+      messages: [{ id: "m1", role: "user" as const, text: "a" }],
+    },
+    {
+      id: "t2",
+      title: "two",
+      messages: [{ id: "m2", role: "user" as const, text: "b" }],
+    },
+  ];
+  let currentId = "t1";
+  const makeAdapter = (): ExternalStoreAdapter<DemoMessage> => ({
+    messages: threads.find((t) => t.id === currentId)!.messages,
+    convertMessage: (m) => ({
+      id: m.id,
+      role: m.role,
+      content: [{ type: "text", text: m.text }],
+    }),
+    onNew: async () => {},
+    adapters: {
+      threadList: {
+        threadId: currentId,
+        threads: threads.map((t) => ({
+          status: "regular" as const,
+          id: t.id,
+          title: t.title,
+        })),
+        onSwitchToThread: (threadId: string) => {
+          currentId = threadId;
+          sync();
+        },
+        onSwitchToNewThread: () => {},
+      },
+    },
+  });
+  const core = new ExternalStoreRuntimeCore(makeAdapter());
+  const runtime = new AssistantRuntimeImpl(core);
+  const sync = () => core.setAdapter(makeAdapter());
+  return runtime;
+};
+
+describe("thread switch events", () => {
+  it("delivers switchedTo to default-scope, star-scope, and aui.on listeners", async () => {
+    const runtime = createRuntime();
+    const defaultScope = vi.fn();
+    const starScope = vi.fn();
+    const auiOn = vi.fn();
+    const switchedAwayStar = vi.fn();
+    let aui!: ReturnType<typeof useAui>;
+    const Consumer = () => {
+      useAuiEvent("threadListItem.switchedTo" as never, defaultScope as never);
+      useAuiEvent(
+        { scope: "*", event: "threadListItem.switchedTo" } as never,
+        starScope as never,
+      );
+      useAuiEvent(
+        { scope: "*", event: "threadListItem.switchedAway" } as never,
+        switchedAwayStar as never,
+      );
+      return null;
+    };
+    const Harness = () => {
+      aui = useAui({ threads: RuntimeAdapter(runtime) } as never);
+      return (
+        <AuiProvider value={aui}>
+          <Consumer />
+        </AuiProvider>
+      );
+    };
+    render(<Harness />);
+    await act(async () => {});
+
+    aui.on("threadListItem.switchedTo" as never, auiOn as never);
+
+    await act(async () => {
+      aui.threads.item({ index: 1 }).switchTo();
+    });
+    await act(async () => {});
+
+    expect(defaultScope).toHaveBeenCalledExactlyOnceWith({ threadId: "t2" });
+    expect(starScope).toHaveBeenCalledExactlyOnceWith({ threadId: "t2" });
+    expect(auiOn).toHaveBeenCalledExactlyOnceWith({ threadId: "t2" });
+    expect(switchedAwayStar).toHaveBeenCalledExactlyOnceWith({
+      threadId: "t1",
+    });
+
+    await act(async () => {
+      aui.threads.item({ index: 0 }).switchTo();
+    });
+    await act(async () => {});
+
+    expect(defaultScope).toHaveBeenCalledTimes(2);
+    expect(defaultScope).toHaveBeenLastCalledWith({ threadId: "t1" });
+    expect(switchedAwayStar).toHaveBeenCalledTimes(2);
+    expect(switchedAwayStar).toHaveBeenLastCalledWith({ threadId: "t2" });
+  });
+
+  it("does not emit for the initially selected thread on mount", async () => {
+    const runtime = createRuntime();
+    const anySwitch = vi.fn();
+    const Consumer = () => {
+      useAuiEvent(
+        { scope: "*", event: "threadListItem.switchedTo" } as never,
+        anySwitch as never,
+      );
+      return null;
+    };
+    const Harness = () => {
+      const aui = useAui({ threads: RuntimeAdapter(runtime) } as never);
+      return (
+        <AuiProvider value={aui}>
+          <Consumer />
+        </AuiProvider>
+      );
+    };
+    render(<Harness />);
+    await act(async () => {});
+
+    expect(anySwitch).not.toHaveBeenCalled();
+  });
+});

package/src/types/error.ts

@@ -52,6 +52,30 @@ export const isAssistantError = (value: unknown): value is AssistantError => {
   return true;
 };
 
+const MESSAGE_NOT_SENT = Symbol.for("assistant-ui.message-not-sent");
+
+/**
+ * Rejection reason for a send that never reached the backend, so nothing ran
+ * and nothing is recoverable from the thread. A runtime adapter throws it from
+ * `onNew` to hand the message back to the thread composer, which restores the
+ * draft it cleared at dispatch time when nothing has claimed the composer
+ * since. An edit composer closes at dispatch, so a rejected edit is not
+ * restored.
+ */
+export class MessageNotSentError extends Error {
+  readonly [MESSAGE_NOT_SENT] = true;
+
+  constructor(message = "The message was not sent.") {
+    super(message);
+    this.name = "MessageNotSentError";
+  }
+}
+
+export const isMessageNotSentError = (
+  error: unknown,
+): error is MessageNotSentError =>
+  typeof error === "object" && error !== null && MESSAGE_NOT_SENT in error;
+
 export const toAssistantError = (error: unknown): AssistantError => {
   if (isAssistantError(error)) return error;
   if (error instanceof Error) {

package/src/types/message.ts

@@ -56,6 +56,7 @@ export type ImageMessagePart = {
   readonly type: "image";
   readonly image: string;
   readonly filename?: string;
+  readonly providerMetadata?: PartProviderMetadata;
 };
 
 export type FileMessagePart = {
@@ -65,6 +66,7 @@ export type FileMessagePart = {
   readonly mimeType: string;
   /** How `data` goes on the wire: a url or id reference; omitted = inferred (http(s) → url, else base64). "url" is honored by the LangChain-family, A2A, AG-UI, and Google ADK runtimes; "id" by the LangChain family only. */
   readonly sourceType?: "url" | "id";
+  readonly providerMetadata?: PartProviderMetadata;
   readonly parentId?: string;
 };
 

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

@@ -1,82 +0,0 @@
-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 } },
-    ]);
-  });
-});