@assistant-ui/core 0.3.15 → 0.3.17

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

@@ -5,9 +5,13 @@ import type {
   ChatModelRunOptions,
   ChatModelRunResult,
 } from "../../runtime/utils/chat-model-adapter";
-import type { AppendMessage } from "../../types/message";
+import type { AppendMessage, ToolCallMessagePart } from "../../types/message";
 import type { LocalRuntimeOptionsBase } from "./local-runtime-options";
-import type { ExportedMessageRepositoryItem } from "../../runtime/utils/message-repository";
+import {
+  ExportedMessageRepository,
+  type ExportedMessageRepositoryItem,
+} from "../../runtime/utils/message-repository";
+import type { ThreadMessageLike } from "../../runtime/utils/thread-message-like";
 import type { ThreadSuggestion } from "../../runtime/interfaces/thread-runtime-core";
 import { isMessageNotSentError } from "../../types/error";
 
@@ -57,7 +61,7 @@ const userMessage = (text: string): AppendMessage => ({
 
 const toolCallPart = (
   toolName: string,
-  approval?: { id: string; resolution?: "cancelled" | "expired" },
+  approval?: ToolCallMessagePart["approval"],
 ) => ({
   type: "tool-call" as const,
   toolCallId: `call-${toolName}`,
@@ -69,7 +73,7 @@ const toolCallPart = (
 
 const toolCallResult = (
   toolName: string,
-  approval?: { id: string; resolution?: "cancelled" | "expired" },
+  approval?: ToolCallMessagePart["approval"],
 ): ChatModelRunResult => ({
   content: [toolCallPart(toolName, approval)],
   status: { type: "requires-action", reason: "tool-calls" },
@@ -481,6 +485,32 @@ describe("LocalThreadRuntimeCore tool approvals", () => {
     });
   });
 
+  it("records a free-form answer alongside the decision", async () => {
+    const { thread, runs } = createApprovalThread(
+      toolCallResult("send_email", { id: "a1", display: "text" }),
+    );
+
+    await thread.append(userMessage("send an email"));
+    await flush();
+
+    await thread.respondToToolApproval({
+      approvalId: "a1",
+      approved: true,
+      text: "Quarterly update",
+    });
+    await flush();
+
+    const toolCall = runs[1]!
+      .unstable_getMessage()
+      .content.find((part) => part.type === "tool-call");
+    expect(toolCall?.approval).toEqual({
+      id: "a1",
+      display: "text",
+      approved: true,
+      text: "Quarterly update",
+    });
+  });
+
   it("treats a terminal resolution as non-pending and continues the run", async () => {
     const { thread, runs } = createApprovalThread(
       toolCallResult("deploy", { id: "a1", resolution: "expired" }),
@@ -2002,3 +2032,170 @@ describe("LocalRuntimeCore composer.canCancel", () => {
     thread.cancelRun();
   });
 });
+
+describe("LocalThreadRuntimeCore imported approvals", () => {
+  const pausedOnApproval = (
+    approval: { id: string } | undefined,
+    extra: Record<string, unknown> = {},
+  ): ThreadMessageLike[] => [
+    { role: "user", content: [{ type: "text", text: "send an email" }] },
+    {
+      role: "assistant",
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "call-send_email",
+          toolName: "send_email",
+          args: {},
+          argsText: "{}",
+          ...(approval !== undefined ? { approval } : {}),
+          ...extra,
+        },
+      ],
+    },
+  ];
+
+  const createImportedThread = (
+    initialMessages: ThreadMessageLike[],
+    history?: LocalRuntimeOptionsBase["adapters"]["history"],
+  ) => {
+    const runs: ChatModelRunOptions[] = [];
+    const core = new LocalRuntimeCore(
+      {
+        adapters: {
+          chatModel: {
+            async run(options) {
+              runs.push(options);
+              return { content: [{ type: "text", text: "done" }] };
+            },
+          },
+          ...(history !== undefined && { history }),
+        },
+        unstable_humanToolNames: ["send_email"],
+      },
+      initialMessages,
+    );
+    return { thread: core.threads.getMainThreadRuntimeCore(), runs };
+  };
+
+  it("resumes the run after approving an imported pending approval", async () => {
+    const { thread, runs } = createImportedThread(
+      pausedOnApproval({ id: "a1" }),
+    );
+
+    expect(thread.messages.at(-1)?.status).toMatchObject({
+      type: "requires-action",
+      reason: "tool-calls",
+    });
+
+    thread.respondToToolApproval({ approvalId: "a1", approved: true });
+    await flush();
+
+    expect(runs).toHaveLength(1);
+    expect(thread.messages.at(-1)?.status?.type).toBe("complete");
+  });
+
+  it("keeps the interrupt reason for an imported interrupted tool call", () => {
+    const { thread } = createImportedThread(
+      pausedOnApproval(undefined, {
+        interrupt: { type: "human", payload: { question: "which one?" } },
+      }),
+    );
+
+    expect(thread.messages.at(-1)?.status).toMatchObject({
+      type: "requires-action",
+      reason: "interrupt",
+    });
+  });
+
+  it("resumes the run after approving an approval restored by the history adapter", async () => {
+    const { thread, runs } = createImportedThread([], {
+      async load() {
+        return ExportedMessageRepository.fromArray(
+          pausedOnApproval({ id: "a1" }),
+        );
+      },
+      async append() {},
+      async update() {},
+    });
+
+    thread.__internal_load();
+    await flush();
+
+    expect(thread.messages.at(-1)?.status).toMatchObject({
+      type: "requires-action",
+      reason: "tool-calls",
+    });
+
+    thread.respondToToolApproval({ approvalId: "a1", approved: true });
+    await flush();
+
+    expect(runs).toHaveLength(1);
+    expect(thread.messages.at(-1)?.status?.type).toBe("complete");
+  });
+
+  it("normalizes a serialized approval pause that lost its auto-status marker", async () => {
+    const { thread, runs } = createImportedThread([]);
+    thread.import(
+      JSON.parse(
+        JSON.stringify(
+          ExportedMessageRepository.fromArray(pausedOnApproval({ id: "a1" })),
+        ),
+      ),
+    );
+
+    expect(thread.messages.at(-1)?.status).toMatchObject({
+      type: "requires-action",
+      reason: "tool-calls",
+    });
+
+    thread.respondToToolApproval({ approvalId: "a1", approved: true });
+    await flush();
+
+    expect(runs).toHaveLength(1);
+    expect(thread.messages.at(-1)?.status?.type).toBe("complete");
+  });
+
+  it("completes an imported interrupt that has nothing left to act on", () => {
+    const { thread } = createImportedThread([
+      { role: "user", content: [{ type: "text", text: "send an email" }] },
+      {
+        role: "assistant",
+        status: { type: "requires-action", reason: "interrupt" },
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "call-send_email",
+            toolName: "send_email",
+            args: {},
+            argsText: "{}",
+            result: { sent: true },
+          },
+        ],
+      } as ThreadMessageLike,
+    ]);
+
+    expect(thread.messages.at(-1)?.status?.type).toBe("complete");
+  });
+
+  it("resumes the run after adding a result to an imported resultless tool call", async () => {
+    const { thread, runs } = createImportedThread(pausedOnApproval(undefined));
+
+    expect(thread.messages.at(-1)?.status).toMatchObject({
+      type: "requires-action",
+      reason: "tool-calls",
+    });
+
+    thread.addToolResult({
+      messageId: thread.messages.at(-1)!.id,
+      toolCallId: "call-send_email",
+      toolName: "send_email",
+      result: { sent: true },
+      isError: false,
+    });
+    await flush();
+
+    expect(runs).toHaveLength(1);
+    expect(thread.messages.at(-1)?.status?.type).toBe("complete");
+  });
+});

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

@@ -5,6 +5,8 @@ import type {
   ChatModelRunResult,
 } from "../../runtime/utils/chat-model-adapter";
 import { shouldContinue } from "./should-continue";
+import { getAutoStatus } from "../../runtime/utils/auto-status";
+import type { ExportedMessageRepository } from "../../runtime/utils/message-repository";
 import type { LocalRuntimeOptionsBase } from "./local-runtime-options";
 import { consumeSuggestionResult } from "../../adapters/suggestion";
 import type {
@@ -21,7 +23,7 @@ import type {
   AppendMessage,
   ThreadAssistantMessage,
 } from "../../types/message";
-import type { RunConfig } from "../../types/message";
+import type { RunConfig, ThreadMessage } from "../../types/message";
 import { MessageNotSentError, toAssistantError } from "../../types/error";
 import type { ModelContextProvider } from "../../model-context/types";
 import {
@@ -32,7 +34,7 @@ import type { QueuePlacement } from "../../runtime/queue/external-thread-queue-a
 import {
   EMPTY_QUEUE_ITEMS,
   type QueueItemState,
-} from "../../store/scopes/queue-item";
+} from "../../runtime/queue/queue-item";
 import {
   captureThreadRuntimeGeneration,
   invalidateThreadRuntime,
@@ -49,6 +51,45 @@ class AbortError extends Error {
   }
 }
 
+// `shouldContinue` resumes only on `tool-calls` and `resumeToolCall` throws, so
+// an imported `interrupt` with no interrupt payload would be stranded here.
+// Provenance cannot gate it: a repository that went through JSON has no marker.
+// The replacement stays content-derived, so a message with nothing resultless
+// left to act on lands on `complete` rather than an unactionable pause.
+const withLocalPauseReason = (message: ThreadMessage): ThreadMessage => {
+  if (
+    message.role !== "assistant" ||
+    message.status.type !== "requires-action" ||
+    message.status.reason !== "interrupt" ||
+    message.content.some(
+      (c) =>
+        c.type === "tool-call" && c.result === undefined && c.interrupt != null,
+    )
+  )
+    return message;
+  return {
+    ...message,
+    status: getAutoStatus(
+      false,
+      false,
+      false,
+      message.content.some(
+        (c) => c.type === "tool-call" && c.result === undefined,
+      ),
+    ),
+  };
+};
+
+const withLocalPauseReasons = (
+  data: ExportedMessageRepository,
+): ExportedMessageRepository => ({
+  ...data,
+  messages: data.messages.map((item) => ({
+    ...item,
+    message: withLocalPauseReason(item.message),
+  })),
+});
+
 export class LocalThreadRuntimeCore
   extends BaseThreadRuntimeCore
   implements ThreadRuntimeCore
@@ -272,7 +313,7 @@ export class LocalThreadRuntimeCore
     this._loadPromise = promise
       .then((repo) => {
         if (!repo) return;
-        this.repository.import(repo);
+        this.repository.import(withLocalPauseReasons(repo));
         if (repo.messages.length > 0) {
           this.ensureInitialized();
         }
@@ -434,6 +475,10 @@ export class LocalThreadRuntimeCore
     throw new Error("Runtime does not support exporting external states.");
   }
 
+  public override import(data: ExportedMessageRepository) {
+    super.import(withLocalPauseReasons(data));
+  }
+
   public importExternalState(): void {
     throw new Error("Runtime does not support importing external states.");
   }
@@ -855,8 +900,9 @@ export class LocalThreadRuntimeCore
     approvalId,
     approved,
     optionId,
+    text,
     reason,
-  }: RespondToToolApprovalOptions) {
+  }: RespondToToolApprovalOptions): Promise<void> {
     let message = this.repository
       .getMessages()
       .findLast(
@@ -899,6 +945,7 @@ export class LocalThreadRuntimeCore
         ...targetApproval,
         approved,
         ...(optionId != null && { optionId }),
+        ...(text != null && { text }),
         ...(reason != null && { reason }),
       };
       if (approved) return { ...c, approval };
@@ -923,5 +970,7 @@ export class LocalThreadRuntimeCore
     } else {
       this._persistPausedMessage(parentId, message);
     }
+
+    return Promise.resolve();
   }
 }

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

