@assistant-ui/react-a2a 0.2.29 → 0.2.30

package/src/A2AThreadRuntimeCore.test.ts

@@ -518,6 +518,25 @@ describe("A2AThreadRuntimeCore", () => {
       });
     });
 
+    it("handles malformed status message parts", async () => {
+      const core = createCore({
+        streamMessage: vi.fn().mockImplementation(async function* () {
+          yield {
+            type: "statusUpdate",
+            event: {
+              taskId: "t1",
+              contextId: "ctx-1",
+              status: { state: "completed", message: {} },
+            },
+          } as unknown as A2AStreamEvent;
+        }),
+      });
+
+      await core.append(createUserAppendMessage("Go"));
+
+      expect(core.getMessages()[1]!.content).toEqual([]);
+    });
+
     it("tracks task state from status updates", async () => {
       const core = createCore({
         streamMessage: vi.fn().mockImplementation(async function* () {
@@ -628,6 +647,31 @@ describe("A2AThreadRuntimeCore", () => {
   // --- Artifact handling ---
 
   describe("artifacts", () => {
+    it("treats malformed artifact parts as empty", async () => {
+      const core = createCore({
+        streamMessage: vi.fn().mockImplementation(async function* () {
+          yield {
+            type: "artifactUpdate",
+            event: {
+              taskId: "t1",
+              contextId: "ctx-1",
+              artifact: { artifactId: "a1", parts: {} },
+            },
+          } as unknown as A2AStreamEvent;
+          yield artifactUpdateEvent("a1", [{ text: "part" }], {
+            append: true,
+          });
+          yield statusUpdateEvent("completed", "Done");
+        }),
+      });
+
+      await core.append(createUserAppendMessage("Go"));
+
+      expect(core.getArtifacts()).toEqual([
+        { artifactId: "a1", parts: [{ text: "part" }] },
+      ]);
+    });
+
     it("accumulates artifacts from artifact update events", async () => {
       const core = createCore({
         streamMessage: vi.fn().mockImplementation(async function* () {
@@ -825,6 +869,71 @@ describe("A2AThreadRuntimeCore", () => {
   // --- Task snapshot ---
 
   describe("task snapshot", () => {
+    it("treats malformed artifact parts as empty", async () => {
+      const taskSnapshot = {
+        id: "t1",
+        status: { state: "completed" },
+        artifacts: [{ artifactId: "a1", parts: {} }],
+      } as unknown as A2ATask;
+
+      const core = createCore({
+        streamMessage: vi.fn().mockImplementation(async function* () {
+          yield { type: "task", task: taskSnapshot } as A2AStreamEvent;
+        }),
+      });
+
+      await core.append(createUserAppendMessage("Go"));
+
+      expect(core.getArtifacts()).toEqual([{ artifactId: "a1", parts: [] }]);
+      expect(core.getTask()?.artifacts).toEqual([
+        { artifactId: "a1", parts: [] },
+      ]);
+    });
+
+    it.each([undefined, null, {}, "not-an-array"])(
+      "does not consume malformed task artifacts: %j",
+      async (artifacts) => {
+        const taskSnapshot = {
+          id: "t1",
+          status: { state: "completed" },
+          artifacts,
+          history: artifacts,
+        } as unknown as A2ATask;
+        const core = createCore({
+          streamMessage: vi.fn().mockImplementation(async function* () {
+            yield { type: "task", task: taskSnapshot } as A2AStreamEvent;
+          }),
+        });
+
+        await core.append(createUserAppendMessage("Go"));
+
+        expect(core.getArtifacts()).toEqual([]);
+        if (artifacts === undefined) {
+          expect(core.getTask()?.artifacts).toBeUndefined();
+          expect(core.getTask()?.history).toBeUndefined();
+        } else {
+          expect(core.getTask()?.artifacts).toEqual([]);
+          expect(core.getTask()?.history).toEqual([]);
+        }
+      },
+    );
+
+    it("handles malformed status message parts", async () => {
+      const taskSnapshot = {
+        id: "t1",
+        status: { state: "completed", message: {} },
+      } as unknown as A2ATask;
+      const core = createCore({
+        streamMessage: vi.fn().mockImplementation(async function* () {
+          yield { type: "task", task: taskSnapshot } as A2AStreamEvent;
+        }),
+      });
+
+      await core.append(createUserAppendMessage("Go"));
+
+      expect(core.getMessages()[1]!.content).toEqual([]);
+    });
+
     it("handles full task snapshot from stream", async () => {
       const taskSnapshot: A2ATask = {
         id: "t1",
@@ -1077,19 +1186,32 @@ describe("A2AThreadRuntimeCore", () => {
       },
     );
 
-    it("marks complete when stream ends without terminal status", async () => {
-      const core = createCore({
-        streamMessage: vi.fn().mockImplementation(async function* () {
-          // Stream ends without any events
-        }),
-      });
+    it("rejects a stream that ends without any events", async () => {
+      const onError = vi.fn();
+      const core = createCore(
+        {
+          streamMessage: vi.fn().mockImplementation(async function* () {
+            return;
+          }),
+        },
+        {
+          onError,
+        },
+      );
 
-      await core.append(createUserAppendMessage("Go"));
+      await expect(core.append(createUserAppendMessage("Go"))).rejects.toThrow(
+        "A2A message stream ended without any events.",
+      );
 
+      expect(onError).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: "A2A message stream ended without any events.",
+        }),
+      );
       const assistant = core.getMessages()[1]!;
       expect(assistant.status).toEqual({
-        type: "complete",
-        reason: "stop",
+        type: "incomplete",
+        reason: "error",
       });
     });
   });
@@ -1152,6 +1274,7 @@ describe("A2AThreadRuntimeCore", () => {
           streamMessage.mock.calls.length === 1 ? firstPending : secondPending;
         return (async function* () {
           await pending;
+          yield statusUpdateEvent("completed", "Done");
         })();
       });
       const core = createCore({ streamMessage });
@@ -1200,7 +1323,9 @@ describe("A2AThreadRuntimeCore", () => {
 
 describe("outbound message conversion", () => {
   function createCoreWithStream() {
-    const streamMessage = vi.fn().mockImplementation(async function* () {});
+    const streamMessage = vi.fn().mockImplementation(async function* () {
+      yield statusUpdateEvent("completed", "Done");
+    });
     const core = new A2AThreadRuntimeCore({
       client: createMockClient({ streamMessage }),
       notifyUpdate: vi.fn() as unknown as () => void,

package/src/A2AThreadRuntimeCore.ts

@@ -76,6 +76,13 @@ const invokeRuntimeCallback = <TArgs extends unknown[]>(
   }
 };
 
+function normalizeArtifact(artifact: A2AArtifact): A2AArtifact {
+  return {
+    ...artifact,
+    parts: Array.isArray(artifact.parts) ? artifact.parts : [],
+  };
+}
+
 export class A2AThreadRuntimeCore {
   private client: A2AClient;
   private contextId: string | undefined;
@@ -526,12 +533,18 @@ export class A2AThreadRuntimeCore {
       abortController.signal,
     );
 
+    let receivedEvent = false;
     for await (const event of stream) {
       if (abortController.signal.aborted) break;
+      receivedEvent = true;
       this.handleStreamEvent(assistantId, event);
     }
 
     if (!abortController.signal.aborted) {
+      if (!receivedEvent) {
+        throw new Error("A2A message stream ended without any events.");
+      }
+
       const lastStatus = this.getAssistantStatus(assistantId);
       if (lastStatus?.type === "running") {
         this.updateAssistantStatus(assistantId, {
@@ -617,7 +630,8 @@ export class A2AThreadRuntimeCore {
   }
 
   private handleArtifactUpdate(event: A2ATaskArtifactUpdateEvent) {
-    const { artifact, append, lastChunk } = event;
+    const { append, lastChunk } = event;
+    const artifact = normalizeArtifact(event.artifact);
     const existingIdx = this.currentArtifacts.findIndex(
       (a) => a.artifactId === artifact.artifactId,
     );
@@ -666,13 +680,29 @@ export class A2AThreadRuntimeCore {
   }
 
   private handleTaskSnapshot(assistantId: string, task: A2ATask) {
-    this.currentTask = task;
+    const artifacts =
+      task.artifacts === undefined
+        ? undefined
+        : Array.isArray(task.artifacts)
+          ? task.artifacts.map(normalizeArtifact)
+          : [];
+    const history =
+      task.history === undefined
+        ? undefined
+        : Array.isArray(task.history)
+          ? task.history
+          : [];
+    this.currentTask = {
+      ...task,
+      ...(artifacts === undefined ? {} : { artifacts }),
+      ...(history === undefined ? {} : { history }),
+    };
 
     if (task.contextId) {
       this.contextId = task.contextId;
     }
-    if (task.artifacts) {
-      this.currentArtifacts = task.artifacts;
+    if (artifacts) {
+      this.currentArtifacts = artifacts;
     }
 
     if (task.status.message) {

package/src/conversions.test.ts

@@ -228,6 +228,13 @@ describe("a2aPartsToContent", () => {
   it("handles empty parts array", () => {
     expect(a2aPartsToContent([])).toEqual([]);
   });
+
+  it.each([undefined, null, {}, "not-an-array"])(
+    "treats %j parts as empty content",
+    (parts) => {
+      expect(a2aPartsToContent(parts as unknown as A2APart[])).toEqual([]);
+    },
+  );
 });
 
 describe("a2aMessageToContent", () => {
@@ -242,6 +249,15 @@ describe("a2aMessageToContent", () => {
     expect(result[0]).toEqual({ type: "text", text: "Hello" });
     expect(result[1]).toEqual({ type: "text", text: " world" });
   });
+
+  it.each([undefined, null, {}, "not-an-array"])(
+    "treats a message with %j parts as empty content",
+    (parts) => {
+      expect(a2aMessageToContent({ parts } as unknown as A2AMessage)).toEqual(
+        [],
+      );
+    },
+  );
 });
 
 describe("taskStateToMessageStatus", () => {

package/src/conversions.ts

@@ -54,7 +54,7 @@ export function a2aPartToContent(
 export function a2aPartsToContent(
   parts: A2APart[],
 ): ThreadAssistantMessage["content"] {
-  return parts.map(a2aPartToContent);
+  return (Array.isArray(parts) ? parts : []).map(a2aPartToContent);
 }
 
 const TERMINAL_STATES = new Set<A2ATaskState>([
@@ -183,5 +183,5 @@ export function contentPartsToA2AParts(
 export function a2aMessageToContent(
   message: A2AMessage,
 ): ThreadAssistantMessage["content"] {
-  return a2aPartsToContent(message.parts);
+  return a2aPartsToContent(message?.parts ?? []);
 }

package/src/useA2ARuntime.test.tsx

@@ -3,6 +3,7 @@
 import { act, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { A2AClient } from "./A2AClient";
+import type { A2AStreamEvent } from "./types";
 import { useA2ARuntime } from "./useA2ARuntime";
 
 const createMockClient = (waitForAbort = false) => {
@@ -14,11 +15,21 @@ const createMockClient = (waitForAbort = false) => {
       _configuration: unknown,
       _metadata: unknown,
       signal?: AbortSignal,
-    ): AsyncIterable<never> => {
+    ): AsyncIterable<A2AStreamEvent> => {
       streamSignal = signal;
       return {
         async *[Symbol.asyncIterator]() {
-          if (!waitForAbort || !signal) return;
+          if (!waitForAbort || !signal) {
+            yield {
+              type: "message",
+              message: {
+                messageId: "response",
+                role: "agent",
+                parts: [{ text: "Done" }],
+              },
+            };
+            return;
+          }
           await new Promise<void>((resolve) => {
             if (signal.aborted) {
               resolve();
@@ -103,10 +114,13 @@ describe("useA2ARuntime", () => {
             },
           );
         }
-        return new Response("", {
-          status: 200,
-          headers: { "Content-Type": "text/event-stream" },
-        });
+        return new Response(
+          'data: {"message":{"message_id":"response","role":"ROLE_AGENT","parts":[{"text":"Done"}]}}\n\n',
+          {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+          },
+        );
       },
     );
     vi.stubGlobal("fetch", fetchMock);