@assistant-ui/core 0.2.21 → 0.2.23

package/src/tests/remote-thread-list-test-helpers.ts

@@ -18,6 +18,19 @@ export const contextProvider: ModelContextProvider = {
   subscribe: () => () => {},
 };
 
+export function setStartThreadRuntime(
+  core: RemoteThreadListThreadListRuntimeCore,
+  startThreadRuntime: (id: string) => Promise<unknown>,
+) {
+  (
+    core as unknown as {
+      _hookManager: {
+        startThreadRuntime: (id: string) => Promise<unknown>;
+      };
+    }
+  )._hookManager.startThreadRuntime = startThreadRuntime;
+}
+
 export function makeAdapter(
   overrides: Partial<RemoteThreadListAdapter> = {},
 ): RemoteThreadListAdapter {
@@ -60,12 +73,6 @@ export function createCore(
   );
   // `startThreadRuntime` blocks until a React component attaches a runtime;
   // stub it so non-React unit tests don't hang.
-  (
-    core as unknown as {
-      _hookManager: {
-        startThreadRuntime: (id: string) => Promise<unknown>;
-      };
-    }
-  )._hookManager.startThreadRuntime = async () => ({});
+  setStartThreadRuntime(core, async () => ({}));
   return core;
 }

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

@@ -200,4 +200,61 @@ describe("fromThreadMessageLike", () => {
       });
     });
   });
+
+  describe("metadata.isOptimistic", () => {
+    it("preserves isOptimistic on user messages", () => {
+      const result = fromThreadMessageLike(
+        {
+          role: "user",
+          content: [{ type: "text", text: "hello" }],
+          metadata: { isOptimistic: true },
+        },
+        fallbackId,
+        fallbackStatus,
+      );
+
+      expect(result.metadata.isOptimistic).toBe(true);
+    });
+
+    it("preserves isOptimistic on assistant messages", () => {
+      const result = fromThreadMessageLike(
+        {
+          role: "assistant",
+          content: [{ type: "text", text: "hello" }],
+          metadata: { isOptimistic: true },
+        },
+        fallbackId,
+        fallbackStatus,
+      );
+
+      expect(result.metadata.isOptimistic).toBe(true);
+    });
+
+    it("omits isOptimistic when false", () => {
+      const result = fromThreadMessageLike(
+        {
+          role: "user",
+          content: [{ type: "text", text: "hello" }],
+          metadata: { isOptimistic: false },
+        },
+        fallbackId,
+        fallbackStatus,
+      );
+
+      expect(result.metadata).not.toHaveProperty("isOptimistic");
+    });
+
+    it("omits isOptimistic when not set", () => {
+      const result = fromThreadMessageLike(
+        {
+          role: "user",
+          content: [{ type: "text", text: "hello" }],
+        },
+        fallbackId,
+        fallbackStatus,
+      );
+
+      expect(result.metadata).not.toHaveProperty("isOptimistic");
+    });
+  });
 });

package/src/types/attachment.ts

@@ -52,3 +52,8 @@ export type CreateAttachment = {
   contentType?: string;
   content: ThreadUserMessagePart[];
 };
+
+export const isCreateAttachment = (
+  attachment: File | CreateAttachment,
+): attachment is CreateAttachment =>
+  "content" in attachment && !("lastModified" in attachment);

package/src/types/message.ts

@@ -349,6 +349,7 @@ export type ThreadUserMessage = MessageCommonProps & {
     readonly steps?: undefined;
     readonly submittedFeedback?: undefined;
     readonly timing?: undefined;
+    readonly isOptimistic?: boolean;
     readonly custom: Record<string, unknown>;
   };
 };

package/src/utils/data-url.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from "vitest";
+import { httpUrlPattern, parseDataUrl } from "./data-url";
+
+describe("parseDataUrl", () => {
+  it("parses a base64 data URL", () => {
+    expect(parseDataUrl("data:image/png;base64,aGVsbG8=")).toEqual({
+      mimeType: "image/png",
+      data: "aGVsbG8=",
+    });
+  });
+
+  it("parses a data URL with extra parameters", () => {
+    expect(parseDataUrl("data:text/plain;charset=utf-8;base64,aGk=")).toEqual({
+      mimeType: "text/plain",
+      data: "aGk=",
+    });
+  });
+
+  it("returns null for non-base64 data URLs", () => {
+    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("returns null for plain strings", () => {
+    expect(parseDataUrl("aGVsbG8=")).toBeNull();
+  });
+
+  it("returns null for http URLs", () => {
+    expect(parseDataUrl("https://example.com/a.png")).toBeNull();
+  });
+});
+
+describe("httpUrlPattern", () => {
+  it.each(["http://example.com", "https://example.com", "HTTPS://EXAMPLE.COM"])(
+    "matches %s",
+    (value) => {
+      expect(httpUrlPattern.test(value)).toBe(true);
+    },
+  );
+
+  it.each(["ftp://example.com", "data:image/png;base64,aGk=", "/relative"])(
+    "does not match %s",
+    (value) => {
+      expect(httpUrlPattern.test(value)).toBe(false);
+    },
+  );
+});

package/src/utils/data-url.ts

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

package/src/utils/notify-event-listeners.ts

@@ -0,0 +1,30 @@
+type EventListener = (payload?: unknown) => void;
+
+export const notifyEventListeners = (
+  listeners: Iterable<EventListener>,
+  payload: unknown,
+  errorContext: string,
+) => {
+  const reportError = (error: unknown) => {
+    console.error(
+      `[assistant-ui] ${errorContext} listener threw an error`,
+      error,
+    );
+  };
+
+  for (const listener of listeners) {
+    try {
+      const result = listener(payload) as unknown;
+      if (
+        result !== null &&
+        (typeof result === "object" || typeof result === "function") &&
+        "then" in result &&
+        typeof result.then === "function"
+      ) {
+        void Promise.resolve(result).catch(reportError);
+      }
+    } catch (error) {
+      reportError(error);
+    }
+  }
+};

package/src/tests/OptimisticState-delete-crash.test.ts

@@ -1,208 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { OptimisticState } from "../runtimes/remote-thread-list/optimistic-state";
-import {
-  type RemoteThreadState,
-  createThreadMappingId,
-  updateStatusReducer,
-  getThreadData,
-} from "../runtimes/remote-thread-list/remote-thread-state";
-
-/**
- * This test reproduces the crash from issue #3346:
- * "Entry not available in the store" when deleting the active thread.
- *
- * Root cause: optimisticUpdate's `optimistic` callback runs synchronously
- * and removes the thread from threadData, but mainThreadId still points to
- * the deleted thread. Subscribers that fire during _notifySubscribers() see
- * this inconsistent state and crash.
- */
-
-const createThreadState = (
-  threadId: string,
-  status: "regular" | "archived" = "regular",
-): RemoteThreadState => {
-  const mappingId = createThreadMappingId(threadId);
-  return {
-    isLoading: false,
-    isLoadingMore: false,
-    cursor: undefined,
-    newThreadId: undefined,
-    threadIds: status === "regular" ? [threadId] : [],
-    archivedThreadIds: status === "archived" ? [threadId] : [],
-    threadIdMap: { [threadId]: mappingId },
-    threadData: {
-      [mappingId]: {
-        id: threadId,
-        remoteId: threadId,
-        externalId: undefined,
-        status,
-        title: undefined,
-        initializeTask: Promise.resolve({
-          remoteId: threadId,
-          externalId: undefined,
-        }),
-      },
-    },
-  };
-};
-
-describe("OptimisticState delete crash (#3346)", () => {
-  it("optimistic callback runs synchronously before execute completes", async () => {
-    const state = new OptimisticState(createThreadState("thread-1"));
-    const events: string[] = [];
-
-    state.subscribe(() => {
-      events.push("subscriber-notified");
-    });
-
-    const executeStarted = vi.fn();
-    const executeCompleted = vi.fn();
-
-    const promise = state.optimisticUpdate({
-      execute: async () => {
-        executeStarted();
-        // simulate async work like _ensureThreadIsNotMain
-        await Promise.resolve();
-        executeCompleted();
-      },
-      optimistic: (s) => {
-        events.push("optimistic-ran");
-        return updateStatusReducer(s, "thread-1", "deleted");
-      },
-    });
-
-    // After calling optimisticUpdate but before awaiting:
-    // - optimistic callback has already run (synchronous)
-    // - execute has started but not completed (async)
-    expect(events).toEqual(["optimistic-ran", "subscriber-notified"]);
-    expect(executeStarted).toHaveBeenCalled();
-    expect(executeCompleted).not.toHaveBeenCalled();
-
-    // Thread data is already gone from the optimistic value
-    expect(getThreadData(state.value, "thread-1")).toBeUndefined();
-
-    await promise;
-  });
-
-  it("BUG SCENARIO: subscriber sees deleted thread data while mainThreadId still references it", async () => {
-    const state = new OptimisticState(createThreadState("thread-1"));
-
-    // Simulate what happens in the real code:
-    // mainThreadId is external state that _ensureThreadIsNotMain would update
-    let mainThreadId = "thread-1";
-    let subscriberSawInconsistentState = false;
-
-    state.subscribe(() => {
-      // This fires synchronously during optimisticUpdate.
-      // In the real code, React components would re-render here and try to
-      // access the main thread's data.
-      const threadData = getThreadData(state.value, mainThreadId);
-      if (threadData === undefined && mainThreadId === "thread-1") {
-        // mainThreadId points to a deleted thread — this is the crash condition
-        subscriberSawInconsistentState = true;
-      }
-    });
-
-    // OLD CODE: _ensureThreadIsNotMain inside execute
-    // The optimistic callback deletes thread data BEFORE execute can update mainThreadId
-    const promise = state.optimisticUpdate({
-      execute: async () => {
-        // In old code, _ensureThreadIsNotMain was here.
-        // It would switch mainThreadId, but this runs AFTER optimistic callback
-        await Promise.resolve();
-        mainThreadId = "thread-2"; // too late — subscriber already fired
-      },
-      optimistic: (s) => {
-        return updateStatusReducer(s, "thread-1", "deleted");
-      },
-    });
-
-    // The subscriber saw inconsistent state — mainThreadId points to deleted thread
-    expect(subscriberSawInconsistentState).toBe(true);
-
-    await promise;
-  });
-
-  it("FIX: switching mainThreadId before optimisticUpdate prevents inconsistency", async () => {
-    const state = new OptimisticState(createThreadState("thread-1"));
-
-    let mainThreadId = "thread-1";
-    let subscriberSawInconsistentState = false;
-
-    state.subscribe(() => {
-      const threadData = getThreadData(state.value, mainThreadId);
-      if (threadData === undefined) {
-        subscriberSawInconsistentState = true;
-      }
-    });
-
-    // FIX: _ensureThreadIsNotMain runs BEFORE optimisticUpdate.
-    // switchToNewThread() both creates the new thread in state AND updates mainThreadId.
-    const newThreadId = "thread-2";
-    const mappingId = createThreadMappingId(newThreadId);
-    const currentState = state.value;
-    state.update({
-      ...currentState,
-      newThreadId: newThreadId,
-      threadIdMap: {
-        ...currentState.threadIdMap,
-        [newThreadId]: mappingId,
-      },
-      threadData: {
-        ...currentState.threadData,
-        [mappingId]: {
-          status: "new" as const,
-          id: newThreadId,
-          remoteId: undefined,
-          externalId: undefined,
-          title: undefined,
-        },
-      },
-    });
-    mainThreadId = newThreadId;
-
-    // Reset flag — the state.update above triggered the subscriber
-    subscriberSawInconsistentState = false;
-
-    const promise = state.optimisticUpdate({
-      execute: async () => {
-        // _ensureThreadIsNotMain no longer here
-        return undefined;
-      },
-      optimistic: (s) => {
-        return updateStatusReducer(s, "thread-1", "deleted");
-      },
-    });
-
-    // mainThreadId was already switched to thread-2 which exists in state
-    // — subscriber sees consistent state, no crash
-    expect(subscriberSawInconsistentState).toBe(false);
-
-    await promise;
-  });
-
-  it("archive does NOT remove threadData (no crash even without fix)", async () => {
-    const state = new OptimisticState(createThreadState("thread-1"));
-
-    let threadDataMissingDuringNotify = false;
-
-    state.subscribe(() => {
-      const threadData = getThreadData(state.value, "thread-1");
-      if (threadData === undefined) {
-        threadDataMissingDuringNotify = true;
-      }
-    });
-
-    await state.optimisticUpdate({
-      execute: async () => undefined,
-      optimistic: (s) => {
-        return updateStatusReducer(s, "thread-1", "archived");
-      },
-    });
-
-    // Archive keeps threadData — no SKIP_UPDATE, no crash
-    expect(threadDataMissingDuringNotify).toBe(false);
-    expect(getThreadData(state.value, "thread-1")).toBeDefined();
-    expect(getThreadData(state.value, "thread-1")?.status).toBe("archived");
-  });
-});