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

package/src/AdkSessionAdapter.test.ts

@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { createAdkSessionAdapter } from "./AdkSessionAdapter";
 import { projectAdkToolApprovals } from "./adkToolApproval";
+import type { AdkMessage } from "./types";
 
 // ── Helpers ──
 
@@ -294,6 +295,198 @@ 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("loads valid events when history contains malformed media", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          id: "s1",
+          events: [
+            {
+              id: "user-1",
+              author: "user",
+              content: { parts: [{ text: "before" }] },
+            },
+            {
+              id: "bad-media",
+              author: "agent",
+              content: {
+                parts: [
+                  { inlineData: { data: "aGVsbG8=" } },
+                  { fileData: { mimeType: "image/png" } },
+                ],
+              },
+            },
+            {
+              id: "agent-1",
+              author: "agent",
+              content: { parts: [{ text: "after" }] },
+            },
+          ],
+        }),
+        { status: 200 },
+      ),
+    );
+
+    const { load } = createAdkSessionAdapter(baseOptions);
+    const result = await load("s1");
+
+    expect(result.messages).toMatchObject([
+      { type: "human", content: "before" },
+      { type: "ai", content: [{ type: "text", text: "after" }] },
+    ]);
+  });
+
+  it("loads valid events when history contains request calls without args", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          id: "s1",
+          events: [
+            {
+              id: "user-1",
+              author: "user",
+              content: { parts: [{ text: "before" }] },
+            },
+            {
+              id: "bad-requests",
+              author: "agent",
+              content: {
+                parts: [
+                  {
+                    functionCall: {
+                      name: "adk_request_confirmation",
+                      id: "rc-1",
+                    },
+                  },
+                  {
+                    functionCall: {
+                      name: "adk_request_credential",
+                      id: "rc-2",
+                    },
+                  },
+                ],
+              },
+            },
+            {
+              id: "agent-1",
+              author: "agent",
+              content: { parts: [{ text: "after" }] },
+            },
+          ],
+        }),
+        { status: 200 },
+      ),
+    );
+
+    const { load } = createAdkSessionAdapter(baseOptions);
+    const result = await load("s1");
+
+    expect(result.messages).toMatchObject([
+      { type: "human", content: "before" },
+      { type: "ai" },
+      { type: "ai", content: [{ type: "text", text: "after" }] },
+    ]);
+    expect(
+      (result.messages[1] as AdkMessage & { type: "ai" }).tool_calls,
+    ).toEqual([
+      {
+        id: "rc-1",
+        name: "adk_request_confirmation",
+        args: {},
+        argsText: "{}",
+      },
+      {
+        id: "rc-2",
+        name: "adk_request_credential",
+        args: {},
+        argsText: "{}",
+      },
+    ]);
+    expect(result.toolConfirmations).toMatchObject([{ toolCallId: "rc-1" }]);
+    expect(result.authRequests).toMatchObject([{ toolCallId: "rc-2" }]);
+  });
+
   it("returns the per-turn state the events imply, not just the messages", async () => {
     const session = {
       id: "s1",
@@ -324,6 +517,85 @@ describe("createAdkSessionAdapter - load", () => {
     expect(result.authRequests).toEqual([]);
   });
 
+  it("reports only the requests the stored replies leave unanswered", async () => {
+    const session = {
+      id: "s1",
+      events: [
+        {
+          id: "e1",
+          author: "agent",
+          content: {
+            role: "model",
+            parts: [
+              { functionCall: { name: "transfer", id: "gated-1", args: {} } },
+              { functionCall: { name: "calendar", id: "gated-2", args: {} } },
+            ],
+          },
+        },
+        {
+          id: "e2",
+          author: "agent",
+          longRunningToolIds: ["conf-1", "cred-1"],
+          actions: {
+            requestedToolConfirmations: { "gated-1": { hint: "Transfer?" } },
+          },
+          content: {
+            role: "user",
+            parts: [
+              {
+                functionCall: {
+                  name: "adk_request_confirmation",
+                  id: "conf-1",
+                  args: {
+                    originalFunctionCall: { id: "gated-1", name: "transfer" },
+                    toolConfirmation: { hint: "Transfer?" },
+                  },
+                },
+              },
+              {
+                functionCall: {
+                  name: "adk_request_credential",
+                  id: "cred-1",
+                  args: {
+                    functionCallId: "gated-2",
+                    authConfig: { credentialKey: "k" },
+                  },
+                },
+              },
+            ],
+          },
+        },
+        {
+          id: "e3",
+          author: "user",
+          content: {
+            role: "user",
+            parts: [
+              {
+                functionResponse: {
+                  name: "adk_request_confirmation",
+                  id: "conf-1",
+                  response: { confirmed: true },
+                },
+              },
+            ],
+          },
+        },
+      ],
+    };
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify(session), { status: 200 }),
+    );
+
+    const { load } = createAdkSessionAdapter(baseOptions);
+    const result = await load("s1");
+
+    expect(result.toolConfirmations).toEqual([]);
+    expect(result.authRequests).toEqual([
+      { toolCallId: "cred-1", authConfig: { credentialKey: "k" } },
+    ]);
+  });
+
   it("passes an abort signal through to the request", async () => {
     mockFetch.mockResolvedValueOnce(
       new Response(JSON.stringify({ id: "s1", events: [] }), { status: 200 }),
@@ -543,10 +815,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 });
 
@@ -639,6 +918,7 @@ describe("createAdkSessionAdapter - artifacts", () => {
       "inline data",
       { inlineData: { mimeType: "image/png", data: "aGVsbG8=" } },
     ],
+    ["file data", { fileData: { fileUri: "https://example.test/report.pdf" } }],
   ])("loads valid %s artifacts", async (_label, artifact) => {
     mockFetch.mockResolvedValueOnce(
       new Response(JSON.stringify(artifact), { status: 200 }),
@@ -649,6 +929,75 @@ describe("createAdkSessionAdapter - artifacts", () => {
     await expect(artifacts.load("s1", "report.pdf")).resolves.toEqual(artifact);
   });
 
+  it.each([
+    [
+      "inline data",
+      { inline_data: { mime_type: "application/pdf", data: "aGVsbG8=" } },
+      { inlineData: { mimeType: "application/pdf", data: "aGVsbG8=" } },
+    ],
+    [
+      "file data",
+      {
+        file_data: {
+          mime_type: "application/pdf",
+          file_uri: "https://example.test/report.pdf",
+        },
+      },
+      {
+        fileData: {
+          mimeType: "application/pdf",
+          fileUri: "https://example.test/report.pdf",
+        },
+      },
+    ],
+  ])(
+    "normalizes snake_case %s artifact responses",
+    async (_label, value, expected) => {
+      mockFetch.mockResolvedValueOnce(
+        new Response(JSON.stringify(value), { status: 200 }),
+      );
+
+      const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+      await expect(artifacts.load("s1", "report.pdf")).resolves.toMatchObject(
+        expected,
+      );
+    },
+  );
+
+  it("prefers camelCase artifact fields when both aliases are present", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          inlineData: {
+            mimeType: "image/png",
+            mime_type: "application/pdf",
+            data: "right",
+          },
+          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" },
+        }),
+        { status: 200 },
+      ),
+    );
+
+    const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+    await expect(artifacts.load("s1", "report.pdf")).resolves.toMatchObject({
+      inlineData: { mimeType: "image/png", data: "right" },
+      fileData: {
+        mimeType: "application/pdf",
+        fileUri: "https://example.test/right.pdf",
+      },
+    });
+  });
+
   it("rejects an artifact without supported content", async () => {
     mockFetch.mockResolvedValueOnce(
       new Response(JSON.stringify({}), { status: 200 }),
@@ -657,7 +1006,7 @@ describe("createAdkSessionAdapter - artifacts", () => {
     const { artifacts } = createAdkSessionAdapter(baseOptions);
 
     await expect(artifacts.load("s1", "report.pdf")).rejects.toThrow(
-      'Invalid ADK artifact load response: expected an object containing "text" or "inlineData".',
+      'Invalid ADK artifact load response: expected an object containing "text", "inlineData", or "fileData".',
     );
   });
 
@@ -672,6 +1021,11 @@ describe("createAdkSessionAdapter - artifacts", () => {
       { inlineData: { mimeType: "image/png" } },
       'Invalid ADK artifact load response: "inlineData" must contain string "mimeType" and "data" fields.',
     ],
+    [
+      "file data",
+      { fileData: { mimeType: "application/pdf" } },
+      'Invalid ADK artifact load response: "fileData" must contain a string "fileUri" and an optional string "mimeType" field.',
+    ],
   ])("rejects malformed %s artifact content", async (_label, value, error) => {
     mockFetch.mockResolvedValueOnce(
       new Response(JSON.stringify(value), { status: 200 }),

package/src/AdkSessionAdapter.ts

@@ -6,6 +6,7 @@ import type {
   RemoteThreadMetadata,
 } from "@assistant-ui/core";
 import { AdkEventAccumulator } from "./AdkEventAccumulator";
+import { normalizeAdkPart } from "./normalizeAdkPart";
 import { parseAdkEventValue } from "./parseAdkEvent";
 import type { AdkMessage, AdkThreadSnapshot } from "./types";
 import { trimTrailingSlashes } from "./trimTrailingSlashes";
@@ -37,6 +38,7 @@ export type AdkSessionAdapterOptions = {
 
 export type AdkArtifactData = {
   inlineData?: { mimeType: string; data: string } | undefined;
+  fileData?: { fileUri: string; mimeType?: string | undefined } | undefined;
   text?: string | undefined;
 };
 
@@ -133,14 +135,19 @@ const parseAdkArtifactListResponse = (value: unknown): string[] => {
 const parseAdkArtifactResponse = (value: unknown): AdkArtifactData => {
   if (!isRecord(value)) {
     throw new Error(
-      'Invalid ADK artifact load response: expected an object containing "text" or "inlineData".',
+      'Invalid ADK artifact load response: expected an object containing "text", "inlineData", or "fileData".',
     );
   }
 
-  const { text, inlineData } = value;
-  if (text === undefined && inlineData === undefined) {
+  const normalizedValue = normalizeAdkPart(value);
+  const { text, inlineData, fileData } = normalizedValue;
+  if (
+    text === undefined &&
+    inlineData === undefined &&
+    fileData === undefined
+  ) {
     throw new Error(
-      'Invalid ADK artifact load response: expected an object containing "text" or "inlineData".',
+      'Invalid ADK artifact load response: expected an object containing "text", "inlineData", or "fileData".',
     );
   }
 
@@ -161,7 +168,19 @@ const parseAdkArtifactResponse = (value: unknown): AdkArtifactData => {
     );
   }
 
-  return value as AdkArtifactData;
+  if (
+    fileData !== undefined &&
+    (!isRecord(fileData) ||
+      typeof fileData.fileUri !== "string" ||
+      (fileData.mimeType !== undefined &&
+        typeof fileData.mimeType !== "string"))
+  ) {
+    throw new Error(
+      'Invalid ADK artifact load response: "fileData" must contain a string "fileUri" and an optional string "mimeType" field.',
+    );
+  }
+
+  return normalizedValue as AdkArtifactData;
 };
 
 const parseAdkArtifactVersionsResponse = (value: unknown): number[] => {

package/src/adkToolApproval.test.ts

@@ -206,10 +206,6 @@ describe("projectAdkToolApprovals", () => {
     ]);
   });
 
-  /**
-   * ADK Python spells the confirmation args in snake_case, which the event
-   * accumulator already reads both ways.
-   */
   it("gates the call named by a snake_case confirmation request", () => {
     const { approvals } = projectAdkToolApprovals([
       aiCall(GATED_CALL, "delete_file", { path: "/tmp/a" }),

package/src/adkToolApproval.ts

@@ -85,9 +85,7 @@ const sourceEventOf = (toolMessageId: string): string =>
   toolMessageId.replace(/:\d+$/, "");
 
 /**
- * ADK builds the confirmation request around the call it gates, carrying that
- * call verbatim in `originalFunctionCall` — spelled `original_function_call` by
- * ADK Python, which the accumulator reads the same way.
+ * ADK builds the confirmation request around the call it gates, carrying that call verbatim in `originalFunctionCall`; `original_function_call` is accepted as well, matching the accumulator.
  */
 const gatedCallIdOf = (args: unknown): string | undefined => {
   if (typeof args !== "object" || args === null) return undefined;

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/normalizeAdkPart.ts

@@ -0,0 +1,35 @@
+import { isRecord } from "@assistant-ui/core/internal";
+
+export const normalizeAdkPart = (
+  part: Record<string, unknown>,
+): Record<string, unknown> => {
+  const result: Record<string, unknown> = { ...part };
+  if ("function_call" in part && !("functionCall" in part))
+    result.functionCall = part.function_call;
+  if ("function_response" in part && !("functionResponse" in part))
+    result.functionResponse = part.function_response;
+  if ("inline_data" in part && !("inlineData" in part))
+    result.inlineData = part.inline_data;
+  if ("file_data" in part && !("fileData" in part))
+    result.fileData = part.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 part && !("executableCode" in part))
+    result.executableCode = part.executable_code;
+  if ("code_execution_result" in part && !("codeExecutionResult" in part))
+    result.codeExecutionResult = part.code_execution_result;
+  return result;
+};

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",
+};