@assistant-ui/core 0.2.7 → 0.2.8

package/src/react/utils/groupParts.ts

@@ -1,5 +1,17 @@
 import { isMcpAppUri } from "../../types/message";
 import type { PartState } from "../../store/scopes/part";
+import type { ToolsState } from "../types/scopes/tools";
+
+/**
+ * Registry context passed to a `groupBy` function as its second argument by
+ * `<MessagePrimitive.GroupedParts>`. Carries the live tool-UI registry so a
+ * `groupBy` can resolve registry-driven grouping (e.g. standalone tool calls)
+ * without the part itself having to carry that information.
+ */
+export type GroupByContext = {
+  /** Tool UIs registered in the tool-UI registry, keyed by tool name. */
+  readonly toolUIs?: ToolsState["toolUIs"];
+};
 
 /**
  * Hierarchical adjacent-coalescing grouping for message parts.
@@ -25,12 +37,20 @@ export const GROUPBY_MEMO_KEY: unique symbol = Symbol.for(
 );
 
 /**
- * Synthetic part-type key recognized by {@link groupPartByType}: a
- * tool-call whose `mcp.app.resourceUri` points at an assistant-ui MCP
- * app. Map this key to control how MCP-app tool calls are grouped —
- * separately from regular `"tool-call"` parts.
+ * Synthetic part-type keys recognized by {@link groupPartByType}, in
+ * addition to real {@link PartState} types:
+ *
+ * - `"standalone-tool-call"` — a tool-call whose UI should be presented on its
+ *   own, outside the chain-of-thought grouping. Matches MCP-app tool calls plus
+ *   any tool-call whose registered UI opts into standalone display (human
+ *   tools, the built-in generative-UI tool, and tools that set
+ *   `display: "standalone"`). Resolving the registry-driven cases reads the
+ *   {@link GroupByContext} passed to the `groupBy` function. Takes precedence
+ *   over the `"tool-call"` entry.
+ * - `"mcp-app"` — **deprecated**, kept for back-compat. Matches only MCP-app
+ *   tool calls. Prefer `"standalone-tool-call"`, which is a superset.
  */
