@assistant-ui/react-a2a 0.2.35 → 0.2.37

package/src/conversions.test.ts

@@ -3,6 +3,7 @@ import {
   a2aPartToContent,
   a2aPartsToContent,
   a2aMessageToContent,
+  isA2uiDataPart,
   taskStateToMessageStatus,
   contentPartsToA2AParts,
   isTerminalTaskState,
@@ -157,6 +158,82 @@ describe("a2aPartToContent", () => {
   });
 });
 
+describe("A2UI data parts", () => {
+  it.each([
+    [
+      "media type",
+      {
+        mediaType: "application/vnd.A2UI+json",
+        data: { value: "from media type" },
+      },
+    ],
+    [
+      "metadata",
+      {
+        metadata: { mimeType: "application/a2ui+json" },
+        data: { value: "from metadata" },
+      },
+    ],
+    [
+      "metadata media type",
+      {
+        metadata: { mediaType: "application/a2ui+json" },
+        data: { value: "from metadata media type" },
+      },
+    ],
+    [
+      "operation shape",
+      {
+        data: {
+          version: "v0.9",
+          createSurface: { surfaceId: "surface" },
+        },
+      },
+    ],
+    [
+      "operation array",
+      {
+        data: [
+          {
+            version: "v0.9",
+            createSurface: { surfaceId: "surface" },
+          },
+          {
+            version: "v0.9",
+            deleteSurface: { surfaceId: "surface" },
+          },
+        ],
+      },
+    ],
+  ] as const)("detects A2UI by %s", (_source, part) => {
+    expect(isA2uiDataPart(part)).toBe(true);
+    expect(a2aPartsToContent([part])).toEqual([]);
+  });
+
+  it("does not detect an operation array containing a non-operation", () => {
+    const part = {
+      data: [
+        {
+          version: "v0.9",
+          createSurface: { surfaceId: "surface" },
+        },
+        { value: "not an operation" },
+      ],
+    };
+
+    expect(isA2uiDataPart(part)).toBe(false);
+  });
+
+  it("keeps ordinary data parts as JSON text", () => {
+    expect(a2aPartsToContent([{ data: { value: "plain" } }])).toEqual([
+      {
+        type: "text",
+        text: '{\n  "value": "plain"\n}',
+      },
+    ]);
+  });
+});
+
 describe("inbound file part round trip", () => {
   const restoreFilePart = (part: A2APart) => {
     const restored = a2aPartToContent(part);
@@ -690,4 +767,43 @@ describe("threadMessageToA2AMessage", () => {
     expect(result.contextId).toBeUndefined();
     expect(result.taskId).toBeUndefined();
   });
+
+  it("keeps tool interactions out of outbound messages", () => {
+    const result = threadMessageToA2AMessage({
+      ...userMessage,
+      role: "user",
+      attachments: [],
+      content: [
+        { type: "text", text: "hello" },
+        {
+          type: "file",
+          data: "ZmlsZQ==",
+          mimeType: "text/plain",
+          filename: "file.txt",
+        },
+        {
+          type: "tool-call",
+          toolCallId: "tool-1",
+          toolName: "present",
+          args: {},
+          argsText: "{}",
+          result: {},
+          unstable_interactions: {
+            entries: [
+              {
+                type: "action",
+                occurredAt: 1_700_000_000_000,
+                payload: { value: "selected" },
+              },
+            ],
+          },
+        },
+      ],
+    } as any);
+
+    expect(result.parts).toEqual([
+      { text: "hello" },
+      { raw: "ZmlsZQ==", mediaType: "text/plain", filename: "file.txt" },
+    ]);
+  });
 });

package/src/conversions.ts

@@ -15,6 +15,51 @@ function isImageMediaType(mediaType?: string): boolean {
   return !!mediaType && mediaType.startsWith("image/");
 }
 
+const A2UI_OPERATION_KEYS = [
+  "createSurface",
+  "updateComponents",
+  "updateDataModel",
+  "deleteSurface",
+] as const;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isA2uiOperation = (value: unknown): boolean =>
+  isRecord(value) &&
+  typeof value.version === "string" &&
+  A2UI_OPERATION_KEYS.some((key) => Object.hasOwn(value, key));
+
+const hasA2uiMediaType = (value: unknown): boolean =>
+  typeof value === "string" && value.toLowerCase().includes("a2ui");
+
+export function isA2uiDataPart(part: A2APart): boolean {
+  if (part.data === undefined) return false;
+
+  const metadata = isRecord(part.metadata) ? part.metadata : {};
+  return (
+    hasA2uiMediaType(part.mediaType) ||
+    hasA2uiMediaType(metadata.mimeType) ||
+    hasA2uiMediaType(metadata.mediaType) ||
+    isA2uiOperation(part.data) ||
+    (Array.isArray(part.data) &&
+      part.data.length > 0 &&
+      part.data.every(isA2uiOperation))
+  );
+}
+
+export function a2uiPartToOperations(part: A2APart): readonly unknown[] {
+  if (!isA2uiDataPart(part)) return [];
+  return Array.isArray(part.data) ? part.data : [part.data];
+}
+
+export function a2uiPartsToOperations(
+  parts: readonly A2APart[],
+): readonly unknown[] {
+  if (!Array.isArray(parts)) return [];
+  return parts.flatMap(a2uiPartToOperations);
+}
+
 export function a2aPartToContent(
   part: A2APart,
 ): ThreadAssistantMessage["content"][number] {
@@ -61,7 +106,9 @@ export function a2aPartToContent(
 export function a2aPartsToContent(
   parts: A2APart[],
 ): ThreadAssistantMessage["content"] {
-  return (Array.isArray(parts) ? parts : []).map(a2aPartToContent);
+  return (Array.isArray(parts) ? parts : [])
+    .filter((part) => !isA2uiDataPart(part))
+    .map(a2aPartToContent);
 }
 
 const TERMINAL_STATES = new Set<A2ATaskState>([

package/src/useA2ARuntime.test.tsx

@@ -8,7 +8,10 @@ import {
   type PropsWithChildren,
 } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import type { ThreadMessage } from "@assistant-ui/core";
+import type {
+  ExportedMessageRepository,
+  ThreadMessage,
+} from "@assistant-ui/core";
 import type { A2AClient } from "./A2AClient";
 import type { A2AStreamEvent } from "./types";
 import { useA2ARuntime } from "./useA2ARuntime";
@@ -357,6 +360,338 @@ describe("useA2ARuntime", () => {
     ]);
   });
 
+  it("does not keep the previous thread as a sibling branch after a switch", async () => {
+    const { client } = createMockClient();
+    let resolveNext!: (value: { messages: ThreadMessage[] }) => void;
+    let pending = new Promise<{ messages: ThreadMessage[] }>((resolve) => {
+      resolveNext = resolve;
+    });
+    const { result } = renderHook(() => {
+      const [threadId, setThreadId] = useState("initial");
+      return useA2ARuntime({
+        client,
+        adapters: {
+          threadList: {
+            threadId,
+            onSwitchToThread: async (nextThreadId) => {
+              setThreadId(nextThreadId);
+              return pending;
+            },
+          },
+        },
+      });
+    });
+
+    await act(async () => {
+      const switchA = result.current.threads.switchToThread("thread-a");
+      resolveNext({ messages: [createThreadMessage("thread-a")] });
+      await switchA;
+    });
+    expect(
+      result.current.thread.export().messages.map((m) => m.message.id),
+    ).toEqual(["thread-a"]);
+
+    pending = new Promise<{ messages: ThreadMessage[] }>((resolve) => {
+      resolveNext = resolve;
+    });
+    let switchB!: Promise<void>;
+    act(() => {
+      switchB = result.current.threads.switchToThread("thread-b");
+    });
+    expect(result.current.thread.export().messages).toEqual([]);
+
+    await act(async () => {
+      resolveNext({ messages: [createThreadMessage("thread-b")] });
+      await switchB;
+    });
+    expect(
+      result.current.thread.export().messages.map((m) => m.message.id),
+    ).toEqual(["thread-b"]);
+  });
+
+  it("does not keep the previous thread as a sibling branch after switching to a new thread", async () => {
+    const { client, streamMessage } = createMockClient(true);
+    let resolveNext!: (value: { messages: ThreadMessage[] }) => void;
+    let pending = new Promise<{ messages: ThreadMessage[] }>((resolve) => {
+      resolveNext = resolve;
+    });
+    let resolveNew!: () => void;
+    const pendingNew = new Promise<void>((resolve) => {
+      resolveNew = resolve;
+    });
+    const { result } = renderHook(() => {
+      const [threadId, setThreadId] = useState("initial");
+      return useA2ARuntime({
+        client,
+        adapters: {
+          threadList: {
+            threadId,
+            onSwitchToThread: async (nextThreadId) => {
+              setThreadId(nextThreadId);
+              return pending;
+            },
+            onSwitchToNewThread: async () => {
+              setThreadId("thread-new");
+              await pendingNew;
+            },
+          },
+        },
+      });
+    });
+
+    await act(async () => {
+      const switchA = result.current.threads.switchToThread("thread-a");
+      resolveNext({ messages: [createThreadMessage("thread-a")] });
+      await switchA;
+    });
+    expect(
+      result.current.thread.export().messages.map((m) => m.message.id),
+    ).toEqual(["thread-a"]);
+
+    act(() => {
+      void result.current.thread.append("still running");
+    });
+    await waitFor(() => expect(streamMessage).toHaveBeenCalledOnce());
+
+    let switchNew!: Promise<void>;
+    act(() => {
+      switchNew = result.current.threads.switchToNewThread();
+    });
+    expect(result.current.thread.export().messages).toEqual([]);
+
+    await act(async () => {
+      resolveNew();
+      await switchNew;
+    });
+    expect(result.current.thread.export().messages).toEqual([]);
+  });
+
+  it("leaves a new thread empty after an active run and failed creation", async () => {
+    const { client, streamMessage } = createMockClient(true);
+    let rejectNew!: (error: Error) => void;
+    const pendingNew = new Promise<void>((_, reject) => {
+      rejectNew = reject;
+    });
+    const { result } = renderHook(() => {
+      const [threadId, setThreadId] = useState("initial");
+      return useA2ARuntime({
+        client,
+        adapters: {
+          threadList: {
+            threadId,
+            onSwitchToNewThread: async () => {
+              setThreadId("thread-new");
+              await pendingNew;
+            },
+          },
+        },
+      });
+    });
+
+    act(() => {
+      void result.current.thread.append("still running");
+    });
+    await waitFor(() => expect(streamMessage).toHaveBeenCalledOnce());
+
+    let switchNew!: Promise<void>;
+    act(() => {
+      switchNew = result.current.threads.switchToNewThread();
+    });
+    await waitFor(() =>
+      expect(result.current.threads.getState().mainThreadId).toBe("thread-new"),
+    );
+    rejectNew(new Error("create failed"));
+    await expect(switchNew).rejects.toThrow("create failed");
+
+    expect(result.current.thread.export()).toEqual({
+      headId: null,
+      messages: [],
+    });
+  });
+
+  it("does not clear a newer thread when an older creation finishes", async () => {
+    const { client } = createMockClient();
+    let resolveNew!: () => void;
+    const pendingNew = new Promise<void>((resolve) => {
+      resolveNew = resolve;
+    });
+    const { result } = renderHook(() => {
+      const [threadId, setThreadId] = useState("initial");
+      return useA2ARuntime({
+        client,
+        adapters: {
+          threadList: {
+            threadId,
+            onSwitchToThread: async (nextThreadId) => {
+              setThreadId(nextThreadId);
+              return { messages: [createThreadMessage(nextThreadId)] };
+            },
+            onSwitchToNewThread: async () => {
+              setThreadId("thread-new");
+              await pendingNew;
+            },
+          },
+        },
+      });
+    });
+
+    let switchNew!: Promise<void>;
+    act(() => {
+      switchNew = result.current.threads.switchToNewThread();
+    });
+    await act(async () => {
+      await result.current.threads.switchToThread("thread-b");
+    });
+    await act(async () => {
+      resolveNew();
+      await switchNew;
+    });
+
+    expect(result.current.threads.getState().mainThreadId).toBe("thread-b");
+    expect(result.current.thread.getState().messages.map((m) => m.id)).toEqual([
+      "thread-b",
+    ]);
+  });
+
+  it("does not restore initial history next to the switched thread", async () => {
+    const { client } = createMockClient();
+    let resolveHistory!: (repo: ExportedMessageRepository) => void;
+    const pendingHistory = new Promise<ExportedMessageRepository>((resolve) => {
+      resolveHistory = resolve;
+    });
+    let resolveSwitch!: (value: { messages: ThreadMessage[] }) => void;
+    const pendingSwitch = new Promise<{ messages: ThreadMessage[] }>(
+      (resolve) => {
+        resolveSwitch = resolve;
+      },
+    );
+    const { result } = renderHook(() => {
+      const [threadId, setThreadId] = useState("initial");
+      return useA2ARuntime({
+        client,
+        adapters: {
+          history: { load: () => pendingHistory, append: async () => {} },
+          threadList: {
+            threadId,
+            onSwitchToThread: async (nextThreadId) => {
+              setThreadId(nextThreadId);
+              return pendingSwitch;
+            },
+          },
+        },
+      });
+    });
+
+    let switchB!: Promise<void>;
+    act(() => {
+      switchB = result.current.threads.switchToThread("thread-b");
+    });
+    await act(async () => {
+      resolveHistory({
+        headId: "history-a",
+        messages: [
+          { parentId: null, message: createThreadMessage("history-a") },
+        ],
+      });
+      await pendingHistory;
+    });
+    await act(async () => {
+      resolveSwitch({ messages: [createThreadMessage("thread-b")] });
+      await switchB;
+    });
+
+    expect(
+      result.current.thread.export().messages.map((m) => m.message.id),
+    ).toEqual(["thread-b"]);
+  });
+
+  it("keeps pending history when a run is cancelled in the same thread", async () => {
+    const { client, streamMessage } = createMockClient(true);
+    let resolve!: (repo: ExportedMessageRepository) => void;
+    const pending = new Promise<ExportedMessageRepository>((res) => {
+      resolve = res;
+    });
+    const { result } = renderHook(() =>
+      useA2ARuntime({
+        client,
+        adapters: { history: { load: () => pending, append: async () => {} } },
+      }),
+    );
+    act(() => {
+      result.current.thread.append("Hello");
+    });
+    await waitFor(() => expect(streamMessage).toHaveBeenCalledOnce());
+    await act(async () => {
+      result.current.thread.cancelRun();
+      await new Promise((done) => setTimeout(done, 0));
+    });
+    const wasLoading = result.current.thread.getState().isLoading;
+    const restored = createThreadMessage("restored");
+    await act(async () => {
+      resolve({
+        headId: restored.id,
+        messages: [{ parentId: null, message: restored }],
+      });
+      await pending;
+    });
+    expect(wasLoading).toBe(true);
+    expect(result.current.thread.getState().messages).toEqual([restored]);
+    expect(result.current.thread.getState().isLoading).toBe(false);
+  });
+
+  it.each(["existing", "new"])(
+    "keeps the selected %s thread when initial history finishes later",
+    async (target) => {
+      const { client } = createMockClient();
+      let resolveHistory!: (repo: ExportedMessageRepository) => void;
+      const pending = new Promise<ExportedMessageRepository>((resolve) => {
+        resolveHistory = resolve;
+      });
+      const history = { load: () => pending, append: async () => {} };
+      const { result } = renderHook(() => {
+        const [threadId, setThreadId] = useState("thread-a");
+        return useA2ARuntime({
+          client,
+          adapters: {
+            history,
+            threadList: {
+              threadId,
+              onSwitchToThread: async (id) => {
+                setThreadId(id);
+                return { messages: [createThreadMessage("message-b")] };
+              },
+              onSwitchToNewThread: async () => {
+                setThreadId("thread-new");
+              },
+            },
+          },
+        });
+      });
+
+      await act(async () => {
+        if (target === "existing")
+          await result.current.threads.switchToThread("thread-b");
+        else await result.current.threads.switchToNewThread();
+      });
+      const selectedId = result.current.threads.getState().mainThreadId;
+      const selectedMessages = result.current.thread.getState().messages;
+      await act(async () => {
+        resolveHistory({
+          headId: "message-a",
+          messages: [
+            { parentId: null, message: createThreadMessage("message-a") },
+          ],
+        });
+        await pending;
+      });
+      expect(result.current.threads.getState().mainThreadId).toBe(selectedId);
+      expect(result.current.thread.getState().messages).toEqual(
+        selectedMessages,
+      );
+      expect(result.current.thread.getState().isLoading).toBe(false);
+    },
+  );
+
   it("ignores a thread load superseded by a new thread", async () => {
     const { client } = createMockClient();
     let resolveLoad!: (value: { messages: ThreadMessage[] }) => void;

package/src/useA2ARuntime.ts

@@ -121,6 +121,10 @@ export function useA2ARuntime(options: UseA2ARuntimeOptions): AssistantRuntime {
       onSwitchToNewThread: onSwitchToNewThread
         ? async () => {
             const generation = ++threadSwitchGenerationRef.current;
+            // Clear before the thread id flips, or the old messages leak
+            // into the new thread as a sibling branch.
+            core.applyExternalMessages([]);
+            core.resetContext();
             await onSwitchToNewThread();
             if (generation !== threadSwitchGenerationRef.current) return;
             // Apply first so the abort inside resetContext finds an already
@@ -133,8 +137,13 @@ export function useA2ARuntime(options: UseA2ARuntimeOptions): AssistantRuntime {
       onSwitchToThread: onSwitchToThread
         ? async (threadId: string) => {
             const generation = ++threadSwitchGenerationRef.current;
+            // Clear before the thread id flips, or the old messages leak
+            // into the new thread as a sibling branch.
+            core.applyExternalMessages([]);
+            core.resetContext();
             const result = await onSwitchToThread(threadId);
             if (generation !== threadSwitchGenerationRef.current) return;
+            core.applyExternalMessages([]);
             core.applyExternalMessages(result.messages);
             core.resetContext();
           }
@@ -166,15 +175,20 @@ export function useA2ARuntime(options: UseA2ARuntimeOptions): AssistantRuntime {
       isLoading: core.isLoading,
       messageRepository: core.getMessageRepository(),
       isRunning: core.isRunning(),
+      unstable_persistsHistory: true,
       extras: a2aExtras.provide({
         task: core.getTask(),
         artifacts: core.getArtifacts(),
         agentCard: core.getAgentCard(),
       }),
       onNew: (message: AppendMessage) => core.append(message),
+      onVoiceTranscript: (message: ThreadMessage) =>
+        core.appendVoiceTranscript(message),
       onEdit: (message: AppendMessage) => core.edit(message),
       onReload: (parentId: string | null) => core.reload(parentId),
       onCancel: () => core.cancel(),
+      unstable_onRecordToolInteraction: (options) =>
+        core.recordToolInteraction(options),
       setMessages: (messages: readonly ThreadMessage[]) =>
         core.applyExternalMessages(messages),
       onImport: (messages: readonly ThreadMessage[]) =>