@assistant-ui/react-google-adk 0.0.30 → 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 ──
 
@@ -375,6 +376,117 @@ describe("createAdkSessionAdapter - load", () => {
     ]);
   });
 
+  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",
@@ -405,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 }),
@@ -727,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 }),
@@ -737,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 }),
@@ -745,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".',
     );
   });
 
@@ -760,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/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/structuredEvents.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { toAdkStructuredEvents } from "./structuredEvents";
+import type { AdkEvent } from "./types";
+
+const makeEvent = (overrides: Partial<AdkEvent> = {}): AdkEvent => ({
+  id: "evt-1",
+  ...overrides,
+});
+
+describe("toAdkStructuredEvents", () => {
+  it("converts a function call with args", () => {
+    expect(
+      toAdkStructuredEvents(
+        makeEvent({
+          author: "agent",
+          content: {
+            role: "model",
+            parts: [
+              {
+                functionCall: { name: "search", id: "tc-1", args: { q: "x" } },
+              },
+            ],
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        type: "tool_call",
+        call: { name: "search", id: "tc-1", args: { q: "x" } },
+      },
+    ]);
+  });
+
+  it("defaults a function call without args to empty args", () => {
+    expect(
+      toAdkStructuredEvents(
+        makeEvent({
+          author: "agent",
+          content: {
+            role: "model",
+            parts: [{ functionCall: { name: "search", id: "tc-1" } }],
+          },
+        }),
+      ),
+    ).toEqual([
+      { type: "tool_call", call: { name: "search", id: "tc-1", args: {} } },
+    ]);
+  });
+
+  it("keeps the other parts of an event carrying a call without args", () => {
+    expect(
+      toAdkStructuredEvents(
+        makeEvent({
+          author: "agent",
+          content: {
+            role: "model",
+            parts: [
+              { functionCall: { name: "search" } },
+              { text: "still here" },
+            ],
+          },
+        }),
+      ),
+    ).toEqual([
+      { type: "tool_call", call: { name: "search", args: {} } },
+      { type: "content", content: "still here" },
+    ]);
+  });
+});

package/src/structuredEvents.ts

@@ -28,7 +28,10 @@ export function toAdkStructuredEvents(event: AdkEvent): AdkStructuredEvent[] {
       if (part.functionCall) {
         const call: AdkStructuredEvent & { type: "tool_call" } = {
           type: "tool_call",
-          call: { name: part.functionCall.name, args: part.functionCall.args },
+          call: {
+            name: part.functionCall.name,
+            args: part.functionCall.args ?? {},
+          },
         };
         if (part.functionCall.id != null) call.call.id = part.functionCall.id;
         result.push(call);

package/src/types.ts

@@ -9,7 +9,7 @@ export type AdkEventPart = {
   functionCall?: {
     name: string;
     id?: string;
-    args: Record<string, unknown>;
+    args?: Record<string, unknown>;
   };
   functionResponse?: {
     name: string;

package/src/useAdkMessages.test.ts

@@ -17,7 +17,6 @@ import {
   messageToEvent,
   messagesToEvents,
   useAdkMessages,
-  type UseAdkMessagesOptions,
 } from "./useAdkMessages";
 import { projectAdkToolApprovals } from "./adkToolApproval";
 import { createAdkStream } from "./AdkClient";
@@ -113,7 +112,7 @@ describe("ADK runtime callbacks", () => {
       };
       const eventHandlers = {
         [callbackName]: callback,
-      } as UseAdkMessagesOptions["eventHandlers"];
+      };
       const { result } = renderHook(() =>
         useAdkMessages({ stream, eventHandlers }),
       );
@@ -466,6 +465,10 @@ describe("optimistic confirmation replies", () => {
         projectAdkToolApprovals(result.current.messages).approvals.values(),
       ),
     ]).toEqual([{ id: "conf-a" }, { id: "conf-b" }]);
+    expect(result.current.toolConfirmations.map((c) => c.toolCallId)).toEqual([
+      "conf-a",
+      "conf-b",
+    ]);
   });
 
   it("keeps both gates pending when an ai message sits between the replies", async () => {
@@ -522,6 +525,102 @@ describe("optimistic confirmation replies", () => {
         projectAdkToolApprovals(result.current.messages).approvals.values(),
       ),
     ]).toEqual([{ id: "conf-a", approved: true }, { id: "conf-b" }]);
+    expect(result.current.toolConfirmations.map((c) => c.toolCallId)).toEqual([
+      "conf-b",
+    ]);
+  });
+});
+
+describe("pending requests across sends", () => {
+  it("keeps an unanswered request listed across sends until its reply is sent", async () => {
+    let run = 0;
+    const stream: AdkStreamCallback = async function* () {
+      run += 1;
+      if (run === 1) {
+        yield {
+          id: "requests",
+          author: "agent",
+          longRunningToolIds: ["conf-1", "cred-1"],
+          content: {
+            role: "model",
+            parts: [
+              {
+                functionCall: {
+                  id: "conf-1",
+                  name: "adk_request_confirmation",
+                  args: {
+                    originalFunctionCall: { id: "gated-1", name: "transfer" },
+                    toolConfirmation: { hint: "Transfer?" },
+                  },
+                },
+              },
+              {
+                functionCall: {
+                  id: "cred-1",
+                  name: "adk_request_credential",
+                  args: {
+                    function_call_id: "gated-2",
+                    auth_config: { credentialKey: "k" },
+                  },
+                },
+              },
+            ],
+          },
+        } satisfies AdkEvent;
+      } else if (run === 2) {
+        yield {
+          id: "answer",
+          author: "agent",
+          content: { role: "model", parts: [{ text: "still waiting" }] },
+        } satisfies AdkEvent;
+      }
+    };
+    const { result } = renderHook(() => useAdkMessages({ stream }));
+    const pending = () => ({
+      confirmations: result.current.toolConfirmations.map((c) => c.toolCallId),
+      authRequests: result.current.authRequests.map((r) => r.toolCallId),
+    });
+
+    await act(async () => {
+      await result.current.sendMessage(
+        [{ id: "user-1", type: "human", content: "start" }],
+        {},
+      );
+    });
+    expect(pending()).toEqual({
+      confirmations: ["conf-1"],
+      authRequests: ["cred-1"],
+    });
+
+    await act(async () => {
+      await result.current.sendMessage(
+        [{ id: "user-2", type: "human", content: "any news?" }],
+        {},
+      );
+    });
+    expect(pending()).toEqual({
+      confirmations: ["conf-1"],
+      authRequests: ["cred-1"],
+    });
+
+    await act(async () => {
+      await result.current.sendMessage(
+        [
+          {
+            id: "reply",
+            type: "tool",
+            tool_call_id: "cred-1",
+            name: "adk_request_credential",
+            content: JSON.stringify({
+              exchangedAuthCredential: { authType: "apiKey" },
+            }),
+            status: "success",
+          },
+        ],
+        {},
+      );
+    });
+    expect(pending()).toEqual({ confirmations: ["conf-1"], authRequests: [] });
   });
 });
 
@@ -680,7 +779,7 @@ describe("messageToEvent (contentToParts)", () => {
         name: "search",
       });
 
-      expect(event.content?.parts[0]?.functionResponse?.response).toEqual(
+      expect(event.content?.parts?.[0]?.functionResponse?.response).toEqual(
         response,
       );
     },

package/src/useAdkMessages.ts

@@ -170,6 +170,8 @@ export const useAdkMessages = ({
       }
       setMessagesImmediate(accumulator.getMessages());
       setLongRunningToolIds(accumulator.getLongRunningToolIds());
+      setToolConfirmations(accumulator.getToolConfirmations());
+      setAuthRequests(accumulator.getAuthRequests());
 
       // Google ADK replaces active runs, while React LangGraph queues sends.
       abortControllerRef.current?.abort();