@assistant-ui/react-a2a 0.2.36 → 0.2.37

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

@@ -360,6 +360,251 @@ 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;

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[]) =>