@assistant-ui/core 0.3.13 → 0.3.15

package/src/store/primitive-predicates.ts

@@ -0,0 +1,43 @@
+import type { AssistantState } from "@assistant-ui/store";
+
+/**
+ * Disabled predicates shared by every binding's primitive layer. Each binding
+ * consumes these as state selectors so the disabled semantics of a primitive
+ * cannot drift between frameworks.
+ */
+
+export const composerSendDisabled = (s: AssistantState): boolean =>
+  !s.composer.canSend || (s.thread.isRunning && !s.thread.capabilities.queue);
+
+export const composerCancelDisabled = (s: AssistantState): boolean =>
+  !s.composer.canCancel;
+
+export const composerInputDisabled = (s: AssistantState): boolean =>
+  s.thread.isDisabled || s.composer.dictation?.inputDisabled === true;
+
+export const actionBarEditDisabled = (s: AssistantState): boolean =>
+  s.composer.isEditing;
+
+export const actionBarReloadDisabled = (s: AssistantState): boolean =>
+  s.thread.isRunning || s.thread.isDisabled || s.message.role !== "assistant";
+
+export const actionBarCopyDisabled = (s: AssistantState): boolean =>
+  !(
+    (s.message.role !== "assistant" || s.message.status?.type !== "running") &&
+    s.message.parts.some((part) => part.type === "text" && part.text.length > 0)
+  );
+
+export const branchPickerPreviousDisabled = (s: AssistantState): boolean =>
+  s.message.branchNumber <= 1 ||
+  (s.thread.isRunning && !s.thread.capabilities.switchBranchDuringRun);
+
+export const branchPickerNextDisabled = (s: AssistantState): boolean =>
+  s.message.branchNumber >= s.message.branchCount ||
+  (s.thread.isRunning && !s.thread.capabilities.switchBranchDuringRun);
+
+export const suggestionTriggerDisabled = (
+  s: AssistantState,
+  send: boolean,
+): boolean =>
+  s.thread.isDisabled ||
+  (send && s.thread.isRunning && !s.thread.capabilities.queue);

package/src/store/runtime-clients/attachment-runtime-client.test.ts

@@ -0,0 +1,41 @@
+import { createTapRoot, useResource } from "@assistant-ui/tap";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { AttachmentRuntime } from "../../runtime/api/attachment-runtime";
+import { AttachmentRuntimeClient } from "./attachment-runtime-client";
+
+describe("AttachmentRuntimeClient", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("reports attachment removal failures", async () => {
+    const error = new Error("storage unavailable");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const state = {
+      id: "attachment-1",
+      type: "file",
+      name: "notes.txt",
+      status: { type: "complete" },
+      content: [],
+      source: "thread-composer",
+    };
+    const runtime = {
+      getState: () => state,
+      subscribe: () => () => {},
+      remove: () => Promise.reject(error),
+    } as unknown as AttachmentRuntime;
+    const root = createTapRoot(function AttachmentClientRoot() {
+      return useResource(AttachmentRuntimeClient({ runtime }));
+    });
+
+    await expect(root.getValue().remove()).rejects.toBe(error);
+
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] attachment remove failed:",
+      error,
+    );
+    root.unmount();
+  });
+});

package/src/store/runtime-clients/attachment-runtime-client.ts

@@ -1,6 +1,7 @@
 import { resource } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import type { AttachmentRuntime } from "../../runtime/api/attachment-runtime";
