@assistant-ui/react-google-adk 0.0.28 → 0.0.30

package/src/AdkClient.test.ts

@@ -1,6 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { createAdkStream } from "./AdkClient";
 import { adkEventStream } from "./server/adkEventStream";
+import { AdkEventAccumulator } from "./AdkEventAccumulator";
+import { parseAdkRequest, toAdkContent } from "./server/parseAdkRequest";
 import type { AdkEvent, AdkMessage, AdkSendMessageConfig } from "./types";
 
 // ── Helpers ──
@@ -65,9 +67,103 @@ beforeEach(() => {
   mockFetch.mockReset();
 });
 
+describe.each(["direct", "proxy", "proxy batch"] as const)(
+  "%s tool outcomes",
+  (mode) => {
+    it.each(["error", "success"] as const)(
+      "preserves %s through the runner request",
+      async (status) => {
+        mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
+        const stream = createAdkStream(
+          mode === "direct"
+            ? { api: "http://localhost:8000", appName: "app", userId: "user" }
+            : { api: "/api/adk" },
+        );
+        const messages: AdkMessage[] = [
+          {
+            id: "result",
+            type: "tool",
+            name: "search",
+            tool_call_id: "tc-1",
+            content: "permission denied",
+            status,
+          },
+        ];
+        if (mode === "proxy batch")
+          messages.push({ id: "human", type: "human", content: "continue" });
+        const events = await stream(messages, makeConfig());
+        for await (const event of events) expect(event).toBeUndefined();
+        const body = JSON.parse(mockFetch.mock.calls[0]![1]!.body as string);
+        const content =
+          mode === "direct"
+            ? body.newMessage
+            : toAdkContent(
+                await parseAdkRequest(
+                  new Request("http://localhost/api/adk", {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                    headers: { "Content-Type": "application/json" },
+                  }),
+                ),
+              );
+        expect(content.parts[0]).toEqual({
+          functionResponse: {
+            id: "tc-1",
+            name: "search",
+            response:
+              status === "error"
+                ? { error: "permission denied" }
+                : { result: "permission denied" },
+          },
+        });
+      },
+    );
+  },
+);
+
 // ── Proxy mode ──
 
 describe("createAdkStream - proxy mode", () => {
+  it("accumulates snake_case image and file parts from SSE", async () => {
+    const event = {
+      id: "media",
+      author: "agent",
+      content: {
+        parts: [
+          { inline_data: { mime_type: "image/png", data: "aGVsbG8=" } },
+          {
+            file_data: {
+              mime_type: "application/pdf",
+              file_uri: "https://example.test/report.pdf",
+            },
+          },
+        ],
+      },
+    };
+    mockFetch.mockResolvedValueOnce(
+      sseResponse(sseBody(`data: ${JSON.stringify(event)}\n\n`)),
+    );
+    const stream = createAdkStream({ api: "/api/adk" });
+    const events = await stream(
+      [{ id: "human", type: "human", content: "show files" }],
+      makeConfig(),
+    );
+    const acc = new AdkEventAccumulator();
+    for await (const item of events) acc.processEvent(item);
+    expect(acc.getMessages()).toMatchObject([
+      {
+        content: [
+          { type: "image", mimeType: "image/png", data: "aGVsbG8=" },
+          {
+            type: "file_url",
+            mimeType: "application/pdf",
+            url: "https://example.test/report.pdf",
+          },
+        ],
+      },
+    ]);
+  });
+
   it("POSTs to the api URL directly", async () => {
     mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
@@ -378,7 +474,7 @@ describe("createAdkStream - direct mode", () => {
     });
   });
 
-  it("falls back to raw string when tool content is not valid JSON", async () => {
+  it("wraps non-JSON tool content in a function response object", async () => {
     mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
@@ -401,9 +497,50 @@ describe("createAdkStream - direct mode", () => {
     }
 
     const body = JSON.parse(mockFetch.mock.calls[0]![1]?.body as string);
-    expect(body.newMessage.parts[0].functionResponse.response).toBe("not-json");
+    expect(body.newMessage.parts[0].functionResponse.response).toEqual({
+      result: "not-json",
+    });
   });
 
+  it.each([
+    ["false", { result: false }],
+    ["0", { result: 0 }],
+    ["null", { result: null }],
+    ['"done"', { result: "done" }],
+    ["[1,2]", { results: [1, 2] }],
+  ])(
+    "wraps scalar or array tool result %s in direct mode",
+    async (content, response) => {
+      mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
+
+      const stream = createAdkStream({
+        api: "http://localhost:8000",
+        appName: "app",
+        userId: "u",
+      });
+      const gen = await stream(
+        [
+          {
+            id: "t1",
+            type: "tool",
+            content,
+            tool_call_id: "tc-1",
+            name: "search",
+          },
+        ],
+        makeConfig(),
+      );
+      for await (const _ of gen) {
+        /* noop */
+      }
+
+      const body = JSON.parse(mockFetch.mock.calls[0]![1]?.body as string);
+      expect(body.newMessage.parts[0].functionResponse.response).toEqual(
+        response,
+      );
+    },
+  );
+
   it("sends empty text part when no messages provided", async () => {
     mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
@@ -472,6 +609,59 @@ describe("createAdkStream - SSE parsing", () => {
     },
   );
 
+  it.each([
+    [{ content: [] }, "content", "an object"],
+    [{ content: { parts: 42 } }, "content.parts", "an array of objects"],
+    [{ content: { parts: [null] } }, "content.parts", "an array of objects"],
+  ])(
+    "rejects malformed nested stream event content: %#",
+    async (event, field, expectation) => {
+      mockFetch.mockResolvedValueOnce(
+        sseResponse(sseBody(`data: ${JSON.stringify(event)}\n\n`)),
+      );
+
+      const stream = createAdkStream({ api: "/api/adk" });
+      const consume = async () => {
+        const gen = await stream(
+          [{ id: "m1", type: "human", content: "Hi" }],
+          makeConfig(),
+        );
+        for await (const _event of gen) {
+          void _event;
+        }
+      };
+
+      await expect(consume()).rejects.toThrow(
+        `Invalid ADK stream event: expected "${field}" to be ${expectation} when present.`,
+      );
+    },
+  );
+
+  it.each([
+    [{ id: "e1", content: null }, undefined],
+    [{ id: "e1", content: { role: "model", parts: null } }, { role: "model" }],
+  ])(
+    "accepts null optional nested stream event content: %#",
+    async (event, expectedContent) => {
+      mockFetch.mockResolvedValueOnce(
+        sseResponse(sseBody(`data: ${JSON.stringify(event)}\n\n`)),
+      );
+
+      const stream = createAdkStream({ api: "/api/adk" });
+      const gen = await stream(
+        [{ id: "m1", type: "human", content: "Hi" }],
+        makeConfig(),
+      );
+      const collected: AdkEvent[] = [];
+      for await (const parsedEvent of gen) {
+        collected.push(parsedEvent);
+      }
+
+      expect(collected).toHaveLength(1);
+      expect(collected[0]!.content).toEqual(expectedContent);
+    },
+  );
+
   it("reports invalid JSON as an ADK stream event error", async () => {
     mockFetch.mockResolvedValueOnce(sseResponse(sseBody("data: not-json\n\n")));
 

package/src/AdkClient.ts

@@ -1,6 +1,7 @@
 import { SSEEventDecoder } from "assistant-stream/utils";
 import { contentToParts } from "./contentToParts";
 import { parseAdkEventValue } from "./parseAdkEvent";
+import { toAdkFunctionResponse } from "./toAdkFunctionResponse";
 import { trimTrailingSlashes } from "./trimTrailingSlashes";
 import type {
   AdkEvent,
@@ -180,7 +181,7 @@ function messagesToContent(messages: AdkMessage[]): {
         functionResponse: {
           name: msg.name,
           id: msg.tool_call_id,
-          response,
+          response: toAdkFunctionResponse(response, msg.status === "error"),
         },
       });
     }

package/src/AdkEventAccumulator.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from "vitest";
 import { AdkEventAccumulator } from "./AdkEventAccumulator";
+import { parseAdkEventValue } from "./parseAdkEvent";
 import type { AdkEvent, AdkMessage, AdkMessageContentPart } from "./types";
 
 const makeEvent = (overrides: Partial<AdkEvent> = {}): AdkEvent => ({
@@ -18,6 +19,41 @@ const makeTextEvent = (
     content: { role: "model", parts: [{ text }] },
   });
 
+describe.each(["user", "agent"])("%s function response status", (author) => {
+  it.each([
+    [{ error: "denied" }, "error"],
+    [{ error: { message: "denied" }, output: "partial" }, "error"],
+    [{ error: null }, "error"],
+    [{ error: false }, "error"],
+    [{ error: "" }, "error"],
+    [{ output: { error: "application data" } }, "success"],
+    [{ result: "done" }, "success"],
+    [{}, "success"],
+  ] as const)("classifies response %j as %s", (response, status) => {
+    const acc = new AdkEventAccumulator();
+    const messages = acc.processEvent(
+      makeEvent({
+        author,
+        content: {
+          parts: [
+            {
+              functionResponse: { id: "tc-1", name: "search", response },
+            },
+          ],
+        },
+      }),
+    );
+    expect(messages).toMatchObject([
+      {
+        type: "tool",
+        tool_call_id: "tc-1",
+        status,
+        content: JSON.stringify(response),
+      },
+    ]);
+  });
+});
+
 describe("AdkEventAccumulator - text handling", () => {
   it("accumulates a single non-partial text event into an AI message", () => {
     const acc = new AdkEventAccumulator();
@@ -838,6 +874,27 @@ describe("AdkEventAccumulator - actions tracking", () => {
     expect(acc.getArtifactDelta()).toEqual({ "file.txt": 1 });
   });
 
+  it("preserves prototype-named state and artifact keys", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(
+      makeEvent({
+        actions: {
+          stateDelta: JSON.parse('{"__proto__":"session"}'),
+          artifactDelta: JSON.parse('{"__proto__":1}'),
+        },
+        author: "agent",
+        content: { parts: [{ text: "x" }] },
+      }),
+    );
+
+    const stateDelta = acc.getStateDelta();
+    const artifactDelta = acc.getArtifactDelta();
+    expect(Object.hasOwn(stateDelta, "__proto__")).toBe(true);
+    expect(stateDelta["__proto__"]).toBe("session");
+    expect(Object.hasOwn(artifactDelta, "__proto__")).toBe(true);
+    expect(artifactDelta["__proto__"]).toBe(1);
+  });
+
   it("tracks escalation flag", () => {
     const acc = new AdkEventAccumulator();
     expect(acc.isEscalated()).toBe(false);
@@ -912,6 +969,99 @@ describe("AdkEventAccumulator - actions tracking", () => {
     );
     expect(acc.getLongRunningToolIds()).toEqual(["lrt-1"]);
   });
+
+  it("settles a long-running id when a user-authored response answers it", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(
+      makeEvent({
+        author: "agent",
+        longRunningToolIds: ["lrt-1", "lrt-2"],
+        content: {
+          parts: [
+            {
+              functionCall: { name: "ask_for_approval", id: "lrt-1", args: {} },
+            },
+            {
+              functionCall: { name: "ask_for_approval", id: "lrt-2", args: {} },
+            },
+          ],
+        },
+      }),
+    );
+    acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: {
+          parts: [
+            {
+              functionResponse: {
+                name: "ask_for_approval",
+                id: "lrt-1",
+                response: { status: "approved" },
+              },
+            },
+          ],
+        },
+      }),
+    );
+    expect(acc.getLongRunningToolIds()).toEqual(["lrt-2"]);
+  });
+
+  it("keeps a long-running id pending through the interim response ADK authors", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(
+      makeEvent({
+        author: "agent",
+        longRunningToolIds: ["lrt-1"],
+        content: {
+          parts: [
+            {
+              functionCall: { name: "ask_for_approval", id: "lrt-1", args: {} },
+            },
+          ],
+        },
+      }),
+    );
+    acc.processEvent(
+      makeEvent({
+        author: "agent",
+        content: {
+          parts: [
+            {
+              functionResponse: {
+                name: "ask_for_approval",
+                id: "lrt-1",
+                response: { status: "pending" },
+              },
+            },
+          ],
+        },
+      }),
+    );
+    expect(acc.getLongRunningToolIds()).toEqual(["lrt-1"]);
+  });
+
+  it("seeds and settles longRunningToolIds from a user response", () => {
+    const acc = new AdkEventAccumulator([], ["lrt-1", "lrt-2"]);
+    acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: {
+          role: "user",
+          parts: [
+            {
+              functionResponse: {
+                id: "lrt-1",
+                name: "adk_request_confirmation",
+                response: { confirmed: true },
+              },
+            },
+          ],
+        },
+      }),
+    );
+    expect(acc.getLongRunningToolIds()).toEqual(["lrt-2"]);
+  });
 });
 
 describe("AdkEventAccumulator - special function calls", () => {
@@ -1023,6 +1173,153 @@ describe("AdkEventAccumulator - author/agent tracking", () => {
 });
 
 describe("AdkEventAccumulator - snake_case normalization", () => {
+  describe.each(["user", "agent"])("%s media", (author) => {
+    it.each([
+      {
+        part: { inline_data: { mime_type: "image/png", data: "aGVsbG8=" } },
+        expected: { type: "image", mimeType: "image/png", data: "aGVsbG8=" },
+      },
+      {
+        part: {
+          inline_data: { mime_type: "application/pdf", data: "aGVsbG8=" },
+        },
+        expected: {
+          type: "file",
+          mimeType: "application/pdf",
+          data: "aGVsbG8=",
+        },
+      },
+      {
+        part: {
+          file_data: {
+            mime_type: "image/png",
+            file_uri: "https://example.test/image.png",
+          },
+        },
+        expected: { type: "image_url", url: "https://example.test/image.png" },
+      },
+      {
+        part: {
+          file_data: {
+            mime_type: "application/pdf",
+            file_uri: "https://example.test/report.pdf",
+          },
+        },
+        expected: {
+          type: "file_url",
+          mimeType: "application/pdf",
+          url: "https://example.test/report.pdf",
+        },
+      },
+      {
+        part: { inlineData: { mime_type: "image/png", data: "aGVsbG8=" } },
+        expected: { type: "image", mimeType: "image/png", data: "aGVsbG8=" },
+      },
+      {
+        part: {
+          fileData: {
+            mime_type: "application/pdf",
+            file_uri: "https://example.test/report.pdf",
+          },
+        },
+        expected: {
+          type: "file_url",
+          mimeType: "application/pdf",
+          url: "https://example.test/report.pdf",
+        },
+      },
+      {
+        part: { inline_data: { mimeType: "image/png", data: "aGVsbG8=" } },
+        expected: { type: "image", mimeType: "image/png", data: "aGVsbG8=" },
+      },
+      {
+        part: {
+          file_data: {
+            mimeType: "application/pdf",
+            fileUri: "https://example.test/report.pdf",
+          },
+        },
+        expected: {
+          type: "file_url",
+          mimeType: "application/pdf",
+          url: "https://example.test/report.pdf",
+        },
+      },
+    ])(
+      "normalizes media aliases without mutating the event: $part",
+      ({ part, expected }) => {
+        const input = { id: "media", author, content: { parts: [part] } };
+        const original = structuredClone(input);
+        const event = parseAdkEventValue(input, "test");
+        const messages = new AdkEventAccumulator().processEvent(event);
+        expect(messages).toMatchObject([
+          { type: author === "user" ? "human" : "ai", content: [expected] },
+        ]);
+        expect(input).toEqual(original);
+      },
+    );
+  });
+
+  it("prefers camelCase media containers and nested values when both exist", () => {
+    const event = parseAdkEventValue(
+      {
+        id: "media",
+        author: "agent",
+        content: {
+          parts: [
+            {
+              inlineData: {
+                mimeType: "image/png",
+                mime_type: "application/pdf",
+                data: "aGVsbG8=",
+              },
+              inline_data: { mime_type: "text/plain", data: "wrong" },
+            },
+            {
+              fileData: {
+                mimeType: "application/pdf",
+                mime_type: "image/png",
+                fileUri: "https://example.test/right.pdf",
+                file_uri: "https://example.test/wrong.png",
+              },
+              file_data: { file_uri: "https://example.test/other.png" },
+            },
+          ],
+        },
+      },
+      "test",
+    );
+    expect(new AdkEventAccumulator().processEvent(event)).toMatchObject([
+      {
+        content: [
+          { type: "image", mimeType: "image/png", data: "aGVsbG8=" },
+          {
+            type: "file_url",
+            mimeType: "application/pdf",
+            url: "https://example.test/right.pdf",
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("leaves similarly named tool arguments untouched", () => {
+    const args = { inline_data: { mime_type: "custom", file_uri: "opaque" } };
+    const event = parseAdkEventValue(
+      {
+        id: "call",
+        author: "agent",
+        content: {
+          parts: [{ function_call: { name: "test", id: "tc-1", args } }],
+        },
+      },
+      "test",
+    );
+    expect(new AdkEventAccumulator().processEvent(event)).toMatchObject([
+      { tool_calls: [{ args }] },
+    ]);
+  });
+
   it("normalizes function_call to functionCall in parts", () => {
     const acc = new AdkEventAccumulator();
     const msgs = acc.processEvent(

package/src/AdkEventAccumulator.ts

@@ -1,4 +1,5 @@
 import { generateId } from "@assistant-ui/core";
+import { isRecord } from "@assistant-ui/core/internal";
 import type { MessageStatus } from "@assistant-ui/core";
 import type {
   AdkEvent,
@@ -11,6 +12,7 @@ import type {
   AdkMessageMetadata,
 } from "./types";
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
+import { isAdkFunctionError } from "./toAdkFunctionResponse";
 
 type InProgressMessage = AdkMessage & { type: "ai" };
 
@@ -125,6 +127,21 @@ const normalizeEventPart = (part: AdkEventPart): AdkEventPart => {
   if ("inline_data" in p && !("inlineData" in p))
     result.inlineData = p.inline_data;
   if ("file_data" in p && !("fileData" in p)) result.fileData = p.file_data;
+  if (isRecord(result.inlineData)) {
+    const data = result.inlineData;
+    if ("mime_type" in data && !("mimeType" in data))
+      result.inlineData = { ...data, mimeType: data.mime_type };
+  }
+  if (isRecord(result.fileData)) {
+    const data = result.fileData;
+    result.fileData = {
+      ...data,
+      ...("mime_type" in data &&
+        !("mimeType" in data) && { mimeType: data.mime_type }),
+      ...("file_uri" in data &&
+        !("fileUri" in data) && { fileUri: data.file_uri }),
+    };
+  }
   if ("executable_code" in p && !("executableCode" in p))
     result.executableCode = p.executable_code;
   if ("code_execution_result" in p && !("codeExecutionResult" in p))
@@ -194,8 +211,9 @@ export class AdkEventAccumulator {
   private finalTextReplacedThisEvent = false;
   private finalReasoningReplacedThisEvent = false;
   private partialReasoningBuffer = "";
-  private accumulatedStateDelta: Record<string, unknown> = {};
-  private accumulatedArtifactDelta: Record<string, number> = {};
+  private accumulatedStateDelta: Record<string, unknown> = Object.create(null);
+  private accumulatedArtifactDelta: Record<string, number> =
+    Object.create(null);
   private lastAgentInfo: {
     name?: string | undefined;
     branch?: string | undefined;
@@ -209,12 +227,18 @@ export class AdkEventAccumulator {
   // How many assistant messages each event has opened, so a replay of that
   // event opens them with the same ids.
   private aiMessageOrdinals = new Map<string, number>();
-  constructor(initialMessages?: AdkMessage[]) {
+  constructor(
+    initialMessages?: AdkMessage[],
+    initialLongRunningToolIds?: readonly string[],
+  ) {
     if (initialMessages) {
       for (const msg of initialMessages) {
         this.messagesMap.set(msg.id, msg);
       }
     }
+    if (initialLongRunningToolIds) {
+      this.pendingLongRunningToolIds = new Set(initialLongRunningToolIds);
+    }
   }
 
   processEvent(rawEvent: AdkEvent): AdkMessage[] {
@@ -358,8 +382,12 @@ export class AdkEventAccumulator {
             tool_call_id: part.functionResponse.id,
             name: part.functionResponse.name,
             content: JSON.stringify(part.functionResponse.response),
-            status: "success",
+            status: isAdkFunctionError(part.functionResponse.response)
+              ? "error"
+              : "success",
           });
+          // Only a user-authored response settles a long-running call; the response ADK authors for one is the tool's interim result.
+          this.pendingLongRunningToolIds.delete(part.functionResponse.id);
         }
       }
       // The replies answer the preceding assistant turn, so they are emitted
@@ -540,7 +568,9 @@ export class AdkEventAccumulator {
         tool_call_id: part.functionResponse.id ?? "",
         name: part.functionResponse.name,
         content: JSON.stringify(part.functionResponse.response),
-        status: "success",
+        status: isAdkFunctionError(part.functionResponse.response)
+          ? "error"
+          : "success",
       };
       this.messagesMap.set(toolMsg.id, toolMsg);
       return;