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

package/dist/useAdkRuntime.d.ts

@@ -1,53 +1,52 @@
-import { AdkMessage, AdkStreamCallback, AdkThreadSnapshot, OnAdkAgentTransferCallback, OnAdkCustomEventCallback, OnAdkErrorCallback } from "./types.js";
-import { AttachmentAdapter, DictationAdapter, ExternalStoreSharedOptions, FeedbackAdapter, RealtimeVoiceAdapter, RemoteThreadListAdapter, SpeechSynthesisAdapter } from "@assistant-ui/core";
-import { AssistantCloud } from "assistant-cloud";
-//#region src/useAdkRuntime.d.ts
+import { type AttachmentAdapter, type DictationAdapter, type ExternalStoreSharedOptions, type FeedbackAdapter, type RealtimeVoiceAdapter, type SpeechSynthesisAdapter } from "@assistant-ui/core";
+import type { AssistantCloud } from "assistant-cloud";
+import type { RemoteThreadListAdapter } from "@assistant-ui/core";
+import type { AdkMessage, AdkThreadSnapshot, AdkStreamCallback, OnAdkErrorCallback, OnAdkCustomEventCallback, OnAdkAgentTransferCallback } from "./types.js";
 export type UseAdkRuntimeOptions = ExternalStoreSharedOptions & {
-  stream: AdkStreamCallback;
-  /**
-   * Called whenever the active thread's canonical (remote) ID changes, so the
-   * value can be treated as a managed/controlled variable (e.g. synced to a URL
-   * query param). Only the settled remote ID is emitted: while a freshly created
-   * thread is still optimistic the value is `undefined`, and the real ID is
-   * emitted once the thread is initialized; the transient local ID is never
-   * surfaced.
-   */
-  onThreadIdChange?: ((threadId: string | undefined) => void) | undefined;
-  autoCancelPendingToolCalls?: boolean | undefined;
-  unstable_allowCancellation?: boolean | undefined;
-  getCheckpointId?: (threadId: string, parentMessages: AdkMessage[]) => Promise<string | null>;
-  /**
-   * Loads a thread's stored state. Called when the thread opens, and again for
-   * `threads.reloadMainThread()`, which refetches in place rather than
-   * remounting the runtime; the signal aborts a load the runtime no longer
-   * needs.
-   */
-  load?: (threadId: string, options?: {
-    signal?: AbortSignal | undefined;
-  }) => Promise<AdkThreadSnapshot>;
-  create?: () => Promise<{
-    externalId: string;
-  }>;
-  delete?: (threadId: string) => Promise<void>;
-  adapters?: {
-    attachments?: AttachmentAdapter;
-    speech?: SpeechSynthesisAdapter;
-    dictation?: DictationAdapter;
-    voice?: RealtimeVoiceAdapter;
-    feedback?: FeedbackAdapter;
-  } | undefined;
-  eventHandlers?: {
-    onError?: OnAdkErrorCallback;
-    onCustomEvent?: OnAdkCustomEventCallback;
-    onAgentTransfer?: OnAdkAgentTransferCallback;
-  } | undefined;
-  cloud?: AssistantCloud | undefined;
-  /**
-   * A `RemoteThreadListAdapter` to use instead of the cloud adapter.
-   * Use with `createAdkSessionAdapter` for ADK session-backed persistence.
-   */
-  sessionAdapter?: RemoteThreadListAdapter | undefined;
+    stream: AdkStreamCallback;
+    /**
+     * Called whenever the active thread's canonical (remote) ID changes, so the
+     * value can be treated as a managed/controlled variable (e.g. synced to a URL
+     * query param). Only the settled remote ID is emitted: while a freshly created
+     * thread is still optimistic the value is `undefined`, and the real ID is
+     * emitted once the thread is initialized; the transient local ID is never
+     * surfaced.
+     */
+    onThreadIdChange?: ((threadId: string | undefined) => void) | undefined;
+    autoCancelPendingToolCalls?: boolean | undefined;
+    unstable_allowCancellation?: boolean | undefined;
+    getCheckpointId?: (threadId: string, parentMessages: AdkMessage[]) => Promise<string | null>;
+    /**
+     * Loads a thread's stored state. Called when the thread opens, and again for
+     * `threads.reloadMainThread()`, which refetches in place rather than
+     * remounting the runtime; the signal aborts a load the runtime no longer
+     * needs.
+     */
+    load?: (threadId: string, options?: {
+        signal?: AbortSignal | undefined;
+    }) => Promise<AdkThreadSnapshot>;
+    create?: () => Promise<{
+        externalId: string;
+    }>;
+    delete?: (threadId: string) => Promise<void>;
+    adapters?: {
+        attachments?: AttachmentAdapter;
+        speech?: SpeechSynthesisAdapter;
+        dictation?: DictationAdapter;
+        voice?: RealtimeVoiceAdapter;
+        feedback?: FeedbackAdapter;
+    } | undefined;
+    eventHandlers?: {
+        onError?: OnAdkErrorCallback;
+        onCustomEvent?: OnAdkCustomEventCallback;
+        onAgentTransfer?: OnAdkAgentTransferCallback;
+    } | undefined;
+    cloud?: AssistantCloud | undefined;
+    /**
+     * A `RemoteThreadListAdapter` to use instead of the cloud adapter.
+     * Use with `createAdkSessionAdapter` for ADK session-backed persistence.
+     */
+    sessionAdapter?: RemoteThreadListAdapter | undefined;
 };
 export declare const useAdkRuntime: ({ cloud, sessionAdapter, create, delete: deleteFn, onThreadIdChange, ...options }: UseAdkRuntimeOptions) => import("@assistant-ui/core").AssistantRuntime;
