@assistant-ui/core 0.3.13 → 0.3.15

package/src/react/runtimes/external-message-converter.test.ts

@@ -344,6 +344,149 @@ describe("convertExternalMessages", () => {
     });
   });
 
+  describe("metadata merging across joined messages", () => {
+    it("keeps the final assistant message's metadata after a tool call", () => {
+      const messages = [
+        {
+          id: "a1",
+          role: "assistant" as const,
+          content: [
+            {
+              type: "tool-call" as const,
+              toolCallId: "t1",
+              toolName: "search",
+              args: {},
+            },
+          ],
+        },
+        {
+          role: "tool" as const,
+          toolCallId: "t1",
+          toolName: "search",
+          result: { ok: true },
+        },
+        {
+          id: "a2",
+          role: "assistant" as const,
+          content: [{ type: "text" as const, text: "final answer" }],
+          metadata: {
+            unstable_annotations: [{ note: "final" }],
+            steps: [{ usage: { promptTokens: 1, completionTokens: 2 } }],
+          },
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg as useExternalMessageConverter.Message;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+      const metadata = result[0]!.metadata as any;
+      expect(metadata.unstable_annotations).toEqual([{ note: "final" }]);
+      expect(metadata.steps).toEqual([
+        { usage: { promptTokens: 1, completionTokens: 2 } },
+      ]);
+    });
+
+    it("accumulates annotations and data from every joined assistant message", () => {
+      const messages = [
+        {
+          id: "a1",
+          role: "assistant" as const,
+          content: [{ type: "text" as const, text: "first" }],
+          metadata: {
+            unstable_annotations: [{ a: 1 }],
+            unstable_data: [{ d: 1 }],
+          },
+        },
+        {
+          id: "a2",
+          role: "assistant" as const,
+          content: [{ type: "text" as const, text: "second" }],
+          metadata: {
+            unstable_annotations: [{ a: 2 }],
+            unstable_data: [{ d: 2 }],
+          },
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg as useExternalMessageConverter.Message;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+      const metadata = result[0]!.metadata as any;
+      expect(metadata.unstable_annotations).toEqual([{ a: 1 }, { a: 2 }]);
+      expect(metadata.unstable_data).toEqual([{ d: 1 }, { d: 2 }]);
+    });
+
+    it("keeps the last joined output's timing, dropping earlier timing", () => {
+      const messages = [
+        {
+          id: "a1",
+          role: "assistant" as const,
+          content: [{ type: "text" as const, text: "first" }],
+          metadata: {
+            timing: { streamStartTime: 1 },
+          },
+        },
+        {
+          id: "a2",
+          role: "assistant" as const,
+          content: [{ type: "text" as const, text: "second" }],
+          metadata: {
+            timing: { streamStartTime: 2 },
+          },
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg as useExternalMessageConverter.Message;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+      const metadata = result[0]!.metadata as any;
+      expect(metadata.timing).toEqual({ streamStartTime: 2 });
+    });
+
+    it("merges custom across joined outputs, with later keys overwriting earlier ones", () => {
+      const messages = [
+        {
+          id: "a1",
+          role: "assistant" as const,
+          content: [{ type: "text" as const, text: "first" }],
+          metadata: {
+            custom: { author: "agent-a", branch: "main" },
+          },
+        },
+        {
+          id: "a2",
+          role: "assistant" as const,
+          content: [{ type: "text" as const, text: "second" }],
+          metadata: {
+            custom: { author: "agent-b" },
+          },
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg as useExternalMessageConverter.Message;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+      const metadata = result[0]!.metadata as any;
+      expect(metadata.custom).toEqual({ author: "agent-b", branch: "main" });
+    });
+  });
+
   describe("invalid converter output", () => {
     it("throws a descriptive error when the callback returns undefined", () => {
       const messages = [{ id: "m1", type: "remove" }];

package/src/react/runtimes/external-message-converter.ts

@@ -200,52 +200,52 @@ const joinExternalMessages = (
                 ...output.attachments,
               ];
             }
+          }
 
-            if (output.metadata) {
-              assistantMessage.metadata ??= {};
-              if (output.metadata.unstable_state !== undefined) {
-                assistantMessage.metadata.unstable_state =
-                  output.metadata.unstable_state;
-              }
-              if (output.metadata.unstable_annotations) {
-                assistantMessage.metadata.unstable_annotations = [
-                  ...(assistantMessage.metadata.unstable_annotations ?? []),
-                  ...output.metadata.unstable_annotations,
-                ];
-              }
-              if (output.metadata.unstable_data) {
-                assistantMessage.metadata.unstable_data = [
-                  ...(assistantMessage.metadata.unstable_data ?? []),
-                  ...output.metadata.unstable_data,
-                ];
-              }
-              if (output.metadata.steps) {
-                assistantMessage.metadata.steps = [
-                  ...(assistantMessage.metadata.steps ?? []),
-                  ...output.metadata.steps,
-                ];
-              }
-              if (output.metadata.custom) {
-                assistantMessage.metadata.custom = {
-                  ...(assistantMessage.metadata.custom ?? {}),
-                  ...output.metadata.custom,
-                };
-              }
+          if (output.metadata) {
+            assistantMessage.metadata ??= {};
+            if (output.metadata.unstable_state !== undefined) {
+              assistantMessage.metadata.unstable_state =
+                output.metadata.unstable_state;
+            }
+            if (output.metadata.unstable_annotations) {
+              assistantMessage.metadata.unstable_annotations = [
+                ...(assistantMessage.metadata.unstable_annotations ?? []),
+                ...output.metadata.unstable_annotations,
+              ];
+            }
+            if (output.metadata.unstable_data) {
+              assistantMessage.metadata.unstable_data = [
+                ...(assistantMessage.metadata.unstable_data ?? []),
+                ...output.metadata.unstable_data,
+              ];
+            }
+            if (output.metadata.steps) {
+              assistantMessage.metadata.steps = [
+                ...(assistantMessage.metadata.steps ?? []),
+                ...output.metadata.steps,
+              ];
+            }
+            if (output.metadata.custom) {
+              assistantMessage.metadata.custom = {
+                ...(assistantMessage.metadata.custom ?? {}),
+                ...output.metadata.custom,
+              };
+            }
 
-              if (output.metadata.timing) {
-                assistantMessage.metadata.timing = output.metadata.timing;
-              }
+            if (output.metadata.timing) {
+              assistantMessage.metadata.timing = output.metadata.timing;
+            }
 
-              if (output.metadata.submittedFeedback) {
-                assistantMessage.metadata.submittedFeedback =
-                  output.metadata.submittedFeedback;
-              }
+            if (output.metadata.submittedFeedback) {
+              assistantMessage.metadata.submittedFeedback =
+                output.metadata.submittedFeedback;
+            }
 
-              if (output.metadata.isOptimistic) {
-                assistantMessage.metadata.isOptimistic = true;
-              }
+            if (output.metadata.isOptimistic) {
+              assistantMessage.metadata.isOptimistic = true;
             }
-            // TODO keep this in sync
+            // TODO keep this in sync with ThreadMessageLike["metadata"] / fromThreadMessageLike
           }
 
           // Add content parts, merging reasoning parts with same parentId

package/src/react/runtimes/remote-thread-hook-on-tap.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import {
+  createTapRoot,
+  resource,
+  useResources,
+  withKey,
+} from "@assistant-ui/tap";
+import { useExternalStoreRuntime } from "./useExternalStoreRuntime";
+import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
+
+const EMPTY_MESSAGES: readonly never[] = [];
+
+const useTestThreadRuntime = () =>
+  useExternalStoreRuntime({
+    messages: EMPTY_MESSAGES,
+    isRunning: false,
+    onNew: async () => {},
+  });
+
+const TestThread = resource(useTestThreadRuntime);
+
+describe("runtimeHook hosted under one tap root", () => {
+  it("starts N independent threads as keyed resources", () => {
+    const ids = ["a", "b", "c"] as const;
+    const root = createTapRoot(function RemoteThreadListHost() {
+      return useResources(ids.map((id) => withKey(id, TestThread(), [id])));
+    });
+
+    try {
+      const runtimes = root.getValue();
+      expect(runtimes).toHaveLength(3);
+      for (const runtime of runtimes) {
+        expect(runtime.thread.getState().messages).toEqual([]);
+        expect(runtime.thread.getState().isRunning).toBe(false);
+      }
+      expect(new Set(runtimes).size).toBe(3);
+    } finally {
+      root.unmount();
+    }
+  });
+
+  it("keeps a sibling resource after another key is removed", () => {
+    let ids = ["first", "second"];
+    const root = createTapRoot(function RemoteThreadListHost() {
+      return useResources(ids.map((id) => withKey(id, TestThread(), [id])));
+    });
+
+    try {
+      const [kept] = root.getValue() as [AssistantRuntime, AssistantRuntime];
+      ids = ["first"];
+      root.getValue();
+      expect(root.getValue()[0]).toBe(kept);
+      expect(kept.thread.getState().messages).toEqual([]);
+    } finally {
+      root.unmount();
+    }
+  });
+});

package/src/react/runtimes/useExternalStoreRuntime.lifecycle.test.tsx

@@ -0,0 +1,83 @@
+// @vitest-environment jsdom
+
+import { StrictMode } from "react";
+import { act, render } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { useExternalStoreRuntime } from "./useExternalStoreRuntime";
+import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
+
+describe("useExternalStoreRuntime lifecycle", () => {
+  it("keeps dispatching appends after StrictMode's simulated remount", async () => {
+    const onNew = vi.fn(async () => {});
+    const capture: { runtime: AssistantRuntime | null } = { runtime: null };
+    const App = () => {
+      const runtime = useExternalStoreRuntime({ messages: [], onNew });
+      capture.runtime = runtime;
+      return null;
+    };
+    render(
+      <StrictMode>
+        <App />
+      </StrictMode>,
+    );
+    expect(capture.runtime).not.toBeNull();
+
+    await act(async () => {
+      await capture.runtime!.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      });
+    });
+
+    expect(onNew).toHaveBeenCalledTimes(1);
+  });
+
+  it("dispatches an append before unmount", async () => {
+    let resolveInitialization!: () => void;
+    const initialization = new Promise<void>((resolve) => {
+      resolveInitialization = resolve;
+    });
+    const onNew = vi.fn(async () => {});
+    const capture: { runtime: AssistantRuntime | null } = { runtime: null };
+    const App = () => {
+      const runtime = useExternalStoreRuntime({ messages: [], onNew });
+      capture.runtime = runtime;
+      return null;
+    };
+    const view = render(<App />);
+    expect(capture.runtime).not.toBeNull();
+    const core = (
+      capture.runtime!.thread as unknown as {
+        __internal_threadBinding: {
+          getState(): {
+            __internal_setGetInitializePromise(
+              getPromise: () => Promise<unknown> | undefined,
+            ): void;
+            append(message: unknown): Promise<void>;
+          };
+        };
+      }
+    ).__internal_threadBinding.getState();
+    core.__internal_setGetInitializePromise(() => initialization);
+
+    const appendPromise = core.append({
+      parentId: null,
+      sourceId: null,
+      runConfig: {},
+      role: "user",
+      content: [{ type: "text", text: "hello" }],
+      attachments: [],
+      metadata: { custom: {} },
+      createdAt: new Date(0),
+    });
+    await Promise.resolve();
+
+    expect(onNew).toHaveBeenCalledTimes(1);
+
+    view.unmount();
+    resolveInitialization();
+
+    await appendPromise;
+    expect(onNew).toHaveBeenCalledTimes(1);
+  });
+});

package/src/react/runtimes/useExternalStoreRuntime.suggestions.test.tsx

@@ -52,20 +52,30 @@ afterEach(() => {
 describe("useExternalStoreRuntime suggestions scope", () => {
   it("exposes runtime suggestions on the suggestions scope", () => {
     render(
-      <App suggestions={[{ prompt: "Tell me a joke" }, { prompt: "Help" }]} />,
+      <App
+        suggestions={[
+          { title: "Weather", label: "in SF", prompt: "What's the weather?" },
+          { prompt: "Help" },
+        ]}
+      />,
     );
 
     expect(scopeSuggestions).toEqual([
-      { title: "Tell me a joke", label: "", prompt: "Tell me a joke" },
+      { title: "Weather", label: "in SF", prompt: "What's the weather?" },
       { title: "Help", label: "", prompt: "Help" },
     ]);
+    expect(aui.suggestions.suggestion({ index: 0 }).getState()).toEqual({
+      title: "Weather",
+      label: "in SF",
+      prompt: "What's the weather?",
+    });
     expect(aui.suggestions.suggestion({ index: 1 }).getState()).toEqual({
       title: "Help",
       label: "",
       prompt: "Help",
     });
     expect(aui.thread.getState().suggestions).toEqual([
-      { prompt: "Tell me a joke" },
+      { title: "Weather", label: "in SF", prompt: "What's the weather?" },
       { prompt: "Help" },
     ]);
   });

package/src/react/runtimes/useExternalStoreRuntime.ts

@@ -5,6 +5,7 @@ import { ExternalStoreRuntimeCore } from "../../runtimes/internal";
 import type { ExternalStoreAdapter } from "../../runtimes/external-store/external-store-adapter";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
 import { AssistantRuntimeImpl } from "../../runtime/internal";
+import { invalidateThreadRuntime } from "../../runtime/utils/thread-runtime-lifecycle";
 import { useRuntimeAdapters } from "./RuntimeAdapterProvider";
 
 export const useExternalStoreRuntime = <T>(
@@ -12,6 +13,12 @@ export const useExternalStoreRuntime = <T>(
 ): AssistantRuntime => {
   const [runtime] = useState(() => new ExternalStoreRuntimeCore(store));
 
+  useEffect(() => {
+    return () => {
+      invalidateThreadRuntime(runtime.threads.getMainThreadRuntimeCore());
+    };
+  }, [runtime]);
+
   useEffect(() => {
     runtime.setAdapter(store);
   });

package/src/react/runtimes/useExternalStoreSharedOptions.ts

@@ -16,7 +16,9 @@ export const useExternalStoreSharedOptions = (
         unstable_capabilities,
         suggestions,
       }) satisfies {
-        [K in keyof Required<ExternalStoreSharedOptions>]: ExternalStoreSharedOptions[K];
+        [
+          K in keyof Required<ExternalStoreSharedOptions>
+        ]: ExternalStoreSharedOptions[K];
       },
     [isDisabled, isSendDisabled, unstable_capabilities, suggestions],
   );

package/src/react/runtimes/useLocalRuntime.test.tsx

@@ -1,9 +1,10 @@
 // @vitest-environment jsdom
 
-import { render, waitFor } from "@testing-library/react";
-import { StrictMode } from "react";
+import { act, render, waitFor } from "@testing-library/react";
+import { type FC, StrictMode } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { AssistantCloud } from "assistant-cloud";
+import { useAui, useAuiState } from "@assistant-ui/store";
 import type { ChatModelAdapter } from "../../runtime/utils/chat-model-adapter";
 import { AssistantRuntimeProvider } from "../AssistantRuntimeProvider";
 import { useLocalRuntime } from "./useLocalRuntime";
@@ -17,13 +18,49 @@ const makeCloud = () =>
     threads: {
       list: vi.fn().mockResolvedValue({ threads: [] }),
     },
+    files: {
+      generatePresignedUploadUrl: vi.fn().mockResolvedValue({
+        signedUrl: "https://storage.example/upload",
+        publicUrl: "https://cdn.example/file.txt",
+      }),
+    },
   }) as unknown as AssistantCloud;
 
 afterEach(() => {
+  vi.unstubAllGlobals();
   vi.restoreAllMocks();
 });
 
 describe("useLocalRuntime", () => {
+  it("surfaces the live thread after mount without user input", async () => {
+    const auiRef: { current: ReturnType<typeof useAui> | null } = {
+      current: null,
+    };
+    const loadingRef = { current: true };
+    const Capture: FC = () => {
+      auiRef.current = useAui();
+      loadingRef.current = useAuiState((s) => s.thread.isLoading);
+      return null;
+    };
+
+    const App = () => {
+      const runtime = useLocalRuntime(chatModel, {
+        unstable_enableMessageQueue: true,
+      });
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <Capture />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(<App />);
+    await waitFor(() => {
+      expect(loadingRef.current).toBe(false);
+      expect(auiRef.current!.thread.getState().capabilities.queue).toBe(true);
+    });
+  });
+
   it("keeps the Cloud thread list loaded across unrelated rerenders", async () => {
     const firstCloud = makeCloud();
     const secondCloud = makeCloud();
@@ -46,17 +83,58 @@ describe("useLocalRuntime", () => {
     const { rerender } = render(<App cloud={firstCloud} label="first" />);
 
     await waitFor(() => {
-      expect(firstCloud.threads.list).toHaveBeenCalledOnce();
+      expect(firstCloud.threads.list).toHaveBeenCalledTimes(2);
     });
 
     rerender(<App cloud={firstCloud} label="second" />);
-    expect(firstCloud.threads.list).toHaveBeenCalledOnce();
+    expect(firstCloud.threads.list).toHaveBeenCalledTimes(2);
 
     rerender(<App cloud={secondCloud} label="third" />);
     await waitFor(() => {
-      expect(secondCloud.threads.list).toHaveBeenCalledOnce();
+      expect(secondCloud.threads.list).toHaveBeenCalledTimes(2);
+    });
+    expect(firstCloud.threads.list).toHaveBeenCalledTimes(2);
+  });
+
+  it("uses the current Cloud client for attachment uploads", async () => {
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ ok: true }));
+    const firstCloud = makeCloud();
+    const secondCloud = makeCloud();
+    let addAttachment: ((file: File) => Promise<void>) | undefined;
+    let getAttachmentStatus: (() => unknown) | undefined;
+
+    const App = ({ cloud }: { cloud: AssistantCloud }) => {
+      const runtime = useLocalRuntime(chatModel, { cloud });
+      addAttachment = (file) => runtime.thread.composer.addAttachment(file);
+      getAttachmentStatus = () =>
+        runtime.thread.composer.getState().attachments[0]?.status;
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <div />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    const { rerender } = render(<App cloud={firstCloud} />);
+
+    await waitFor(() => {
+      expect(firstCloud.threads.list).toHaveBeenCalledTimes(2);
+    });
+
+    rerender(<App cloud={secondCloud} />);
+
+    await act(async () => {
+      await addAttachment!(
+        new File(["hello"], "notes.txt", { type: "text/plain" }),
+      );
+    });
+
+    expect(firstCloud.files.generatePresignedUploadUrl).not.toHaveBeenCalled();
+    expect(secondCloud.files.generatePresignedUploadUrl).toHaveBeenCalledOnce();
+    expect(getAttachmentStatus!()).toEqual({
+      type: "requires-action",
+      reason: "composer-send",
     });
-    expect(firstCloud.threads.list).toHaveBeenCalledOnce();
   });
 
   it("handles rejected history loads", async () => {
@@ -92,8 +170,56 @@ describe("useLocalRuntime", () => {
       );
     });
 
+    const loadsAfterMount = history.load.mock.calls.length;
+    const errorsAfterMount = consoleError.mock.calls.length;
+    expect(loadsAfterMount).toBeGreaterThan(0);
     rerender(renderApp());
-    expect(history.load).toHaveBeenCalledTimes(1);
-    expect(consoleError).toHaveBeenCalledTimes(1);
+    expect(history.load).toHaveBeenCalledTimes(loadsAfterMount);
+    expect(consoleError).toHaveBeenCalledTimes(errorsAfterMount);
+  });
+
+  it("exposes composer.canCancel while a run started after initial messages is in flight", async () => {
+    const hangingModel: ChatModelAdapter = {
+      async *run({ abortSignal }) {
+        await new Promise<void>((resolve) => {
+          if (abortSignal.aborted) {
+            resolve();
+            return;
+          }
+          abortSignal.addEventListener("abort", () => resolve(), {
+            once: true,
+          });
+        });
+      },
+    };
+    let runtime: ReturnType<typeof useLocalRuntime> | null = null;
+    const App = () => {
+      runtime = useLocalRuntime(hangingModel, {
+        initialMessages: [
+          {
+            role: "assistant",
+            content: [{ type: "text", text: "Hello" }],
+            status: { type: "complete", reason: "stop" },
+          },
+        ],
+      });
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <div />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(<App />);
+    act(() => {
+      runtime!.thread.append("Run");
+    });
+    await waitFor(() => {
+      expect(runtime!.thread.getState().isRunning).toBe(true);
+      expect(runtime!.thread.composer.getState().canCancel).toBe(true);
+    });
+    act(() => {
+      runtime!.thread.cancelRun();
+    });
   });
 });