@assistant-ui/core 0.3.17 → 0.3.19

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

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import type { ThreadMessage } from "../../types/message";
+import { ExportedMessageRepository } from "./message-repository";
+
+const nestedRunningAssistant: ThreadMessage = {
+  id: "nested-assistant",
+  createdAt: new Date(0),
+  role: "assistant",
+  content: [],
+  status: { type: "running" },
+  metadata: {
+    unstable_state: {},
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+};
+
+const delegating = {
+  id: "assistant-1",
+  role: "assistant" as const,
+  content: [
+    {
+      type: "tool-call" as const,
+      toolCallId: "delegate-1",
+      toolName: "delegate",
+      args: {},
+      argsText: "",
+      messages: [nestedRunningAssistant],
+    },
+  ],
+};
+
+describe("ExportedMessageRepository", () => {
+  it("imports a message saved mid-delegation as pending, not running", () => {
+    const fromArray = ExportedMessageRepository.fromArray([delegating]);
+    const fromBranchable = ExportedMessageRepository.fromBranchableArray([
+      { message: delegating, parentId: null },
+    ]);
+
+    for (const repository of [fromArray, fromBranchable]) {
+      expect(repository.messages[0]?.message.status).toMatchObject({
+        type: "requires-action",
+        reason: "tool-calls",
+      });
+    }
+  });
+});

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

@@ -2,7 +2,7 @@ import type { ThreadMessage } from "../../types/message";
 import type { RunConfig } from "../../types/message";
 import { generateId } from "../../utils/id";
 import type { ThreadMessageLike } from "./thread-message-like";
-import { getContentAutoStatus } from "./auto-status";
+import { getRepositoryContentAutoStatus } from "./auto-status";
 import { fromThreadMessageLike } from "./thread-message-like";
 
 export type ExportedMessageRepositoryItem = {
@@ -28,7 +28,7 @@ export const ExportedMessageRepository = {
       fromThreadMessageLike(
         m,
         generateId(),
-        getContentAutoStatus(m.content, false, false),
+        getRepositoryContentAutoStatus(m.content),
       ),
     );
 
@@ -62,7 +62,7 @@ export const ExportedMessageRepository = {
           message: fromThreadMessageLike(
             message,
             message.id,
-            getContentAutoStatus(message.content, false, false),
+            getRepositoryContentAutoStatus(message.content),
           ),
         };
       }),
@@ -134,6 +134,16 @@ export class MessageRepository {
     }
   }
 
