@assistant-ui/core 0.3.15 → 0.3.17

package/src/runtime/utils/tool-call-tree.ts

@@ -0,0 +1,97 @@
+import type {
+  ThreadAssistantMessage,
+  ThreadAssistantMessagePart,
+  ThreadMessage,
+  ToolCallMessagePart,
+} from "../../types/message";
+
+export type ToolCallTreeEntry = {
+  readonly part: ToolCallMessagePart;
+  /** Id of the message whose content directly holds `part`. */
+  readonly messageId: string;
+};
+
+/**
+ * Walk every tool-call part reachable from `messages`. A tool call projects a
+ * child run as nested messages on `ToolCallMessagePart.messages`, so a
+ * subagent's own calls live below the top-level content and a seam that only
+ * scans the top level cannot reach them.
+ *
+ * Parts arrive in document order, each one ahead of its own descendants.
+ * `messageId` names the message that directly holds the part, which for a
+ * nested call is the child run's message rather than the top-level message the
+ * tree hangs from. Only assistant messages are descended, the same rule
+ * {@link mapToolCallPartsDeep} rewrites under, so a part this reports is always
+ * a part that can be written back.
+ */
+export function* walkToolCallTree(
+  messages: readonly ThreadMessage[],
+): Generator<ToolCallTreeEntry> {
+  for (const message of messages) {
+    if (message?.role !== "assistant" || !Array.isArray(message.content)) {
+      continue;
+    }
+    for (const part of message.content) {
+      if (!part || part.type !== "tool-call") continue;
+      yield { part, messageId: message.id };
+      if (part.messages?.length) yield* walkToolCallTree(part.messages);
+    }
+  }
+}
+
+/**
+ * Content-level form of {@link walkToolCallTree}, for a caller that already
+ * holds one assistant message's content and does not need the owning id.
+ */
+export function* iterateToolCallParts(
+  content: readonly ThreadAssistantMessagePart[],
+): Generator<ToolCallMessagePart> {
+  for (const part of content) {
+    if (!part || part.type !== "tool-call") continue;
+    yield part;
+    if (part.messages?.length) {
+      for (const entry of walkToolCallTree(part.messages)) {
+        yield entry.part;
+      }
+    }
+  }
+}
+
+/**
+ * Rebuild `content` with `fn` applied to every tool-call part in the tree.
+ * Arrays and nested messages are reused wherever `fn` returned the part it was
+ * given, so an unchanged subtree keeps its identity and `changed` reports
+ * whether anything moved.
+ */
+export function mapToolCallPartsDeep(
+  content: readonly ThreadAssistantMessagePart[],
+  fn: (part: ToolCallMessagePart) => ToolCallMessagePart,
+): { content: readonly ThreadAssistantMessagePart[]; changed: boolean } {
+  let changed = false;
+  const next = content.map((part): ThreadAssistantMessagePart => {
+    if (part.type !== "tool-call") return part;
+    let mapped = fn(part);
+    if (mapped.messages !== undefined) {
+      let nestedChanged = false;
+      const nestedMessages = mapped.messages.map((nested) => {
+        if (nested.role !== "assistant" || !Array.isArray(nested.content)) {
+          return nested;
+        }
+        const assistant = nested as ThreadAssistantMessage;
+        const result = mapToolCallPartsDeep(assistant.content, fn);
+        if (!result.changed) return nested;
+        nestedChanged = true;
+        return { ...assistant, content: result.content };
+      });
+      if (nestedChanged) {
+        mapped =
+          mapped === part
+            ? { ...part, messages: nestedMessages }
+            : { ...mapped, messages: nestedMessages };
+      }
+    }
+    if (mapped !== part) changed = true;
+    return mapped;
+  });
+  return changed ? { content: next, changed } : { content, changed };
+}

package/src/runtimes/external-store/external-store-adapter.ts

