@assistant-ui/core 0.3.1 → 0.3.3

package/src/store/clients/thread-message-client.test.ts

@@ -0,0 +1,84 @@
+import { createTapRoot, useResource } from "@assistant-ui/tap";
+import { describe, expect, it } from "vitest";
+import type { ThreadAssistantMessage } from "../../types/message";
+import { ThreadMessageClient } from "./thread-message-client";
+
+describe("ThreadMessageClient", () => {
+  const getPartStatus = (
+    part: ThreadAssistantMessage["content"][number],
+    status: ThreadAssistantMessage["status"],
+  ) => {
+    const message: ThreadAssistantMessage = {
+      id: "message-1",
+      role: "assistant",
+      createdAt: new Date(0),
+      content: [part],
+      status,
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+    };
+    const root = createTapRoot(function ThreadMessageRoot() {
+      return useResource(ThreadMessageClient({ message, index: 0 }));
+    });
+
+    try {
+      return root.getValue().getState().parts[0]?.status;
+    } finally {
+      root.unmount();
+    }
+  };
+
+  it("preserves a running part status on a running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "running" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "running" })).toEqual({
+      type: "running",
+    });
+  });
+
+  it("normalizes an unknown incomplete reason on a running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "incomplete", reason: "unknown" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "running" })).toEqual({
+      type: "incomplete",
+      reason: "other",
+    });
+  });
+
+  it("normalizes an upstream complete reason on a running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "complete", reason: "unknown" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "running" })).toEqual({
+      type: "complete",
+    });
+  });
+
+  it("marks parts complete on a non-running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "running" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "complete", reason: "stop" })).toEqual({
+      type: "complete",
+    });
+  });
+});

package/src/store/clients/thread-message-client.ts

@@ -11,19 +11,27 @@ import { useClientLookup } from "@assistant-ui/store";
 import type { MessageState } from "../scopes/message";
 import type { PartState } from "../scopes/part";
 import { NoOpComposerClient } from "./no-op-composer-client";
