@assistant-ui/react-google-adk 0.0.25 → 0.0.26

package/src/AdkClient.ts

@@ -1,5 +1,6 @@
 import { SSEEventDecoder } from "assistant-stream/utils";
 import { contentToParts } from "./contentToParts";
+import { parseAdkEventValue } from "./parseAdkEvent";
 import { trimTrailingSlashes } from "./trimTrailingSlashes";
 import type {
   AdkEvent,
@@ -131,6 +132,17 @@ function validateEventStreamContentType(response: Response): void {
   }
 }
 
+function parseAdkEvent(data: string): AdkEvent {
+  let value: unknown;
+  try {
+    value = JSON.parse(data);
+  } catch {
+    throw new Error("Invalid ADK stream event: expected valid JSON.");
+  }
+
+  return parseAdkEventValue(value, "Invalid ADK stream event");
+}
+
 async function resolveHeaders(
   headers:
     | Record<string, string>
@@ -258,7 +270,7 @@ async function* parseSSEResponse(response: Response): AsyncGenerator<AdkEvent> {
       if (done) {
         shouldCancel = false;
         for (const event of sseDecoder.push(decoder.decode())) {
-          yield JSON.parse(event.data) as AdkEvent;
+          yield parseAdkEvent(event.data);
         }
         break;
       }
@@ -266,12 +278,12 @@ async function* parseSSEResponse(response: Response): AsyncGenerator<AdkEvent> {
       for (const event of sseDecoder.push(
         decoder.decode(value, { stream: true }),
       )) {
-        yield JSON.parse(event.data) as AdkEvent;
+        yield parseAdkEvent(event.data);
       }
     }
 
     const trailing = sseDecoder.flush();
-    if (trailing !== null) yield JSON.parse(trailing.data) as AdkEvent;
+    if (trailing !== null) yield parseAdkEvent(trailing.data);
   } finally {
     try {
       if (shouldCancel) await reader.cancel().catch(() => undefined);

package/src/AdkEventAccumulator.test.ts

@@ -240,6 +240,29 @@ describe("AdkEventAccumulator - function responses", () => {
     });
   });
 
+  it("skips a user function response that answers no call", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: {
+          role: "user",
+          parts: [
+            {
+              functionResponse: {
+                name: "adk_request_confirmation",
+                response: { confirmed: true },
+              },
+            },
+          ],
+        },
+      }),
+    );
+    // Without an id it answers no call: core drops it as an orphan, and
+    // keeping it would let it settle the confirmation batch it grouped into.
+    expect(msgs.filter((m) => m.type === "tool")).toEqual([]);
+  });
+
   // A session load replays the stored events through a fresh accumulator.
   it("gives a tool message the same id on every replay of an event", () => {
     const event = makeEvent({
@@ -1091,6 +1114,60 @@ describe("AdkEventAccumulator - user message handling", () => {
     });
   });
 
+  it("creates a tool message for a user-authored function response", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: {
+          role: "user",
+          parts: [
+            {
+              functionResponse: {
+                id: "tc-1",
+                name: "adk_request_confirmation",
+                response: { confirmed: true },
+              },
+            },
+          ],
+        },
+      }),
+    );
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatchObject({
+      type: "tool",
+      tool_call_id: "tc-1",
+      name: "adk_request_confirmation",
+      content: JSON.stringify({ confirmed: true }),
+      status: "success",
+    });
+  });
+
+  it("orders function responses from one user event before its text", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: {
+          role: "user",
+          parts: [
+            { text: "go ahead" },
+            {
+              functionResponse: {
+                id: "tc-1",
+                name: "adk_request_confirmation",
+                response: { confirmed: true },
+              },
+            },
+          ],
+        },
+      }),
+    );
+    expect(msgs).toHaveLength(2);
+    expect(msgs[0]).toMatchObject({ type: "tool", tool_call_id: "tc-1" });
+    expect(msgs[1]).toMatchObject({ type: "human", content: "go ahead" });
+  });
+
   it("creates separate human and AI messages for a user/agent turn", () => {
     const acc = new AdkEventAccumulator();
     acc.processEvent(

package/src/AdkEventAccumulator.ts

@@ -331,7 +331,8 @@ export class AdkEventAccumulator {
     if (event.author === "user") {
       this.finalizeCurrentMessage();
       const humanParts: AdkMessageContentPart[] = [];
-      for (const part of parts) {
+      const toolMessages: AdkMessage[] = [];
+      for (const [index, part] of parts.entries()) {
         if (part.text != null && !part.thought) {
           humanParts.push({ type: "text", text: part.text });
         } else if (part.inlineData) {
@@ -342,8 +343,30 @@ export class AdkEventAccumulator {
           humanParts.push(
             fileDataToPart(part.fileData.fileUri, part.fileData.mimeType),
           );
+        } else if (part.functionResponse?.id) {
+          // ADK records tool confirmation and other client-supplied tool
+          // results as user-authored function responses, and its request
+          // confirmation processors search user events for them. Dropping
+          // them here would replay a settled gate as pending. A response
+          // carrying no id answers no call: core drops it as an orphan, and
+          // keeping it would let it settle the batch it was grouped into.
+          toolMessages.push({
+            id: toolMessageId(event, index),
+            type: "tool",
+            tool_call_id: part.functionResponse.id,
+            name: part.functionResponse.name,
+            content: JSON.stringify(part.functionResponse.response),
+            status: "success",
+          });
         }
       }
+      // The replies answer the preceding assistant turn, so they are emitted
+      // before any user content in the same event. A human message between the
+      // tool call and its reply splits them into separate converted messages,
+      // orphaning the reply and leaving its gate unsettled.
+      for (const toolMsg of toolMessages) {
+        this.messagesMap.set(toolMsg.id, toolMsg);
+      }
       if (humanParts.length > 0) {
         const id = event.id ?? uuidv4();
         const first = humanParts[0];

package/src/AdkSessionAdapter.test.ts

@@ -1,5 +1,6 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { createAdkSessionAdapter } from "./AdkSessionAdapter";
+import { projectAdkToolApprovals } from "./adkToolApproval";
 
 // ── Helpers ──
 
@@ -410,6 +411,45 @@ describe("createAdkSessionAdapter - load", () => {
     );
   });
 
+  it("rejects malformed events inside a session history", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({ id: "s1", events: [{}] }), {
+        status: 200,
+      }),
+    );
+
+    const { load } = createAdkSessionAdapter(baseOptions);
+
+    await expect(load("s1")).rejects.toThrow(
+      "Invalid ADK session event at index 0: expected a non-empty object.",
+    );
+  });
+
+  it("rejects partial replay when a history event is malformed", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          id: "s1",
+          events: [
+            {
+              id: "e1",
+              author: "user",
+              content: { role: "user", parts: [{ text: "Hello" }] },
+            },
+            {},
+          ],
+        }),
+        { status: 200 },
+      ),
+    );
+
+    const { load } = createAdkSessionAdapter(baseOptions);
+
+    await expect(load("s1")).rejects.toThrow(
+      "Invalid ADK session event at index 1: expected a non-empty object.",
+    );
+  });
+
   it("throws when session fetch fails", async () => {
     mockFetch.mockResolvedValueOnce(
       new Response("Server error", { status: 500 }),
@@ -448,6 +488,110 @@ describe("createAdkSessionAdapter - load", () => {
   });
 });
 
+describe("createAdkSessionAdapter - load replays tool confirmations", () => {
+  const CONFIRMATION_CALL = "conf-1";
+
+  const confirmationSession = (response: unknown) => ({
+    id: "s1",
+    events: [
+      {
+        id: "e1",
+        author: "agent",
+        longRunningToolIds: [CONFIRMATION_CALL],
+        content: {
+          role: "model",
+          parts: [
+            {
+              functionCall: {
+                id: CONFIRMATION_CALL,
+                name: "adk_request_confirmation",
+                args: {
+                  originalFunctionCall: { id: "tc-1", name: "delete_file" },
+                  toolConfirmation: { hint: "Delete /tmp/a?" },
+                },
+              },
+            },
+          ],
+        },
+      },
+      {
+        id: "e2",
+        author: "user",
+        content: {
+          role: "user",
+          parts: [
+            {
+              functionResponse: {
+                id: CONFIRMATION_CALL,
+                name: "adk_request_confirmation",
+                response,
+              },
+            },
+          ],
+        },
+      },
+    ],
+  });
+
+  const loadApprovals = async (response: unknown) => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify(confirmationSession(response)), {
+        status: 200,
+      }),
+    );
+    const { load } = createAdkSessionAdapter(baseOptions);
+    const result = await load("s1");
+    return {
+      messages: result.messages,
+      approvals: projectAdkToolApprovals(result.messages).approvals,
+    };
+  };
+
+  it("keeps a user-authored confirmation reply as a tool message", async () => {
+    const { messages } = await loadApprovals({ confirmed: true });
+
+    expect(messages.map((m) => m.type)).toEqual(["ai", "tool"]);
+    expect(messages[1]).toMatchObject({
+      type: "tool",
+      tool_call_id: CONFIRMATION_CALL,
+      name: "adk_request_confirmation",
+    });
+  });
+
+  it.each([
+    ["direct", { confirmed: true }, { approved: true }],
+    ["direct denial", { confirmed: false }, { approved: false }],
+    [
+      "wrapped",
+      { response: JSON.stringify({ confirmed: true }) },
+      { approved: true },
+    ],
+    [
+      "wrapped denial",
+      { response: JSON.stringify({ confirmed: false }) },
+      { approved: false },
+    ],
+  ])(
+    "projects a settled gate from a replayed %s reply",
+    async (_name, response, expected) => {
+      const { approvals } = await loadApprovals(response);
+
+      expect(approvals.get(CONFIRMATION_CALL)).toEqual({
+        id: CONFIRMATION_CALL,
+        ...expected,
+      });
+    },
+  );
+
+  it("leaves the gate pending when the replayed reply is unreadable", async () => {
+    const { approvals } = await loadApprovals({ response: "not json" });
+
+    expect(approvals.get(CONFIRMATION_CALL)).toEqual({
+      id: CONFIRMATION_CALL,
+    });
+  });
+});
+
 describe("createAdkSessionAdapter - artifacts", () => {
   it("lists names from current and legacy artifact responses", async () => {
     mockFetch.mockResolvedValueOnce(

package/src/AdkSessionAdapter.ts

@@ -6,7 +6,8 @@ import type {
   RemoteThreadMetadata,
 } from "@assistant-ui/core";
 import { AdkEventAccumulator } from "./AdkEventAccumulator";
-import type { AdkEvent, AdkMessage, AdkThreadSnapshot } from "./types";
+import { parseAdkEventValue } from "./parseAdkEvent";
+import type { AdkMessage, AdkThreadSnapshot } from "./types";
 import { trimTrailingSlashes } from "./trimTrailingSlashes";
 
 export type AdkSessionAdapterOptions = {
@@ -323,7 +324,11 @@ export function createAdkSessionAdapter(
       );
     }
 
-    const events = session.events as AdkEvent[] | undefined;
+    // Events carry ordered state and tool transitions, so partial replay can
+    // produce a plausible but incorrect thread.
+    const events = session.events?.map((event, index) =>
+      parseAdkEventValue(event, `Invalid ADK session event at index ${index}`),
+    );
 
     if (!events?.length) {
       return { messages: [] };