@@ -1,4 +1,8 @@
-import type { AppendMessage, ThreadMessage } from "../../types/message";
+import type {
+  AppendMessage,
+  ThreadMessage,
+  ToolCallMessagePart,
+} from "../../types/message";
 import type { ThreadMessageLike } from "../../runtime/utils/thread-message-like";
 import type { AttachmentAdapter } from "../../adapters/attachment";
 import type {
@@ -14,7 +18,10 @@ import type {
   ResumeRunConfig,
   ThreadSuggestion,
 } from "../../runtime/interfaces/thread-runtime-core";
-import type { ExportedMessageRepository } from "../../runtime/utils/message-repository";
+import type {
+  ExportedMessageRepository,
+  MessageRepository,
+} from "../../runtime/utils/message-repository";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import type { ToolExecutionStatus } from "../tool-invocations/ToolInvocationTracker";
 import type { ExternalThreadQueueAdapter } from "../../runtime/queue/external-thread-queue-adapter";
@@ -105,6 +112,15 @@ type ExternalStoreAdapterBase<T> = {
   isLoading?: boolean | undefined;
   messages?: readonly T[];
   messageRepository?: ExportedMessageRepository;
+  /**
+   * An externally owned message repository instance. When provided, the
+   * thread runtime adopts it as its branch store and swaps to it atomically
+   * whenever a different instance is passed, so hosts that route multiple
+   * conversations through one runtime keep each conversation's history and
+   * branches isolated in its own instance. Omit it to keep the runtime's own
+   * repository.
+   */
+  unstable_messageRepositoryInstance?: MessageRepository | undefined;
   suggestions?: readonly ThreadSuggestion[] | undefined;
   state?: ReadonlyJSONValue | undefined;
   extras?: unknown;
@@ -207,6 +223,26 @@ type ExternalStoreAdapterBase<T> = {
    * `modelContent` populated when present.
    */
   unstable_enableToolInvocations?: boolean | undefined;
+  /**
+   * Decides whether a tool call's result is produced on the client. Only
+   * consulted when `unstable_enableToolInvocations` is `true`.
+   *
+   * A provider that runs tools itself answers its own calls, and its result
+   * arrives one or more snapshots after the call's arguments complete. In
+   * that window the call is complete and result-less, so a registered tool
+   * of the same name would otherwise execute locally and produce a result
+   * the provider never asked for. An adapter that can tell the two apart
+   * supplies this predicate; it is read once per tool call, when the call is
+   * first observed live.
+   *
+   * The predicate is also what licenses running a frontend tool while the
+   * provider's run is still open. Without it, ownership is unknown until the
+   * run ends, so a registered tool executes only once the run's outcome is
+   * known and cannot fire on a call the provider was about to answer or gate.
+   */
+  unstable_isClientToolCall?:
+    | ((toolCall: ToolCallMessagePart) => boolean)
+    | undefined;
   /**
    * Receives the current per-tool-call execution status map whenever it
    * changes. Only invoked when `unstable_enableToolInvocations` is `true`

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

@@ -1,4 +1,3 @@
-import type { Unsubscribe } from "../../types/unsubscribe";
 import type { ExternalStoreThreadRuntimeCore } from "./external-store-thread-runtime-core";
 import type {
   ThreadListItemCoreState,
@@ -6,7 +5,7 @@ import type {
 } from "../../runtime/interfaces/thread-list-runtime-core";
 import type { ExternalStoreThreadListAdapter } from "./external-store-adapter";
 import { invalidateThreadRuntime } from "../../runtime/utils/thread-runtime-lifecycle";
-import { notifySubscribers } from "../../subscribable/subscribable";
+import { BaseSubscribable } from "../../subscribable/subscribable";
 
 export type ExternalStoreThreadFactory = () => ExternalStoreThreadRuntimeCore;
 
@@ -24,7 +23,10 @@ const DEFAULT_THREAD_DATA = Object.freeze({
   [DEFAULT_THREAD_ID]: DEFAULT_THREAD,
 });
 
-export class ExternalStoreThreadListRuntimeCore implements ThreadListRuntimeCore {
+export class ExternalStoreThreadListRuntimeCore
+  extends BaseSubscribable
+  implements ThreadListRuntimeCore
+{
   private _mainThreadId: string = DEFAULT_THREAD_ID;
   private _threads: readonly string[] = DEFAULT_THREADS;
   private _archivedThreads: readonly string[] = EMPTY_ARRAY;
@@ -68,6 +70,7 @@ export class ExternalStoreThreadListRuntimeCore implements ThreadListRuntimeCore
     adapter: ExternalStoreThreadListAdapter = {},
     threadFactory: ExternalStoreThreadFactory,
   ) {
+    super();
     this.threadFactory = threadFactory;
     this.__internal_setAdapter(adapter, true);
   }
@@ -262,15 +265,4 @@ export class ExternalStoreThreadListRuntimeCore implements ThreadListRuntimeCore
   public generateTitle(): never {
     throw new Error("Method not implemented.");
   }
-
-  private _subscriptions = new Set<() => void>();
-
-  public subscribe(callback: () => void): Unsubscribe {
-    this._subscriptions.add(callback);
-    return () => this._subscriptions.delete(callback);
-  }
-
-  private _notifySubscribers() {
-    notifySubscribers(this._subscriptions);
-  }
 }