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

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 ──
 
@@ -21,6 +22,23 @@ const baseOptions = {
 const expectedBaseUrl =
   "http://localhost:8000/apps/my-app/users/user-1/sessions";
 
+describe("createAdkSessionAdapter - load cancellation", () => {
+  it("aborts while dynamic headers are pending", async () => {
+    const controller = new AbortController();
+    const reason = new Error("cancelled");
+    const { load } = createAdkSessionAdapter({
+      ...baseOptions,
+      headers: () => new Promise<Record<string, string>>(() => {}),
+    });
+
+    const result = load("session-1", { signal: controller.signal });
+    controller.abort(reason);
+
+    await expect(result).rejects.toBe(reason);
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+});
+
 // ── adapter.list() ──
 
 describe("createAdkSessionAdapter - list", () => {
@@ -375,6 +393,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 +534,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 +935,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 +946,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 +1023,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 +1038,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,9 +6,11 @@ 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";
+import { raceWithAbortSignal } from "./raceWithAbortSignal";
 
 export type AdkSessionAdapterOptions = {
   /**
@@ -37,6 +39,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 +136,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 +169,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[] => {
@@ -211,9 +231,13 @@ export function createAdkSessionAdapter(
   const normalizedApiUrl = trimTrailingSlashes(apiUrl);
   const baseUrl = `${normalizedApiUrl}/apps/${encodeURIComponent(appName)}/users/${encodeURIComponent(userId)}/sessions`;
 
-  const getHeaders = async (): Promise<Record<string, string>> => {
+  const getHeaders = async (
+    signal?: AbortSignal,
+  ): Promise<Record<string, string>> => {
     if (!options.headers) return {};
-    if (typeof options.headers === "function") return await options.headers();
+    if (typeof options.headers === "function") {
+      return await raceWithAbortSignal(signal, options.headers);
+    }
     return options.headers;
   };
 
@@ -308,7 +332,7 @@ export function createAdkSessionAdapter(
     sessionId: string,
     options?: { signal?: AbortSignal | undefined },
   ): Promise<AdkThreadSnapshot> => {
-    const headers = await getHeaders();
+    const headers = await getHeaders(options?.signal);
     const res = await fetch(`${baseUrl}/${encodeURIComponent(sessionId)}`, {
       headers,
       ...(options?.signal ? { signal: options.signal } : {}),

package/src/adkAuthRequest.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import { toAdkAuthReply } from "./adkAuthRequest";
+import type { AdkAuthRequest } from "./types";
+
+const CREDENTIAL_CALL = "adk-credential-1";
+
+const apiKeyScheme = { type: "apiKey", in: "header", name: "x-api-key" };
+
+const request = (authConfig: unknown): AdkAuthRequest => ({
+  toolCallId: CREDENTIAL_CALL,
+  authConfig,
+});
+
+const wire = (content: string) => JSON.parse(content);
+
+describe("toAdkAuthReply", () => {
+  it("answers the credential call with the request's config carrying the credential", () => {
+    const reply = toAdkAuthReply(
+      CREDENTIAL_CALL,
+      { authType: "apiKey", apiKey: "secret" },
+      [request({ authScheme: apiKeyScheme, credentialKey: "weather" })],
+    );
+
+    expect(reply).toMatchObject({
+      type: "tool",
+      tool_call_id: CREDENTIAL_CALL,
+      name: "adk_request_credential",
+      status: "success",
+    });
+    expect(wire(reply.content)).toEqual({
+      authScheme: apiKeyScheme,
+      credentialKey: "weather",
+      exchangedAuthCredential: { authType: "apiKey", apiKey: "secret" },
+    });
+  });
+
+  it("lays the OAuth2 answer over the exchanged credential the request issued", () => {
+    const oauth2Scheme = { type: "oauth2", flows: {} };
+    const reply = toAdkAuthReply(
+      CREDENTIAL_CALL,
+      {
+        authType: "oauth2",
+        oauth2: { authResponseUri: "https://app/cb?code=c&state=s" },
+      },
+      [
+        request({
+          authScheme: oauth2Scheme,
+          credentialKey: "calendar",
+          rawAuthCredential: { authType: "oauth2", oauth2: { clientId: "id" } },
+          exchangedAuthCredential: {
+            authType: "oauth2",
+            oauth2: {
+              clientId: "id",
+              authUri: "https://idp/authorize?state=s",
+              state: "s",
+              redirectUri: "https://app/cb",
+            },
+          },
+        }),
+      ],
+    );
+
+    expect(wire(reply.content)).toEqual({
+      authScheme: oauth2Scheme,
+      credentialKey: "calendar",
+      rawAuthCredential: { authType: "oauth2", oauth2: { clientId: "id" } },
+      exchangedAuthCredential: {
+        authType: "oauth2",
+        oauth2: {
+          clientId: "id",
+          authUri: "https://idp/authorize?state=s",
+          state: "s",
+          redirectUri: "https://app/cb",
+          authResponseUri: "https://app/cb?code=c&state=s",
+        },
+      },
+    });
+  });
+
+  it("sends the credential alone when the request carried no config", () => {
+    const reply = toAdkAuthReply(
+      CREDENTIAL_CALL,
+      { authType: "apiKey", apiKey: "secret" },
+      [request(undefined)],
+    );
+
+    expect(wire(reply.content)).toEqual({
+      exchangedAuthCredential: { authType: "apiKey", apiKey: "secret" },
+    });
+  });
+
+  it("throws for an id that is not a pending request", () => {
+    expect(() =>
+      toAdkAuthReply("adk-credential-2", { authType: "apiKey", apiKey: "x" }, [
+        request({ authScheme: apiKeyScheme, credentialKey: "weather" }),
+      ]),
+    ).toThrow(
+      'No pending ADK auth request for tool call id "adk-credential-2"',
+    );
+  });
+});

package/src/adkAuthRequest.ts

@@ -0,0 +1,50 @@
+import { generateId } from "@assistant-ui/core";
+import { isRecord } from "@assistant-ui/core/internal";
+import type { AdkAuthCredential, AdkAuthRequest, AdkMessage } from "./types";
+
+export const ADK_REQUEST_CREDENTIAL = "adk_request_credential";
+
+const recordOf = (value: unknown): Record<string, unknown> =>
+  isRecord(value) ? value : {};
+
+/**
+ * ADK binds a credential reply to the `adk_request_credential` call it issued
+ * and takes only `exchangedAuthCredential` off the response, so the reply is
+ * the request's own auth config with the credential filled in, as ADK's
+ * reference client sends it: adk-python validates the response as a whole auth
+ * config, and it exchanges an OAuth2 code with the client id, redirect uri and
+ * state the request carried, so the caller's fields land over the request's
+ * exchanged credential rather than replacing it. An id that is not a pending
+ * request would send a reply adk-js ignores and adk-python answers by
+ * requesting again, so it throws instead.
+ */
+export const toAdkAuthReply = (
+  toolCallId: string,
+  credential: AdkAuthCredential,
+  requests: readonly AdkAuthRequest[],
+): AdkMessage & { type: "tool" } => {
+  const request = requests.find((r) => r.toolCallId === toolCallId);
+  if (request === undefined)
+    throw new Error(
+      `No pending ADK auth request for tool call id "${toolCallId}"`,
+    );
+
+  const authConfig = recordOf(request.authConfig);
+  const requested = recordOf(authConfig.exchangedAuthCredential);
+  const oauth2 = { ...recordOf(requested.oauth2), ...credential.oauth2 };
+  return {
+    id: generateId(),
+    type: "tool",
+    tool_call_id: toolCallId,
+    name: ADK_REQUEST_CREDENTIAL,
+    content: JSON.stringify({
+      ...authConfig,
+      exchangedAuthCredential: {
+        ...requested,
+        ...credential,
+        ...(Object.keys(oauth2).length > 0 && { oauth2 }),
+      },
+    }),
+    status: "success",
+  };
+};

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/convertAdkMessages.test.ts

@@ -13,6 +13,20 @@ describe("convertAdkMessage - human messages", () => {
     });
   });
 
+  it("returns empty content when content is neither a string nor an array", () => {
+    for (const content of [null, undefined, { text: "Hello" }]) {
+      const msg = {
+        id: "m1",
+        type: "human",
+        content,
+      } as unknown as AdkMessage;
+      expect(convertAdkMessage(msg, {})).toMatchObject({
+        role: "user",
+        content: [],
+      });
+    }
+  });
+
   it("converts a human message with text content parts", () => {
     const msg: AdkMessage = {
       id: "m1",
@@ -128,6 +142,33 @@ describe("convertAdkMessage - human messages", () => {
 });
 
 describe("convertAdkMessage - ai messages", () => {
+  it("coerces missing text on text and reasoning parts to an empty string", () => {
+    const msg = {
+      id: "m1",
+      type: "ai",
+      content: [{ type: "text" }, { type: "reasoning" }],
+    } as AdkMessage;
+    expect(convertAdkMessage(msg, {})).toMatchObject({
+      role: "assistant",
+      content: [
+        { type: "text", text: "" },
+        { type: "reasoning", text: "" },
+      ],
+    });
+  });
+
+  it("skips non-object entries in content arrays", () => {
+    const msg = {
+      id: "m1",
+      type: "ai",
+      content: [null, "Hello", { type: "text", text: "Hi" }],
+    } as unknown as AdkMessage;
+    expect(convertAdkMessage(msg, {})).toMatchObject({
+      role: "assistant",
+      content: [{ type: "text", text: "Hi" }],
+    });
+  });
+
   it("converts an ai message with text content", () => {
     const msg: AdkMessage = {
       id: "m1",