+import {
+  COMPLETE_STATUS,
+  normalizePartStatus,
+} from "../../utils/normalizePartStatus";
 import { getThreadMessageText } from "../../utils/text";
 
 const useThreadMessagePartClient = ({
   part,
+  isMessageRunning,
 }: {
   part: ThreadAssistantMessagePart | ThreadUserMessagePart;
+  isMessageRunning: boolean;
 }): ClientOutput<"part"> => {
   const state = useMemo<PartState>(() => {
     return {
       ...part,
-      status: { type: "complete" },
+      status: isMessageRunning
+        ? (normalizePartStatus(part) ?? COMPLETE_STATUS)
+        : COMPLETE_STATUS,
     };
-  }, [part]);
+  }, [part, isMessageRunning]);
 
   return {
     getState: () => state,
@@ -74,6 +82,8 @@ const useThreadMessageClient = ({
 }: ThreadMessageClientProps): ClientOutput<"message"> => {
   const [isCopiedState, setIsCopied] = useState(false);
   const [isHoveringState, setIsHovering] = useState(false);
+  const isMessageRunning =
+    message.role === "assistant" && message.status.type === "running";
 
   const parts = useClientLookup(
     message.content.map((part, idx) =>
@@ -81,8 +91,8 @@ const useThreadMessageClient = ({
         "toolCallId" in part && part.toolCallId != null
           ? `toolCallId-${part.toolCallId}`
           : `index-${idx}`,
-        ThreadMessagePartClient({ part }),
-        [part],
+        ThreadMessagePartClient({ part, isMessageRunning }),
+        [part, isMessageRunning],
       ),
     ),
   );

package/src/store/scopes/thread.ts

@@ -108,7 +108,7 @@ export type ThreadMethods = {
    * @param initialMessages - Optional array of initial messages to populate the thread
    */
   reset(initialMessages?: readonly ThreadMessageLike[]): void;
-  importExternalState?(state: unknown): void;
+  importExternalState(state: unknown): void;
   message(selector: { id: string } | { index: number }): MessageMethods;
   /** @deprecated This API is still under active development and might change without notice. */
   stopSpeaking(): void;

package/src/tests/auiV0Encode.test.ts

@@ -155,6 +155,99 @@ describe("auiV0Encode", () => {
       },
     ]);
   });
+
+  it("drops per-part status from message parts in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        { type: "reasoning", text: "thinking", status: { type: "complete" } },
+        { type: "text", text: "answer", status: { type: "running" } },
+      ],
+    });
+
+    expect(encoded.content).toEqual([
+      { type: "reasoning", text: "thinking" },
+      { type: "text", text: "answer" },
+    ]);
+  });
+
+  it("drops per-part status from attachment content in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "user",
+      metadata: { custom: {} },
+      content: [{ type: "text", text: "please review this" }],
+      attachments: [
+        {
+          id: "att-1",
+          type: "document",
+          name: "notes.txt",
+          status: { type: "complete" },
+          content: [
+            { type: "text", text: "notes", status: { type: "running" } },
+          ],
+        },
+      ],
+    });
+
+    expect(encoded.attachments?.[0]?.content).toEqual([
+      { type: "text", text: "notes" },
+    ]);
+  });
+
+  it("preserves every attachment content field the wire shape carries in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "user",
+      metadata: { custom: {} },
+      content: [{ type: "text", text: "please review these" }],
+      attachments: [
+        {
+          id: "att-1",
+          type: "file",
+          name: "bundle",
+          status: { type: "complete" },
+          content: [
+            {
+              type: "image",
+              image: "data:image/png;base64,iVBORw0KGgo=",
+              filename: "shot.png",
+            },
+            {
+              type: "audio",
+              audio: { data: "data:audio/mp3;base64,SUQzAw==", format: "mp3" },
+            },
+            { type: "data", name: "telemetry", data: { runs: 3 } },
+          ],
+        },
+      ],
+    });
+
+    expect(encoded.attachments?.[0]?.content).toEqual([
+      {
+        type: "image",
+        image: "data:image/png;base64,iVBORw0KGgo=",
+        filename: "shot.png",
+      },
+      {
+        type: "audio",
+        audio: { data: "data:audio/mp3;base64,SUQzAw==", format: "mp3" },
+      },
+      { type: "data", name: "telemetry", data: { runs: 3 } },
+    ]);
+  });
 });
 
 describe("auiV0Decode", () => {

package/src/tests/remote-thread-list-reactive-threadId.test.ts

@@ -2,98 +2,6 @@ import { describe, it, expect, vi } from "vitest";
 import type { RemoteThreadListAdapter } from "../runtimes/remote-thread-list/types";
 import { createCore, makeAdapter } from "./remote-thread-list-test-helpers";
 
-/**
- * Tests for the reactive threadId useEffect logic in useRemoteThreadListRuntime.
- *
- * The useEffect compares options.threadId against a prevThreadIdRef and calls
- * switchToThread or switchToNewThread when it changes. We test this logic
- * by simulating the ref + comparison pattern.
- */
-
-// Mirrors the useEffect in useRemoteThreadListRuntimeImpl.
-// Keep in sync if that implementation changes.
-function simulateThreadIdEffect(
-  prevRef: { current: string | undefined },
-  threadId: string | undefined,
-  switchToThread: (id: string) => void,
-  switchToNewThread: () => void,
-) {
-  if (threadId === prevRef.current) return;
-  prevRef.current = threadId;
-  if (threadId) {
-    switchToThread(threadId);
-  } else {
-    switchToNewThread();
-  }
-}
-
-describe("threadId reactive effect", () => {
-  it("does nothing when threadId stays the same", () => {
-    const ref = { current: "thread-1" };
-    const switchToThread = vi.fn();
-    const switchToNewThread = vi.fn();
-
-    simulateThreadIdEffect(ref, "thread-1", switchToThread, switchToNewThread);
-
-    expect(switchToThread).not.toHaveBeenCalled();
-    expect(switchToNewThread).not.toHaveBeenCalled();
-  });
-
-  it("calls switchToThread when threadId changes", () => {
-    const ref = { current: "thread-1" };
-    const switchToThread = vi.fn();
-    const switchToNewThread = vi.fn();
-
-    simulateThreadIdEffect(ref, "thread-2", switchToThread, switchToNewThread);
-
-    expect(switchToThread).toHaveBeenCalledWith("thread-2");
-    expect(ref.current).toBe("thread-2");
-  });
-
-  it("calls switchToNewThread when threadId becomes undefined", () => {
-    const ref = { current: "thread-1" };
-    const switchToThread = vi.fn();
-    const switchToNewThread = vi.fn();
-
-    simulateThreadIdEffect(ref, undefined, switchToThread, switchToNewThread);
-
-    expect(switchToNewThread).toHaveBeenCalledOnce();
-    expect(ref.current).toBeUndefined();
-  });
-
-  it("skips switchToNewThread on first render when threadId is already undefined", () => {
-    const ref = { current: undefined as string | undefined };
-    const switchToThread = vi.fn();
-    const switchToNewThread = vi.fn();
-
-    // First render: undefined === undefined → skipped
-    simulateThreadIdEffect(ref, undefined, switchToThread, switchToNewThread);
-    expect(switchToNewThread).not.toHaveBeenCalled();
-  });
-
-  it("handles full navigation cycle", () => {
-    const ref = { current: undefined as string | undefined };
-    const switchToThread = vi.fn();
-    const switchToNewThread = vi.fn();
-
-    // Mount with thread-1
-    simulateThreadIdEffect(ref, "thread-1", switchToThread, switchToNewThread);
-    expect(switchToThread).toHaveBeenCalledWith("thread-1");
-
-    // Navigate to thread-2
-    simulateThreadIdEffect(ref, "thread-2", switchToThread, switchToNewThread);
-    expect(switchToThread).toHaveBeenCalledWith("thread-2");
-
-    // Navigate to new thread
-    simulateThreadIdEffect(ref, undefined, switchToThread, switchToNewThread);
-    expect(switchToNewThread).toHaveBeenCalledOnce();
-
-    // Navigate back to thread-1
-    simulateThreadIdEffect(ref, "thread-1", switchToThread, switchToNewThread);
-    expect(switchToThread).toHaveBeenCalledTimes(3);
-  });
-});
-
 /**
  * Tests for onThreadIdChange, driving the real
  * RemoteThreadListThreadListRuntimeCore via a mock adapter (no React). These

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

@@ -159,6 +159,21 @@ describe("fromThreadMessageLike", () => {
 
       expect(result.content).toEqual([]);
     });
+
+    it("keeps an image part with an uppercase-scheme data URL", () => {
+      const result = fromThreadMessageLike(
+        {
+          role: "assistant",
+          content: [{ type: "image", image: "DATA:IMAGE/PNG;base64,AAAA" }],
+        },
+        fallbackId,
+        fallbackStatus,
+      );
+
+      expect(result.content).toEqual([
+        { type: "image", image: "DATA:IMAGE/PNG;base64,AAAA" },
+      ]);
+    });
   });
 
   describe("providerMetadata passthrough", () => {

package/src/tests/useRemoteThreadListRuntime-controlled.test.tsx

@@ -0,0 +1,293 @@
+// @vitest-environment jsdom
+
+import { act, render, waitFor } from "@testing-library/react";
+import { useEffect } from "react";
+import { describe, expect, it, vi } from "vitest";
+import { AssistantRuntimeProvider } from "../react/AssistantRuntimeProvider";
+import { useExternalStoreRuntime } from "../react/runtimes/useExternalStoreRuntime";
+import { useRemoteThreadListRuntime } from "../react/runtimes/useRemoteThreadListRuntime";
+import type { AssistantRuntime } from "../runtime/api/assistant-runtime";
+import type {
+  RemoteThreadListAdapter,
+  RemoteThreadMetadata,
+} from "../runtimes/remote-thread-list/types";
+import { deferred, makeAdapter } from "./remote-thread-list-test-helpers";
+
+const EMPTY_MESSAGES: readonly never[] = [];
+
+const makeThreadMetadata = (remoteId: string): RemoteThreadMetadata => ({
+  status: "regular",
+  remoteId,
+  externalId: remoteId,
+  title: "Test",
+});
+
+const useTestThreadRuntime = () =>
+  useExternalStoreRuntime({
+    messages: EMPTY_MESSAGES,
+    isRunning: false,
+    onNew: async () => {},
+  });
+
+type RuntimeRef = {
+  current: AssistantRuntime | null;
+};
+
+const ControlledRuntime = ({
+  adapter,
+  threadId,
+  onThreadIdChange,
+  runtimeRef,
+}: {
+  adapter: RemoteThreadListAdapter;
+  threadId: string | undefined;
+  onThreadIdChange: (threadId: string | undefined) => void;
+  runtimeRef: RuntimeRef;
+}) => {
+  const runtime = useRemoteThreadListRuntime({
+    adapter,
+    threadId,
+    onThreadIdChange,
+    runtimeHook: useTestThreadRuntime,
+  });
+
+  useEffect(() => {
+    runtimeRef.current = runtime;
+  }, [runtime, runtimeRef]);
+
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      {null}
+    </AssistantRuntimeProvider>
+  );
+};
+
+const waitForRemoteThread = async (
+  runtimeRef: RuntimeRef,
+  remoteId: string,
+) => {
+  await waitFor(() => {
+    expect(runtimeRef.current).not.toBeNull();
+    expect(runtimeRef.current!.threads.mainItem.getState().remoteId).toBe(
+      remoteId,
+    );
+  });
+};
+
+describe("useRemoteThreadListRuntime controlled threadId", () => {
+  it("treats an initial empty string as a supplied thread ID", async () => {
+    const adapter = makeAdapter();
+    const onThreadIdChange = vi.fn();
+    const runtimeRef: RuntimeRef = { current: null };
+
+    render(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId=""
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitForRemoteThread(runtimeRef, "");
+    expect(adapter.fetch).toHaveBeenCalledWith("");
+    expect(onThreadIdChange).not.toHaveBeenCalled();
+  });
+
+  it("switches to an empty string supplied after mount", async () => {
+    const adapter = makeAdapter();
+    const onThreadIdChange = vi.fn();
+    const runtimeRef: RuntimeRef = { current: null };
+
+    const { rerender } = render(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId="thread-a"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+    await waitForRemoteThread(runtimeRef, "thread-a");
+
+    rerender(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId=""
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+    await waitForRemoteThread(runtimeRef, "");
+    expect(adapter.fetch).toHaveBeenLastCalledWith("");
+    expect(onThreadIdChange).not.toHaveBeenCalled();
+  });
+
+  it("does not echo prop-driven thread switches", async () => {
+    const adapter = makeAdapter();
+    const onThreadIdChange = vi.fn();
+    const runtimeRef: RuntimeRef = { current: null };
+
+    const { rerender } = render(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId="thread-a"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitForRemoteThread(runtimeRef, "thread-a");
+    expect(onThreadIdChange).not.toHaveBeenCalled();
+
+    rerender(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId="thread-b"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitForRemoteThread(runtimeRef, "thread-b");
+    expect(onThreadIdChange).not.toHaveBeenCalled();
+
+    const previousMainThreadId =
+      runtimeRef.current!.threads.getState().mainThreadId;
+    rerender(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId={undefined}
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(runtimeRef.current!.threads.getState().mainThreadId).not.toBe(
+        previousMainThreadId,
+      );
+      expect(
+        runtimeRef.current!.threads.mainItem.getState().remoteId,
+      ).toBeUndefined();
+    });
+    expect(onThreadIdChange).not.toHaveBeenCalled();
+  });
+
+  it("still emits runtime-initiated thread switches", async () => {
+    const adapter = makeAdapter();
+    const onThreadIdChange = vi.fn();
+    const runtimeRef: RuntimeRef = { current: null };
+
+    render(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId="thread-a"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitForRemoteThread(runtimeRef, "thread-a");
+    onThreadIdChange.mockClear();
+
+    await act(async () => {
+      await runtimeRef.current!.threads.switchToThread("thread-b");
+    });
+    expect(onThreadIdChange).toHaveBeenLastCalledWith("thread-b");
+
+    onThreadIdChange.mockClear();
+    await act(async () => {
+      await runtimeRef.current!.threads.switchToNewThread();
+    });
+    expect(onThreadIdChange).toHaveBeenLastCalledWith(undefined);
+  });
+
+  it("does not retain suppression after an initial switch fails", async () => {
+    let threadAFetchCount = 0;
+    const adapter = makeAdapter({
+      fetch: vi.fn(async (threadId) => {
+        if (threadId === "thread-a" && threadAFetchCount++ === 0) {
+          throw new Error("initial fetch failed");
+        }
+        return makeThreadMetadata(threadId);
+      }),
+    });
+    const onThreadIdChange = vi.fn();
+    const runtimeRef: RuntimeRef = { current: null };
+
+    render(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId="thread-a"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(adapter.fetch).toHaveBeenCalledWith("thread-a");
+      expect(runtimeRef.current).not.toBeNull();
+    });
+
+    await act(async () => {
+      await runtimeRef.current!.threads.switchToThread("thread-b");
+    });
+    expect(onThreadIdChange).toHaveBeenLastCalledWith("thread-b");
+
+    onThreadIdChange.mockClear();
+    await act(async () => {
+      await runtimeRef.current!.threads.switchToThread("thread-a");
+    });
+    expect(onThreadIdChange).toHaveBeenLastCalledWith("thread-a");
+  });
+
+  it("emits a concurrent runtime switch to the controlled target", async () => {
+    const firstThreadBFetch = deferred<RemoteThreadMetadata>();
+    let threadBFetchCount = 0;
+    const adapter = makeAdapter({
+      fetch: vi.fn(async (threadId) => {
+        if (threadId === "thread-b" && threadBFetchCount++ === 0) {
+          return firstThreadBFetch.promise;
+        }
+        return makeThreadMetadata(threadId);
+      }),
+    });
+    const onThreadIdChange = vi.fn();
+    const runtimeRef: RuntimeRef = { current: null };
+
+    const { rerender } = render(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId="thread-a"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitForRemoteThread(runtimeRef, "thread-a");
+    onThreadIdChange.mockClear();
+
+    rerender(
+      <ControlledRuntime
+        adapter={adapter}
+        threadId="thread-b"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+    await waitFor(() => {
+      expect(adapter.fetch).toHaveBeenCalledWith("thread-b");
+    });
+
+    await act(async () => {
+      await runtimeRef.current!.threads.switchToThread("thread-b");
+    });
+    expect(onThreadIdChange).toHaveBeenCalledExactlyOnceWith("thread-b");
+
+    await act(async () => {
+      firstThreadBFetch.resolve(makeThreadMetadata("thread-b"));
+      await firstThreadBFetch.promise;
+    });
+    expect(onThreadIdChange).toHaveBeenCalledExactlyOnceWith("thread-b");
+  });
+});

package/src/types/index.ts

@@ -18,6 +18,7 @@ export type {
   ThreadAssistantMessagePart,
   // Message status
   MessagePartStatus,
+  MessagePartStreamStatus,
   ToolCallMessagePartStatus,
   MessageStatus,
   // Thread messages