+  private selectPathTo(message: RepositoryMessage) {
+    for (
+      let current: RepositoryMessage | null = message;
+      current;
+      current = current.prev
+    ) {
+      (current.prev ?? this.root).next = current;
+    }
+  }
+
   private performOp(
     newParent: RepositoryMessage | null,
     child: RepositoryMessage,
@@ -182,12 +192,17 @@ export class MessageRepository {
         child.current.id,
       ];
 
-      if (findHead(child) === this.head || newParentOrRoot.next === null) {
+      child.prev = newParent;
+
+      if (findHead(child) === this.head) {
+        this.selectPathTo(child);
+      } else if (newParentOrRoot.next === null) {
         newParentOrRoot.next = child;
+        if (this.head === newParentOrRoot) {
+          this.head = findHead(child);
+        }
       }
 
-      child.prev = newParent;
-
       const newLevel = newParent ? newParent.level + 1 : 0;
       this.updateLevels(child, newLevel);
     }
@@ -381,8 +396,7 @@ export class MessageRepository {
       );
 
     const previousHead = this.head;
-    const prevOrRoot = message.prev ?? this.root;
-    prevOrRoot.next = message;
+    this.selectPathTo(message);
 
     this.head = findHead(message);
 
@@ -423,17 +437,7 @@ export class MessageRepository {
     }
 
     this.head = message;
-    for (
-      let current: RepositoryMessage | null = message;
-      current;
-      current = current.prev
-    ) {
-      if (current.prev) {
-        current.prev.next = current;
-      } else {
-        this.root.next = current;
-      }
-    }
+    this.selectPathTo(message);
 
     this.evictOffBranchOptimisticMessages(previousHead, this.head);
 
@@ -456,7 +460,15 @@ export class MessageRepository {
     // Optimistic messages are ephemeral and never persisted. A persisted child
     // of an optimistic node is re-parented onto its nearest persisted ancestor
     // so the exported tree never references a skipped id.
-    for (const [, message] of this.messages) {
+    // Import and external-state conversion require parents before children, so
+    // the tree is walked in pre-order rather than iterated in insertion order.
+    const pending = [...this.root.children].reverse();
+    while (pending.length > 0) {
+      const message = this.messages.get(pending.pop()!);
+      if (!message) continue;
+      for (let i = message.children.length - 1; i >= 0; i--) {
+        pending.push(message.children[i]!);
+      }
       if (message.current.metadata?.isOptimistic) continue;
       let prev = message.prev;
       while (prev && prev.current.metadata?.isOptimistic) {

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

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { fromThreadMessageLike } from "./thread-message-like";
+
+describe("fromThreadMessageLike", () => {
+  it("preserves modality on user and assistant messages", () => {
+    const user = fromThreadMessageLike(
+      {
+        role: "user",
+        content: "Hello",
+        metadata: { modality: "voice" },
+      },
+      "user-id",
+      { type: "complete", reason: "unknown" },
+    );
+    const assistant = fromThreadMessageLike(
+      {
+        role: "assistant",
+        content: "Hi",
+        metadata: { modality: "voice" },
+      },
+      "assistant-id",
+      { type: "complete", reason: "unknown" },
+    );
+
+    expect(user.metadata.modality).toBe("voice");
+    expect(assistant.metadata.modality).toBe("voice");
+  });
+
+  it("leaves modality absent when the input has none", () => {
+    const message = fromThreadMessageLike(
+      { role: "user", content: "Hello" },
+      "user-id",
+      { type: "complete", reason: "unknown" },
+    );
+
+    expect(message.metadata).not.toHaveProperty("modality");
+  });
+
+  it("ignores modality on system messages", () => {
+    const message = fromThreadMessageLike(
+      {
+        role: "system",
+        content: "Instructions",
+        metadata: { modality: "voice" },
+      },
+      "system-id",
+      { type: "complete", reason: "unknown" },
+    );
+
+    expect(message.metadata).not.toHaveProperty("modality");
+  });
+});

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

@@ -20,6 +20,7 @@ import type {
 } from "../../types/message";
 import type { CompleteAttachment } from "../../types/attachment";
 import type {
+  MessageModality,
   MessageTiming,
   PartProviderMetadata,
   TextMessagePart,
@@ -88,6 +89,7 @@ export type ThreadMessageLike = {
         readonly timing?: MessageTiming | undefined;
         readonly submittedFeedback?: { readonly type: "positive" | "negative" };
         readonly isOptimistic?: boolean | undefined;
+        readonly modality?: MessageModality | undefined;
         readonly custom?: Record<string, unknown> | undefined;
       }
     | undefined;
@@ -179,7 +181,7 @@ export const fromThreadMessageLike = (
                 const { parentId, messages, ...basePart } = part;
                 const commonProps = {
                   ...basePart,
-                  toolCallId: part.toolCallId ?? `tool-${generateId()}`,
+                  toolCallId: part.toolCallId || `tool-${generateId()}`,
                   ...(parentId !== undefined && { parentId }),
                   ...(messages !== undefined && { messages }),
                 };
@@ -223,6 +225,7 @@ export const fromThreadMessageLike = (
             submittedFeedback: metadata.submittedFeedback,
           }),
           ...(metadata?.isOptimistic && { isOptimistic: true }),
+          ...(metadata?.modality && { modality: metadata.modality }),
         },
       } satisfies ThreadAssistantMessage;
 
@@ -263,6 +266,7 @@ export const fromThreadMessageLike = (
         metadata: {
           custom: metadata?.custom ?? {},
           ...(metadata?.isOptimistic && { isOptimistic: true }),
+          ...(metadata?.modality && { modality: metadata.modality }),
         },
       } satisfies ThreadUserMessage;
 

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

@@ -6,6 +6,7 @@ import type {
 import type { ExternalStoreThreadListAdapter } from "./external-store-adapter";
 import { invalidateThreadRuntime } from "../../runtime/utils/thread-runtime-lifecycle";
 import { BaseSubscribable } from "../../subscribable/subscribable";
+import { nullProtoRecord } from "../../utils/record";
 
 export type ExternalStoreThreadFactory = () => ExternalStoreThreadRuntimeCore;
 
@@ -19,9 +20,11 @@ const DEFAULT_THREAD = Object.freeze({
   status: "regular",
 });
 const RESOLVED_PROMISE = Promise.resolve();
-const DEFAULT_THREAD_DATA = Object.freeze({
-  [DEFAULT_THREAD_ID]: DEFAULT_THREAD,
-});
+const DEFAULT_THREAD_DATA = Object.freeze(
+  nullProtoRecord<ThreadListItemCoreState>({
+    [DEFAULT_THREAD_ID]: DEFAULT_THREAD,
+  }),
+);
 
 export class ExternalStoreThreadListRuntimeCore
   extends BaseSubscribable
@@ -84,7 +87,9 @@ export class ExternalStoreThreadListRuntimeCore
   }
 
   public getItemById(threadId: string) {
-    return this._threadData[threadId];
+    return Object.hasOwn(this._threadData, threadId)
+      ? this._threadData[threadId]
+      : undefined;
   }
 
   public __internal_setAdapter(
@@ -105,6 +110,7 @@ export class ExternalStoreThreadListRuntimeCore
 
     if (
       !initialLoad &&
+      (previousAdapter.isLoading ?? false) === (adapter.isLoading ?? false) &&
       previousThreadId === newThreadId &&
       previousThreads === newThreads &&
       previousArchivedThreads === newArchivedThreads
@@ -117,9 +123,9 @@ export class ExternalStoreThreadListRuntimeCore
       previousArchivedThreads !== newArchivedThreads ||
       previousThreadId !== newThreadId
     ) {
-      this._threadData = {
-        ...DEFAULT_THREAD_DATA,
-        ...Object.fromEntries(
+      this._threadData = nullProtoRecord(
+        DEFAULT_THREAD_DATA,
+        Object.fromEntries(
           adapter.threads?.map((t) => [
             t.id,
             {
@@ -130,7 +136,7 @@ export class ExternalStoreThreadListRuntimeCore
             },
           ]) ?? [],
         ),
-        ...Object.fromEntries(
+        Object.fromEntries(
           adapter.archivedThreads?.map((t) => [
             t.id,
             {
@@ -141,7 +147,7 @@ export class ExternalStoreThreadListRuntimeCore
             },
           ]) ?? [],
         ),
-      };
+      );
     }
 
     if (previousThreads !== newThreads) {
@@ -160,16 +166,15 @@ export class ExternalStoreThreadListRuntimeCore
       this._mainThread = this.threadFactory();
     }
 
-    if (!this._threadData[this._mainThreadId]) {
-      this._threadData = {
-        ...this._threadData,
+    if (!Object.hasOwn(this._threadData, this._mainThreadId)) {
+      this._threadData = nullProtoRecord(this._threadData, {
         [this._mainThreadId]: {
           id: this._mainThreadId,
           remoteId: undefined,
           externalId: undefined,
           status: "regular",
         },
-      };
+      });
     }
 
     this._notifySubscribers();

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

@@ -637,6 +637,8 @@ export class ExternalStoreThreadRuntimeCore
   }
 
   public async append(rawMessage: AppendMessage): Promise<void> {
+    if (this._isVoiceMessage(rawMessage.sourceId))
+      throw new Error("Voice transcript messages cannot be edited");
     // sourceId marks an edit send; the parent may coincide with the head
     // after a resync (e.g. cancelRun dropped the edited message).
     const isEdit =
@@ -786,6 +788,8 @@ export class ExternalStoreThreadRuntimeCore
   public async startRun(config: StartRunConfig): Promise<void> {
     if (!this._store.onReload)
       throw new Error("Runtime does not support reloading messages.");
+    if (this._isVoiceMessage(config.sourceId))
+      throw new Error("Voice transcript messages cannot be reloaded");
 
     this._pendingDeleteEvictions.clear();
 
@@ -800,6 +804,8 @@ export class ExternalStoreThreadRuntimeCore
   public async resumeRun(config: ResumeRunConfig): Promise<void> {
     if (!this._store.onResume)
       throw new Error("Runtime does not support resuming runs.");
+    if (this._isVoiceMessage(config.sourceId))
+      throw new Error("Voice transcript messages cannot be reloaded");
 
     await this._store.onResume(config);
   }
@@ -961,8 +967,32 @@ export class ExternalStoreThreadRuntimeCore
   ): Promise<void> {
     if (!this._store.onRespondToToolApproval)
       throw new Error("Runtime does not support tool approvals.");
+    const message = this.messages.findLast(
+      (candidate) =>
+        candidate.role === "assistant" &&
+        candidate.content.some(
+          (part) =>
+            part.type === "tool-call" &&
+            part.approval?.id === options.approvalId,
+        ),
+    );
+    const toolCall = message?.content.find(
+      (part) =>
+        part.type === "tool-call" && part.approval?.id === options.approvalId,
+    );
     try {
-      return Promise.resolve(this._store.onRespondToToolApproval(options));
+      return Promise.resolve(this._store.onRespondToToolApproval(options)).then(
+        () => {
+          if (message && toolCall?.type === "tool-call") {
+            this._notifyToolApprovalAnswered(
+              message.id,
+              toolCall.toolCallId,
+              toolCall.toolName,
+              options.approved,
+            );
+          }
+        },
+      );
     } catch (error) {
       return Promise.reject(error);
     }

package/src/runtimes/internal.ts

@@ -31,6 +31,7 @@ export type {
 export {
   createThreadMappingId,
   getThreadData,
+  promoteNewThreadReducer,
   updateStatusReducer,
 } from "./remote-thread-list/remote-thread-state";
 export type {

package/src/runtimes/local/local-thread-runtime-core.test.ts

@@ -427,6 +427,27 @@ describe("LocalThreadRuntimeCore state", () => {
 });
 
 describe("LocalThreadRuntimeCore tool approvals", () => {
+  it("emits a decision with its message and tool call IDs", async () => {
+    const { thread } = createApprovalThread(
+      toolCallResult("send_email", { id: "a1" }),
+    );
+    const answered = vi.fn();
+    thread.unstable_on("toolApprovalAnswered", answered);
+
+    await thread.append(userMessage("send an email"));
+    await flush();
+    const messageId = thread.messages.at(-1)?.id;
+
+    await thread.respondToToolApproval({ approvalId: "a1", approved: false });
+
+    expect(answered).toHaveBeenCalledWith({
+      messageId,
+      toolCallId: "call-send_email",
+      toolName: "send_email",
+      approved: false,
+    });
+  });
+
   it("pauses the run while an approval is pending, even for unlisted tools", async () => {
     const { thread, runs } = createApprovalThread(
       toolCallResult("deploy", { id: "a1" }),

package/src/runtimes/local/local-thread-runtime-core.ts

@@ -342,6 +342,8 @@ export class LocalThreadRuntimeCore
   }
 
   public async append(message: AppendMessage): Promise<void> {
+    if (this._isVoiceMessage(message.sourceId))
+      throw new Error("Voice transcript messages cannot be edited");
     const isTail = message.parentId === (this.messages.at(-1)?.id ?? null);
     const willRun = message.startRun ?? message.role === "user";
     if (this._queue && willRun && isTail) {
@@ -488,10 +490,12 @@ export class LocalThreadRuntimeCore
   }
 
   public async startRun(
-    { parentId, runConfig }: StartRunConfig,
+    { parentId, sourceId, runConfig }: StartRunConfig,
     runCallback?: ChatModelAdapter["run"],
   ): Promise<void> {
     this.ensureInitialized();
+    if (this._isVoiceMessage(sourceId))
+      throw new Error("Voice transcript messages cannot be reloaded");
 
     // add assistant message
     const id = generateId();
@@ -961,6 +965,12 @@ export class LocalThreadRuntimeCore
     const { parentId } = this.repository.getMessage(message.id);
     this.repository.addOrUpdateMessage(parentId, message);
     this._notifySubscribers();
+    this._notifyToolApprovalAnswered(
+      message.id,
+      target.toolCallId,
+      target.toolName,
+      approved,
+    );
 
     if (
       this.repository.headId === message.id &&

package/src/runtimes/remote-thread-list/remote-thread-state.test.ts

@@ -3,6 +3,9 @@ import {
   classifyThreads,
   createEmptyRemoteThreadState,
   createThreadMappingId,
+  getThreadData,
+  promoteNewThreadReducer,
+  reconcileInitializedThread,
   seedNewThread,
   updateStatusReducer,
 } from "./remote-thread-state";
@@ -13,12 +16,16 @@ import type {
 
 const initializedDraft = () => {
   const seeded = seedNewThread(createEmptyRemoteThreadState());
-  const regular = updateStatusReducer(seeded.state, seeded.id, "regular");
-  const mappingId = regular.threadIdMap[seeded.id]!;
   const initializeTask = Promise.resolve({
     remoteId: "remote-1",
     externalId: "remote-1",
   });
+  const regular = promoteNewThreadReducer(
+    seeded.state,
+    seeded.id,
+    initializeTask,
+  );
+  const mappingId = regular.threadIdMap[seeded.id]!;
   return {
     id: seeded.id,
     mappingId,
@@ -54,6 +61,7 @@ describe("remote thread state", () => {
   it("creates an empty state", () => {
     expect(createEmptyRemoteThreadState()).toEqual({
       isLoading: true,
+      loadError: undefined,
       isLoadingMore: false,
       cursor: undefined,
       newThreadId: undefined,
@@ -80,6 +88,39 @@ describe("remote thread state", () => {
     expect(Object.keys(second.state.threadData)).toEqual([first.id, second.id]);
   });
 
+  it("carries the initialization task onto the promoted slot", () => {
+    const seeded = seedNewThread(createEmptyRemoteThreadState());
+    const initializeTask = Promise.resolve({
+      remoteId: "remote-1",
+      externalId: "external-1",
+    });
+
+    const promoted = promoteNewThreadReducer(
+      seeded.state,
+      seeded.id,
+      initializeTask,
+    );
+    const data = getThreadData(promoted, seeded.id);
+
+    expect(data?.status).toBe("regular");
+    expect(data?.status === "new" ? undefined : data?.initializeTask).toBe(
+      initializeTask,
+    );
+    expect(promoted.newThreadId).toBeUndefined();
+    expect(promoted.threadIds).toEqual([seeded.id]);
+  });
+
+  it.each(["regular", "archived"] as const)(
+    "leaves a new thread untouched when moved to %s without an initialization task",
+    (newStatus) => {
+      const seeded = seedNewThread(createEmptyRemoteThreadState());
+
+      expect(updateStatusReducer(seeded.state, seeded.id, newStatus)).toBe(
+        seeded.state,
+      );
+    },
+  );
+
   it("refreshes the local slot when a listed thread already has a mapping", () => {
     const draft = initializedDraft();
 
@@ -131,6 +172,91 @@ describe("remote thread state", () => {
     expect(listed.threadData[createThreadMappingId("a")]?.title).toBe("second");
   });
 
+  it("retains a listed external id when that slot survives reconciliation", async () => {
+    const seeded = seedNewThread(createEmptyRemoteThreadState());
+    const regular = promoteNewThreadReducer(
+      seeded.state,
+      seeded.id,
+      Promise.resolve({ remoteId: "remote-1", externalId: "external-1" }),
+    );
+    const classified = classifyThreads(
+      [
+        {
+          status: "regular",
+          remoteId: "remote-1",
+          externalId: "external-1",
+        },
+      ],
+      {
+        threadIds: [...regular.threadIds],
+        archivedThreadIds: [...regular.archivedThreadIds],
+        threadIdMap: { ...regular.threadIdMap },
+        threadData: { ...regular.threadData },
+      },
+    );
+    const state = { ...regular, ...classified };
+
+    const reconciled = reconcileInitializedThread(
+      state,
+      seeded.id,
+      "remote-1",
+      undefined,
+      "remote-1",
+    );
+    const survivor = reconciled.state.threadData[reconciled.survivorMappingId]!;
+
+    expect(survivor.externalId).toBe("external-1");
+    if (survivor.status === "new") throw new Error("Expected initialized slot");
+    await expect(survivor.initializeTask).resolves.toEqual({
+      remoteId: "remote-1",
+      externalId: "external-1",
+    });
+  });
+
+  it.each(["__proto__", "constructor", "toString"])(
+    "handles a prototype-named remote id %s",
+    (remoteId) => {
+      const classified = classifyThreads(
+        [
+          {
+            status: "regular",
+            remoteId,
+            externalId: undefined,
+            title: `title-${remoteId}`,
+          },
+          {
+            status: "regular",
+            remoteId: "ok",
+            externalId: undefined,
+            title: "title-ok",
+          },
+        ],
+        {
+          threadIds: [],
+          archivedThreadIds: [],
+          threadIdMap: {},
+          threadData: {},
+        },
+      );
+      const listed: RemoteThreadState = {
+        ...createEmptyRemoteThreadState(),
+        threadIds: classified.threadIds,
+        archivedThreadIds: classified.archivedThreadIds,
+        threadIdMap: classified.threadIdMap,
+        threadData: classified.threadData,
+      };
+
+      expect(Object.keys(listed.threadIdMap)).toEqual([remoteId, "ok"]);
+      expect(typeof listed.threadIdMap[remoteId]).toBe("string");
+      expect(Object.keys(listed.threadData)).toEqual([remoteId, "ok"]);
+
+      const deleted = updateStatusReducer(listed, remoteId, "deleted");
+      expect(Object.keys(deleted.threadIdMap)).toEqual(["ok"]);
+      expect(Object.keys(deleted.threadData)).toEqual(["ok"]);
+      expect(deleted.threadIds).toEqual(["ok"]);
+    },
+  );
+
   it("deletes every alias of an identity, by either id", () => {
     for (const target of ["remote-1", "local"] as const) {
       const draft = initializedDraft();