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

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();
@@ -933,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", () => {
@@ -1044,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))
@@ -210,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[] {
@@ -359,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
@@ -541,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;

package/src/AdkSessionAdapter.test.ts

@@ -294,6 +294,87 @@ describe("createAdkSessionAdapter - fetch", () => {
 // ── load() ──
 
 describe("createAdkSessionAdapter - load", () => {
+  it("restores tool failures from stored function responses", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          id: "s1",
+          events: [
+            {
+              id: "failed",
+              author: "user",
+              content: {
+                parts: [
+                  {
+                    functionResponse: {
+                      id: "tc-1",
+                      name: "search",
+                      response: { error: "denied" },
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        }),
+        { status: 200 },
+      ),
+    );
+    const { load } = createAdkSessionAdapter(baseOptions);
+    const result = await load("s1");
+    expect(result.messages).toMatchObject([
+      {
+        type: "tool",
+        tool_call_id: "tc-1",
+        status: "error",
+        content: JSON.stringify({ error: "denied" }),
+      },
+    ]);
+  });
+
+  it("restores snake_case image and file parts from session history", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          id: "s1",
+          events: [
+            {
+              id: "media",
+              author: "user",
+              content: {
+                parts: [
+                  { inline_data: { mime_type: "image/png", data: "aGVsbG8=" } },
+                  {
+                    file_data: {
+                      mime_type: "application/pdf",
+                      file_uri: "https://example.test/report.pdf",
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        }),
+        { status: 200 },
+      ),
+    );
+    const { load } = createAdkSessionAdapter(baseOptions);
+    const result = await load("s1");
+    expect(result.messages).toMatchObject([
+      {
+        type: "human",
+        content: [
+          { type: "image", mimeType: "image/png", data: "aGVsbG8=" },
+          {
+            type: "file_url",
+            mimeType: "application/pdf",
+            url: "https://example.test/report.pdf",
+          },
+        ],
+      },
+    ]);
+  });
+
   it("returns the per-turn state the events imply, not just the messages", async () => {
     const session = {
       id: "s1",
@@ -543,10 +624,17 @@ describe("createAdkSessionAdapter - load replays tool confirmations", () => {
     const result = await load("s1");
     return {
       messages: result.messages,
+      longRunningToolIds: result.longRunningToolIds,
       approvals: projectAdkToolApprovals(result.messages).approvals,
     };
   };
 
+  it("settles an answered long-running tool on replay", async () => {
+    const { longRunningToolIds } = await loadApprovals({ confirmed: true });
+
+    expect(longRunningToolIds).toEqual([]);
+  });
+
   it("keeps a user-authored confirmation reply as a tool message", async () => {
     const { messages } = await loadApprovals({ confirmed: true });
 

package/src/convertToAdkMessages.test.ts

@@ -7,6 +7,7 @@ import {
 import { convertAdkMessage } from "./convertAdkMessages";
 import type { AppendMessage } from "@assistant-ui/core";
 import type { AdkMessage } from "./types";
+import { contentToParts } from "./contentToParts";
 
 const makeAppendMessage = (content: AppendMessage["content"]): AppendMessage =>
   ({
@@ -155,6 +156,75 @@ describe("getPendingCancellations", () => {
 });
 
 describe("getMessageContent", () => {
+  it("serializes data URL images as inline data", () => {
+    const content = getMessageContent(
+      makeAppendMessage([
+        { type: "image", image: "data:image/png;base64,AAAA" },
+      ]),
+    );
+
+    expect(contentToParts(content)).toEqual([
+      { inlineData: { mimeType: "image/png", data: "AAAA" } },
+    ]);
+  });
+
+  it("infers an image MIME type when the data URL declares a generic type", () => {
+    const content = getMessageContent(
+      makeAppendMessage([
+        {
+          type: "image",
+          image: "data:application/octet-stream;base64,iVBORw0KGgo=",
+        },
+      ]),
+    );
+
+    expect(contentToParts(content)).toEqual([
+      { inlineData: { mimeType: "image/png", data: "iVBORw0KGgo=" } },
+    ]);
+  });
+
+  it("prefers an attachment's declared image MIME type", () => {
+    const message = makeAppendMessage([]);
+    const content = getMessageContent({
+      ...message,
+      attachments: [
+        {
+          id: "attachment-1",
+          type: "image",
+          name: "photo.webp",
+          contentType: "image/webp",
+          status: { type: "complete" },
+          content: [{ type: "image", image: "data:image/png;base64,AAAA" }],
+        },
+      ],
+    });
+
+    expect(contentToParts(content)).toEqual([
+      { inlineData: { mimeType: "image/webp", data: "AAAA" } },
+    ]);
+  });
+
+  it("resolves wildcard attachment MIME types to a concrete image type", () => {
+    const message = makeAppendMessage([]);
+    const content = getMessageContent({
+      ...message,
+      attachments: [
+        {
+          id: "attachment-1",
+          type: "image",
+          name: "photo.jpg",
+          contentType: "image/*",
+          status: { type: "complete" },
+          content: [{ type: "image", image: "data:image/jpeg;base64,AAAA" }],
+        },
+      ],
+    });
+
+    expect(contentToParts(content)).toEqual([
+      { inlineData: { mimeType: "image/jpeg", data: "AAAA" } },
+    ]);
+  });
+
   it("preserves file part data and mimeType end-to-end", () => {
     const result = getMessageContent(
       makeAppendMessage([

package/src/convertToAdkMessages.ts

@@ -8,6 +8,7 @@ import {
   createToolCallCancellationStub,
   parseDataUrl,
   resolveFilePartSource,
+  resolveImageMediaType,
   scanPendingToolCalls,
 } from "@assistant-ui/core/internal";
 import type { AdkMessage } from "./types";
@@ -15,16 +16,30 @@ import type { AdkMessage } from "./types";
 /** Exported for unit tests. */
 export const getMessageContent = (msg: AppendMessage) => {
   const allContent = [
-    ...msg.content,
-    ...(msg.attachments?.flatMap((a) => a.content) ?? []),
+    ...msg.content.map((part) => ({ part, contentType: undefined })),
+    ...(msg.attachments?.flatMap((attachment) =>
+      attachment.content.map((part) => ({
+        part,
+        contentType: attachment.contentType,
+      })),
+    ) ?? []),
   ];
-  const content = allContent.flatMap((part) => {
+  const content = allContent.flatMap(({ part, contentType }) => {
     const type = part.type;
     switch (type) {
       case "text":
         return { type: "text" as const, text: part.text };
-      case "image":
+      case "image": {
+        const parsed = parseDataUrl(part.image);
+        if (parsed) {
+          return {
+            type: "image" as const,
+            mimeType: resolveImageMediaType(part.image, contentType),
+            data: parsed.data,
+          };
+        }
         return { type: "image_url" as const, url: part.image };
+      }
       case "file": {
         const source = resolveFilePartSource(part);
         if (source.kind === "url") {

package/src/sdkIdentity.ts

@@ -0,0 +1,9 @@
+import type { SdkIdentity } from "assistant-cloud";
+
+export const ADK_SDK: SdkIdentity = {
+  name: "@assistant-ui/react-google-adk",
+  version:
+    typeof __AUI_PACKAGE_VERSION__ === "string"
+      ? __AUI_PACKAGE_VERSION__
+      : "0.0.0",
+};

package/src/server/parseAdkRequest.test.ts

@@ -239,6 +239,41 @@ describe("parseAdkRequest", () => {
 });
 
 describe("toAdkContent", () => {
+  it.each([
+    ["permission denied", { error: "permission denied" }],
+    [
+      { message: "permission denied" },
+      { error: { message: "permission denied" } },
+    ],
+    [["denied"], { error: ["denied"] }],
+    [null, { error: null }],
+    [false, { error: false }],
+    [0, { error: 0 }],
+    ["", { error: "" }],
+    [
+      { error: "denied", output: "partial" },
+      { error: "denied", output: "partial" },
+    ],
+  ])(
+    "preserves explicit tool failure %j in the function response",
+    async (result, response) => {
+      const parsed = await parseAdkRequest(
+        makeRequest({
+          type: "tool-result",
+          toolCallId: "tc-1",
+          toolName: "search",
+          result,
+          isError: true,
+        }),
+      );
+      expect(toAdkContent(parsed).parts).toEqual([
+        {
+          functionResponse: { name: "search", id: "tc-1", response },
+        },
+      ]);
+    },
+  );
+
   it("converts a text message to user content with text part", () => {
     const content = toAdkContent({
       type: "message",
@@ -292,4 +327,32 @@ describe("toAdkContent", () => {
       ],
     });
   });
+
+  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 %j in a function response object",
+    (result, response) => {
+      const content = toAdkContent({
+        type: "tool-result",
+        toolCallId: "tc-1",
+        toolName: "search",
+        result,
+        isError: false,
+        config: {},
+      });
+
+      expect(content.parts[0]).toEqual({
+        functionResponse: {
+          name: "search",
+          id: "tc-1",
+          response,
+        },
+      });
+    },
+  );
 });