@assistant-ui/core 0.3.17 → 0.3.19

package/src/store/primitive-predicates.test.ts

@@ -50,8 +50,12 @@ describe("primitive predicates", () => {
     ).toBe(true);
   });
 
-  it("actionBarReloadDisabled rejects user messages and busy threads", () => {
-    const thread = { isRunning: false, isDisabled: false };
+  it("actionBarReloadDisabled rejects user messages, busy threads, and runtimes without reload", () => {
+    const thread = {
+      isRunning: false,
+      isDisabled: false,
+      capabilities: { reload: true },
+    };
     expect(
       actionBarReloadDisabled(
         state({ thread, message: { role: "assistant" } }),
@@ -68,6 +72,14 @@ describe("primitive predicates", () => {
         }),
       ),
     ).toBe(true);
+    expect(
+      actionBarReloadDisabled(
+        state({
+          thread: { ...thread, capabilities: { reload: false } },
+          message: { role: "assistant" },
+        }),
+      ),
+    ).toBe(true);
   });
 
   it("actionBarCopyDisabled requires settled content with non-empty text", () => {
@@ -109,7 +121,7 @@ describe("primitive predicates", () => {
   it("branch picker predicates respect bounds and run capabilities", () => {
     const thread = {
       isRunning: false,
-      capabilities: { switchBranchDuringRun: false },
+      capabilities: { switchToBranch: true, switchBranchDuringRun: false },
     };
     const message = { branchNumber: 2, branchCount: 3 };
     expect(branchPickerPreviousDisabled(state({ thread, message }))).toBe(
@@ -131,6 +143,16 @@ describe("primitive predicates", () => {
         state({ thread: { ...thread, isRunning: true }, message }),
       ),
     ).toBe(true);
+    const noSwitching = {
+      ...thread,
+      capabilities: { ...thread.capabilities, switchToBranch: false },
+    };
+    expect(
+      branchPickerPreviousDisabled(state({ thread: noSwitching, message })),
+    ).toBe(true);
+    expect(
+      branchPickerNextDisabled(state({ thread: noSwitching, message })),
+    ).toBe(true);
   });
 
   it("suggestionTriggerDisabled gates on send only for queueless runs", () => {
@@ -174,11 +196,32 @@ describe("primitive predicates", () => {
       ),
     ).toBe(true);
 
+    const editable = { optional: { thread: { capabilities: { edit: true } } } };
     expect(
-      actionBarEditDisabled(state({ composer: { isEditing: false } })),
+      actionBarEditDisabled(
+        state({ ...editable, composer: { isEditing: false } }),
+      ),
     ).toBe(false);
     expect(
-      actionBarEditDisabled(state({ composer: { isEditing: true } })),
+      actionBarEditDisabled(
+        state({ ...editable, composer: { isEditing: true } }),
+      ),
+    ).toBe(true);
+    expect(
+      actionBarEditDisabled(
+        state({
+          optional: { thread: { capabilities: { edit: false } } },
+          composer: { isEditing: false },
+        }),
+      ),
     ).toBe(true);
+    expect(
+      actionBarEditDisabled(
+        state({
+          optional: { thread: undefined },
+          composer: { isEditing: false },
+        }),
+      ),
+    ).toBe(false);
   });
 });

package/src/store/primitive-predicates.ts

@@ -20,10 +20,13 @@ export const composerInputDisabled = (s: AssistantState): boolean =>
   s.thread.isDisabled || s.composer.dictation?.inputDisabled === true;
 
 export const actionBarEditDisabled = (s: AssistantState): boolean =>
-  s.composer.isEditing;
+  s.composer.isEditing || s.optional.thread?.capabilities.edit === false;
 
 export const actionBarReloadDisabled = (s: AssistantState): boolean =>
-  s.thread.isRunning || s.thread.isDisabled || s.message.role !== "assistant";
+  s.thread.isRunning ||
+  s.thread.isDisabled ||
+  s.message.role !== "assistant" ||
+  !s.thread.capabilities.reload;
 
 export const actionBarCopyDisabled = (s: AssistantState): boolean =>
   !(
@@ -33,10 +36,12 @@ export const actionBarCopyDisabled = (s: AssistantState): boolean =>
 
 export const branchPickerPreviousDisabled = (s: AssistantState): boolean =>
   s.message.branchNumber <= 1 ||
+  !s.thread.capabilities.switchToBranch ||
   (s.thread.isRunning && !s.thread.capabilities.switchBranchDuringRun);
 
 export const branchPickerNextDisabled = (s: AssistantState): boolean =>
   s.message.branchNumber >= s.message.branchCount ||
+  !s.thread.capabilities.switchToBranch ||
   (s.thread.isRunning && !s.thread.capabilities.switchBranchDuringRun);
 
 export const suggestionTriggerDisabled = (

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

@@ -1,5 +1,5 @@
 import type { Unsubscribe } from "../../types/unsubscribe";
-import { useMemo, useEffect } from "react";
+import { useMemo, useEffect, useRef } from "react";
 import { useResource, resource, withKey } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import { useAssistantEmit, useClientLookup } from "@assistant-ui/store/client";
@@ -59,28 +59,48 @@ const useComposerClient = ({
   threadIdRef,
   messageIdRef,
   runtime,
+  isSuggestion,
 }: {
   threadIdRef: { current: string };
   messageIdRef?: { current: string };
   runtime: ComposerRuntime;
+  isSuggestion?: ((text: string) => boolean) | undefined;
 }): ClientOutput<"composer"> => {
   const runtimeState = useSubscribable(runtime);
   const emit = useAssistantEmit();
+  const pendingSuggestion = useRef(false);
 
   // Bind composer events to event manager
   useEffect(() => {
     const unsubscribers: Unsubscribe[] = [];
 
     // Subscribe to composer events
-    for (const event of ["send", "attachmentAdd"] as const) {
-      const unsubscribe = runtime.unstable_on(event, () => {
-        emit(`composer.${event}`, {
+    const sendUnsubscribe = runtime.unstable_on("send", (payload) => {
+      const suggestion = pendingSuggestion.current;
+      pendingSuggestion.current = false;
+      emit("composer.send", {
+        threadId: threadIdRef.current,
+        ...(messageIdRef && { messageId: messageIdRef.current }),
+        chars: payload.chars,
+        attachments: payload.attachments,
+        ...(suggestion ? { suggestion: true } : undefined),
+      });
+    });
+    unsubscribers.push(sendUnsubscribe);
+
+    const attachmentUnsubscribe = runtime.unstable_on(
+      "attachmentAdd",
+      (payload) => {
+        emit("composer.attachmentAdd", {
           threadId: threadIdRef.current,
           ...(messageIdRef && { messageId: messageIdRef.current }),
+          ...(payload.contentType
+            ? { contentType: payload.contentType }
+            : undefined),
         });
-      });
-      unsubscribers.push(unsubscribe);
-    }
+      },
+    );
+    unsubscribers.push(attachmentUnsubscribe);
 
     unsubscribers.push(
       runtime.unstable_on("attachmentAddError", (payload) => {
@@ -91,6 +111,9 @@ const useComposerClient = ({
           ...(payload.attachmentId && { attachmentId: payload.attachmentId }),
           reason: payload.reason,
           message: payload.message,
+          ...(payload.contentType
+            ? { contentType: payload.contentType }
+            : undefined),
         });
       }),
     );
@@ -153,8 +176,18 @@ const useComposerClient = ({
     addAttachment: runtime.addAttachment,
     reset: runtime.reset,
     clearAttachments: runtime.clearAttachments,
-    send: runtime.send,
-    cancel: runtime.cancel,
+    send: (options) => {
+      const state = runtime.getState();
+      pendingSuggestion.current =
+        state.canSend && (isSuggestion?.(state.text) ?? false);
+      runtime.send(options);
+    },
+    cancel: () => {
+      if (!messageIdRef && runtime.getState().canCancel) {
+        emit("composer.cancel", { threadId: threadIdRef.current });
+      }
+      runtime.cancel();
+    },
     beginEdit:
       (runtime as EditComposerRuntime).beginEdit ??
       (() => {

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

@@ -1,7 +1,11 @@
-import { useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } 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 {
+  useAssistantEmit,
+  useClientLookup,
+  useClientResource,
+} from "@assistant-ui/store/client";
 import type { MessageRuntime } from "../../runtime/api/message-runtime";
 import { useSubscribable } from "./useSubscribable";
 import { liveRef } from "./liveRef";
@@ -47,11 +51,14 @@ const MessagePartByIndex = resource(useMessagePartByIndex);
 const useMessageClient = ({
   runtime,
   threadIdRef,
+  threadId,
 }: {
   runtime: MessageRuntime;
   threadIdRef: { current: string };
+  threadId: string;
 }): ClientOutput<"message"> => {
   const runtimeState = useSubscribable(runtime);
+  const emit = useAssistantEmit();
 
   const [isCopiedState, setIsCopied] = useState(false);
   const [isHoveringState, setIsHovering] = useState(false);
@@ -60,6 +67,33 @@ const useMessageClient = ({
     () => liveRef(() => runtime.getState().id),
     [runtime],
   );
+  const previousStatus = useRef(runtimeState.status);
+  const emitMessageEvent = (
+    event:
+      | "message.reload"
+      | "message.speak"
+      | "message.branchSwitched"
+      | "message.copied",
+  ) => {
+    emit(event, { threadId, messageId: runtime.getState().id });
+  };
+
+  useEffect(() => {
+    const status = runtimeState.status;
+    const previous = previousStatus.current;
+    previousStatus.current = status;
+    if (
+      status?.type === "incomplete" &&
+      status.reason === "error" &&
+      (previous?.type !== "incomplete" || previous.reason !== "error")
+    ) {
+      emit("message.error", {
+        threadId,
+        messageId: runtimeState.id,
+        reason: "error",
+      });
+    }
+  }, [runtimeState.status, runtimeState.id, emit, threadId]);
 
   const composer = useClientResource(
     ComposerClient({
@@ -114,11 +148,20 @@ const useMessageClient = ({
     composer: () => composer.methods,
 
     delete: () => runtime.delete(),
-    reload: (config) => runtime.reload(config),
-    speak: () => runtime.speak(),
+    reload: (config) => {
+      emitMessageEvent("message.reload");
+      return runtime.reload(config);
+    },
+    speak: () => {
+      emitMessageEvent("message.speak");
+      return runtime.speak();
+    },
     stopSpeaking: () => runtime.stopSpeaking(),
     submitFeedback: (feedback) => runtime.submitFeedback(feedback),
-    switchToBranch: (options) => runtime.switchToBranch(options),
+    switchToBranch: (options) => {
+      emitMessageEvent("message.branchSwitched");
+      return runtime.switchToBranch(options);
+    },
     getCopyText: () => runtime.unstable_getCopyText(),
     part: (selector) => {
       if ("index" in selector) {
@@ -136,7 +179,12 @@ const useMessageClient = ({
       }
     },
 
-    setIsCopied,
+    setIsCopied: (value) => {
+      if (value) {
+        emitMessageEvent("message.copied");
+      }
+      setIsCopied(value);
+    },
     setIsHovering,
 
     __internal_getRuntime: () => runtime,

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

@@ -52,8 +52,10 @@ const useThreadListItemClient = ({
     unarchive: () =>
       handleThreadListAction("unarchive", () => runtime.unarchive()),
     delete: () => handleThreadListAction("delete", () => runtime.delete()),
-    generateTitle: () =>
-      handleThreadListAction("generate title", () => runtime.generateTitle()),
+    generateTitle: (options) =>
+      handleThreadListAction("generate title", () =>
+        runtime.generateTitle(options),
+      ),
     initialize: runtime.initialize,
     detach: runtime.detach,
     __internal_getRuntime: () => runtime,

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

@@ -82,6 +82,7 @@ const useThreadListClient = ({
       mainThreadId: runtimeState.mainThreadId,
       newThreadId: runtimeState.newThreadId ?? null,
       isLoading: runtimeState.isLoading,
+      loadError: runtimeState.loadError,
       isLoadingMore: runtimeState.isLoadingMore,
       hasMore: runtimeState.hasMore,
       threadIds: runtimeState.threadIds,

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

@@ -1,7 +1,10 @@
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { ThreadRuntimeEventType } from "../../runtime/interfaces/thread-runtime-core";
-import type { ThreadRuntime } from "../../runtime/api/thread-runtime";
-import { useMemo, useEffect, type RefObject } from "react";
+import type {
+  CreateAppendMessage,
+  ThreadRuntime,
+} from "../../runtime/api/thread-runtime";
+import { useMemo, useEffect, useCallback, type RefObject } from "react";
 import { useResource, resource, withKey } from "@assistant-ui/tap";
 import { liveRef } from "./liveRef";
 import type { ClientOutput } from "@assistant-ui/store";
@@ -13,6 +16,11 @@ import {
 import { ComposerClient } from "./composer-runtime-client";
 import { MessageClient } from "./message-runtime-client";
 import { ThreadSuggestions } from "../clients/suggestions";
+import {
+  createTaskDeriver,
+  getTaskKey,
+  TaskClient,
+} from "../clients/thread-tasks";
 import { useSubscribable } from "./useSubscribable";
 import type { ThreadState } from "../scopes/thread";
 
@@ -20,17 +28,21 @@ const useMessageClientById = ({
   runtime,
   id,
   threadIdRef,
+  threadId,
 }: {
   runtime: ThreadRuntime;
   id: string;
   threadIdRef: RefObject<string>;
+  threadId: string;
 }) => {
   const messageRuntime = useMemo(
     () => runtime.getMessageById(id),
     [runtime, id],
   );
 
-  return useResource(MessageClient({ runtime: messageRuntime, threadIdRef }));
+  return useResource(
+    MessageClient({ runtime: messageRuntime, threadIdRef, threadId }),
+  );
 };
 
 const MessageClientById = resource(useMessageClientById);
@@ -63,6 +75,13 @@ const useThreadClient = ({
       unsubscribers.push(unsubscribe);
     }
 
+    unsubscribers.push(
+      runtime.unstable_on("toolApprovalAnswered", (payload) => {
+        const threadId = runtime.getState()?.threadId || "unknown";
+        emit("thread.toolApprovalAnswered", { threadId, ...payload });
+      }),
+    );
+
     return () => {
       for (const unsub of unsubscribers) unsub();
     };
@@ -72,23 +91,51 @@ const useThreadClient = ({
     () => liveRef(() => runtime.getState()!.threadId),
     [runtime],
   );
+  const emitThreadEvent = (
+    event: "thread.cancelRun" | "thread.voiceStarted",
+  ) => {
+    emit(event, { threadId: runtime.getState()!.threadId });
+  };
+  const isSuggestion = useCallback(
+    (text: string) =>
+      runtime
+        .getState()!
+        .suggestions.some((suggestion) => suggestion.prompt === text),
+    [runtime],
+  );
 
   const composer = useClientResource(
     ComposerClient({
       runtime: runtime.composer,
       threadIdRef,
+      isSuggestion,
     }),
   );
   const suggestions = useClientResource(
     ThreadSuggestions(runtimeState.suggestions),
   );
+  const taskDeriver = useMemo(() => createTaskDeriver(), []);
+  const tasks = useMemo(
+    () => taskDeriver(runtimeState.messages),
+    [taskDeriver, runtimeState.messages],
+  );
+  const taskClients = useClientLookup(
+    tasks.map((task) =>
+      withKey(getTaskKey(task), TaskClient({ task }), [task]),
+    ),
+  );
   const messages = useClientLookup(
     runtimeState.messages.map((m) =>
-      withKey(m.id, MessageClientById({ runtime, id: m.id, threadIdRef }), [
-        runtime,
+      withKey(
         m.id,
-        threadIdRef,
-      ]),
+        MessageClientById({
+          runtime,
+          id: m.id,
+          threadIdRef,
+          threadId: runtimeState.threadId,
+        }),
+        [runtime, m.id, threadIdRef, runtimeState.threadId],
+      ),
     ),
   );
 
@@ -107,25 +154,56 @@ const useThreadClient = ({
 
       composer: composer.state,
       messages: messages.state,
+      tasks,
     };
-  }, [runtimeState, messages, composer.state]);
+  }, [runtimeState, messages, composer.state, tasks]);
 
   return {
     getState: () => state,
     composer: () => composer.methods,
     suggestions: () => suggestions.methods,
-    append: runtime.append,
+    task: (selector) => {
+      if ("id" in selector) {
+        const task = tasks.find((candidate) => candidate.id === selector.id);
+        return taskClients.get({ key: task ? getTaskKey(task) : selector.id });
+      }
+      return taskClients.get(selector);
+    },
+    append: (message) => {
+      const appended: Exclude<CreateAppendMessage, string> =
+        typeof message === "string"
+          ? { content: [{ type: "text", text: message }] }
+          : message;
+      if ((appended.role ?? "user") === "user") {
+        const text = appended.content
+          .map((part) => (part.type === "text" ? part.text : ""))
+          .join("");
+        emit("composer.send", {
+          threadId: runtime.getState()!.threadId,
+          chars: text.length,
+          attachments: appended.attachments?.length ?? 0,
+          ...(isSuggestion(text) ? { suggestion: true } : undefined),
+        });
+      }
+      runtime.append(message);
+    },
     deleteMessage: runtime.deleteMessage,
     startRun: runtime.startRun,
     resumeRun: runtime.resumeRun,
     importExternalState: runtime.importExternalState,
-    cancelRun: runtime.cancelRun,
+    cancelRun: () => {
+      if (runtimeState.isRunning) emitThreadEvent("thread.cancelRun");
+      runtime.cancelRun();
+    },
     getModelContext: runtime.getModelContext,
     export: runtime.export,
     import: runtime.import,
     reset: runtime.reset,
     stopSpeaking: runtime.stopSpeaking,
-    connectVoice: runtime.connectVoice,
+    connectVoice: () => {
+      runtime.connectVoice();
+      emitThreadEvent("thread.voiceStarted");
+    },
     disconnectVoice: runtime.disconnectVoice,
     getVoiceVolume: runtime.getVoiceVolume,
     subscribeVoiceVolume: runtime.subscribeVoiceVolume,

package/src/store/scope-registration.ts

@@ -10,6 +10,7 @@ import type { SuggestionsClientSchema } from "./scopes/suggestions";
 import type { SuggestionClientSchema } from "./scopes/suggestion";
 import type { ChainOfThoughtClientSchema } from "./scopes/chain-of-thought";
 import type { QueueItemClientSchema } from "./scopes/queue-item";
+import type { TaskClientSchema } from "./scopes/task";
 
 declare module "@assistant-ui/store" {
   interface ScopeRegistry {
@@ -25,5 +26,6 @@ declare module "@assistant-ui/store" {
     suggestion: SuggestionClientSchema;
     chainOfThought: ChainOfThoughtClientSchema;
     queueItem: QueueItemClientSchema;
+    task: TaskClientSchema;
   }
 }

package/src/store/scopes/composer.ts

@@ -109,22 +109,34 @@ export type ComposerMeta = {
 
 export type ComposerEvents = {
   /**
-   * The user sent the composer contents. `messageId` is set when the send
-   * came from an edit composer.
+   * The user sent a message, from the composer or through `thread.append`.
+   * `messageId` is set when the send came from an edit composer.
    */
-  "composer.send": { threadId: string; messageId?: string };
+  "composer.send": {
+    threadId: string;
+    messageId?: string;
+    chars: number;
+    attachments: number;
+    suggestion?: boolean;
+  };
   /**
    * 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.attachmentAdd": {
+    threadId: string;
+    messageId?: string;
+    contentType?: string;
+  };
   "composer.attachmentAddError": {
     threadId: string;
     messageId?: string;
     attachmentId?: string;
     reason: AttachmentAddErrorReason;
     message: string;
+    contentType?: string;
   };
+  "composer.cancel": { threadId: string };
 };
 
 export type ComposerClientSchema = {

package/src/store/scopes/message.ts

@@ -66,7 +66,21 @@ export type MessageMeta = {
   query: { type: "id"; id: string } | { type: "index"; index: number };
 };
 
+export type MessageEvents = {
+  /** The user asked for this assistant message to be generated again. */
+  "message.reload": { threadId: string; messageId: string };
+  /** The user moved to another branch at this message. */
+  "message.branchSwitched": { threadId: string; messageId: string };
+  /** The user copied this message. */
+  "message.copied": { threadId: string; messageId: string };
+  /** Speech synthesis started for this message. */
+  "message.speak": { threadId: string; messageId: string };
+  /** This message entered an error status. */
+  "message.error": { threadId: string; messageId: string; reason: "error" };
+};
+
 export type MessageClientSchema = {
   methods: MessageMethods;
   meta: MessageMeta;
+  events: MessageEvents;
 };

package/src/store/scopes/task.ts

@@ -0,0 +1,34 @@
+import type {
+  ThreadMessage,
+  ToolCallMessagePart,
+  ToolCallMessagePartStatus,
+} from "../../types/message";
+
+/** A tool call that carries a nested conversation, read as one unit of child work; `id` is its toolCallId. */
+export type TaskState = {
+  readonly id: string;
+  readonly toolName: string;
+  readonly args: ToolCallMessagePart["args"];
+  readonly result?: ToolCallMessagePart["result"];
+  readonly isError?: boolean;
+  readonly status: ToolCallMessagePartStatus;
+  readonly timing?: ToolCallMessagePart["timing"];
+  readonly messageId: string;
+  readonly parentTaskId: string | null;
+  readonly depth: number;
+  readonly messages: readonly ThreadMessage[];
+};
+
+export type TaskMethods = {
+  getState(): TaskState;
+};
+
+export type TaskMeta = {
+  source: "thread";
+  query: { type: "index"; index: number } | { type: "id"; id: string };
+};
+
+export type TaskClientSchema = {
+  methods: TaskMethods;
+  meta: TaskMeta;
+};

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

@@ -1,4 +1,7 @@
-import type { ThreadListItemRuntime } from "../../runtime/api/thread-list-item-runtime";
+import type {
+  ThreadListItemGenerateTitleOptions,
+  ThreadListItemRuntime,
+} from "../../runtime/api/thread-list-item-runtime";
 import type { ThreadListItemStatus } from "../../runtime/interfaces/thread-list-runtime-core";
 
 export type ThreadListItemState = {
@@ -26,7 +29,7 @@ export type ThreadListItemMethods = {
   archive(): void;
   unarchive(): void;
   delete(): void;
-  generateTitle(): void;
+  generateTitle(options?: ThreadListItemGenerateTitleOptions): void;
   initialize(): Promise<{ remoteId: string; externalId: string | undefined }>;
   detach(): void;
   __internal_getRuntime?(): ThreadListItemRuntime;