@assistant-ui/core 0.3.13 → 0.3.15

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

@@ -7,6 +7,7 @@ import {
   unstable_toolResultStream,
   type Tool,
   type ToolModelContentPart,
+  type ToolResultStreamOptions,
 } from "assistant-stream";
 import {
   AssistantMetaTransformStream,
@@ -15,6 +16,8 @@ import {
 import { isJSONValueEqual } from "../../utils/json/is-json-equal";
 import type { ThreadMessage } from "../../types/message";
 
+const TOOL_EXECUTION_ID = Symbol.for("assistant-stream.tool-execution-id");
+
 /**
  * Streaming execution state for a frontend tool.
  */
@@ -39,6 +42,8 @@ type ToolCallEntry = {
   toolName: string;
   argsText: string;
   hasResult: boolean;
+  executionId?: symbol;
+  skipExecute?: boolean;
 } & (
   | {
       /** Restored phase — observed during a history-load snapshot. */
@@ -52,6 +57,11 @@ type ToolCallEntry = {
     }
 );
 
+type SettledResolver = {
+  executionIds: ReadonlySet<symbol>;
+  resolve: () => void;
+};
+
 const isArgsTextComplete = (argsText: string) => {
   try {
     JSON.parse(argsText);
@@ -76,6 +86,11 @@ const isEquivalentCompleteArgsText = (previous: string, next: string) => {
   return isJSONValueEqual(previousValue, nextValue);
 };
 
+const getToolExecutionId = (value: object): symbol | undefined =>
+  (value as Record<PropertyKey, unknown>)[TOOL_EXECUTION_ID] as
+    | symbol
+    | undefined;
+
 /**
  * Plain-class port of the former `useToolInvocations` React hook. Owns the
  * assistant-stream pipeline that drives client-side `streamCall` / `execute`
@@ -103,27 +118,16 @@ export class ToolInvocationTracker {
   private readonly _callbacks: ToolInvocationTracker.Callbacks;
 
   private readonly _entries = new Map<string, ToolCallEntry>();
-  /**
-   * Tool call ids whose `execute` should be short-circuited in the wrapper.
-   * Populated when an entry is created with a result already attached
-   * (history reload, mid-run resume, etc.) — `execute` is suppressed so
-   * client-side side effects don't double-run. Membership outlives the
-   * entry: `reset()` deliberately does *not* clear this so post-abort
-   * cancellation `result` chunks for pre-resolved entries can still be
-   * recognized and dropped. Growth is bounded by the number of pre-resolved
-   * tool calls observed in the session.
-   */
-  private readonly _skipExecuteStreamIds = new Set<string>();
   private readonly _humanInput = new Map<
     string,
     {
+      executionId: symbol;
       resolve: (payload: unknown) => void;
       reject: (reason: unknown) => void;
     }
   >();
-  /** In-flight `execute` invocations keyed by tool call id. */
-  private readonly _executing = new Set<string>();
-  private readonly _settledResolvers: Array<() => void> = [];
+  private readonly _executing = new Set<symbol>();
+  private readonly _settledResolvers: SettledResolver[] = [];
 
   private _statuses = new Map<string, ToolExecutionStatus>();
 
@@ -166,14 +170,21 @@ export class ToolInvocationTracker {
     const [stream, controller] = createAssistantStreamController();
     this._controller = controller;
 
+    const human = (
+      toolCallId: string,
+      payload: unknown,
+      executionId?: symbol,
+    ) => this._onHumanInput(toolCallId, payload, executionId);
     const transform = unstable_toolResultStream(
       () => this._getWrappedTools(),
       () => this._ac.signal,
-      (toolCallId, payload) => this._onHumanInput(toolCallId, payload),
+      human,
       {
-        onExecutionStart: (id) => this._onExecutionStart(id),
-        onExecutionEnd: (id) => this._onExecutionEnd(id),
-      },
+        onExecutionStart: (id: string, _name: string, executionId?: symbol) =>
+          this._onExecutionStart(id, executionId),
+        onExecutionEnd: (id: string, _name: string, executionId?: symbol) =>
+          this._onExecutionEnd(id, executionId),
+      } as ToolResultStreamOptions,
     );
 
     stream
@@ -281,10 +292,16 @@ export class ToolInvocationTracker {
       this._pendingRestore = true;
       this._entries.clear();
       this._lastSnapshot = null;
-      // `_skipExecuteStreamIds` is intentionally not cleared — see field doc.
-      void this.abort().finally(() => {
-        this._executing.clear();
-      });
+      void this.abort();
+      // Statuses are cleared synchronously: discarded executions may never
+      // settle (aborting hands the signal to the tool, it does not force
+      // settlement), and a late settlement of one sibling must not republish
+      // the others. `_deleteStatus` no-ops for cleared ids, so post-reset
+      // settlements stay silent.
+      if (this._statuses.size > 0) {
+        this._statuses = new Map();
+        this._invokeOnStatusesChange();
+      }
     } catch (err) {
       console.error("[ToolInvocationTracker] reset failed", err);
     }
@@ -312,8 +329,9 @@ export class ToolInvocationTracker {
       if (this._executing.size === 0) {
         return Promise.resolve();
       }
+      const executionIds = new Set(this._executing);
       return new Promise<void>((resolve) => {
-        this._settledResolvers.push(resolve);
+        this._settledResolvers.push({ executionIds, resolve });
       });
     } catch (err) {
       console.error("[ToolInvocationTracker] abort failed", err);
@@ -360,34 +378,70 @@ export class ToolInvocationTracker {
     return Object.fromEntries(
       Object.entries(tools).map(([name, tool]) => {
         const execute = tool.execute;
-        if (execute === undefined) return [name, tool];
+        const streamCall = tool.streamCall;
+        if (execute === undefined && streamCall === undefined)
+          return [name, tool];
 
         const wrappedTool = {
           ...tool,
-          execute: (
-            ...[args, context]: Parameters<NonNullable<typeof execute>>
-          ) => {
-            if (this._skipExecuteStreamIds.has(context.toolCallId)) {
-              // Pre-resolved tool call: never invoke the host's execute.
-              // Returning a never-settling Promise keeps the executor's
-              // pending entry alive but enqueues nothing.
-              return new Promise(() => {}) as never;
-            }
-            return execute(args, context);
-          },
+          ...(execute !== undefined && {
+            execute: (...[args, context]: Parameters<typeof execute>) => {
+              const executionId = getToolExecutionId(context);
+              const entry = this._captureExecution(
+                context.toolCallId,
+                executionId,
+              );
+              if (!entry || entry.skipExecute) {
+                return new Promise(() => {}) as never;
+              }
+              return execute(args, context);
+            },
+          }),
+          ...(streamCall !== undefined && {
+            streamCall: (
+              ...[reader, context]: Parameters<typeof streamCall>
+            ) => {
+              const executionId = getToolExecutionId(context);
+              const entry = this._captureExecution(
+                context.toolCallId,
+                executionId,
+              );
+              if (!entry) return;
+              return streamCall(reader, context);
+            },
+          }),
         } as Tool;
         return [name, wrappedTool];
       }),
     ) as Record<string, Tool>;
   }
 
+  private _captureExecution(
+    toolCallId: string,
+    executionId: symbol | undefined,
+  ): ToolCallEntry | undefined {
+    if (executionId === undefined) return undefined;
+    const entry = this._entries.get(toolCallId);
+    if (!entry?.controller) return undefined;
+    if (entry.executionId === undefined) entry.executionId = executionId;
+    return entry.executionId === executionId ? entry : undefined;
+  }
+
   // ──────────────── internal: execution lifecycle callbacks ────────────────
 
   private _onHumanInput(
     toolCallId: string,
     payload: unknown,
+    executionId?: symbol,
   ): Promise<unknown> {
     return new Promise<unknown>((resolve, reject) => {
+      // A discarded execution must not resurrect a status entry or park an
+      // unanswerable request after its id has been reused.
+      const entry = this._entries.get(toolCallId);
+      if (!entry?.controller || entry.executionId !== executionId) {
+        reject(new Error("Tool execution aborted"));
+        return;
+      }
       const previous = this._humanInput.get(toolCallId);
       if (previous) {
         try {
@@ -398,7 +452,11 @@ export class ToolInvocationTracker {
           // host rejection handler threw; ignore and proceed
         }
       }
-      this._humanInput.set(toolCallId, { resolve, reject });
+      this._humanInput.set(toolCallId, {
+        executionId: executionId!,
+        resolve,
+        reject,
+      });
       this._setStatus(toolCallId, {
         type: "interrupt",
         payload: { type: "human", payload },
@@ -406,28 +464,42 @@ export class ToolInvocationTracker {
     });
   }
 
-  private _onExecutionStart(toolCallId: string): void {
-    if (this._skipExecuteStreamIds.has(toolCallId)) return;
+  private _onExecutionStart(
+    toolCallId: string,
+    executionId: symbol | undefined,
+  ): void {
+    if (!this._captureExecution(toolCallId, executionId)) return;
+    const entry = this._entries.get(toolCallId)!;
+    if (entry.skipExecute) return;
 
-    this._executing.add(toolCallId);
+    this._executing.add(executionId!);
     this._setStatus(toolCallId, { type: "executing" });
   }
 
-  private _onExecutionEnd(toolCallId: string): void {
-    if (!this._executing.delete(toolCallId)) return;
+  private _onExecutionEnd(
+    toolCallId: string,
+    executionId: symbol | undefined,
+  ): void {
+    if (executionId === undefined || !this._executing.delete(executionId))
+      return;
 
-    this._deleteStatus(toolCallId);
+    const entry = this._entries.get(toolCallId);
+    if (entry?.executionId === executionId) this._deleteStatus(toolCallId);
 
-    if (this._executing.size === 0) {
-      const resolvers = this._settledResolvers.splice(0);
-      resolvers.forEach((resolve) => {
-        try {
-          resolve();
-        } catch {
-          // ignore — settled-resolver consumer threw
-        }
-      });
-    }
+    const pending: SettledResolver[] = [];
+    this._settledResolvers.forEach(({ executionIds, resolve }) => {
+      if ([...executionIds].some((id) => this._executing.has(id))) {
+        pending.push({ executionIds, resolve });
+        return;
+      }
+      try {
+        resolve();
+      } catch {
+        // ignore — settled-resolver consumer threw
+      }
+    });
+    this._settledResolvers.length = 0;
+    this._settledResolvers.push(...pending);
   }
 
   private _handleResultChunk(chunk: {
@@ -439,14 +511,10 @@ export class ToolInvocationTracker {
     meta: { toolCallId: string; toolName: string };
   }): void {
     const toolCallId = chunk.meta.toolCallId;
+    const executionId = getToolExecutionId(chunk);
     const entry = this._entries.get(toolCallId);
 
-    // Pre-resolved tool call whose entry has been cleared by `reset()`.
-    // The post-abort cancellation chunk lands here after the entry is
-    // gone; suppress via the long-lived skip-execute marker.
-    if (!entry && this._skipExecuteStreamIds.has(toolCallId)) {
-      return;
-    }
+    if (!entry || entry.executionId !== executionId) return;
 
     // The host already set the result (via the live snapshot's
     // `setResponse` path). Suppress the executor's redundant emit.
@@ -538,14 +606,12 @@ export class ToolInvocationTracker {
       toolName,
       toolCallId,
     });
-    if (skipExecute) {
-      this._skipExecuteStreamIds.add(toolCallId);
-    }
     const entry: ToolCallEntry = {
       toolName,
       controller: toolCallController,
       argsText: "",
       hasResult: false,
+      skipExecute,
       argsComplete: false,
     };
     this._entries.set(toolCallId, entry);

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

@@ -1085,7 +1085,7 @@ const useExternalThread = ({
     }));
 
     return {
-      isEmpty: messages.length === 0,
+      isEmpty: messages.length === 0 && !isLoading,
       isDisabled: false,
       isLoading,
       isRunning,

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

@@ -39,10 +39,12 @@ describe("ModelContext", () => {
   it("reflects modelName from a registered provider", async () => {
     const { sub, unmount } = render();
     try {
-      sub.getValue().register(provider({ config: { modelName: "gpt-4" } }));
+      sub
+        .getValue()
+        .register(provider({ config: { modelName: "gpt-5.6-luna" } }));
       await tick();
 
-      expect(sub.getValue().getState().modelName).toBe("gpt-4");
+      expect(sub.getValue().getState().modelName).toBe("gpt-5.6-luna");
     } finally {
       unmount();
     }
@@ -67,11 +69,15 @@ describe("ModelContext", () => {
   it("keeps the same state reference when an extra provider does not change the merged values", async () => {
     const { sub, unmount } = render();
     try {
-      sub.getValue().register(provider({ config: { modelName: "gpt-4" } }));
+      sub
+        .getValue()
+        .register(provider({ config: { modelName: "gpt-5.6-luna" } }));
       await tick();
       const before = sub.getValue().getState();
 
-      sub.getValue().register(provider({ config: { modelName: "gpt-4" } }));
+      sub
+        .getValue()
+        .register(provider({ config: { modelName: "gpt-5.6-luna" } }));
       await tick();
       const after = sub.getValue().getState();
 
@@ -86,9 +92,9 @@ describe("ModelContext", () => {
     try {
       const unsubscribe = sub
         .getValue()
-        .register(provider({ config: { modelName: "gpt-4" } }));
+        .register(provider({ config: { modelName: "gpt-5.6-luna" } }));
       await tick();
-      expect(sub.getValue().getState().modelName).toBe("gpt-4");
+      expect(sub.getValue().getState().modelName).toBe("gpt-5.6-luna");
 
       unsubscribe();
       await tick();
@@ -102,9 +108,11 @@ describe("ModelContext", () => {
   it("reflects modelName synchronously after register without awaiting", () => {
     const { sub, unmount } = render();
     try {
-      sub.getValue().register(provider({ config: { modelName: "gpt-4" } }));
+      sub
+        .getValue()
+        .register(provider({ config: { modelName: "gpt-5.6-luna" } }));
 
-      expect(sub.getValue().getState().modelName).toBe("gpt-4");
+      expect(sub.getValue().getState().modelName).toBe("gpt-5.6-luna");
     } finally {
       unmount();
     }

package/src/store/clients/suggestions.ts

@@ -72,8 +72,8 @@ const useThreadSuggestions = (
   const state = useMemo<SuggestionsState>(
     () => ({
       suggestions: suggestions.map((s) => ({
-        title: s.prompt,
-        label: "",
+        title: s.title ?? s.prompt,
+        label: s.label ?? "",
         prompt: s.prompt,
       })),
     }),

package/src/store/clients/thread-selection-events.ts

@@ -0,0 +1,21 @@
+import { useEffect, useRef } from "react";
+import { useAssistantEmit } from "@assistant-ui/store/client";
+
+/**
+ * Emits `threads.selectionChanged` whenever the main thread selection changes.
+ * Does not emit for the initially selected thread on mount. Every `threads`
+ * client whose selection can change calls this with its current main thread id.
+ */
+export const useThreadSelectionEvents = (mainThreadId: string) => {
+  const emit = useAssistantEmit();
+  const previousMainThreadIdRef = useRef(mainThreadId);
+  useEffect(() => {
+    const previousThreadId = previousMainThreadIdRef.current;
+    if (previousThreadId === mainThreadId) return;
+    previousMainThreadIdRef.current = mainThreadId;
+    emit("threads.selectionChanged", {
+      threadId: mainThreadId,
+      previousThreadId,
+    });
+  }, [mainThreadId, emit]);
+};

package/src/store/env.ts

@@ -0,0 +1,11 @@
+// Bundlers replace the process.env.NODE_ENV literal statically (Vite, webpack,
+// Metro); the try covers hosts where no process binding exists at runtime.
+export const isDevelopment = (() => {
+  try {
+    return (
+      process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test"
+    );
+  } catch {
+    return false;
+  }
+})();

package/src/store/index.ts

@@ -5,6 +5,7 @@
 export type {
   ThreadsState,
   ThreadsMethods,
+  ThreadsEvents,
   ThreadsClientSchema,
 } from "./scopes/threads";
 export type {
@@ -79,7 +80,19 @@ export type {
 } from "./scopes/chain-of-thought";
 
 // runtime wiring
-export { RuntimeAdapter } from "../react/RuntimeAdapter";
+export {
+  RuntimeAdapter,
+  runtimeAdapterTransformScopes,
+} from "../react/RuntimeAdapter";
+export {
+  InMemoryThreadList,
+  inMemoryThreadListTransformScopes,
+  type InMemoryThreadListProps,
+} from "../react/client/InMemoryThreadList";
+export {
+  RemoteThreadList,
+  type RemoteThreadListProps,
+} from "../react/client/RemoteThreadList";
 export {
   useExternalMessageConverter,
   convertExternalMessages,

package/src/store/internal.ts

@@ -6,3 +6,16 @@ export { ThreadClient } from "./runtime-clients/thread-runtime-client";
 export { ThreadListItemClient } from "./runtime-clients/thread-list-item-runtime-client";
 export { ThreadListClient } from "./runtime-clients/thread-list-runtime-client";
 export { baseRuntimeAdapterTransformScopes } from "./clients/runtime-adapter";
+export {
+  actionBarCopyDisabled,
+  actionBarEditDisabled,
+  actionBarReloadDisabled,
+  branchPickerNextDisabled,
+  branchPickerPreviousDisabled,
+  composerCancelDisabled,
+  composerInputDisabled,
+  composerSendDisabled,
+  suggestionTriggerDisabled,
+} from "./primitive-predicates";
+export { isDevelopment } from "./env";
+export { useThreadSelectionEvents } from "./clients/thread-selection-events";

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

@@ -0,0 +1,184 @@
+import { describe, expect, it } from "vitest";
+import {
+  actionBarCopyDisabled,
+  actionBarEditDisabled,
+  actionBarReloadDisabled,
+  branchPickerNextDisabled,
+  branchPickerPreviousDisabled,
+  composerCancelDisabled,
+  composerInputDisabled,
+  composerSendDisabled,
+  suggestionTriggerDisabled,
+} from "./primitive-predicates";
+
+const state = (partial: Record<string, unknown>) => partial as never;
+
+describe("primitive predicates", () => {
+  it("composerSendDisabled requires canSend and either an idle thread or a queue", () => {
+    const composer = { canSend: true };
+    expect(
+      composerSendDisabled(
+        state({
+          composer,
+          thread: { isRunning: false, capabilities: { queue: false } },
+        }),
+      ),
+    ).toBe(false);
+    expect(
+      composerSendDisabled(
+        state({
+          composer,
+          thread: { isRunning: true, capabilities: { queue: true } },
+        }),
+      ),
+    ).toBe(false);
+    expect(
+      composerSendDisabled(
+        state({
+          composer,
+          thread: { isRunning: true, capabilities: { queue: false } },
+        }),
+      ),
+    ).toBe(true);
+    expect(
+      composerSendDisabled(
+        state({
+          composer: { canSend: false },
+          thread: { isRunning: false, capabilities: { queue: false } },
+        }),
+      ),
+    ).toBe(true);
+  });
+
+  it("actionBarReloadDisabled rejects user messages and busy threads", () => {
+    const thread = { isRunning: false, isDisabled: false };
+    expect(
+      actionBarReloadDisabled(
+        state({ thread, message: { role: "assistant" } }),
+      ),
+    ).toBe(false);
+    expect(
+      actionBarReloadDisabled(state({ thread, message: { role: "user" } })),
+    ).toBe(true);
+    expect(
+      actionBarReloadDisabled(
+        state({
+          thread: { ...thread, isRunning: true },
+          message: { role: "assistant" },
+        }),
+      ),
+    ).toBe(true);
+  });
+
+  it("actionBarCopyDisabled requires settled content with non-empty text", () => {
+    expect(
+      actionBarCopyDisabled(
+        state({
+          message: {
+            role: "assistant",
+            status: { type: "complete" },
+            parts: [{ type: "text", text: "hi" }],
+          },
+        }),
+      ),
+    ).toBe(false);
+    expect(
+      actionBarCopyDisabled(
+        state({
+          message: {
+            role: "assistant",
+            status: { type: "running" },
+            parts: [{ type: "text", text: "hi" }],
+          },
+        }),
+      ),
+    ).toBe(true);
+    expect(
+      actionBarCopyDisabled(
+        state({
+          message: {
+            role: "user",
+            status: undefined,
+            parts: [{ type: "text", text: "" }],
+          },
+        }),
+      ),
+    ).toBe(true);
+  });
+
+  it("branch picker predicates respect bounds and run capabilities", () => {
+    const thread = {
+      isRunning: false,
+      capabilities: { switchBranchDuringRun: false },
+    };
+    const message = { branchNumber: 2, branchCount: 3 };
+    expect(branchPickerPreviousDisabled(state({ thread, message }))).toBe(
+      false,
+    );
+    expect(branchPickerNextDisabled(state({ thread, message }))).toBe(false);
+    expect(
+      branchPickerPreviousDisabled(
+        state({ thread, message: { ...message, branchNumber: 1 } }),
+      ),
+    ).toBe(true);
+    expect(
+      branchPickerNextDisabled(
+        state({ thread, message: { ...message, branchNumber: 3 } }),
+      ),
+    ).toBe(true);
+    expect(
+      branchPickerNextDisabled(
+        state({ thread: { ...thread, isRunning: true }, message }),
+      ),
+    ).toBe(true);
+  });
+
+  it("suggestionTriggerDisabled gates on send only for queueless runs", () => {
+    const thread = {
+      isDisabled: false,
+      isRunning: true,
+      capabilities: { queue: false },
+    };
+    expect(suggestionTriggerDisabled(state({ thread }), false)).toBe(false);
+    expect(suggestionTriggerDisabled(state({ thread }), true)).toBe(true);
+    expect(
+      suggestionTriggerDisabled(
+        state({ thread: { ...thread, capabilities: { queue: true } } }),
+        true,
+      ),
+    ).toBe(false);
+  });
+  it("composerCancelDisabled, composerInputDisabled, and actionBarEditDisabled mirror their fields", () => {
+    expect(
+      composerCancelDisabled(state({ composer: { canCancel: true } })),
+    ).toBe(false);
+    expect(
+      composerCancelDisabled(state({ composer: { canCancel: false } })),
+    ).toBe(true);
+
+    const enabledThread = { isDisabled: false };
+    expect(
+      composerInputDisabled(state({ thread: enabledThread, composer: {} })),
+    ).toBe(false);
+    expect(
+      composerInputDisabled(
+        state({
+          thread: enabledThread,
+          composer: { dictation: { inputDisabled: true } },
+        }),
+      ),
+    ).toBe(true);
+    expect(
+      composerInputDisabled(
+        state({ thread: { isDisabled: true }, composer: {} }),
+      ),
+    ).toBe(true);
+
+    expect(
+      actionBarEditDisabled(state({ composer: { isEditing: false } })),
+    ).toBe(false);
+    expect(
+      actionBarEditDisabled(state({ composer: { isEditing: true } })),
+    ).toBe(true);
+  });
+});