@assistant-ui/react 0.15.12 → 0.15.14

package/src/client/InMemoryThreadList.ts

@@ -7,8 +7,9 @@ import {
   attachTransformScopes,
   useClientResource,
 } from "@assistant-ui/store";
+import { generateId } from "@assistant-ui/core";
 
-import { ModelContext, Suggestions } from "@assistant-ui/core/store";
+import { ModelContext } from "@assistant-ui/core/store";
 import { Tools, DataRenderers } from "@assistant-ui/core/react";
 
 const RESOLVED_PROMISE = Promise.resolve();
@@ -137,7 +138,7 @@ const useInMemoryThreadList = (
   };
 
   const handleSwitchToNewThread = () => {
-    const newId = `thread-${Date.now()}`;
+    const newId = `thread-${generateId()}`;
     setThreads((prev) => [
       ...prev,
       { id: newId, title: "New Thread", status: "regular" },
@@ -190,7 +191,8 @@ const useInMemoryThreadList = (
     switchToNewThread: handleSwitchToNewThread,
     getLoadThreadsPromise: () => RESOLVED_PROMISE,
     reload: () => RESOLVED_PROMISE,
-    reloadMainThread: () => RESOLVED_PROMISE,
+    reloadMainThread: () =>
+      mainThreadClient.methods.unstable_refetchThread?.() ?? RESOLVED_PROMISE,
     loadMore: () => RESOLVED_PROMISE,
     item: (selector) => {
       if (selector === "main") {
@@ -236,6 +238,10 @@ attachTransformScopes(useInMemoryThreadList, (scopes, parent) => {
     scopes.dataRenderers = DataRenderers();
   }
   if (!scopes.suggestions && parent.suggestions.source === null) {
-    scopes.suggestions = Suggestions();
+    scopes.suggestions = Derived({
+      source: "thread",
+      query: {},
+      get: (aui) => aui.thread.suggestions(),
+    });
   }
 });

package/src/index.ts

@@ -139,6 +139,7 @@ export type {
   ExternalStoreThreadData,
   ExternalStoreBranchChange,
 } from "@assistant-ui/core";
+export { MessageNotSentError, isMessageNotSentError } from "@assistant-ui/core";
 export {
   createMessageQueue,
   type MessageQueueDriver,
@@ -425,12 +426,12 @@ export {
   ExternalThread,
   type ExternalThreadProps,
   type ExternalThreadMessage,
-} from "./client/ExternalThread";
+} from "@assistant-ui/core/store";
 export {
   InMemoryThreadList,
   type InMemoryThreadListProps,
 } from "./client/InMemoryThreadList";
-export { SingleThreadList } from "./client/SingleThreadList";
+export { SingleThreadList } from "@assistant-ui/core/store";
 
 export * as INTERNAL from "./internal";
 

package/src/legacy-runtime/runtime-cores/assistant-transport/replayBoundaryStream.test.ts

@@ -272,8 +272,11 @@ describe("createReplayBoundaryStream", () => {
   it("clears replaying when the stream ends before the boundary", async () => {
     const { waitForRender, releaseNext } = createRenderWait();
     const setReplaying = vi.fn();
+    const body = createBody(["hi"]);
     const streamPromise = createReplayBoundaryStream(
-      createResponse(["hi"], 10),
+      new Response(body, {
+        headers: { [REPLAY_CONTENT_LENGTH_HEADER]: "10" },
+      }),
       {
         setReplaying,
         waitForRender,
@@ -288,6 +291,7 @@ describe("createReplayBoundaryStream", () => {
 
     await expect(text).resolves.toBe("hi");
     expect(setReplaying).toHaveBeenLastCalledWith(false);
+    expect(body.locked).toBe(false);
   });
 
   it("clears replaying when the gated stream is cancelled", async () => {
@@ -313,6 +317,27 @@ describe("createReplayBoundaryStream", () => {
 
     expect(setReplaying).toHaveBeenLastCalledWith(false);
     expect(cancelled).toBe(true);
+    expect(body.locked).toBe(false);
+  });
+
+  it("releases the response body reader after a read failure", async () => {
+    const { waitForRender, releaseNext } = createRenderWait();
+    const error = new Error("stream failed");
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.error(error);
+      },
+    });
+    const streamPromise = createReplayBoundaryStream(
+      new Response(body, { headers: { [REPLAY_CONTENT_LENGTH_HEADER]: "10" } }),
+      { setReplaying: vi.fn(), waitForRender },
+    );
+
+    await releaseNext();
+    const stream = await streamPromise;
+
+    await expect(stream.getReader().read()).rejects.toBe(error);
+    expect(body.locked).toBe(false);
   });
 
   it("does not wait for replay completion after cancellation unblocks a read", async () => {

package/src/legacy-runtime/runtime-cores/assistant-transport/replayBoundaryStream.ts

@@ -90,6 +90,26 @@ export const createReplayBoundaryStream = async (
   const reader = body.getReader();
   let bytesForwarded = 0;
   let replayFinished = false;
+  let readerCleanup: Promise<void> | undefined;
+
+  const releaseReader = () => {
+    if (readerCleanup) return readerCleanup;
+    reader.releaseLock();
+    readerCleanup = Promise.resolve();
+    return readerCleanup;
+  };
+
+  const cancelReader = (reason?: unknown) => {
+    if (readerCleanup) return readerCleanup;
+    readerCleanup = (async () => {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        reader.releaseLock();
+      }
+    })();
+    return readerCleanup;
+  };
 
   const finishReplay = async () => {
     if (replayFinished) return;
@@ -103,44 +123,50 @@ export const createReplayBoundaryStream = async (
 
   return new ReadableStream<Uint8Array>({
     async pull(controller) {
-      const { done, value } = await reader.read();
-
-      if (done) {
-        await finishReplay();
-        controller.close();
-        return;
-      }
-
-      if (replayFinished) {
-        controller.enqueue(value);
-        return;
-      }
-
-      const nextBytesForwarded = bytesForwarded + value.byteLength;
-
-      if (nextBytesForwarded < replayContentLength) {
-        bytesForwarded = nextBytesForwarded;
-        controller.enqueue(value);
-        return;
-      }
-
-      if (nextBytesForwarded === replayContentLength) {
-        controller.enqueue(value);
+      try {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          await releaseReader();
+          await finishReplay();
+          controller.close();
+          return;
+        }
+
+        if (replayFinished) {
+          controller.enqueue(value);
+          return;
+        }
+
+        const nextBytesForwarded = bytesForwarded + value.byteLength;
+
+        if (nextBytesForwarded < replayContentLength) {
+          bytesForwarded = nextBytesForwarded;
+          controller.enqueue(value);
+          return;
+        }
+
+        if (nextBytesForwarded === replayContentLength) {
+          controller.enqueue(value);
+          await finishReplay();
+          return;
+        }
+
+        const replayBytesInChunk = replayContentLength - bytesForwarded;
+
+        controller.enqueue(value.subarray(0, replayBytesInChunk));
         await finishReplay();
-        return;
+        controller.enqueue(value.subarray(replayBytesInChunk));
+      } catch (error) {
+        await cancelReader(error).catch(() => {});
+        throw error;
       }
-
-      const replayBytesInChunk = replayContentLength - bytesForwarded;
-
-      controller.enqueue(value.subarray(0, replayBytesInChunk));
-      await finishReplay();
-      controller.enqueue(value.subarray(replayBytesInChunk));
     },
     async cancel(reason) {
       const wasFinished = replayFinished;
       replayFinished = true;
       if (!wasFinished) setReplaying(false);
-      await reader.cancel(reason);
+      await cancelReader(reason);
     },
   });
 };

package/src/tests/augmentations.test.ts

@@ -0,0 +1,39 @@
+import { describe, expectTypeOf, it } from "vitest";
+import type { UserCommands, UserExternalState } from "../augmentations";
+
+declare module "../augmentations" {
+  namespace Assistant {
+    interface Commands {
+      reactCommand: { type: "react-command"; data: number };
+    }
+    interface ExternalState {
+      reactState: { fromReact: boolean };
+    }
+  }
+}
+
+declare module "@assistant-ui/core" {
+  namespace Assistant {
+    interface Commands {
+      coreCommand: { type: "core-command" };
+    }
+    interface ExternalState {
+      coreState: { fromCore: boolean };
+    }
+  }
+}
+
+describe("Assistant augmentations", () => {
+  it("react-side contributions reach UserCommands and UserExternalState", () => {
+    expectTypeOf<{
+      type: "react-command";
+      data: number;
+    }>().toExtend<UserCommands>();
+    expectTypeOf<{ fromReact: boolean }>().toExtend<UserExternalState>();
+  });
+
+  it("core-side contributions flow into the react-side unions", () => {
+    expectTypeOf<{ type: "core-command" }>().toExtend<UserCommands>();
+    expectTypeOf<{ fromCore: boolean }>().toExtend<UserExternalState>();
+  });
+});

package/src/tests/in-memory-thread-list.test.tsx

@@ -2,10 +2,10 @@
 
 import { render, waitFor } from "@testing-library/react";
 import type { FC } from "react";
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi } from "vitest";
 import { useAui, AuiProvider } from "@assistant-ui/store";
 import { InMemoryThreadList } from "../client/InMemoryThreadList";
-import { ExternalThread } from "../client/ExternalThread";
+import { ExternalThread } from "../index";
 
 const renderThreads = () => {
   const captured: { aui?: ReturnType<typeof useAui> } = {};
@@ -29,7 +29,7 @@ const renderThreads = () => {
   return { aui: () => captured.aui! };
 };
 
-describe("InMemoryThreadList delete", () => {
+describe("InMemoryThreadList", () => {
   it("falls back to a live thread when the switch target is deleted in the same tick", async () => {
     const { aui } = renderThreads();
 
@@ -52,4 +52,88 @@ describe("InMemoryThreadList delete", () => {
       expect(state.threadIds).not.toContain(newId);
     });
   });
+
+  it("creates unique IDs for threads created in the same millisecond", async () => {
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+
+    try {
+      const { aui } = renderThreads();
+      aui().threads.switchToNewThread();
+      aui().threads.switchToNewThread();
+
+      await waitFor(() => {
+        const generatedIds = aui()
+          .threads.getState()
+          .threadIds.filter((id) => id !== "main");
+        expect(generatedIds).toHaveLength(2);
+        expect(new Set(generatedIds).size).toBe(2);
+      });
+    } finally {
+      now.mockRestore();
+    }
+  });
+});
+
+describe("InMemoryThreadList reloadMainThread", () => {
+  it("routes reloadMainThread to the main thread's refetch callback", async () => {
+    const refetched: string[] = [];
+    const captured: { aui?: ReturnType<typeof useAui> } = {};
+    const Capture: FC = () => {
+      captured.aui = useAui();
+      return null;
+    };
+    const App: FC = () => {
+      const aui = useAui({
+        threads: InMemoryThreadList({
+          thread: (threadId) =>
+            ExternalThread({
+              messages: [],
+              onRefetchThread: async () => {
+                refetched.push(threadId);
+              },
+            }),
+        }),
+      });
+      return (
+        <AuiProvider value={aui}>
+          <Capture />
+        </AuiProvider>
+      );
+    };
+    render(<App />);
+    const aui = () => captured.aui!;
+
+    await waitFor(() => expect(captured.aui).toBeDefined());
+    await aui().threads.reloadMainThread();
+    expect(refetched).toEqual(["main"]);
+
+    aui().threads.switchToNewThread();
+    await waitFor(() =>
+      expect(aui().threads.getState().mainThreadId).not.toBe("main"),
+    );
+    const newId = aui().threads.getState().mainThreadId;
+
+    await aui().threads.reloadMainThread();
+    expect(refetched).toEqual(["main", newId]);
+  });
+
+  it("resolves reloadMainThread when the thread has no refetch callback", async () => {
+    const { aui } = renderThreads();
+
+    await waitFor(() => expect(aui()).toBeDefined());
+    await expect(aui().threads.reloadMainThread()).resolves.toBeUndefined();
+  });
+});
+
+describe("InMemoryThreadList suggestions", () => {
+  it("derives the suggestions scope from the main thread", async () => {
+    const { aui } = renderThreads();
+
+    await waitFor(() => {
+      expect(aui().suggestions.getState()).toEqual({ suggestions: [] });
+    });
+    expect(aui().suggestions.getState()).toBe(
+      aui().thread.suggestions().getState(),
+    );
+  });
 });

package/dist/client/ExternalThread.d.ts

@@ -1,48 +0,0 @@
-import { ClientOutput } from "@assistant-ui/store";
-import { AddToolResultOptions, AppendMessage, AttachmentAdapter, ExternalThreadBranchAdapter, ExternalThreadQueueAdapter, FeedbackAdapter, RespondToToolApprovalOptions, ResumeToolCallOptions, SpeechSynthesisAdapter, ThreadMessage } from "@assistant-ui/core";
-import { ReadonlyJSONValue } from "assistant-stream/utils";
-//#region src/client/ExternalThread.d.ts
-type ExternalThreadMessage = ThreadMessage & {
-  id: string;
-};
-type ExternalThreadProps = {
-  messages: readonly ExternalThreadMessage[];
-  isRunning?: boolean;
-  isLoading?: boolean | undefined;
-  state?: ReadonlyJSONValue | undefined;
-  extras?: unknown;
-  /**
-   * Whether sending new messages is currently disabled. When `true`, the
-   * thread composer's input remains usable but `send()` is a no-op and
-   * `composer.canSend` is `false`. Edit composers (saving message edits)
-   * intentionally ignore this flag.
-   */
-  isSendDisabled?: boolean;
-  /**
-   * Callback for new messages (non-queue runtimes).
-   * @note Unused when `queue` is provided — new messages are routed through `queue.enqueue` instead.
-   */
-  onNew?: (message: AppendMessage) => void;
-  onEdit?: (message: AppendMessage) => void;
-  onReload?: (parentId: string | null) => void;
-  onStartRun?: () => void;
-  onCancel?: () => void;
-  onResume?: (() => void) | undefined;
-  onAddToolResult?: ((options: AddToolResultOptions) => void) | undefined;
-  /** Callback for resuming a tool call that is waiting for human input. */
-  onResumeToolCall?: ((options: ResumeToolCallOptions) => void) | undefined;
-  onLoadExternalState?: ((state: unknown) => void) | undefined;
-  attachmentAdapter?: AttachmentAdapter | undefined;
-  feedbackAdapter?: FeedbackAdapter | undefined;
-  speechAdapter?: SpeechSynthesisAdapter | undefined;
-  /** Queue adapter for runtimes that support message queuing and steering. */
-  queue?: ExternalThreadQueueAdapter;
-  /** Branch adapter for runtimes that track sibling variants of messages. */
-  branches?: ExternalThreadBranchAdapter;
-  /** Callback for tool approval decisions. Absent: responding to an approval throws a capability error. */
-  onRespondToToolApproval?: (options: RespondToToolApprovalOptions) => void;
-};
-declare const ExternalThread: import("@assistant-ui/tap").Resource<ClientOutput<"thread">, [ExternalThreadProps]>;
-//#endregion
-export { ExternalThread, ExternalThreadMessage, ExternalThreadProps };
-//# sourceMappingURL=ExternalThread.d.ts.map

package/dist/client/ExternalThread.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ExternalThread.d.ts","names":[],"sources":["../../src/client/ExternalThread.ts"],"mappings":";;;;KAkDY,wBAAwB;EAClC;;KAgBU;EACV,mBAAmB;EACnB;EACA;EACA,QAAQ;EACR;;;;;;;EAOA;;;;;EAKA,SAAS,SAAS;EAClB,UAAU,SAAS;EACnB,YAAY;EACZ;EACA;EACA;EACA,oBAAoB,SAAS;;EAE7B,qBAAqB,SAAS;EAC9B,wBAAwB;EACxB,oBAAoB;EACpB,kBAAkB;EAClB,gBAAgB;;EAEhB,QAAQ;;EAER,WAAW;;EAEX,2BAA2B,SAAS;;cA2+BzB,4CAAc,SAAA,yBAAA"}