-type GroupPartType = PartState["type"] | "mcp-app";
+type GroupPartType = PartState["type"] | "standalone-tool-call" | "mcp-app";
 
 /**
  * Build a `groupBy` from a `part.type → group-key path` lookup.
@@ -38,9 +58,12 @@ type GroupPartType = PartState["type"] | "mcp-app";
  * function carries a stable {@link GROUPBY_MEMO_KEY} fingerprint so
  * `<MessagePrimitive.GroupedParts>` can memoize its tree across renders.
  *
- * Special key `"mcp-app"` matches tool-call parts that point at an
- * assistant-ui MCP app resource (`ui://...`) and takes precedence over
- * the `"tool-call"` entry for those parts.
+ * The synthetic `"standalone-tool-call"` key matches tool calls that should
+ * render outside the chain-of-thought grouping. MCP-app calls are detected from
+ * the part alone; the registry-driven cases (human tools, the generative-UI
+ * tool, `display: "standalone"` opt-ins) are resolved from the
+ * {@link GroupByContext} that `<MessagePrimitive.GroupedParts>` passes to the
+ * `groupBy` function — the helper needs nothing threaded into it.
  *
  * @example
  * ```tsx
@@ -48,7 +71,7 @@ type GroupPartType = PartState["type"] | "mcp-app";
  *   groupBy={groupPartByType({
  *     reasoning: ["group-thought", "group-reasoning"],
  *     "tool-call": ["group-thought", "group-tool"],
- *     "mcp-app": [],
+ *     "standalone-tool-call": [],
  *   })}
  * >
  *   {({ part, children }) => { ... }}
@@ -57,18 +80,26 @@ type GroupPartType = PartState["type"] | "mcp-app";
  */
 export const groupPartByType = <TKey extends `group-${string}`>(
   map: Partial<Readonly<Record<GroupPartType, readonly TKey[]>>>,
-): ((part: PartState) => readonly TKey[]) => {
+): ((part: PartState, context?: GroupByContext) => readonly TKey[]) => {
   const lookup = map as Readonly<Record<string, readonly TKey[] | undefined>>;
-  const fn = ((part) => {
-    if (
-      part.type === "tool-call" &&
-      lookup["mcp-app"] !== undefined &&
-      isMcpAppUri(part.mcp?.app?.resourceUri)
-    ) {
-      return lookup["mcp-app"]!;
+  const fn = ((part, context) => {
+    if (part.type === "tool-call") {
+      const isMcpApp = isMcpAppUri(part.mcp?.app?.resourceUri);
+      // Read the first registration's flag — the same one `resolveToolRender`
+      // renders — so grouping and rendering never disagree for a tool name.
+      const isStandalone =
+        isMcpApp ||
+        (context?.toolUIs?.[part.toolName]?.[0]?.standalone ?? false);
+      if (isStandalone && lookup["standalone-tool-call"] !== undefined) {
+        return lookup["standalone-tool-call"]!;
+      }
+      // TODO(v0.15): drop the deprecated "mcp-app" key (superseded by "standalone-tool-call").
+      if (isMcpApp && lookup["mcp-app"] !== undefined) {
+        return lookup["mcp-app"]!;
+      }
     }
     return lookup[part.type] ?? [];
-  }) as ((part: PartState) => readonly TKey[]) & {
+  }) as ((part: PartState, context?: GroupByContext) => readonly TKey[]) & {
     [GROUPBY_MEMO_KEY]?: string;
   };
   // Sort keys so the fingerprint is insensitive to map insertion order —

package/src/runtime/utils/message-repository.ts

@@ -1,6 +1,6 @@
 import type { ThreadMessage } from "../../types/message";
 import type { RunConfig } from "../../types/message";
-import { generateId, generateOptimisticId } from "../../utils/id";
+import { generateId } from "../../utils/id";
 import type { ThreadMessageLike } from "./thread-message-like";
 import { getAutoStatus } from "./auto-status";
 import { fromThreadMessageLike } from "./thread-message-like";
@@ -259,20 +259,6 @@ export class MessageRepository {
     };
   }
 
-  appendOptimisticMessage(parentId: string | null, message: ThreadMessageLike) {
-    let optimisticId: string;
-    do {
-      optimisticId = generateOptimisticId();
-    } while (this.messages.has(optimisticId));
-
-    this.addOrUpdateMessage(
-      parentId,
-      fromThreadMessageLike(message, optimisticId, { type: "running" }),
-    );
-
-    return optimisticId;
-  }
-
   deleteMessage(messageId: string, replacementId?: string | null | undefined) {
     const message = this.messages.get(messageId);
 
@@ -322,6 +308,45 @@ export class MessageRepository {
     return children;
   }
 
+  /**
+   * Evicts optimistic messages (`metadata.isOptimistic`) the head just moved
+   * away from. Since eviction runs on every head move, the only optimistic
+   * messages in the repository live on the branch the head previously pointed
+   * at — so we walk just that branch rather than the whole repository. Keeps a
+   * client→server id swap from leaving a phantom sibling, and drops off-branch
+   * placeholders.
+   */
+  private evictOffBranchOptimisticMessages(
+    previousHead: RepositoryMessage | null,
+    currentHead: RepositoryMessage | null,
+  ) {
+    if (!previousHead) return;
+
+    const onHeadBranch = new Set<string>();
+    for (let current = currentHead; current; current = current.prev) {
+      onHeadBranch.add(current.current.id);
+    }
+
+    const stale: string[] = [];
+    for (
+      let current: RepositoryMessage | null = previousHead;
+      current;
+      current = current.prev
+    ) {
+      // Stop at the first node shared with the current head branch: every
+      // ancestor above it is shared too, so nothing further can be off-branch.
+      if (onHeadBranch.has(current.current.id)) break;
+      if (current.current.metadata?.isOptimistic) {
+        stale.push(current.current.id);
+      }
+    }
+
+    for (const id of stale) {
+      // A prior deletion may have already removed this node.
+      if (this.messages.has(id)) this.deleteMessage(id);
+    }
+  }
+
   switchToBranch(messageId: string) {
     const message = this.messages.get(messageId);
     if (!message)
@@ -329,11 +354,14 @@ export class MessageRepository {
         "MessageRepository(switchToBranch): Branch not found. This is likely an internal bug in assistant-ui.",
       );
 
+    const previousHead = this.head;
     const prevOrRoot = message.prev ?? this.root;
     prevOrRoot.next = message;
 
     this.head = findHead(message);
 
+    this.evictOffBranchOptimisticMessages(previousHead, this.head);
+
     this._messages.dirty();
   }
 
@@ -349,6 +377,8 @@ export class MessageRepository {
         "MessageRepository(resetHead): Branch not found. This is likely an internal bug in assistant-ui.",
       );
 
+    const previousHead = this.head;
+
     if (message.children.length > 0) {
       const deleteDescendants = (msg: RepositoryMessage) => {
         for (const childId of msg.children) {
@@ -378,6 +408,8 @@ export class MessageRepository {
       }
     }
 
+    this.evictOffBranchOptimisticMessages(previousHead, this.head);
+
     this._messages.dirty();
   }
 
@@ -394,15 +426,24 @@ export class MessageRepository {
   export(): ExportedMessageRepository {
     const exportItems: ExportedMessageRepository["messages"] = [];
 
+    // Optimistic messages are ephemeral and never persisted. They're always
+    // leaf nodes, so skipping them can't orphan a persisted child.
     for (const [, message] of this.messages) {
+      if (message.current.metadata?.isOptimistic) continue;
       exportItems.push({
         message: message.current,
         parentId: message.prev?.current.id ?? null,
       });
     }
 
+    // The head may itself be optimistic; walk up to the nearest persisted ancestor.
+    let head = this.head;
+    while (head?.current.metadata?.isOptimistic) {
+      head = head.prev;
+    }
+
     return {
-      headId: this.head?.current.id ?? null,
+      headId: head?.current.id ?? null,
       messages: exportItems,
     };
   }

package/src/runtime/utils/thread-message-like.ts

@@ -81,6 +81,7 @@ export type ThreadMessageLike = {
         readonly steps?: readonly ThreadStep[] | undefined;
         readonly timing?: MessageTiming | undefined;
         readonly submittedFeedback?: { readonly type: "positive" | "negative" };
+        readonly isOptimistic?: boolean | undefined;
         readonly custom?: Record<string, unknown> | undefined;
       }
     | undefined;
@@ -210,6 +211,7 @@ export const fromThreadMessageLike = (
           ...(metadata?.submittedFeedback && {
             submittedFeedback: metadata.submittedFeedback,
           }),
+          ...(metadata?.isOptimistic && { isOptimistic: true }),
         },
       } satisfies ThreadAssistantMessage;
 

package/src/runtimes/external-store/external-store-shared-options.ts

@@ -0,0 +1,18 @@
+import type { ExternalStoreAdapter } from "./external-store-adapter";
+
+export type ExternalStoreSharedOptions = Pick<
+  ExternalStoreAdapter,
+  "isDisabled" | "isSendDisabled" | "unstable_capabilities" | "suggestions"
+>;
+
+export const pickExternalStoreSharedOptions = (
+  options: ExternalStoreSharedOptions,
+): ExternalStoreSharedOptions =>
+  ({
+    isDisabled: options.isDisabled,
+    isSendDisabled: options.isSendDisabled,
+    unstable_capabilities: options.unstable_capabilities,
+    suggestions: options.suggestions,
+  }) satisfies {
+    [K in keyof Required<ExternalStoreSharedOptions>]: ExternalStoreSharedOptions[K];
+  };

package/src/runtimes/external-store/external-store-thread-runtime-core.ts

@@ -30,6 +30,7 @@ import {
   ExportedMessageRepository,
   MessageRepository,
 } from "../../runtime/utils/message-repository";
+import { generateId } from "../../utils/id";
 import { ToolInvocationTracker } from "../tool-invocations/ToolInvocationTracker";
 
 const EMPTY_ARRAY: readonly ThreadSuggestion[] = Object.freeze([]);
@@ -54,9 +55,6 @@ export class ExternalStoreThreadRuntimeCore
   extends BaseThreadRuntimeCore
   implements ThreadRuntimeCore
 {
-  private _assistantOptimisticId: string | null = null;
-  private _lastSyncedMessageIds = new Set<string>();
-
   private _capabilities: RuntimeCapabilities = {
     switchToBranch: false,
     switchBranchDuringRun: false,
@@ -176,10 +174,7 @@ export class ExternalStoreThreadRuntimeCore
         return;
       }
 
-      // Clear and import the message repository
       this.repository.clear();
-      this._assistantOptimisticId = null;
-      this._lastSyncedMessageIds = new Set();
       this.repository.import(store.messageRepository);
 
       messages = this.repository.getMessages();
@@ -232,12 +227,6 @@ export class ExternalStoreThreadRuntimeCore
             return newMessage;
           });
 
-      const nextIds = new Set(messages.map((m) => m.id));
-      for (const prevId of this._lastSyncedMessageIds) {
-        if (!nextIds.has(prevId)) this.repository.deleteMessage(prevId);
-      }
-      this._lastSyncedMessageIds = nextIds;
-
       for (let i = 0; i < messages.length; i++) {
         const message = messages[i]!;
         const parent = messages[i - 1];
@@ -260,24 +249,23 @@ export class ExternalStoreThreadRuntimeCore
       }
     }
 
-    if (this._assistantOptimisticId) {
-      this.repository.deleteMessage(this._assistantOptimisticId);
-      this._assistantOptimisticId = null;
-    }
-
+    // Append an optimistic placeholder while running but before a trailing
+    // assistant message exists. resetHead evicts off-branch optimistic messages
+    // (prior placeholders, mid-run id-swap siblings); export() never persists them.
+    let optimisticId: string | null = null;
     if (hasUpcomingMessage(isRunning, messages)) {
-      this._assistantOptimisticId = this.repository.appendOptimisticMessage(
+      optimisticId = generateId();
+      this.repository.addOrUpdateMessage(
         messages.at(-1)?.id ?? null,
-        {
-          role: "assistant",
-          content: [],
-        },
+        fromThreadMessageLike(
+          { role: "assistant", content: [], metadata: { isOptimistic: true } },
+          optimisticId,
+          { type: "running" },
+        ),
       );
     }
 
-    this.repository.resetHead(
-      this._assistantOptimisticId ?? messages.at(-1)?.id ?? null,
-    );
+    this.repository.resetHead(optimisticId ?? messages.at(-1)?.id ?? null);
 
     this._messages = this.repository.getMessages();
 
@@ -476,9 +464,11 @@ export class ExternalStoreThreadRuntimeCore
 
     this._store.onCancel();
 
-    if (this._assistantOptimisticId) {
-      this.repository.deleteMessage(this._assistantOptimisticId);
-      this._assistantOptimisticId = null;
+    // Drop an empty optimistic head (placeholder or pre-stream message); a
+    // partially-streamed one is kept and re-supplied by the store on resync.
+    const head = this.repository.getMessages().at(-1);
+    if (head && head.metadata.isOptimistic && head.content.length === 0) {
+      this.repository.deleteMessage(head.id);
     }
 
     let messages = this.repository.getMessages();
@@ -488,7 +478,6 @@ export class ExternalStoreThreadRuntimeCore
       previousMessage.id === messages.at(-1)?.id // ensure the previous message is a leaf node
     ) {
       this.repository.deleteMessage(previousMessage.id);
-      this._lastSyncedMessageIds.delete(previousMessage.id);
       if (!this.composer.text.trim()) {
         this.composer.setText(getThreadMessageText(previousMessage));
       }
@@ -537,16 +526,12 @@ export class ExternalStoreThreadRuntimeCore
   }
 
   public override reset(initialMessages?: readonly ThreadMessageLike[]) {
-    this._lastSyncedMessageIds = new Set();
     const repo = new MessageRepository();
     repo.import(ExportedMessageRepository.fromArray(initialMessages ?? []));
     this.updateMessages(repo.getMessages());
   }
 
   public override import(data: ExportedMessageRepository) {
-    this._assistantOptimisticId = null;
-    this._lastSyncedMessageIds = new Set();
-
     super.import(data);
 
     if (this._store.onImport) {

package/src/runtimes/tool-invocations/ToolInvocationTracker.ts

@@ -446,7 +446,6 @@ export class ToolInvocationTracker {
 
     if (this._executing.size === 0) {
       const resolvers = this._settledResolvers.splice(0);
-      // biome-ignore lint/suspicious/useIterableCallbackReturn: forEach callback intentionally has no return
       resolvers.forEach((resolve) => {
         try {
           resolve();

package/src/tests/MessageRepository.test.ts

@@ -7,20 +7,14 @@ import type { ThreadMessage } from "../types/message";
 import type { TextMessagePart } from "../types/message";
 import type { ThreadMessageLike } from "../runtime/utils/thread-message-like";
 
-// Mock generateId and generateOptimisticId to make tests deterministic
+// Mock generateId to make tests deterministic
 const mockGenerateId = vi.fn();
-const mockGenerateOptimisticId = vi.fn();
-const mockIsOptimisticId = vi.fn((id: string) =>
-  id.startsWith("__optimistic__"),
-);
 
 vi.mock("../utils/id", async (importOriginal) => {
   const original = await importOriginal<typeof import("../utils/id")>();
   return {
     ...original,
     generateId: () => mockGenerateId(),
-    generateOptimisticId: () => mockGenerateOptimisticId(),
-    isOptimisticId: (id: string) => mockIsOptimisticId(id),
   };
 });
 
@@ -58,23 +52,11 @@ describe("MessageRepository", () => {
     ...overrides,
   });
 
-  /**
-   * Creates a test CoreMessage with the given overrides.
-   */
-  const createThreadMessageLike = (overrides = {}): ThreadMessageLike => ({
-    role: "assistant",
-    content: [{ type: "text", text: "Test message" }],
-    ...overrides,
-  });
-
   beforeEach(() => {
     repository = new MessageRepository();
     // Reset mocks with predictable counter-based values
     nextMockId = 1;
     mockGenerateId.mockImplementation(() => `mock-id-${nextMockId++}`);
-    mockGenerateOptimisticId.mockImplementation(
-      () => `__optimistic__mock-id-${nextMockId++}`,
-    );
   });
 
   afterEach(() => {
@@ -297,53 +279,102 @@ describe("MessageRepository", () => {
   });
 
   describe("Optimistic messages", () => {
-    it("should create an optimistic message with a unique ID", () => {
-      mockGenerateOptimisticId.mockReturnValue("__optimistic__generated-id");
+    const optimistic = (overrides = {}) =>
+      createTestMessage({
+        status: { type: "running" },
+        metadata: {
+          unstable_state: null,
+          unstable_annotations: [],
+          unstable_data: [],
+          steps: [],
+          custom: {},
+          isOptimistic: true,
+        },
+        ...overrides,
+      });
 
-      const coreMessage = createThreadMessageLike();
-      const optimisticId = repository.appendOptimisticMessage(
-        null,
-        coreMessage,
-      );
+    it("excludes optimistic messages from export()", () => {
+      const parent = createTestMessage({ id: "u" });
+      repository.addOrUpdateMessage(null, parent);
+      repository.addOrUpdateMessage("u", optimistic({ id: "placeholder" }));
+      repository.resetHead("placeholder");
 
-      expect(optimisticId).toBe("__optimistic__generated-id");
-      expect(repository.getMessage(optimisticId).message.status?.type).toBe(
-        "running",
-      );
+      const exported = repository.export();
+
+      expect(exported.messages.map((m) => m.message.id)).toEqual(["u"]);
+      // head was the optimistic placeholder; the exported head must fall back
+      // to the nearest persisted ancestor so it always resolves on import.
+      expect(exported.headId).toBe("u");
     });
 
-    it("should create an optimistic message as a child of a specified parent", () => {
-      const parent = createTestMessage({ id: "parent-id" });
+    it("round-trips through export/import without resurrecting the placeholder", () => {
+      const parent = createTestMessage({ id: "u" });
+      const real = createTestMessage({ id: "a" });
       repository.addOrUpdateMessage(null, parent);
+      repository.addOrUpdateMessage("u", real);
+      repository.resetHead("a");
 
-      const coreMessage = createThreadMessageLike();
-      const optimisticId = repository.appendOptimisticMessage(
-        "parent-id",
-        coreMessage,
-      );
+      const restored = new MessageRepository();
+      restored.import(repository.export());
 
-      const result = repository.getMessage(optimisticId);
-      expect(result.parentId).toBe("parent-id");
+      expect(restored.export().messages.map((m) => m.message.id)).toEqual([
+        "u",
+        "a",
+      ]);
     });
 
-    it("should retry generating unique optimistic IDs if initial one exists", () => {
-      mockGenerateOptimisticId.mockReturnValueOnce("__optimistic__existing-id");
+    describe("HEAD-branch invariant", () => {
+      it("evicts an off-branch optimistic sibling when resetHead moves the head", () => {
+        // u -> { client_id (optimistic), server_id (optimistic) }. When the
+        // head moves to server_id, the dangling client_id sibling is evicted.
+        const parent = createTestMessage({ id: "u" });
+        repository.addOrUpdateMessage(null, parent);
+        repository.addOrUpdateMessage("u", optimistic({ id: "client_id" }));
+        repository.addOrUpdateMessage("u", optimistic({ id: "server_id" }));
+
+        repository.resetHead("server_id");
 
-      const existingMessage = createTestMessage({
-        id: "__optimistic__existing-id",
+        expect(repository.getBranches("server_id")).toEqual(["server_id"]);
+        expect(() => repository.getMessage("client_id")).toThrow();
       });
-      repository.addOrUpdateMessage(null, existingMessage);
 
-      mockGenerateOptimisticId.mockReturnValueOnce("__optimistic__unique-id");
+      it("keeps the optimistic message that is on the head branch", () => {
+        const parent = createTestMessage({ id: "u" });
+        repository.addOrUpdateMessage(null, parent);
+        repository.addOrUpdateMessage("u", optimistic({ id: "a" }));
 
-      const coreMessage = createThreadMessageLike();
-      const optimisticId = repository.appendOptimisticMessage(
-        null,
-        coreMessage,
-      );
+        repository.resetHead("a");
+
+        expect(repository.getMessage("a").message.id).toBe("a");
+      });
 
-      expect(optimisticId).toBe("__optimistic__unique-id");
-      expect(mockGenerateOptimisticId).toHaveBeenCalledTimes(2);
+      it("never evicts real (non-optimistic) sibling branches", () => {
+        const parent = createTestMessage({ id: "u" });
+        repository.addOrUpdateMessage(null, parent);
+        repository.addOrUpdateMessage("u", createTestMessage({ id: "a1" }));
+        repository.addOrUpdateMessage("u", createTestMessage({ id: "a2" }));
+
+        repository.resetHead("a2");
+
+        // a1 is off the head branch but not optimistic, so it survives.
+        expect(repository.getBranches("a2")).toEqual(["a1", "a2"]);
+      });
+
+      it("evicts optimistic messages from the previous branch on switchToBranch", () => {
+        // Two real branches under u; the head branch (a2) carries an optimistic
+        // child. Switching to a1 must drop the optimistic message left on a2.
+        const parent = createTestMessage({ id: "u" });
+        repository.addOrUpdateMessage(null, parent);
+        repository.addOrUpdateMessage("u", createTestMessage({ id: "a1" }));
+        repository.addOrUpdateMessage("u", createTestMessage({ id: "a2" }));
+        repository.addOrUpdateMessage("a2", optimistic({ id: "opt" }));
+        repository.resetHead("opt");
+
+        repository.switchToBranch("a1");
+
+        expect(() => repository.getMessage("opt")).toThrow();
+        expect(repository.getBranches("a1")).toEqual(["a1", "a2"]);
+      });
     });
   });
 

package/src/tests/OptimisticState-list-race.test.ts

@@ -89,7 +89,6 @@ describe("list + delete race condition", () => {
     const listPromise = state.optimisticUpdate({
       execute: () => listDeferred.promise,
       loading: (s) => ({ ...s, isLoading: true }),
-      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -147,7 +146,6 @@ describe("list + delete race condition", () => {
     const listPromise = state.optimisticUpdate({
       execute: () => listDeferred.promise,
       loading: (s) => ({ ...s, isLoading: true }),
-      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -185,7 +183,6 @@ describe("list + delete race condition", () => {
     const listPromise = state.optimisticUpdate({
       execute: () => listDeferred.promise,
       loading: (s) => ({ ...s, isLoading: true }),
-      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -223,7 +220,6 @@ describe("list + delete race condition", () => {
     const listPromise = state.optimisticUpdate({
       execute: () => listDeferred.promise,
       loading: (s) => ({ ...s, isLoading: true }),
-      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });