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

package/src/AdkEventAccumulator.test.ts

@@ -117,7 +117,7 @@ describe("AdkEventAccumulator - function calls", () => {
     });
   });
 
-  it("generates a UUID for functionCall without an id", () => {
+  it("generates an ID for functionCall without an id", () => {
     const acc = new AdkEventAccumulator();
     const msgs = acc.processEvent(
       makeEvent({
@@ -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(
@@ -1400,3 +1477,86 @@ describe("AdkEventAccumulator - user message handling", () => {
     });
   });
 });
+
+describe("AdkEventAccumulator - multiple parts in one event", () => {
+  it("keeps every text part of a single non-partial event in order", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        content: { role: "model", parts: [{ text: "A" }, { text: "B" }] },
+      }),
+    );
+
+    expect(msgs[0]?.content).toEqual([
+      { type: "text", text: "A" },
+      { type: "text", text: "B" },
+    ]);
+  });
+
+  it("preserves the Gemini code-execution shape", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        content: {
+          role: "model",
+          parts: [
+            { text: "Here is the code:" },
+            { executableCode: { code: "print(1)", language: "python" } },
+            { codeExecutionResult: { outcome: "OUTCOME_OK", output: "1" } },
+            { text: "The result is 1." },
+          ],
+        },
+      }),
+    );
+
+    expect(msgs[0]?.content).toEqual([
+      { type: "text", text: "Here is the code:" },
+      { type: "code", code: "print(1)", language: "python" },
+      { type: "code_result", output: "1", outcome: "OUTCOME_OK" },
+      { type: "text", text: "The result is 1." },
+    ]);
+  });
+
+  it("keeps every reasoning part of a single non-partial event", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        content: {
+          role: "model",
+          parts: [
+            { text: "First thought", thought: true },
+            { text: "Second thought", thought: true },
+          ],
+        },
+      }),
+    );
+
+    expect(msgs[0]?.content).toEqual([
+      { type: "reasoning", text: "First thought" },
+      { type: "reasoning", text: "Second thought" },
+    ]);
+  });
+
+  it("still replaces the streamed buffer with the final text", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(makeTextEvent("Hel", true));
+    acc.processEvent(makeTextEvent("lo", true));
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        content: {
+          role: "model",
+          parts: [{ text: "Hello" }, { text: "Again" }],
+        },
+      }),
+    );
+
+    expect(msgs[0]?.content).toEqual([
+      { type: "text", text: "Hello" },
+      { type: "text", text: "Again" },
+    ]);
+  });
+});

package/src/AdkEventAccumulator.ts

@@ -1,4 +1,4 @@
-import { v4 as uuidv4 } from "uuid";
+import { generateId } from "@assistant-ui/core";
 import type { MessageStatus } from "@assistant-ui/core";
 import type {
   AdkEvent,
@@ -26,10 +26,10 @@ type InProgressMessage = AdkMessage & { type: "ai" };
  * event has already opened.
  */
 const toolMessageId = (event: AdkEvent, partIndex: number): string =>
-  event.id ? `${event.id}:${partIndex}` : uuidv4();
+  event.id ? `${event.id}:${partIndex}` : generateId();
 
 const aiMessageId = (event: AdkEvent, ordinal: number): string =>
-  event.id ? `${event.id}:ai${ordinal === 0 ? "" : ordinal}` : uuidv4();
+  event.id ? `${event.id}:ai${ordinal === 0 ? "" : ordinal}` : generateId();
 
 const ADK_REQUEST_CONFIRMATION = "adk_request_confirmation";
 const ADK_REQUEST_CREDENTIAL = "adk_request_credential";
@@ -191,6 +191,8 @@ export class AdkEventAccumulator {
   private messagesMap = new Map<string, AdkMessage>();
   private currentMessageId: string | null = null;
   private partialTextBuffer = "";
+  private finalTextReplacedThisEvent = false;
+  private finalReasoningReplacedThisEvent = false;
   private partialReasoningBuffer = "";
   private accumulatedStateDelta: Record<string, unknown> = {};
   private accumulatedArtifactDelta: Record<string, number> = {};
@@ -331,7 +333,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,10 +345,32 @@ 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 id = event.id ?? generateId();
         const first = humanParts[0];
         const content: string | AdkMessageContentPart[] =
           humanParts.length === 1 && first?.type === "text"
@@ -364,6 +389,11 @@ export class AdkEventAccumulator {
       }
     }
 
+    // Replace-semantics close out the streamed partial buffer, which only
+    // the first final text/reasoning part of an event may do; later parts
+    // of the same event are distinct content and append.
+    this.finalTextReplacedThisEvent = false;
+    this.finalReasoningReplacedThisEvent = false;
     for (const [index, part] of parts.entries()) {
       this.processPart(part, event, index);
     }
@@ -449,9 +479,12 @@ export class AdkEventAccumulator {
       if (event.partial) {
         this.partialReasoningBuffer += part.text;
         this.replaceLastReasoningContent(msg, this.partialReasoningBuffer);
-      } else {
+      } else if (!this.finalReasoningReplacedThisEvent) {
+        this.finalReasoningReplacedThisEvent = true;
         this.partialReasoningBuffer = "";
         this.replaceLastReasoningContent(msg, part.text);
+      } else {
+        this.appendContent(msg, { type: "reasoning", text: part.text });
       }
       return;
     }
@@ -462,9 +495,12 @@ export class AdkEventAccumulator {
       if (event.partial) {
         this.partialTextBuffer += part.text;
         this.replaceLastTextContent(msg, this.partialTextBuffer);
-      } else {
+      } else if (!this.finalTextReplacedThisEvent) {
+        this.finalTextReplacedThisEvent = true;
         this.partialTextBuffer = "";
         this.replaceLastTextContent(msg, part.text);
+      } else {
+        this.appendContent(msg, { type: "text", text: part.text });
       }
       return;
     }
@@ -474,7 +510,7 @@ export class AdkEventAccumulator {
       if (event.partial) return;
       const msg = this.getOrCreateAiMessage(event);
       const toolCall: AdkToolCall = {
-        id: part.functionCall.id ?? uuidv4(),
+        id: part.functionCall.id ?? generateId(),
         name: part.functionCall.name,
         args: part.functionCall.args as ReadonlyJSONObject,
         argsText: JSON.stringify(part.functionCall.args),

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: [] };