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

package/src/AdkSessionAdapter.test.ts

@@ -294,6 +294,87 @@ describe("createAdkSessionAdapter - fetch", () => {
 // ── load() ──
 
 describe("createAdkSessionAdapter - load", () => {
+  it("restores tool failures from stored function responses", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          id: "s1",
+          events: [
+            {
+              id: "failed",
+              author: "user",
+              content: {
+                parts: [
+                  {
+                    functionResponse: {
+                      id: "tc-1",
+                      name: "search",
+                      response: { error: "denied" },
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        }),
+        { status: 200 },
+      ),
+    );
+    const { load } = createAdkSessionAdapter(baseOptions);
+    const result = await load("s1");
+    expect(result.messages).toMatchObject([
+      {
+        type: "tool",
+        tool_call_id: "tc-1",
+        status: "error",
+        content: JSON.stringify({ error: "denied" }),
+      },
+    ]);
+  });
+
+  it("restores snake_case image and file parts from session history", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          id: "s1",
+          events: [
+            {
+              id: "media",
+              author: "user",
+              content: {
+                parts: [
+                  { inline_data: { mime_type: "image/png", data: "aGVsbG8=" } },
+                  {
+                    file_data: {
+                      mime_type: "application/pdf",
+                      file_uri: "https://example.test/report.pdf",
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        }),
+        { status: 200 },
+      ),
+    );
+    const { load } = createAdkSessionAdapter(baseOptions);
+    const result = await load("s1");
+    expect(result.messages).toMatchObject([
+      {
+        type: "human",
+        content: [
+          { type: "image", mimeType: "image/png", data: "aGVsbG8=" },
+          {
+            type: "file_url",
+            mimeType: "application/pdf",
+            url: "https://example.test/report.pdf",
+          },
+        ],
+      },
+    ]);
+  });
+
   it("returns the per-turn state the events imply, not just the messages", async () => {
     const session = {
       id: "s1",
@@ -543,10 +624,17 @@ describe("createAdkSessionAdapter - load replays tool confirmations", () => {
     const result = await load("s1");
     return {
       messages: result.messages,
+      longRunningToolIds: result.longRunningToolIds,
       approvals: projectAdkToolApprovals(result.messages).approvals,
     };
   };
 
+  it("settles an answered long-running tool on replay", async () => {
+    const { longRunningToolIds } = await loadApprovals({ confirmed: true });
+
+    expect(longRunningToolIds).toEqual([]);
+  });
+
   it("keeps a user-authored confirmation reply as a tool message", async () => {
     const { messages } = await loadApprovals({ confirmed: true });
 

package/src/convertToAdkMessages.test.ts

@@ -7,6 +7,7 @@ import {
 import { convertAdkMessage } from "./convertAdkMessages";
 import type { AppendMessage } from "@assistant-ui/core";
 import type { AdkMessage } from "./types";
+import { contentToParts } from "./contentToParts";
 
 const makeAppendMessage = (content: AppendMessage["content"]): AppendMessage =>
   ({
@@ -155,6 +156,75 @@ describe("getPendingCancellations", () => {
 });
 
 describe("getMessageContent", () => {
+  it("serializes data URL images as inline data", () => {
+    const content = getMessageContent(
+      makeAppendMessage([
+        { type: "image", image: "data:image/png;base64,AAAA" },
+      ]),
+    );
+
+    expect(contentToParts(content)).toEqual([
+      { inlineData: { mimeType: "image/png", data: "AAAA" } },
+    ]);
+  });
+
+  it("infers an image MIME type when the data URL declares a generic type", () => {
+    const content = getMessageContent(
+      makeAppendMessage([
+        {
+          type: "image",
+          image: "data:application/octet-stream;base64,iVBORw0KGgo=",
+        },
+      ]),
+    );
+
+    expect(contentToParts(content)).toEqual([
+      { inlineData: { mimeType: "image/png", data: "iVBORw0KGgo=" } },
+    ]);
+  });
+
+  it("prefers an attachment's declared image MIME type", () => {
+    const message = makeAppendMessage([]);
+    const content = getMessageContent({
+      ...message,
+      attachments: [
+        {
+          id: "attachment-1",
+          type: "image",
+          name: "photo.webp",
+          contentType: "image/webp",
+          status: { type: "complete" },
+          content: [{ type: "image", image: "data:image/png;base64,AAAA" }],
+        },
+      ],
+    });
+
+    expect(contentToParts(content)).toEqual([
+      { inlineData: { mimeType: "image/webp", data: "AAAA" } },
+    ]);
+  });
+
+  it("resolves wildcard attachment MIME types to a concrete image type", () => {
+    const message = makeAppendMessage([]);
+    const content = getMessageContent({
+      ...message,
+      attachments: [
+        {
+          id: "attachment-1",
+          type: "image",
+          name: "photo.jpg",
+          contentType: "image/*",
+          status: { type: "complete" },
+          content: [{ type: "image", image: "data:image/jpeg;base64,AAAA" }],
+        },
+      ],
+    });
+
+    expect(contentToParts(content)).toEqual([
+      { inlineData: { mimeType: "image/jpeg", data: "AAAA" } },
+    ]);
+  });
+
   it("preserves file part data and mimeType end-to-end", () => {
     const result = getMessageContent(
       makeAppendMessage([

package/src/convertToAdkMessages.ts

@@ -8,6 +8,7 @@ import {
   createToolCallCancellationStub,
   parseDataUrl,
   resolveFilePartSource,
+  resolveImageMediaType,
   scanPendingToolCalls,
 } from "@assistant-ui/core/internal";
 import type { AdkMessage } from "./types";
@@ -15,16 +16,30 @@ import type { AdkMessage } from "./types";
 /** Exported for unit tests. */
 export const getMessageContent = (msg: AppendMessage) => {
   const allContent = [
-    ...msg.content,
-    ...(msg.attachments?.flatMap((a) => a.content) ?? []),
+    ...msg.content.map((part) => ({ part, contentType: undefined })),
+    ...(msg.attachments?.flatMap((attachment) =>
+      attachment.content.map((part) => ({
+        part,
+        contentType: attachment.contentType,
+      })),
+    ) ?? []),
   ];
-  const content = allContent.flatMap((part) => {
+  const content = allContent.flatMap(({ part, contentType }) => {
     const type = part.type;
     switch (type) {
       case "text":
         return { type: "text" as const, text: part.text };
-      case "image":
+      case "image": {
+        const parsed = parseDataUrl(part.image);
+        if (parsed) {
+          return {
+            type: "image" as const,
+            mimeType: resolveImageMediaType(part.image, contentType),
+            data: parsed.data,
+          };
+        }
         return { type: "image_url" as const, url: part.image };
+      }
       case "file": {
         const source = resolveFilePartSource(part);
         if (source.kind === "url") {

package/src/hooks.render.test.tsx

@@ -0,0 +1,74 @@
+// @vitest-environment jsdom
+
+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 { useAdkRuntime } from "./useAdkRuntime";
+
+describe("ADK state hook rendering", () => {
+  it("keeps app state stable across unrelated store updates", async () => {
+    const deltas = [
+      {
+        "app:visible": 1,
+        "app:__proto__": { source: "provider" },
+      },
+      { unrelated: true },
+      { "app:visible": 2 },
+    ];
+    const stream = vi.fn(async function* () {
+      const call = stream.mock.calls.length - 1;
+      yield {
+        id: `event-${call}`,
+        author: "agent",
+        actions: { stateDelta: deltas[call] },
+        turnComplete: true,
+      } satisfies AdkEvent;
+    });
+
+    let runtime: AssistantRuntime | undefined;
+    let appState: Record<string, unknown> | undefined;
+
+    const Probe = () => {
+      appState = useAdkAppState();
+      return null;
+    };
+
+    const App = () => {
+      runtime = useAdkRuntime({
+        stream,
+        create: async () => ({ externalId: "thread-1" }),
+      });
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <Probe />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(<App />);
+    const send = (text: string) =>
+      act(async () => {
+        await runtime!.thread.append({
+          role: "user",
+          content: [{ type: "text", text }],
+        });
+      });
+
+    await send("first");
+    await waitFor(() => expect(appState?.visible).toBe(1));
+
+    const initial = appState;
+    expect(Object.hasOwn(initial!, "__proto__")).toBe(true);
+    expect(initial?.["__proto__"]).toEqual({ source: "provider" });
+
+    await send("second");
+    expect(appState).toBe(initial);
+
+    await send("third");
+    await waitFor(() => expect(appState?.visible).toBe(2));
+    expect(appState).not.toBe(initial);
+  });
+});

package/src/hooks.test.tsx

@@ -0,0 +1,33 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  stateDelta: {} as Record<string, unknown>,
+}));
+
+vi.mock("./adkExtras", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("./adkExtras")>()),
+  adkExtras: {
+    use: (
+      selector: (extras: { stateDelta: Record<string, unknown> }) => unknown,
+    ) => selector({ stateDelta: mocks.stateDelta }),
+  },
+}));
+
+import { useAdkAppState } from "./hooks";
+
+describe("ADK state hooks", () => {
+  it("preserves a prototype-named state key", () => {
+    mocks.stateDelta = Object.fromEntries([
+      ["app:__proto__", { source: "provider" }],
+      ["app:visible", true],
+    ]);
+
+    const { result } = renderHook(() => useAdkAppState());
+
+    expect(Object.getPrototypeOf(result.current)).toBe(Object.prototype);
+    expect(Object.hasOwn(result.current, "__proto__")).toBe(true);
+    expect(result.current["__proto__"]).toEqual({ source: "provider" });
+    expect(result.current.visible).toBe(true);
+  });
+});

package/src/hooks.ts

@@ -1,5 +1,6 @@
 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 { adkExtras } from "./adkExtras";
 import { toAdkConfirmationReply } from "./adkToolApproval";
@@ -10,6 +11,7 @@ import type {
   AdkAuthCredential,
   AdkAuthRequest,
   AdkMessageMetadata,
+  AdkRuntimeExtras,
 } from "./types";
 
 const EMPTY_STATE_DELTA: Record<string, unknown> = {};
@@ -119,33 +121,26 @@ const TEMP_PREFIX = "temp:";
 const filterByPrefix = (
   state: Record<string, unknown>,
   prefix: string,
-): Record<string, unknown> => {
-  const result: Record<string, unknown> = {};
-  for (const key of Object.keys(state)) {
-    if (key.startsWith(prefix)) {
-      result[key.slice(prefix.length)] = state[key];
-    }
-  }
-  return result;
-};
+): Record<string, unknown> =>
+  Object.fromEntries(
+    Object.entries(state)
+      .filter(([key]) => key.startsWith(prefix))
+      .map(([key, value]) => [key.slice(prefix.length), value]),
+  );
 
-/** Returns app-level state (keys prefixed with `app:`, prefix stripped). */
-export const useAdkAppState = () =>
+const useAdkStateByPrefix = (prefix: string) =>
   adkExtras.use(
-    (e) => filterByPrefix(e.stateDelta, APP_PREFIX),
+    useShallowSelector((e: AdkRuntimeExtras) =>
+      filterByPrefix(e.stateDelta, prefix),
+    ),
     EMPTY_STATE_DELTA,
   );
 
+/** Returns app-level state (keys prefixed with `app:`, prefix stripped). */
+export const useAdkAppState = () => useAdkStateByPrefix(APP_PREFIX);
+
 /** Returns user-level state (keys prefixed with `user:`, prefix stripped). */
-export const useAdkUserState = () =>
-  adkExtras.use(
-    (e) => filterByPrefix(e.stateDelta, USER_PREFIX),
-    EMPTY_STATE_DELTA,
-  );
+export const useAdkUserState = () => useAdkStateByPrefix(USER_PREFIX);
 
 /** Returns temp state (keys prefixed with `temp:`, prefix stripped). Not persisted. */
-export const useAdkTempState = () =>
-  adkExtras.use(
-    (e) => filterByPrefix(e.stateDelta, TEMP_PREFIX),
-    EMPTY_STATE_DELTA,
-  );
+export const useAdkTempState = () => useAdkStateByPrefix(TEMP_PREFIX);

package/src/parseAdkEvent.ts

@@ -1,19 +1,26 @@
+import { isRecord } from "@assistant-ui/core/internal";
 import type { AdkEvent } from "./types";
 
+const invalidField = (
+  errorPrefix: string,
+  field: string,
+  expectation: string,
+): Error =>
+  new Error(`${errorPrefix}: expected "${field}" to be ${expectation}.`);
+
 export function parseAdkEventValue(
   value: unknown,
   errorPrefix: string,
 ): AdkEvent {
-  if (
-    typeof value !== "object" ||
-    value === null ||
-    Array.isArray(value) ||
-    Object.keys(value).length === 0
-  ) {
+  if (!isRecord(value) || Object.keys(value).length === 0) {
     throw new Error(`${errorPrefix}: expected a non-empty object.`);
   }
 
-  const { id: rawId, ...event } = value as Record<string, unknown>;
+  const {
+    id: rawId,
+    content: rawContent,
+    ...event
+  } = value as Record<string, unknown>;
   if (
     rawId != null &&
     typeof rawId !== "string" &&
@@ -24,12 +31,34 @@ export function parseAdkEventValue(
     );
   }
 
+  let content: Record<string, unknown> | undefined;
+  if (rawContent != null) {
+    if (!isRecord(rawContent)) {
+      throw invalidField(errorPrefix, "content", "an object when present");
+    }
+
+    const { parts, ...contentFields } = rawContent;
+    if (parts != null && (!Array.isArray(parts) || !parts.every(isRecord))) {
+      throw invalidField(
+        errorPrefix,
+        "content.parts",
+        "an array of objects when present",
+      );
+    }
+
+    content = {
+      ...contentFields,
+      ...(parts != null && { parts }),
+    };
+  }
+
   const errorMessage =
     "error" in event && typeof event.error === "string"
       ? event.error
       : undefined;
   return {
     ...event,
+    ...(content !== undefined && { content }),
     ...(rawId != null && { id: String(rawId) }),
     ...(errorMessage !== undefined &&
       !("errorMessage" in event) &&

package/src/sdkIdentity.ts

@@ -0,0 +1,9 @@
+import type { SdkIdentity } from "assistant-cloud";
+
+export const ADK_SDK: SdkIdentity = {
+  name: "@assistant-ui/react-google-adk",
+  version:
+    typeof __AUI_PACKAGE_VERSION__ === "string"
+      ? __AUI_PACKAGE_VERSION__
+      : "0.0.0",
+};

package/src/server/parseAdkRequest.test.ts

@@ -239,6 +239,41 @@ describe("parseAdkRequest", () => {
 });
 
 describe("toAdkContent", () => {
+  it.each([
+    ["permission denied", { error: "permission denied" }],
+    [
+      { message: "permission denied" },
+      { error: { message: "permission denied" } },
+    ],
+    [["denied"], { error: ["denied"] }],
+    [null, { error: null }],
+    [false, { error: false }],
+    [0, { error: 0 }],
+    ["", { error: "" }],
+    [
+      { error: "denied", output: "partial" },
+      { error: "denied", output: "partial" },
+    ],
+  ])(
+    "preserves explicit tool failure %j in the function response",
+    async (result, response) => {
+      const parsed = await parseAdkRequest(
+        makeRequest({
+          type: "tool-result",
+          toolCallId: "tc-1",
+          toolName: "search",
+          result,
+          isError: true,
+        }),
+      );
+      expect(toAdkContent(parsed).parts).toEqual([
+        {
+          functionResponse: { name: "search", id: "tc-1", response },
+        },
+      ]);
+    },
+  );
+
   it("converts a text message to user content with text part", () => {
     const content = toAdkContent({
       type: "message",
@@ -292,4 +327,32 @@ describe("toAdkContent", () => {
       ],
     });
   });
+
+  it.each([
+    [false, { result: false }],
+    [0, { result: 0 }],
+    [null, { result: null }],
+    ["done", { result: "done" }],
+    [[1, 2], { results: [1, 2] }],
+  ])(
+    "wraps scalar or array tool result %j in a function response object",
+    (result, response) => {
+      const content = toAdkContent({
+        type: "tool-result",
+        toolCallId: "tc-1",
+        toolName: "search",
+        result,
+        isError: false,
+        config: {},
+      });
+
+      expect(content.parts[0]).toEqual({
+        functionResponse: {
+          name: "search",
+          id: "tc-1",
+          response,
+        },
+      });
+    },
+  );
 });

package/src/server/parseAdkRequest.ts

@@ -1,5 +1,6 @@
 import { isRecord } from "@assistant-ui/core/internal";
 import type { AdkSendMessageConfig } from "../types";
+import { toAdkFunctionResponse } from "../toAdkFunctionResponse";
 
 type ParsedAdkRequest =
   | {
@@ -240,7 +241,7 @@ export const toAdkContent = (
           functionResponse: {
             name: parsed.toolName,
             id: parsed.toolCallId,
-            response: parsed.result,
+            response: toAdkFunctionResponse(parsed.result, parsed.isError),
           },
         },
       ],

package/src/toAdkFunctionResponse.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import {
+  isAdkFunctionError,
+  toAdkFunctionResponse,
+} from "./toAdkFunctionResponse";
+
+describe("ADK function response errors", () => {
+  it("retains an existing error envelope without mutating or nesting it", () => {
+    const response = Object.freeze({ error: "denied", output: "partial" });
+    expect(toAdkFunctionResponse(response, true)).toBe(response);
+  });
+
+  it("preserves a failure with no details through JSON serialization", () => {
+    const response = JSON.parse(
+      JSON.stringify(toAdkFunctionResponse(undefined, true)),
+    );
+    expect(response).toEqual({ error: null });
+    expect(isAdkFunctionError(response)).toBe(true);
+  });
+
+  it("does not classify an undefined error field as an on-wire error", () => {
+    expect(isAdkFunctionError({ error: undefined })).toBe(false);
+    expect(
+      isAdkFunctionError(JSON.parse(JSON.stringify({ error: undefined }))),
+    ).toBe(false);
+  });
+
+  it("does not classify inherited error fields as an on-wire error", () => {
+    const response = Object.create({ error: "inherited" });
+    response.output = "done";
+    expect(isAdkFunctionError(response)).toBe(false);
+  });
+
+  it.each([
+    ["done", { result: "done" }],
+    [[1, 2], { results: [1, 2] }],
+    [
+      { output: { error: "application data" } },
+      { output: { error: "application data" } },
+    ],
+    [null, { result: null }],
+  ])("leaves successful result %j unchanged", (result, expected) => {
+    expect(toAdkFunctionResponse(result)).toEqual(expected);
+    expect(isAdkFunctionError(toAdkFunctionResponse(result))).toBe(false);
+  });
+});

package/src/toAdkFunctionResponse.ts

@@ -0,0 +1,18 @@
+import { isRecord } from "@assistant-ui/core/internal";
+
+export const isAdkFunctionError = (response: unknown): boolean =>
+  isRecord(response) &&
+  Object.hasOwn(response, "error") &&
+  response.error !== undefined;
+
+export const toAdkFunctionResponse = (
+  result: unknown,
+  isError = false,
+): Record<string, unknown> => {
+  if (isError && !isAdkFunctionError(result)) return { error: result ?? null };
+  return Array.isArray(result)
+    ? { results: result }
+    : isRecord(result)
+      ? result
+      : { result };
+};