+import { handleRuntimeAction } from "./handle-runtime-action";
 import { useSubscribable } from "./useSubscribable";
 
 const useAttachmentRuntimeClient = ({
@@ -12,7 +13,7 @@ const useAttachmentRuntimeClient = ({
 
   return {
     getState: () => state,
-    remove: runtime.remove,
+    remove: () => handleRuntimeAction("attachment remove", runtime.remove),
     __internal_getRuntime: () => runtime,
   };
 };

package/src/store/runtime-clients/handle-runtime-action.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from "vitest";
+import { ThreadListAdapterChangedError } from "../../runtimes/remote-thread-list/adapter-changed";
+import { handleRuntimeAction } from "./handle-runtime-action";
+
+describe("handleRuntimeAction", () => {
+  it("does not log a silent adapter-change cancellation", async () => {
+    const error = new ThreadListAdapterChangedError();
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    try {
+      await expect(
+        handleRuntimeAction("thread list archive", () => Promise.reject(error)),
+      ).rejects.toBe(error);
+      expect(consoleError).not.toHaveBeenCalled();
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+
+  it("logs an ordinary rejection", async () => {
+    const error = new Error("archive failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    try {
+      await expect(
+        handleRuntimeAction("thread list archive", () => Promise.reject(error)),
+      ).rejects.toBe(error);
+      expect(consoleError).toHaveBeenCalledExactlyOnceWith(
+        "[assistant-ui] thread list archive failed:",
+        error,
+      );
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+});

package/src/store/runtime-clients/handle-runtime-action.ts

@@ -0,0 +1,14 @@
+import { isSilentRuntimeAction } from "../../utils/silent-runtime-action";
+
+export const handleRuntimeAction = (
+  label: string,
+  execute: () => Promise<void>,
+): Promise<void> => {
+  const task = execute();
+
+  void task.catch((error: unknown) => {
+    if (isSilentRuntimeAction(error)) return;
+    console.error(`[assistant-ui] ${label} failed:`, error);
+  });
+  return task;
+};

package/src/store/runtime-clients/handle-thread-list-action.test.ts

@@ -0,0 +1,69 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { handleThreadListAction } from "./handle-thread-list-action";
+
+describe("handleThreadListAction", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("reports a rejected task", async () => {
+    const error = new Error("unavailable");
+    const task = Promise.reject(error);
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    const result = handleThreadListAction("delete", () => task);
+
+    expect(result).toBe(task);
+    await expect(result).rejects.toBe(error);
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] thread list delete failed:",
+      error,
+    );
+  });
+
+  it("preserves synchronous failures", () => {
+    const error = new Error("invalid thread");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    expect(() =>
+      handleThreadListAction("switch", () => {
+        throw error;
+      }),
+    ).toThrow(error);
+    expect(consoleError).not.toHaveBeenCalled();
+  });
+
+  it("does not leak an ignored action as an unhandled rejection", async () => {
+    const error = new Error("delete failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const rejections: unknown[] = [];
+    const onUnhandledRejection = (reason: unknown) => {
+      rejections.push(reason);
+    };
+    const priorListeners = process.listeners("unhandledRejection");
+    process.removeAllListeners("unhandledRejection");
+    process.on("unhandledRejection", onUnhandledRejection);
+
+    try {
+      handleThreadListAction("delete", () => Promise.reject(error));
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    } finally {
+      process.removeListener("unhandledRejection", onUnhandledRejection);
+      for (const listener of priorListeners) {
+        process.on("unhandledRejection", listener);
+      }
+    }
+
+    expect(rejections).toEqual([]);
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] thread list delete failed:",
+      error,
+    );
+  });
+});

package/src/store/runtime-clients/handle-thread-list-action.ts

@@ -0,0 +1,6 @@
+import { handleRuntimeAction } from "./handle-runtime-action";
+
+export const handleThreadListAction = (
+  action: string,
+  execute: () => Promise<void>,
+): Promise<void> => handleRuntimeAction(`thread list ${action}`, execute);

package/src/store/runtime-clients/thread-list-item-runtime-client.ts

@@ -4,6 +4,7 @@ import type { ClientOutput } from "@assistant-ui/store";
 import { useAssistantEmit } from "@assistant-ui/store/client";
 import type { ThreadListItemRuntime } from "../../runtime/api/thread-list-item-runtime";
 import { useSubscribable } from "./useSubscribable";
+import { handleThreadListAction } from "./handle-thread-list-action";
 
 const useThreadListItemClient = ({
   runtime,
@@ -39,13 +40,20 @@ const useThreadListItemClient = ({
 
   return {
     getState: () => state,
-    switchTo: runtime.switchTo,
-    rename: runtime.rename,
-    updateCustom: runtime.updateCustom,
-    archive: runtime.archive,
-    unarchive: runtime.unarchive,
-    delete: runtime.delete,
-    generateTitle: runtime.generateTitle,
+    switchTo: (options) =>
+      handleThreadListAction("switch", () => runtime.switchTo(options)),
+    rename: (newTitle) =>
+      handleThreadListAction("rename", () => runtime.rename(newTitle)),
+    updateCustom: (custom) =>
+      handleThreadListAction("update custom metadata", () =>
+        runtime.updateCustom(custom),
+      ),
+    archive: () => handleThreadListAction("archive", () => runtime.archive()),
+    unarchive: () =>
+      handleThreadListAction("unarchive", () => runtime.unarchive()),
+    delete: () => handleThreadListAction("delete", () => runtime.delete()),
+    generateTitle: () =>
+      handleThreadListAction("generate title", () => runtime.generateTitle()),
     initialize: runtime.initialize,
     detach: runtime.detach,
     __internal_getRuntime: () => runtime,

package/src/store/runtime-clients/thread-list-runtime-client.ts

@@ -2,12 +2,14 @@ import { useMemo } from "react";
 import { useResource, withKey, resource } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import { useClientLookup, useClientResource } from "@assistant-ui/store/client";
+import { useThreadSelectionEvents } from "../clients/thread-selection-events";
 import type { ThreadListRuntime } from "../../runtime/api/thread-list-runtime";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
 import { useSubscribable } from "./useSubscribable";
 import { ThreadListItemClient } from "./thread-list-item-runtime-client";
 import { ThreadClient } from "./thread-runtime-client";
 import type { ThreadsState } from "../scopes/threads";
+import { handleThreadListAction } from "./handle-thread-list-action";
 
 const useThreadListItemClientById = ({
   runtime,
@@ -40,6 +42,7 @@ const useThreadListClient = ({
   __internal_assistantRuntime: AssistantRuntime;
 }): ClientOutput<"threads"> => {
   const runtimeState = useSubscribable(runtime);
+  useThreadSelectionEvents(runtimeState.mainThreadId);
 
   const main = useClientResource(
     ThreadClient({
@@ -93,12 +96,12 @@ const useThreadListClient = ({
         : state.threadIds[index]!;
       return threadItems.get({ key: id });
     },
-    switchToThread: async (threadId, options) => {
-      await runtime.switchToThread(threadId, options);
-    },
-    switchToNewThread: async () => {
-      await runtime.switchToNewThread();
-    },
+    switchToThread: (threadId, options) =>
+      handleThreadListAction("switch", () =>
+        runtime.switchToThread(threadId, options),
+      ),
+    switchToNewThread: () =>
+      handleThreadListAction("create", () => runtime.switchToNewThread()),
     getLoadThreadsPromise: () => runtime.getLoadThreadsPromise(),
     reload: () => runtime.reload(),
     reloadMainThread: () => runtime.reloadMainThread(),

package/src/store/scopes/composer.ts

@@ -27,6 +27,11 @@ export type ComposerState = {
   readonly attachments: readonly Attachment[];
   readonly runConfig: RunConfig;
   readonly isEditing: boolean;
+  /**
+   * Whether the composer can cancel the current run. `true` when the runtime
+   * supports cancel and a run is in flight, not merely when cancel is a
+   * capability.
+   */
   readonly canCancel: boolean;
   /**
    * Whether the composer is currently willing to send. `true` when the
@@ -104,13 +109,13 @@ export type ComposerMeta = {
 
 export type ComposerEvents = {
   /**
-   * @deprecated State-derivable. Observe composer `text` clearing via
-   * `useAuiState` instead. Kept for backward compatibility.
+   * The user sent the composer contents. `messageId` is set when the send
+   * came from an edit composer.
    */
   "composer.send": { threadId: string; messageId?: string };
   /**
-   * @deprecated State-derivable. Observe composer `attachments` via
-   * `useAuiState` instead. Kept for backward compatibility.
+   * An attachment was added to the composer. `messageId` is set when the
+   * attachment was added to an edit composer.
    */
   "composer.attachmentAdd": { threadId: string; messageId?: string };
   "composer.attachmentAddError": {

package/src/store/scopes/thread-list-item.ts

@@ -42,15 +42,16 @@ export type ThreadListItemMeta = {
 
 export type ThreadListItemEvents = {
   /**
-   * @deprecated State-derivable. Compare `s.threads.mainThreadId` against the
-   * item's `s.threadListItem.id` via `useAuiState` instead. Kept for backward
-   * compatibility.
+   * @deprecated Use `threads.selectionChanged` instead; its `threadId` is the
+   * newly selected thread. Inside a per-item `threadListItem` scope, filter by
+   * `threadId === threadListItem.id` to reproduce the per-item delivery. Kept
+   * for backward compatibility.
    */
   "threadListItem.switchedTo": { threadId: string };
   /**
-   * @deprecated State-derivable. Compare `s.threads.mainThreadId` against the
-   * item's `s.threadListItem.id` via `useAuiState` instead. Kept for backward
-   * compatibility.
+   * @deprecated Use `threads.selectionChanged` instead; its
+   * `previousThreadId` is the thread that was switched away from. Kept for
+   * backward compatibility.
    */
   "threadListItem.switchedAway": { threadId: string };
 };

package/src/store/scopes/thread.ts

@@ -145,19 +145,20 @@ export type ThreadMeta = {
 
 export type ThreadEvents = {
   /**
-   * @deprecated State-derivable. Observe `isRunning` flipping to `true` via
-   * `useAuiState` instead. Kept for backward compatibility.
+   * A run started on this thread. Also observable as `isRunning` flipping to
+   * `true` in thread state.
    */
   "thread.runStart": { threadId: string };
   /**
-   * @deprecated State-derivable. Observe `isRunning` flipping to `false` via
-   * `useAuiState` instead. Kept for backward compatibility.
+   * A run on this thread ended, whether it completed, errored, or was
+   * cancelled. Also observable as `isRunning` flipping to `false` in thread
+   * state.
    */
   "thread.runEnd": { threadId: string };
   /**
-   * @deprecated State-derivable. This event fires before the first message is
-   * added; observe `messages` becoming non-empty via `useAuiState` instead of
-   * reading state inside this event handler. Kept for backward compatibility.
+   * The thread transitioned from new to initialized. Fires before the first
+   * message is added, so read thread state via `useAuiState` rather than
+   * inside this event handler.
    */
   "thread.initialize": { threadId: string };
   /**

package/src/store/scopes/threads.ts

@@ -35,6 +35,20 @@ export type ThreadsMethods = {
   __internal_getAssistantRuntime?(): AssistantRuntime;
 };
 
+export type ThreadsEvents = {
+  /**
+   * The main thread selection changed. Fires once per switch with the newly
+   * selected thread and the thread that was selected before. Does not fire
+   * for the initially selected thread on mount. Runtimes that resolve a
+   * deep-linked `threadId`/`initialThreadId` after mount (such as
+   * `useRemoteThreadListRuntime`) start on a placeholder new thread, so the
+   * deep link's resolution fires this event with the placeholder as
+   * `previousThreadId`.
+   */
+  "threads.selectionChanged": { threadId: string; previousThreadId: string };
+};
+
 export type ThreadsClientSchema = {
   methods: ThreadsMethods;
+  events: ThreadsEvents;
 };

package/src/subscribable/subscribable.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 import type { SubscribableWithState } from "./subscribable";
-import { ShallowMemoizeSubject } from "./subscribable";
+import { LazyMemoizeSubject, ShallowMemoizeSubject } from "./subscribable";
 
 type TestState = {
   status: string;
@@ -26,6 +26,9 @@ const createBinding = (initialState: TestState) => {
       state = nextState;
       for (const callback of subscribers) callback();
     },
+    replace(nextState: TestState) {
+      state = nextState;
+    },
   };
 };
 
@@ -55,4 +58,77 @@ describe("ShallowMemoizeSubject", () => {
 
     expect(subscriber).not.toHaveBeenCalled();
   });
+
+  it("notifies later subscribers when one throws", () => {
+    const source = createBinding({ status: "empty" });
+    const subject = new ShallowMemoizeSubject(source.binding);
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+    subject.subscribe(() => {
+      throw error;
+    });
+    subject.subscribe(laterSubscriber);
+
+    expect(() => source.update({ status: "ready" })).toThrow(error);
+    expect(laterSubscriber).toHaveBeenCalledOnce();
+    expect(subject.getState()).toEqual({ status: "ready" });
+  });
+
+  it("reads a value that landed while nobody was subscribed", () => {
+    const source = createBinding({ status: "empty" });
+    const subject = new ShallowMemoizeSubject(source.binding);
+    expect(subject.getState()).toEqual({ status: "empty" });
+
+    source.update({ status: "ready" });
+    const subscriber = vi.fn();
+    subject.subscribe(subscriber);
+
+    expect(subject.getState()).toEqual({ status: "ready" });
+    expect(subscriber).not.toHaveBeenCalled();
+  });
+});
+
+describe("LazyMemoizeSubject", () => {
+  it("notifies later subscribers when one throws", () => {
+    const source = createBinding({ status: "empty" });
+    const subject = new LazyMemoizeSubject(source.binding);
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+    subject.subscribe(() => {
+      throw error;
+    });
+    subject.subscribe(laterSubscriber);
+
+    expect(() => source.update({ status: "ready" })).toThrow(error);
+    expect(laterSubscriber).toHaveBeenCalledOnce();
+    expect(subject.getState()).toEqual({ status: "ready" });
+  });
+
+  it("reads a value replaced before connecting", () => {
+    const source = createBinding({ status: "empty" });
+    const subject = new LazyMemoizeSubject(source.binding);
+    expect(subject.getState()).toEqual({ status: "empty" });
+
+    source.replace({ status: "ready" });
+    const subscriber = vi.fn();
+    const unsubscribe = subject.subscribe(subscriber);
+
+    expect(subject.getState()).toEqual({ status: "ready" });
+    expect(subscriber).not.toHaveBeenCalled();
+    unsubscribe();
+  });
+
+  it("resynchronizes after reconnecting", () => {
+    const source = createBinding({ status: "empty" });
+    const subject = new LazyMemoizeSubject(source.binding);
+    expect(subject.getState()).toEqual({ status: "empty" });
+
+    const unsubscribe = subject.subscribe(() => {});
+    unsubscribe();
+    source.replace({ status: "ready" });
+    const reconnect = subject.subscribe(() => {});
+
+    expect(subject.getState()).toEqual({ status: "ready" });
+    reconnect();
+  });
 });

package/src/subscribable/subscribable.ts

@@ -32,6 +32,31 @@ export type EventSubscribable<TEvent extends string> = {
   >;
 };
 
+export const notifySubscribers = <TArgs extends unknown[]>(
+  subscribers: Iterable<(...args: TArgs) => void>,
+  ...args: TArgs
+): void => {
+  const errors: unknown[] = [];
+  for (const callback of subscribers) {
+    try {
+      callback(...args);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+
+  if (errors.length > 1) {
+    for (const error of errors) {
+      console.error(error);
+    }
+    throw new AggregateError(errors);
+  }
+};
+
 function shallowEqual<T extends object>(
   objA: T | undefined,
   objB: T | undefined,
@@ -70,25 +95,7 @@ export class BaseSubscribable {
   }
 
   protected _notifySubscribers() {
-    const errors = [];
-    for (const callback of this._subscribers) {
-      try {
-        callback();
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-
-    if (errors.length > 0) {
-      if (errors.length === 1) {
-        throw errors[0];
-      } else {
-        for (const error of errors) {
-          console.error(error);
-        }
-        throw new AggregateError(errors);
-      }
-    }
+    notifySubscribers(this._subscribers);
   }
 }
 
@@ -109,7 +116,7 @@ export abstract class BaseSubject {
       return;
     }
 
-    for (const callback of this._subscriptions) callback(payload);
+    notifySubscribers(this._subscriptions, payload);
   }
 
   private _updateConnection() {
@@ -173,7 +180,9 @@ export class ShallowMemoizeSubject<TState extends object, TPath>
       }
     };
 
-    return this.binding.subscribe(callback);
+    const unsubscribe = this.binding.subscribe(callback);
+    this._syncState();
+    return unsubscribe;
   }
 }
 
@@ -197,7 +206,11 @@ export class LazyMemoizeSubject<TState extends object, TPath>
   public getState = () => {
     if (!this.isConnected || this._previousStateDirty) {
       const newState = this.binding.getState();
-      if (newState !== SKIP_UPDATE) {
+      if (
+        newState !== SKIP_UPDATE &&
+        (this._previousState === undefined ||
+          !shallowEqual(newState, this._previousState))
+      ) {
         this._previousState = newState;
       }
       this._previousStateDirty = false;
@@ -213,7 +226,9 @@ export class LazyMemoizeSubject<TState extends object, TPath>
       this.notifySubscribers();
     };
 
-    return this.binding.subscribe(callback);
+    const unsubscribe = this.binding.subscribe(callback);
+    this._previousStateDirty = true;
+    return unsubscribe;
   }
 }