-//#endregion
 //# sourceMappingURL=useAdkRuntime.d.ts.map

package/dist/useAdkRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAdkRuntime.d.ts","names":[],"sources":["../src/useAdkRuntime.ts"],"mappings":";;;;YA6DY,uBAAuB;EACjC,QAAQ;;;;;;;;;EASR,qBAAqB;EACrB;EACA;EACA,mBACE,kBACA,gBAAgB,iBACb;;;;;;;EAOL,QACE,kBACA;IAAY,SAAS;QAClB,QAAQ;EACb,eAAe;IAAU;;EACzB,UAAU,qBAAqB;EAC/B;IAEM,cAAc;IACd,SAAS;IACT,YAAY;IACZ,QAAQ;IACR,WAAW;;EAGjB;IAEM,UAAU;IACV,gBAAgB;IAChB,kBAAkB;;EAGxB,QAAQ;;;;;EAKR,iBAAiB;;qBAkYN,kBAAiB,OAAA,gBAAA,QAAA,QAAA,UAAA,qBAAA,WAO3B,sDAAoB"}
+{"version":3,"file":"useAdkRuntime.d.ts","sourceRoot":"","sources":["../src/useAdkRuntime.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,0BAA0B,EAC/B,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAK5B,MAAM,oBAAoB,CAAC;AAY5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EAEjB,iBAAiB,EACjB,kBAAkB,EAClB,wBAAwB,EACxB,0BAA0B,EAC3B,mBAAgB;AAmBjB,MAAM,MAAM,oBAAoB,GAAG,0BAA0B,GAAG;IAC9D,MAAM,EAAE,iBAAiB,CAAC;IAC1B;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACxE,0BAA0B,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACjD,0BAA0B,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACjD,eAAe,CAAC,EAAE,CAChB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,UAAU,EAAE,KACzB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC5B;;;;;OAKG;IACH,IAAI,CAAC,EAAE,CACL,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAA;KAAE,KAC3C,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAChC,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,QAAQ,CAAC,EACL;QACE,WAAW,CAAC,EAAE,iBAAiB,CAAC;QAChC,MAAM,CAAC,EAAE,sBAAsB,CAAC;QAChC,SAAS,CAAC,EAAE,gBAAgB,CAAC;QAC7B,KAAK,CAAC,EAAE,oBAAoB,CAAC;QAC7B,QAAQ,CAAC,EAAE,eAAe,CAAC;KAC5B,GACD,SAAS,CAAC;IACd,aAAa,CAAC,EACV;QACE,OAAO,CAAC,EAAE,kBAAkB,CAAC;QAC7B,aAAa,CAAC,EAAE,wBAAwB,CAAC;QACzC,eAAe,CAAC,EAAE,0BAA0B,CAAC;KAC9C,GACD,SAAS,CAAC;IACd,KAAK,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IACnC;;;OAGG;IACH,cAAc,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;CACtD,CAAC;AAiYF,eAAO,MAAM,aAAa,GAAI,mFAO3B,oBAAoB,kDAsBtB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-google-adk",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "description": "Google ADK adapter for assistant-ui",
   "keywords": [
     "google-adk",
@@ -34,10 +34,10 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "^0.3.20",
-    "@assistant-ui/store": "^0.3.14",
+    "@assistant-ui/core": "^0.3.21",
+    "@assistant-ui/store": "^0.3.15",
     "assistant-cloud": "*",
-    "assistant-stream": "^0.3.44"
+    "assistant-stream": "^0.3.45"
   },
   "peerDependencies": {
     "@google/adk": ">=0.5.0",
@@ -53,7 +53,7 @@
     }
   },
   "devDependencies": {
-    "@assistant-ui/x-buildutils": "0.0.28",
+    "@assistant-ui/x-buildutils": "0.0.29",
     "@testing-library/dom": "^10.4.2",
     "@testing-library/react": "^16.3.3",
     "@types/react": "^19.3.0",

package/src/AdkClient.test.ts

@@ -124,6 +124,24 @@ describe.each(["direct", "proxy", "proxy batch"] as const)(
 // ── Proxy mode ──
 
 describe("createAdkStream - proxy mode", () => {
+  it("aborts while dynamic headers are pending", async () => {
+    const controller = new AbortController();
+    const stream = createAdkStream({
+      api: "/api/adk",
+      headers: () => new Promise<Record<string, string>>(() => {}),
+    });
+    const events = await stream(
+      [{ id: "m1", type: "human", content: "Hello" }],
+      makeConfig({ abortSignal: controller.signal }),
+    );
+
+    const next = events.next();
+    controller.abort();
+
+    await expect(next).rejects.toBe(controller.signal.reason);
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
   it("accumulates snake_case image and file parts from SSE", async () => {
     const event = {
       id: "media",
@@ -1077,6 +1095,38 @@ describe("createAdkStream - error handling", () => {
       'Expected ADK stream response Content-Type "text/event-stream", received no Content-Type header',
     );
   });
+
+  it("rejects event-stream responses without a body", async () => {
+    mockFetch.mockResolvedValueOnce(sseResponse(null));
+
+    const stream = createAdkStream({ api: "/api/adk" });
+    await expect(async () => {
+      const gen = await stream(
+        [{ id: "m1", type: "human", content: "Hi" }],
+        makeConfig(),
+      );
+      for await (const _ of gen) {
+        /* noop */
+      }
+    }).rejects.toThrow("Expected ADK stream response body, received no body");
+  });
+
+  it("rejects non-standard responses with an undefined body", async () => {
+    const response = sseResponse(null);
+    Object.defineProperty(response, "body", { value: undefined });
+    mockFetch.mockResolvedValueOnce(response);
+
+    const stream = createAdkStream({ api: "/api/adk" });
+    await expect(async () => {
+      const gen = await stream(
+        [{ id: "m1", type: "human", content: "Hi" }],
+        makeConfig(),
+      );
+      for await (const _ of gen) {
+        /* noop */
+      }
+    }).rejects.toThrow("Expected ADK stream response body, received no body");
+  });
 });
 
 // ── Headers ──

package/src/AdkClient.ts

@@ -1,6 +1,7 @@
 import { SSEEventDecoder } from "assistant-stream/utils";
 import { contentToParts } from "./contentToParts";
 import { parseAdkEventValue } from "./parseAdkEvent";
+import { raceWithAbortSignal } from "./raceWithAbortSignal";
 import { toAdkFunctionResponse } from "./toAdkFunctionResponse";
 import { trimTrailingSlashes } from "./trimTrailingSlashes";
 import type {
@@ -76,7 +77,7 @@ export function createAdkStream(
   }
 
   return async function* (messages, config) {
-    const headers = await resolveHeaders(options.headers);
+    const headers = await resolveHeaders(options.headers, config.abortSignal);
 
     let url: string;
     let body: unknown;
@@ -149,9 +150,12 @@ async function resolveHeaders(
     | Record<string, string>
     | (() => Record<string, string> | Promise<Record<string, string>>)
     | undefined,
+  signal?: AbortSignal,
 ): Promise<Record<string, string>> {
   if (!headers) return {};
-  if (typeof headers === "function") return await headers();
+  if (typeof headers === "function") {
+    return await raceWithAbortSignal(signal, headers);
+  }
   return headers;
 }
 
@@ -252,7 +256,10 @@ function messagesToProxyBody(
 }
 
 async function* parseSSEResponse(response: Response): AsyncGenerator<AdkEvent> {
-  const reader = response.body!.getReader();
+  if (!response.body) {
+    throw new Error("Expected ADK stream response body, received no body");
+  }
+  const reader = response.body.getReader();
   const decoder = new TextDecoder();
   const sseDecoder = new SSEEventDecoder({ trailing: "dispatch" });
 

package/src/AdkSessionAdapter.test.ts

@@ -22,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", () => {

package/src/AdkSessionAdapter.ts

@@ -10,6 +10,7 @@ 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 = {
   /**
@@ -230,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;
   };
 
@@ -327,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/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",

package/src/convertAdkMessages.ts

@@ -27,14 +27,25 @@ const contentToParts = (
 ): ContentPart[] => {
   if (typeof content === "string")
     return [{ type: "text" as const, text: content }];
+  if (!Array.isArray(content)) return [];
 
-  return (content as AdkMessageContentPart[])
+  return content
+    .filter(
+      (part): part is AdkMessageContentPart =>
+        typeof part === "object" && part !== null,
+    )
     .map((part): ContentPart | null => {
       switch (part.type) {
         case "text":
-          return { type: "text", text: part.text };
+          return {
+            type: "text",
+            text: typeof part.text === "string" ? part.text : "",
+          };
         case "reasoning":
-          return { type: "reasoning", text: part.text };
+          return {
+            type: "reasoning",
+            text: typeof part.text === "string" ? part.text : "",
+          };
         case "image":
           return {
             type: "image",
@@ -132,10 +143,11 @@ export const createAdkMessageConverter =
 
       case "tool": {
         // A confirmation reply ADK could not read leaves its gate undecided.
-        // Any result settles the tool call in core, so the reply is dropped
-        // here to keep the gate requiring action and answerable again. Only a
-        // reply to the confirmation itself is dropped: the gated call carries
-        // the same approval, and its own result is the agent's real output.
+        // The reply is not the agent's output, so it is dropped rather than
+        // shown as the call's result while the gate waits to be answered again.
+        // Only a reply to the confirmation itself is dropped: the gated call
+        // carries the same approval, and its own result is the agent's real
+        // output.
         const approval = approvals.get(message.tool_call_id);
         if (
           message.name === ADK_REQUEST_CONFIRMATION &&

package/src/hooks.render.test.tsx

@@ -4,8 +4,8 @@ import { act, render, waitFor } from "@testing-library/react";
 import type { AssistantRuntime } from "@assistant-ui/core";
 import { AssistantRuntimeProvider } from "@assistant-ui/core/react";
 import { describe, expect, it, vi } from "vitest";
-import { useAdkAppState } from "./hooks";
-import type { AdkEvent } from "./types";
+import { useAdkAppState, useAdkAuthRequests, useAdkSubmitAuth } from "./hooks";
+import type { AdkAuthRequest, AdkEvent, AdkMessage } from "./types";
 import { useAdkRuntime } from "./useAdkRuntime";
 
 describe("ADK state hook rendering", () => {
@@ -72,3 +72,96 @@ describe("ADK state hook rendering", () => {
     expect(appState).not.toBe(initial);
   });
 });
+
+describe("useAdkSubmitAuth", () => {
+  it("answers the pending credential request with its config and the credential", async () => {
+    const authConfig = {
+      authScheme: { type: "apiKey", in: "header", name: "x-api-key" },
+      credentialKey: "weather",
+    };
+    const stream = vi.fn(async function* () {
+      if (stream.mock.calls.length === 1) {
+        yield {
+          id: "event-1",
+          author: "agent",
+          content: {
+            role: "model",
+            parts: [
+              {
+                functionCall: {
+                  id: "cred-1",
+                  name: "adk_request_credential",
+                  args: { function_call_id: "tc-1", auth_config: authConfig },
+                },
+              },
+            ],
+          },
+          longRunningToolIds: ["cred-1"],
+          turnComplete: true,
+        } satisfies AdkEvent;
+        return;
+      }
+      yield {
+        id: "event-2",
+        author: "agent",
+        content: { role: "model", parts: [{ text: "Sunny" }] },
+        turnComplete: true,
+      } satisfies AdkEvent;
+    });
+
+    let runtime: AssistantRuntime | undefined;
+    let authRequests: AdkAuthRequest[] | undefined;
+    let submitAuth: ReturnType<typeof useAdkSubmitAuth> | undefined;
+
+    const Probe = () => {
+      authRequests = useAdkAuthRequests();
+      submitAuth = useAdkSubmitAuth();
+      return null;
+    };
+
+    const App = () => {
+      runtime = useAdkRuntime({
+        stream,
+        create: async () => ({ externalId: "thread-1" }),
+      });
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <Probe />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(<App />);
+    await act(async () => {
+      await runtime!.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "weather?" }],
+      });
+    });
+    await waitFor(() =>
+      expect(authRequests).toEqual([{ toolCallId: "cred-1", authConfig }]),
+    );
+
+    await act(async () => {
+      await submitAuth!("cred-1", { authType: "apiKey", apiKey: "secret" });
+    });
+
+    const [replied] = stream.mock.calls[1] as unknown as [AdkMessage[]];
+    expect(replied).toHaveLength(1);
+    expect(replied[0]).toMatchObject({
+      type: "tool",
+      tool_call_id: "cred-1",
+      name: "adk_request_credential",
+    });
+    expect(JSON.parse((replied[0] as { content: string }).content)).toEqual({
+      ...authConfig,
+      exchangedAuthCredential: { authType: "apiKey", apiKey: "secret" },
+    });
+    await waitFor(() => expect(authRequests).toEqual([]));
+
+    expect(() =>
+      submitAuth!("cred-1", { authType: "apiKey", apiKey: "again" }),
+    ).toThrow('No pending ADK auth request for tool call id "cred-1"');
+    expect(stream).toHaveBeenCalledTimes(2);
+  });
+});