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

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);
+  });
+});

package/src/hooks.ts

@@ -2,6 +2,7 @@ import { generateId } from "@assistant-ui/core";
 import { useAui } from "@assistant-ui/store";
 import { useShallowSelector } from "@assistant-ui/store/internal";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import { toAdkAuthReply } from "./adkAuthRequest";
 import { adkExtras } from "./adkExtras";
 import { toAdkConfirmationReply } from "./adkToolApproval";
 import type {
@@ -74,23 +75,21 @@ export const useAdkConfirmTool = () => {
       .send([toAdkConfirmationReply(toolCallId, confirmed, payload)], {});
 };
 
-/** Returns a function to submit auth credentials for a pending auth request. */
+/**
+ * Returns a function to submit auth credentials for a pending auth request.
+ * The reply carries the request's auth config with the credential as its
+ * `exchangedAuthCredential`, which is the shape ADK resumes the tool on, so the
+ * id must name a request `useAdkAuthRequests` currently lists.
+ */
 export const useAdkSubmitAuth = () => {
   const aui = useAui();
-  return (toolCallId: string, credential: AdkAuthCredential) =>
-    adkExtras.get(aui).send(
-      [
-        {
-          id: generateId(),
-          type: "tool",
-          tool_call_id: toolCallId,
-          name: "adk_request_credential",
-          content: JSON.stringify(credential),
-          status: "success",
-        },
-      ],
+  return (toolCallId: string, credential: AdkAuthCredential) => {
+    const extras = adkExtras.get(aui);
+    return extras.send(
+      [toAdkAuthReply(toolCallId, credential, extras.authRequests)],
       {},
     );
+  };
 };
 
 /** Returns a function to submit the user's answer for a pending `adk_request_input` HITL interrupt. */

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

@@ -0,0 +1,73 @@
+import { describe, expect, it, vi } from "vitest";
+import { raceWithAbortSignal } from "./raceWithAbortSignal";
+
+describe("raceWithAbortSignal", () => {
+  it("invokes the operation synchronously without a signal", async () => {
+    const order: string[] = [];
+
+    const result = raceWithAbortSignal(undefined, () => {
+      order.push("operation");
+      return "done";
+    });
+    order.push("after");
+
+    expect(order).toEqual(["operation", "after"]);
+    await expect(result).resolves.toBe("done");
+  });
+
+  it("converts a synchronous operation error to a rejection", async () => {
+    const error = new Error("failed");
+
+    const result = raceWithAbortSignal(undefined, () => {
+      throw error;
+    });
+
+    await expect(result).rejects.toBe(error);
+  });
+
+  it("rejects a pending operation with the abort reason", async () => {
+    const controller = new AbortController();
+    const reason = new Error("cancelled");
+    let resolveOperation!: (value: string) => void;
+    const operation = new Promise<string>((resolve) => {
+      resolveOperation = resolve;
+    });
+
+    const result = raceWithAbortSignal(controller.signal, () => operation);
+    controller.abort(reason);
+
+    await expect(result).rejects.toBe(reason);
+    resolveOperation("late result");
+  });
+
+  it("rejects before invoking an operation for an already aborted signal", async () => {
+    const controller = new AbortController();
+    const reason = new Error("already cancelled");
+    const operation = vi.fn(() => "done");
+    controller.abort(reason);
+
+    const result = raceWithAbortSignal(controller.signal, operation);
+
+    await expect(result).rejects.toBe(reason);
+    expect(operation).not.toHaveBeenCalled();
+  });
+
+  it("removes the abort listener after the operation settles", async () => {
+    const controller = new AbortController();
+    const removeEventListener = vi.spyOn(
+      controller.signal,
+      "removeEventListener",
+    );
+    const result = raceWithAbortSignal(controller.signal, () => "done");
+
+    await expect(result).resolves.toBe("done");
+    expect(removeEventListener).toHaveBeenCalledOnce();
+    expect(removeEventListener).toHaveBeenCalledWith(
+      "abort",
+      expect.any(Function),
+    );
+
+    controller.abort(new Error("late abort"));
+    await expect(result).resolves.toBe("done");
+  });
+});

package/src/raceWithAbortSignal.ts

@@ -0,0 +1,48 @@
+const getAbortReason = (signal: AbortSignal): unknown => {
+  if (signal.reason !== undefined) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+};
+
+export const raceWithAbortSignal = <T>(
+  signal: AbortSignal | undefined,
+  operation: () => T | PromiseLike<T>,
+): Promise<T> => {
+  if (!signal) {
+    try {
+      return Promise.resolve(operation());
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  if (signal.aborted) return Promise.reject(getAbortReason(signal));
+
+  return new Promise<T>((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => signal.removeEventListener("abort", handleAbort);
+    const resolveOnce = (value: T) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const rejectOnce = (error: unknown) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const handleAbort = () => rejectOnce(getAbortReason(signal));
+
+    signal.addEventListener("abort", handleAbort, { once: true });
+    let result: T | PromiseLike<T>;
+    try {
+      result = operation();
+    } catch (error) {
+      rejectOnce(error);
+      return;
+    }
+    Promise.resolve(result).then(resolveOnce, rejectOnce);
+  });
+};

package/src/server/adkEventStream.test.ts

@@ -20,6 +20,153 @@ async function readSSE(response: Response): Promise<string> {
 }
 
 describe("adkEventStream", () => {
+  it("does not advance the generator before the response is read", async () => {
+    let produced = 0;
+    async function* events() {
+      for (let index = 0; index < 1000; index++) {
+        produced++;
+        yield { id: String(index) };
+      }
+    }
+    const response = adkEventStream(events());
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    try {
+      expect(produced).toBe(0);
+    } finally {
+      await response.body!.cancel();
+    }
+  });
+
+  it("buffers at most one event ahead of a slow reader", async () => {
+    let produced = 0;
+    async function* events() {
+      for (let index = 0; index < 1000; index++) {
+        produced++;
+        yield { id: String(index) };
+      }
+    }
+    const reader = adkEventStream(events()).body!.getReader();
+    try {
+      expect(new TextDecoder().decode((await reader.read()).value)).toBe(
+        ":ok\n\n",
+      );
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(produced).toBe(1);
+      expect(new TextDecoder().decode((await reader.read()).value)).toContain(
+        '"id":"0"',
+      );
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(produced).toBe(2);
+    } finally {
+      await reader.cancel();
+      reader.releaseLock();
+    }
+  });
+
+  it("finalizes the generator when the reader cancels between events", async () => {
+    const finalized = vi.fn();
+    const onError = vi.fn();
+    async function* events() {
+      try {
+        while (true) yield { id: "event" };
+      } finally {
+        finalized();
+      }
+    }
+    const reader = adkEventStream(events(), { onError }).body!.getReader();
+    await reader.read();
+    await reader.read();
+    await reader.cancel();
+    expect(finalized).toHaveBeenCalledTimes(1);
+    expect(onError).not.toHaveBeenCalled();
+    expect(await reader.read()).toEqual({ done: true, value: undefined });
+    reader.releaseLock();
+  });
+
+  it("delivers every event in order when the response is fully consumed", async () => {
+    async function* events() {
+      for (let index = 0; index < 1000; index++) yield { id: String(index) };
+    }
+    const text = await readSSE(adkEventStream(events()));
+    const ids = text
+      .split("\n\n")
+      .filter((line) => line.startsWith("data: "))
+      .map((line) => JSON.parse(line.slice(6)).id);
+    expect(ids).toEqual(
+      Array.from({ length: 1000 }, (_, index) => String(index)),
+    );
+  });
+
+  it("allows onError to cancel the reader without writing to the closed stream", async () => {
+    let reader: ReadableStreamDefaultReader<Uint8Array>;
+    let cancelled: Promise<void> | undefined;
+    async function* events() {
+      throw new Error("stream failed");
+    }
+    const response = adkEventStream(events(), {
+      onError: () => {
+        cancelled = reader.cancel();
+      },
+    });
+    reader = response.body!.getReader();
+    await reader.read();
+    expect(await reader.read()).toEqual({ done: true, value: undefined });
+    await cancelled;
+    reader.releaseLock();
+  });
+
+  it.each(["yield", "finish", "reject"])(
+    "does not write after cancellation while next() later %s",
+    async (outcome) => {
+      let release!: () => void;
+      const waiting = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      let started!: () => void;
+      const entered = new Promise<void>((resolve) => {
+        started = resolve;
+      });
+      const finalized = vi.fn();
+      const onError = vi.fn();
+      async function* events() {
+        try {
+          started();
+          await waiting;
+          if (outcome === "reject") throw new Error("late error");
+          if (outcome === "yield") yield { id: "late" };
+        } finally {
+          finalized();
+        }
+      }
+      const reader = adkEventStream(events(), { onError }).body!.getReader();
+      await reader.read();
+      await entered;
+      const cancelled = reader.cancel();
+      release();
+      await cancelled;
+      expect(finalized).toHaveBeenCalledTimes(1);
+      expect(onError).not.toHaveBeenCalled();
+      expect(await reader.read()).toEqual({ done: true, value: undefined });
+      reader.releaseLock();
+    },
+  );
+
+  it("finalizes the source and emits an error frame if event serialization fails", async () => {
+    const finalized = vi.fn();
+    const onError = vi.fn();
+    async function* events() {
+      try {
+        yield { id: "invalid", customMetadata: { unsupported: 1n } };
+      } finally {
+        finalized();
+      }
+    }
+    const text = await readSSE(adkEventStream(events(), { onError }));
+    expect(text).toContain('"errorCode":"STREAM_ERROR"');
+    expect(finalized).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledTimes(1);
+  });
+
   it("returns a Response with text/event-stream content-type", () => {
     const response = adkEventStream(yieldEvents([]));
     expect(response.headers.get("Content-Type")).toBe("text/event-stream");

package/src/server/adkEventStream.ts

@@ -133,31 +133,38 @@ export const adkEventStream = (
   const encoder = new TextEncoder();
   let cancelled = false;
   const stream = new ReadableStream({
-    async start(controller) {
+    start(controller) {
       // Initial SSE comment to keep connection alive through proxies
       controller.enqueue(encoder.encode(":ok\n\n"));
+    },
+    async pull(controller) {
       try {
-        for await (const event of events) {
-          if (cancelled) break;
-          const wireEvent = convertSdkEvent(event);
-          controller.enqueue(
-            encoder.encode(`data: ${JSON.stringify(wireEvent)}\n\n`),
-          );
+        const { done, value } = await events.next();
+        if (cancelled) return;
+        if (done) {
+          controller.close();
+          return;
         }
+        const wireEvent = convertSdkEvent(value);
+        controller.enqueue(
+          encoder.encode(`data: ${JSON.stringify(wireEvent)}\n\n`),
+        );
       } catch (e) {
-        if (!cancelled) {
-          notifyError(options?.onError, e);
-          const errorEvent: AdkEvent = {
-            id: "",
-            errorCode: "STREAM_ERROR",
-            errorMessage:
-              e instanceof Error ? e.message : "Unknown stream error",
-          };
-          controller.enqueue(
-            encoder.encode(`data: ${JSON.stringify(errorEvent)}\n\n`),
-          );
-        }
-      } finally {
+        if (cancelled) return;
+        try {
+          await events.return?.(undefined as any);
+        } catch {}
+        if (cancelled) return;
+        notifyError(options?.onError, e);
+        if (cancelled) return;
+        const errorEvent: AdkEvent = {
+          id: "",
+          errorCode: "STREAM_ERROR",
+          errorMessage: e instanceof Error ? e.message : "Unknown stream error",
+        };
+        controller.enqueue(
+          encoder.encode(`data: ${JSON.stringify(errorEvent)}\n\n`),
+        );
         controller.close();
       }
     },

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;