@assistant-ui/core 0.3.17 → 0.3.19

package/src/store/clients/external-thread.ts

@@ -21,7 +21,10 @@ import type {
   CreateAttachment,
   PendingAttachment,
 } from "../../types/attachment";
-import { isCreateAttachment } from "../../types/attachment";
+import {
+  isAttachmentComplete,
+  isCreateAttachment,
+} from "../../types/attachment";
 import type {
   AddToolResultOptions,
   RespondToToolApprovalOptions,
@@ -52,6 +55,7 @@ import { toMessagePartStatus } from "../../utils/normalizePartStatus";
 import { generateId } from "../../utils/id";
 import { ModelContext } from "./model-context-client";
 import { ThreadSuggestions } from "./suggestions";
+import { createTaskDeriver, getTaskKey, TaskClient } from "./thread-tasks";
 import { Tools } from "../../react/client/Tools";
 import { DataRenderers } from "../../react/client/DataRenderers";
 import { SingleThreadList } from "./single-thread-list";
@@ -463,6 +467,35 @@ const useLiveState = <T>(initial: T) => {
   return [state, set, ref] as const;
 };
 
+// A try/catch inside the resource makes the React Compiler bail out of the
+// whole hook, so the adapter call and its failure status live at module scope.
+const removeAttachmentThroughAdapter = async (
+  attachment: Attachment,
+  attachmentAdapter: AttachmentAdapter | undefined,
+  setAttachments: (
+    next:
+      | readonly Attachment[]
+      | ((prev: readonly Attachment[]) => readonly Attachment[]),
+  ) => void,
+) => {
+  try {
+    await attachmentAdapter?.remove(attachment);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    setAttachments((prev) =>
+      prev.map((candidate) =>
+        candidate.id === attachment.id && !isAttachmentComplete(candidate)
+          ? {
+              ...candidate,
+              status: { type: "incomplete", reason: "error", message },
+            }
+          : candidate,
+      ),
+    );
+    throw error;
+  }
+};
+
 // Composer Client - minimal implementation
 const useComposerClientResource = ({
   type,
@@ -516,7 +549,13 @@ const useComposerClientResource = ({
           attachment,
           onRemove: async () => {
             attachmentAddOperations.cancel(attachment.id);
-            await attachmentAdapter?.remove(attachment);
+            if (!isAttachmentComplete(attachment)) {
+              await removeAttachmentThroughAdapter(
+                attachment,
+                attachmentAdapter,
+                setAttachments,
+              );
+            }
             setAttachments((prev) =>
               prev.filter((a) => a.id !== attachment.id),
             );
@@ -531,7 +570,7 @@ const useComposerClientResource = ({
     await Promise.all(
       removed
         .filter((a) => a.status.type !== "complete")
-        .map((a) => attachmentAdapter.remove(a)),
+        .map(async (a) => attachmentAdapter.remove(a)),
     );
   };
 
@@ -905,7 +944,11 @@ const useExternalThread = ({
       : undefined;
   };
 
+  // `messages` changes identity on every streamed token, and this body fans out
+  // to one client per message, so pruning during render would re-run the whole
+  // fan-out per token. The effect bails out on an unchanged map instead.
   useEffect(() => {
+    // eslint-disable-next-line react-hooks/set-state-in-effect
     setSubmittedFeedback((prev) => {
       const live = Object.entries(prev).filter(([id, entry]) => {
         const msg = messages.find((m) => m.id === id);
@@ -983,6 +1026,14 @@ const useExternalThread = ({
     }),
   );
 
+  const taskDeriver = useMemo(() => createTaskDeriver(), []);
+  const tasks = useMemo(() => taskDeriver(messages), [taskDeriver, messages]);
+  const taskClients = useClientLookup(
+    tasks.map((task) =>
+      withKey(getTaskKey(task), TaskClient({ task }), [task]),
+    ),
+  );
+
   const handleCancelRun = () => {
     // Nothing is aborted without a handler, so pausing the queue would hold
     // the pending items against a run that keeps going.
@@ -1067,6 +1118,7 @@ const useExternalThread = ({
         queue: hasQueue,
       },
       messages: messageStates,
+      tasks,
       state: threadState ?? {},
       suggestions: EMPTY_SUGGESTIONS,
       extras,
@@ -1092,12 +1144,20 @@ const useExternalThread = ({
     speech,
     messageClients.state,
     composerClient.state,
+    tasks,
   ]);
 
   return {
     getState: () => state,
     composer: () => composerClient.methods,
     suggestions: () => suggestionsClient.methods,
+    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 appendMessage: AppendMessage =
         typeof message === "string"
@@ -1113,7 +1173,10 @@ const useExternalThread = ({
             }
           : {
               createdAt: message.createdAt ?? new Date(),
-              parentId: message.parentId ?? messages.at(-1)?.id ?? null,
+              parentId:
+                message.parentId === undefined
+                  ? (messages.at(-1)?.id ?? null)
+                  : message.parentId,
               sourceId: message.sourceId ?? null,
               role: message.role ?? "user",
               content: message.content,

package/src/store/clients/model-context-client.ts

@@ -3,6 +3,7 @@ import { resource } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import { CompositeContextProvider } from "../../utils/composite-context-provider";
 import type { ModelContextState } from "../scopes/model-context";
+import { shallowEqual } from "@assistant-ui/store/internal";
 
 const EMPTY_TOOL_NAMES: readonly string[] = [];
 
@@ -12,7 +13,7 @@ const INITIAL_STATE: ModelContextState = {
 };
 
 const toolNamesEqual = (a: readonly string[], b: readonly string[]): boolean =>
-  a === b || (a.length === b.length && a.every((v, i) => v === b[i]));
+  a === b || shallowEqual(a, b);
 
 const deriveState = (
   composite: CompositeContextProvider,
@@ -36,6 +37,9 @@ const useModelContext = (): ClientOutput<"modelContext"> => {
   );
 
   useEffect(() => {
+    // The composite is an external store; this catches the snapshot up for
+    // providers registered between render and subscribe.
+    // eslint-disable-next-line react-hooks/set-state-in-effect
     setState((prev) => deriveState(composite, prev));
     return composite.subscribe(() => {
       setState((prev) => deriveState(composite, prev));

package/src/store/clients/single-thread-list.ts

@@ -59,6 +59,7 @@ const useSingleThreadList = ({
       mainThreadId: THREAD_ID,
       newThreadId: null,
       isLoading: false,
+      loadError: undefined,
       isLoadingMore: false,
       hasMore: false,
       threadIds: [THREAD_ID],

package/src/store/clients/suggestions.test.ts

@@ -151,6 +151,46 @@ describe("ThreadSuggestions", () => {
     }
   });
 
+  it("drops sparse holes before the per-suggestion lookup", () => {
+    let setSuggestions!: (suggestions: ThreadSuggestion[]) => void;
+    const root = createTapRoot(function ThreadSuggestionsRoot() {
+      const [suggestions, setValue] = useState<ThreadSuggestion[]>([
+        { prompt: "Prompt A" },
+        { prompt: "Prompt B" },
+      ]);
+      setSuggestions = setValue;
+      return useResource(ThreadSuggestions(suggestions));
+    });
+
+    try {
+      const sparse: ThreadSuggestion[] = new Array(2);
+      sparse[1] = { prompt: "Prompt B" };
+      flushTapSync(() => setSuggestions(sparse));
+
+      const state = root.getValue().getState();
+      const expected = { title: "Prompt B", label: "", prompt: "Prompt B" };
+      expect(state.suggestions).toEqual([expected]);
+      expect(Object.keys(state.suggestions)).toEqual(["0"]);
+      const firstSuggestion = root
+        .getValue()
+        .suggestion({ index: 0 })
+        .getState();
+      expect(firstSuggestion).toEqual(expected);
+
+      // An equivalent sparse update keeps both identities stable.
+      const sparseAgain: ThreadSuggestion[] = new Array(2);
+      sparseAgain[1] = { prompt: "Prompt B" };
+      flushTapSync(() => setSuggestions(sparseAgain));
+
+      expect(root.getValue().getState()).toBe(state);
+      expect(root.getValue().suggestion({ index: 0 }).getState()).toBe(
+        firstSuggestion,
+      );
+    } finally {
+      root.unmount();
+    }
+  });
+
   it("reuses unchanged suggestion state when one entry changes", () => {
     let setSuggestions!: (suggestions: ThreadSuggestion[]) => void;
     const root = createTapRoot(function ThreadSuggestionsRoot() {

package/src/store/clients/suggestions.ts

@@ -17,18 +17,21 @@ const useStableSuggestionsState = (
   const cell = useMemo(() => ({}) as { state?: SuggestionsState }, []);
   const previous = cell.state;
 
-  const suggestions = next.suggestions.map((suggestion, index) => {
-    const previousSuggestion = previous?.suggestions[index];
-    return previousSuggestion && shallowEqual(previousSuggestion, suggestion)
-      ? previousSuggestion
-      : suggestion;
+  // forEach skips array holes, so a sparse caller array normalizes to a dense
+  // list here, before the per-suggestion resource lookup indexes every slot.
+  const suggestions: SuggestionState[] = [];
+  next.suggestions.forEach((suggestion) => {
+    // Probed at the compacted destination index, not the sparse source index,
+    // so an equivalent hole-containing update keeps reusing prior identities.
+    const previousSuggestion = previous?.suggestions[suggestions.length];
+    suggestions.push(
+      previousSuggestion && shallowEqual(previousSuggestion, suggestion)
+        ? previousSuggestion
+        : suggestion,
+    );
   });
   const state =
-    previous &&
-    previous.suggestions.length === suggestions.length &&
-    suggestions.every(
-      (suggestion, index) => suggestion === previous.suggestions[index],
-    )
+    previous && shallowEqual(suggestions, previous.suggestions)
       ? previous
       : { suggestions };
 

package/src/store/clients/thread-tasks.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, it } from "vitest";
+import type { ThreadMessage, ToolCallMessagePart } from "../../types/message";
+import { createTaskDeriver, getTaskKey } from "./thread-tasks";
+
+const assistantMessage = (
+  id: string,
+  status:
+    | { type: "running" }
+    | { type: "complete"; reason: "stop" }
+    | { type: "incomplete"; reason: "error"; error: unknown },
+  content:
+    | readonly ToolCallMessagePart[]
+    | readonly { type: "text"; text: string }[],
+) =>
+  ({
+    id,
+    role: "assistant",
+    createdAt: new Date(0),
+    content,
+    status,
+    metadata: {
+      unstable_state: {},
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {},
+    },
+  }) as unknown as ThreadMessage;
+
+const toolCall = (
+  id: string,
+  messages?: readonly ThreadMessage[],
+  result?: unknown,
+) =>
+  ({
+    type: "tool-call",
+    toolCallId: id,
+    toolName: "delegate",
+    args: { id },
+    argsText: JSON.stringify({ id }),
+    ...(messages !== undefined ? { messages } : undefined),
+    ...(result !== undefined ? { result } : undefined),
+  }) as ToolCallMessagePart;
+
+describe("createTaskDeriver", () => {
+  it("derives top-level and nested tasks in document order", () => {
+    const nestedTask = toolCall("nested-1", []);
+    const nestedMessage = assistantMessage(
+      "nested-message",
+      { type: "running" },
+      [nestedTask],
+    );
+    const topLevelTask = toolCall("top-level-1", [nestedMessage]);
+    const tasks = createTaskDeriver()([
+      assistantMessage("outer-message", { type: "running" }, [topLevelTask]),
+    ]);
+
+    expect(tasks.map((task) => task.id)).toEqual(["top-level-1", "nested-1"]);
+    expect(tasks[0]).toMatchObject({
+      depth: 0,
+      parentTaskId: null,
+      messageId: "outer-message",
+    });
+    expect(tasks[1]).toMatchObject({
+      depth: 1,
+      parentTaskId: "top-level-1",
+      messageId: "nested-message",
+    });
+  });
+
+  it("uses normalized tool call statuses", () => {
+    const tasks = createTaskDeriver()([
+      assistantMessage("outer-message", { type: "running" }, [
+        toolCall("pending", []),
+        toolCall("complete", [], "done"),
+      ]),
+    ]);
+
+    expect(tasks.map((task) => task.status)).toEqual([
+      { type: "running" },
+      { type: "complete" },
+    ]);
+  });
+
+  it("excludes tool calls without nested messages", () => {
+    const tasks = createTaskDeriver()([
+      assistantMessage("outer-message", { type: "running" }, [
+        toolCall("not-a-task"),
+        toolCall("task", []),
+      ]),
+    ]);
+
+    expect(tasks.map((task) => task.id)).toEqual(["task"]);
+  });
+
+  it("preserves the array identity when an unrelated sibling changes", () => {
+    const task = toolCall("delegate-1", []);
+    const derive = createTaskDeriver();
+    const initial = derive([
+      assistantMessage("outer-message", { type: "running" }, [
+        { type: "text", text: "one" },
+        task,
+      ] as unknown as readonly ToolCallMessagePart[]),
+    ]);
+    const updated = derive([
+      assistantMessage("outer-message", { type: "running" }, [
+        { type: "text", text: "two" },
+        task,
+      ] as unknown as readonly ToolCallMessagePart[]),
+    ]);
+
+    expect(updated).toBe(initial);
+  });
+
+  it("creates a fresh entry and array when a nested status changes", () => {
+    const nestedTask = toolCall("nested-1", []);
+    const derive = createTaskDeriver();
+    const initial = derive([
+      assistantMessage("outer-message", { type: "running" }, [
+        toolCall("top-level-1", [
+          assistantMessage("nested-message", { type: "running" }, [nestedTask]),
+        ]),
+      ]),
+    ]);
+    const updated = derive([
+      assistantMessage("outer-message", { type: "running" }, [
+        toolCall("top-level-1", [
+          assistantMessage(
+            "nested-message",
+            { type: "complete", reason: "stop" },
+            [nestedTask],
+          ),
+        ]),
+      ]),
+    ]);
+
+    expect(updated).not.toBe(initial);
+    expect(updated[1]).not.toBe(initial[1]);
+    expect(updated[1]?.status).toMatchObject({ type: "complete" });
+  });
+
+  it("creates a fresh entry when an incomplete status changes its error", () => {
+    const task = toolCall("failing", []);
+    const derive = createTaskDeriver();
+    const initial = derive([
+      assistantMessage(
+        "outer-message",
+        { type: "incomplete", reason: "error", error: "first" },
+        [task],
+      ),
+    ]);
+    const updated = derive([
+      assistantMessage(
+        "outer-message",
+        { type: "incomplete", reason: "error", error: "second" },
+        [task],
+      ),
+    ]);
+
+    expect(updated).not.toBe(initial);
+    expect(updated[0]).not.toBe(initial[0]);
+    expect(updated[0]?.status).toMatchObject({
+      type: "incomplete",
+      reason: "error",
+      error: "second",
+    });
+  });
+
+  it("rebuilds an entry when an unchanged part moves to another message", () => {
+    const part = toolCall("moving", []);
+    const derive = createTaskDeriver();
+    const initial = derive([
+      assistantMessage("first-message", { type: "running" }, [part]),
+    ]);
+    const moved = derive([
+      assistantMessage("second-message", { type: "running" }, [part]),
+    ]);
+
+    expect(moved[0]).not.toBe(initial[0]);
+    expect(moved[0]?.messageId).toBe("second-message");
+  });
+
+  it("stops descending past the depth cap", () => {
+    let content: readonly ToolCallMessagePart[] = [toolCall("leaf", [])];
+    for (let level = 40; level > 0; level -= 1) {
+      content = [
+        toolCall(`level-${level}`, [
+          assistantMessage(`message-${level}`, { type: "running" }, content),
+        ]),
+      ];
+    }
+    const tasks = createTaskDeriver()([
+      assistantMessage("root", { type: "running" }, content),
+    ]);
+
+    expect(Math.max(...tasks.map((task) => task.depth))).toBe(32);
+  });
+
+  it("keeps the array identity when nested conversations repeat a toolCallId", () => {
+    const nested = (messageId: string) =>
+      assistantMessage(messageId, { type: "complete", reason: "stop" }, [
+        toolCall("call_1", [], "ok"),
+      ]);
+    const messages = [
+      assistantMessage("outer-message", { type: "complete", reason: "stop" }, [
+        toolCall("delegate-a", [nested("nested-a")], "ok"),
+        toolCall("delegate-b", [nested("nested-b")], "ok"),
+      ]),
+    ];
+    const derive = createTaskDeriver();
+    const first = derive(messages);
+    const second = derive(messages);
+
+    expect(first.map((task) => task.id)).toEqual([
+      "delegate-a",
+      "call_1",
+      "delegate-b",
+      "call_1",
+    ]);
+    expect(second).toBe(first);
+  });
+
+  it("keys tasks by document order when nested payloads repeat every id", () => {
+    const replay = () =>
+      assistantMessage("nested", { type: "complete", reason: "stop" }, [
+        toolCall("call_1", [], "ok"),
+      ]);
+    const messages = [
+      assistantMessage("outer-message", { type: "complete", reason: "stop" }, [
+        toolCall("delegate-a", [replay()], "ok"),
+        toolCall("delegate-b", [replay()], "ok"),
+      ]),
+    ];
+    const derive = createTaskDeriver();
+    const first = derive(messages);
+
+    expect(new Set(first.map(getTaskKey)).size).toBe(4);
+    expect(derive(messages)).toBe(first);
+  });
+
+  it("reads a nested message without a status as complete", () => {
+    const unnormalized = {
+      ...assistantMessage("nested", { type: "running" }, [
+        toolCall("call_1", []),
+      ]),
+      status: undefined,
+    } as unknown as ThreadMessage;
+    const [, nestedTask] = createTaskDeriver()([
+      assistantMessage("outer-message", { type: "running" }, [
+        toolCall("delegate", [unnormalized], "ok"),
+      ]),
+    ]);
+
+    expect(nestedTask?.status).toEqual({ type: "complete" });
+  });
+
+  it("preserves unchanged entries when a task is appended", () => {
+    const first = toolCall("first", []);
+    const derive = createTaskDeriver();
+    const initial = derive([
+      assistantMessage("outer-message", { type: "running" }, [first]),
+    ]);
+    const updated = derive([
+      assistantMessage("outer-message", { type: "running" }, [
+        first,
+        toolCall("second", []),
+      ]),
+    ]);
+
+    expect(updated).not.toBe(initial);
+    expect(updated[0]).toBe(initial[0]);
+    expect(updated.map((task) => task.id)).toEqual(["first", "second"]);
+  });
+});

package/src/store/clients/thread-tasks.ts

@@ -0,0 +1,138 @@
+import { resource } from "@assistant-ui/tap";
+import type { ClientOutput } from "@assistant-ui/store";
+import type {
+  ThreadMessage,
+  ToolCallMessagePart,
+  ToolCallMessagePartStatus,
+} from "../../types/message";
+import {
+  COMPLETE_STATUS,
+  toMessagePartStatus,
+} from "../../utils/normalizePartStatus";
+import type { TaskState } from "../scopes/task";
+
+type TaskEntry = {
+  readonly task: TaskState;
+  readonly part: ToolCallMessagePart;
+  readonly statusType: ToolCallMessagePartStatus["type"];
+  readonly statusReason: string | undefined;
+  readonly statusError: unknown;
+  readonly messages: readonly ThreadMessage[];
+};
+
+const getStatusReason = (status: ToolCallMessagePartStatus) =>
+  "reason" in status ? status.reason : undefined;
+
+const getStatusError = (status: ToolCallMessagePartStatus) =>
+  "error" in status ? status.error : undefined;
+
+const MAX_TASK_DEPTH = 32;
+
+const taskKeys = new WeakMap<TaskState, string>();
+
+/** Lookup key for a task client: its document-order index path, unique by construction where ids from nested payloads are not. */
+export const getTaskKey = (task: TaskState) => taskKeys.get(task) ?? task.id;
+
+const resolveStatus = (
+  message: ThreadMessage,
+  partIndex: number,
+  part: ToolCallMessagePart,
+): ToolCallMessagePartStatus =>
+  "status" in message && message.status
+    ? toMessagePartStatus(message, partIndex, part)
+    : COMPLETE_STATUS;
+
+export const createTaskDeriver = () => {
+  let previous: readonly TaskState[] = [];
+  let previousEntries = new Map<string, TaskEntry>();
+
+  return (messages: readonly ThreadMessage[]): readonly TaskState[] => {
+    const tasks: TaskState[] = [];
+    const entries = new Map<string, TaskEntry>();
+    let allEntriesReused = true;
+
+    const visit = (
+      threadMessages: readonly ThreadMessage[],
+      parentTaskId: string | null,
+      depth: number,
+      path: string,
+    ) => {
+      if (depth > MAX_TASK_DEPTH) return;
+      for (const [messageIndex, message] of threadMessages.entries()) {
+        for (const [partIndex, part] of message.content.entries()) {
+          if (part.type !== "tool-call" || part.messages === undefined)
+            continue;
+
+          const nestedMessages = part.messages;
+          const status = resolveStatus(message, partIndex, part);
+          const statusReason = getStatusReason(status);
+          const statusError = getStatusError(status);
+          const entryKey = `${path}${messageIndex}.${partIndex}`;
+          const previousEntry = previousEntries.get(entryKey);
+          const task =
+            previousEntry?.part === part &&
+            previousEntry.statusType === status.type &&
+            previousEntry.statusReason === statusReason &&
+            Object.is(previousEntry.statusError, statusError) &&
+            previousEntry.messages === nestedMessages &&
+            previousEntry.task.messageId === message.id &&
+            previousEntry.task.parentTaskId === parentTaskId &&
+            previousEntry.task.depth === depth
+              ? previousEntry.task
+              : {
+                  id: part.toolCallId,
+                  toolName: part.toolName,
+                  args: part.args,
+                  result: part.result,
+                  ...(part.isError === undefined
+                    ? undefined
+                    : { isError: part.isError }),
+                  status,
+                  timing: part.timing,
+                  messageId: message.id,
+                  parentTaskId,
+                  depth,
+                  messages: nestedMessages,
+                };
+
+          if (task !== previousEntry?.task) {
+            allEntriesReused = false;
+            taskKeys.set(task, entryKey);
+          }
+          tasks.push(task);
+          entries.set(entryKey, {
+            task,
+            part,
+            statusType: status.type,
+            statusReason,
+            statusError,
+            messages: nestedMessages,
+          });
+          visit(nestedMessages, task.id, depth + 1, `${entryKey}.`);
+        }
+      }
+    };
+
+    visit(messages, null, 0, "");
+
+    const result =
+      allEntriesReused &&
+      tasks.length === previous.length &&
+      tasks.every((task, index) => task === previous[index])
+        ? previous
+        : tasks;
+    previous = result;
+    previousEntries = entries;
+    return result;
+  };
+};
+
+const useTaskClient = ({
+  task,
+}: {
+  task: TaskState;
+}): ClientOutput<"task"> => ({
+  getState: () => task,
+});
+
+export const TaskClient = resource(useTaskClient);

package/src/store/index.ts

@@ -48,6 +48,12 @@ export type {
   QueueItemMeta,
   QueueItemClientSchema,
 } from "./scopes/queue-item";
+export type {
+  TaskState,
+  TaskMethods,
+  TaskMeta,
+  TaskClientSchema,
+} from "./scopes/task";
 export type {
   AttachmentState,
   AttachmentMethods,
@@ -96,6 +102,8 @@ export {
 export {
   useExternalMessageConverter,
   convertExternalMessages,
+  createExternalMessageConversionCache,
+  type ExternalMessageConversionCache,
   type JoinStrategy,
 } from "../react/runtimes/external-message-converter";
 export {