@@ -0,0 +1,149 @@
+import { describe, expect, it } from "vitest";
+import {
+  classifyThreads,
+  createEmptyRemoteThreadState,
+  createThreadMappingId,
+  seedNewThread,
+  updateStatusReducer,
+} from "./remote-thread-state";
+import type {
+  RemoteThreadData,
+  RemoteThreadState,
+} from "./remote-thread-state";
+
+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",
+  });
+  return {
+    id: seeded.id,
+    mappingId,
+    initializeTask,
+    state: {
+      ...regular,
+      threadIdMap: { ...regular.threadIdMap, "remote-1": mappingId },
+      threadData: {
+        ...regular.threadData,
+        [mappingId]: {
+          ...regular.threadData[mappingId]!,
+          remoteId: "remote-1",
+          externalId: "remote-1",
+          initializeTask,
+        } as RemoteThreadData,
+      },
+    } as RemoteThreadState,
+  };
+};
+
+const expectOneSlotPerIdentity = (state: RemoteThreadState) => {
+  const remoteIds = Object.values(state.threadData)
+    .map((data) => data.remoteId)
+    .filter((remoteId) => remoteId !== undefined);
+  expect(new Set(remoteIds).size).toBe(remoteIds.length);
+
+  for (const id of [...state.threadIds, ...state.archivedThreadIds]) {
+    expect(state.threadData[state.threadIdMap[id]!]?.id).toBe(id);
+  }
+};
+
+describe("remote thread state", () => {
+  it("creates an empty state", () => {
+    expect(createEmptyRemoteThreadState()).toEqual({
+      isLoading: true,
+      isLoadingMore: false,
+      cursor: undefined,
+      newThreadId: undefined,
+      threadIds: [],
+      archivedThreadIds: [],
+      threadIdMap: {},
+      threadData: {},
+    });
+  });
+
+  it("seeds unique local threads with matching mapping ids", () => {
+    const first = seedNewThread(createEmptyRemoteThreadState());
+    const second = seedNewThread(first.state);
+
+    expect(second.id).not.toBe(first.id);
+    expect(first.state.newThreadId).toBe(first.id);
+    expect(second.state.newThreadId).toBe(second.id);
+    expect(first.state.threadIdMap[first.id]).toBe(
+      createThreadMappingId(first.id),
+    );
+    expect(second.state.threadIdMap[second.id]).toBe(
+      createThreadMappingId(second.id),
+    );
+    expect(Object.keys(second.state.threadData)).toEqual([first.id, second.id]);
+  });
+
+  it("refreshes the local slot when a listed thread already has a mapping", () => {
+    const draft = initializedDraft();
+
+    const merged = classifyThreads(
+      [
+        {
+          status: "regular",
+          remoteId: "remote-1",
+          externalId: "remote-1",
+          title: "from the server",
+        },
+      ],
+      {
+        threadIds: [],
+        archivedThreadIds: [],
+        threadIdMap: { ...draft.state.threadIdMap },
+        threadData: { ...draft.state.threadData },
+      },
+    );
+
+    expect(Object.keys(merged.threadData)).toEqual([draft.mappingId]);
+    expect(merged.threadIds).toEqual([draft.id]);
+    expect(merged.threadIdMap["remote-1"]).toBe(draft.mappingId);
+    expect(merged.threadData[draft.mappingId]?.id).toBe(draft.id);
+    expect(merged.threadData[draft.mappingId]?.title).toBe("from the server");
+    expect(merged.threadData[draft.mappingId]?.localOrigin).toBe(true);
+    const refreshed = merged.threadData[draft.mappingId]!;
+    expect(
+      refreshed.status === "new" ? undefined : refreshed.initializeTask,
+    ).toBe(draft.initializeTask);
+    expectOneSlotPerIdentity({ ...draft.state, ...merged });
+  });
+
+  it("lists a repeated remote id once", () => {
+    const listed = classifyThreads(
+      [
+        { status: "regular", remoteId: "a", externalId: "a", title: "first" },
+        { status: "regular", remoteId: "a", externalId: "a", title: "second" },
+      ],
+      {
+        threadIds: [],
+        archivedThreadIds: [],
+        threadIdMap: {},
+        threadData: {},
+      },
+    );
+
+    expect(listed.threadIds).toEqual(["a"]);
+    expect(listed.threadData[createThreadMappingId("a")]?.title).toBe("second");
+  });
+
+  it("deletes every alias of an identity, by either id", () => {
+    for (const target of ["remote-1", "local"] as const) {
+      const draft = initializedDraft();
+      const deleted = updateStatusReducer(
+        draft.state,
+        target === "local" ? draft.id : target,
+        "deleted",
+      );
+
+      expect(deleted.threadData).toEqual({});
+      expect(deleted.threadIdMap).toEqual({});
+      expect(deleted.threadIds).toEqual([]);
+      expect(deleted.archivedThreadIds).toEqual([]);
+    }
+  });
+});