@assistant-ui/core 0.3.1 → 0.3.2

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/utils/data-url.test.ts

@@ -20,8 +20,32 @@ describe("parseDataUrl", () => {
     expect(parseDataUrl("data:text/plain,hello")).toBeNull();
   });
 
-  it("returns null for data URLs with an empty payload", () => {
-    expect(parseDataUrl("data:image/png;base64,")).toBeNull();
+  it("parses a data URL with an empty payload as zero-byte data", () => {
+    expect(parseDataUrl("data:image/png;base64,")).toEqual({
+      mimeType: "image/png",
+      data: "",
+    });
+  });
+
+  it("parses an uppercase scheme", () => {
+    expect(parseDataUrl("DATA:image/png;base64,aGVsbG8=")).toEqual({
+      mimeType: "image/png",
+      data: "aGVsbG8=",
+    });
+  });
+
+  it("parses a mixed-case scheme and base64 token", () => {
+    expect(parseDataUrl("Data:image/png;Base64,aGVsbG8=")).toEqual({
+      mimeType: "image/png",
+      data: "aGVsbG8=",
+    });
+  });
+
+  it("lowercases the captured mime type", () => {
+    expect(parseDataUrl("data:IMAGE/PNG;base64,aGVsbG8=")).toEqual({
+      mimeType: "image/png",
+      data: "aGVsbG8=",
+    });
   });
 
   it("returns null for plain strings", () => {

package/src/utils/data-url.ts

@@ -3,7 +3,7 @@ export const httpUrlPattern = /^https?:\/\//i;
 export function parseDataUrl(
   value: string,
 ): { mimeType: string; data: string } | null {
-  const match = value.match(/^data:([^;,]+)(?:;[^;,]+)*;base64,(.+)$/);
+  const match = value.match(/^data:([^;,]+)(?:;[^;,]+)*;base64,(.*)$/i);
   if (!match) return null;
-  return { mimeType: match[1]!, data: match[2]! };
+  return { mimeType: match[1]!.toLowerCase(), data: match[2]! };
 }