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

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({
@@ -1477,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> = {};
@@ -368,7 +370,7 @@ export class AdkEventAccumulator {
         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"
@@ -387,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);
     }
@@ -472,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;
     }
@@ -485,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;
     }
@@ -497,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/adkToolApproval.ts

@@ -1,9 +1,9 @@
+import { generateId } from "@assistant-ui/core";
 import type {
   RespondToToolApprovalOptions,
   ToolCallMessagePart,
 } from "@assistant-ui/core";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
-import { v4 as uuidv4 } from "uuid";
 import type { AdkMessage } from "./types";
 
 export type AdkToolApproval = NonNullable<ToolCallMessagePart["approval"]>;
@@ -185,7 +185,7 @@ export const toAdkConfirmationReply = (
   confirmed: boolean,
   payload?: ReadonlyJSONValue,
 ): AdkMessage & { type: "tool" } => ({
-  id: uuidv4(),
+  id: generateId(),
   type: "tool",
   tool_call_id: toolCallId,
   name: ADK_REQUEST_CONFIRMATION,

package/src/{useAdkRuntime.test.ts → convertToAdkMessages.test.ts}

@@ -3,7 +3,7 @@ import {
   getMessageContent,
   getPendingCancellations,
   getPendingToolCalls,
-} from "./useAdkRuntime";
+} from "./convertToAdkMessages";
 import { convertAdkMessage } from "./convertAdkMessages";
 import type { AppendMessage } from "@assistant-ui/core";
 import type { AdkMessage } from "./types";

package/src/convertToAdkMessages.ts

@@ -0,0 +1,139 @@
+import {
+  generateId,
+  getExternalStoreMessages,
+  type AppendMessage,
+  type ThreadMessage,
+} from "@assistant-ui/core";
+import {
+  createToolCallCancellationStub,
+  parseDataUrl,
+  resolveFilePartSource,
+  scanPendingToolCalls,
+} from "@assistant-ui/core/internal";
+import type { AdkMessage } from "./types";
+
+/** Exported for unit tests. */
+export const getMessageContent = (msg: AppendMessage) => {
+  const allContent = [
+    ...msg.content,
+    ...(msg.attachments?.flatMap((a) => a.content) ?? []),
+  ];
+  const content = allContent.flatMap((part) => {
+    const type = part.type;
+    switch (type) {
+      case "text":
+        return { type: "text" as const, text: part.text };
+      case "image":
+        return { type: "image_url" as const, url: part.image };
+      case "file": {
+        const source = resolveFilePartSource(part);
+        if (source.kind === "url") {
+          return {
+            type: "file_url" as const,
+            url: source.url,
+            mimeType: part.mimeType,
+          };
+        }
+        return {
+          type: "file" as const,
+          mimeType: part.mimeType,
+          // Lands in Gemini `inlineData.data`, which takes bare base64, so a
+          // data URL envelope is stripped rather than forwarded.
+          data: source.data,
+          ...(part.filename != null && { filename: part.filename }),
+        };
+      }
+      case "audio": {
+        const parsed = parseDataUrl(part.audio.data);
+        return {
+          type: "file" as const,
+          mimeType: `audio/${part.audio.format}`,
+          data: parsed?.data ?? part.audio.data,
+        };
+      }
+      case "data":
+        return [];
+
+      case "tool-call":
+        throw new Error("Tool call appends are not supported.");
+
+      default: {
+        const _exhaustiveCheck: "reasoning" | "source" | "generative-ui" = type;
+        throw new Error(
+          `Unsupported append message part type: ${_exhaustiveCheck}`,
+        );
+      }
+    }
+  });
+
+  if (content.length === 1 && content[0]?.type === "text") {
+    return content[0].text ?? "";
+  }
+
+  return content;
+};
+
+/** Exported for unit tests. */
+export const getPendingToolCalls = (messages: AdkMessage[]) => {
+  return scanPendingToolCalls(
+    messages,
+    (message) => {
+      if (message.type === "ai") {
+        return { toolCalls: message.tool_calls ?? [] };
+      }
+      if (message.type === "tool") {
+        return { toolCallId: message.tool_call_id };
+      }
+      return undefined;
+    },
+    (toolCall) => toolCall.id,
+  );
+};
+
+/**
+ * Exported for unit tests.
+ *
+ * Returns `{cancelled: true}` tool responses for pending tool calls when the
+ * user sends a new turn, EXCEPT for HITL interrupts marked via
+ * `long_running_tool_ids` (`adk_request_input`, `adk_request_confirmation`,
+ * `adk_request_credential`). Those must be answered through a dedicated tool
+ * UI + submit helper, not auto-cancelled.
+ */
+export const getPendingCancellations = (
+  messages: AdkMessage[],
+  longRunningToolIds: readonly string[],
+): Array<AdkMessage & { type: "tool" }> => {
+  const longRunningSet = new Set(longRunningToolIds);
+  return getPendingToolCalls(messages)
+    .filter((t) => !longRunningSet.has(t.id))
+    .map(
+      (t) =>
+        ({
+          id: generateId(),
+          ...createToolCallCancellationStub(t),
+        }) satisfies AdkMessage & { type: "tool" },
+    );
+};
+
+export const truncateAdkMessages = (
+  threadMessages: readonly ThreadMessage[],
+  parentId: string | null,
+): AdkMessage[] => {
+  if (parentId === null) return [];
+  const parentIndex = threadMessages.findIndex((m) => m.id === parentId);
+  if (parentIndex === -1) return [];
+  const truncated: AdkMessage[] = [];
+  for (let i = 0; i <= parentIndex && i < threadMessages.length; i++) {
+    truncated.push(...getExternalStoreMessages<AdkMessage>(threadMessages[i]!));
+  }
+  return truncated;
+};
+
+export const toAdkUserMessage = (
+  msg: AppendMessage,
+  id = generateId(),
+): AdkMessage & { type: "human"; id: string } => ({
+  id,
+  type: "human",
+  content: getMessageContent(msg),
+});

package/src/hooks.ts

@@ -1,5 +1,5 @@
+import { generateId } from "@assistant-ui/core";
 import { useAui } from "@assistant-ui/store";
-import { v4 as uuidv4 } from "uuid";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import { adkExtras } from "./adkExtras";
 import { toAdkConfirmationReply } from "./adkToolApproval";
@@ -79,7 +79,7 @@ export const useAdkSubmitAuth = () => {
     adkExtras.get(aui).send(
       [
         {
-          id: uuidv4(),
+          id: generateId(),
           type: "tool",
           tool_call_id: toolCallId,
           name: "adk_request_credential",
@@ -98,7 +98,7 @@ export const useAdkSubmitInput = () => {
     adkExtras.get(aui).send(
       [
         {
-          id: uuidv4(),
+          id: generateId(),
           type: "tool",
           tool_call_id: toolCallId,
           name: "adk_request_input",

package/src/useAdkMessages.ts

@@ -1,6 +1,14 @@
-import { useState, useCallback, useEffect, useRef, useMemo } from "react";
-import { v4 as uuidv4 } from "uuid";
+import {
+  useState,
+  useCallback,
+  useEffect,
+  useInsertionEffect,
+  useRef,
+  useMemo,
+} from "react";
+import { generateId } from "@assistant-ui/core";
 import { useAui } from "@assistant-ui/store";
+import { invokeUserCallback } from "@assistant-ui/core/internal";
 import { AdkEventAccumulator } from "./AdkEventAccumulator";
 import { contentToParts } from "./contentToParts";
 import type {
@@ -28,24 +36,12 @@ export type UseAdkMessagesOptions = {
 
 type AdkRuntimeCallbackName = "onError" | "onCustomEvent" | "onAgentTransfer";
 
-const reportCallbackError = (name: AdkRuntimeCallbackName, error: unknown) => {
-  console.error(`[react-google-adk] ${name} callback threw an error`, error);
-};
-
-const invokeAdkRuntimeCallback = <TArgs extends unknown[]>(
+const invokeAdkRuntimeCallback = <TArgs extends readonly unknown[]>(
   name: AdkRuntimeCallbackName,
-  callback: ((...args: TArgs) => void | Promise<void>) | undefined,
+  callback: ((...args: TArgs) => unknown) | undefined,
   ...args: TArgs
-) => {
-  if (!callback) return;
-
-  try {
-    void Promise.resolve(callback(...args)).catch((error) => {
-      reportCallbackError(name, error);
-    });
-  } catch (error) {
-    reportCallbackError(name, error);
-  }
+): void => {
+  void invokeUserCallback("react-google-adk", name, callback, ...args);
 };
 
 export const useAdkMessages = ({
@@ -71,14 +67,21 @@ export const useAdkMessages = ({
     Map<string, AdkMessageMetadata>
   >(new Map());
   const lastTransferToAgentRef = useRef<string | undefined>(undefined);
+  // setMessagesImmediate is the only writer of the messages state and publishes
+  // this ref with it, so the ref never trails a commit.
   const messagesRef = useRef(messages);
-  messagesRef.current = messages;
   const stateDeltaRef = useRef(stateDelta);
-  stateDeltaRef.current = stateDelta;
+  useInsertionEffect(() => {
+    stateDeltaRef.current = stateDelta;
+  }, [stateDelta]);
   const artifactDeltaRef = useRef(artifactDelta);
-  artifactDeltaRef.current = artifactDelta;
+  useInsertionEffect(() => {
+    artifactDeltaRef.current = artifactDelta;
+  }, [artifactDelta]);
   const messageMetadataRef = useRef(messageMetadata);
-  messageMetadataRef.current = messageMetadata;
+  useInsertionEffect(() => {
+    messageMetadataRef.current = messageMetadata;
+  }, [messageMetadata]);
 
   const setMessagesImmediate = useCallback((msgs: AdkMessage[]) => {
     messagesRef.current = msgs;
@@ -133,7 +136,7 @@ export const useAdkMessages = ({
   const sendMessage = useCallback(
     async (newMessages: AdkMessage[], config: AdkSendMessageConfig) => {
       const newMessagesWithId = newMessages.map((m) =>
-        m.id ? m : { ...m, id: uuidv4() },
+        m.id ? m : { ...m, id: generateId() },
       ) as AdkMessage[];
 
       // A staged message is already in the thread under its own id, and the
@@ -306,7 +309,7 @@ export const messagesToEvents = (messages: AdkMessage[]): AdkEvent[] => {
   // message. Emitting it here keeps the optimistic view equal to that replay.
   if (parts.length === 0) parts.push({ text: "" });
 
-  const event: AdkEvent = { id: (human ?? run[0])?.id ?? uuidv4() };
+  const event: AdkEvent = { id: (human ?? run[0])?.id ?? generateId() };
   if (human || run.length === 0) event.author = "user";
   event.content = { role: "user", parts };
   events.splice(run.length > 0 ? runIndex : events.length, 0, event);
@@ -318,7 +321,7 @@ export const messagesToEvents = (messages: AdkMessage[]): AdkEvent[] => {
 export const messageToEvent = (msg: AdkMessage): AdkEvent => {
   if (msg.type === "human") {
     return {
-      id: msg.id ?? uuidv4(),
+      id: msg.id ?? generateId(),
       author: "user",
       content: { role: "user", parts: contentToParts(msg.content) },
     };
@@ -332,7 +335,7 @@ export const messageToEvent = (msg: AdkMessage): AdkEvent => {
       response = msg.content;
     }
     return {
-      id: msg.id ?? uuidv4(),
+      id: msg.id ?? generateId(),
       content: {
         role: "user",
         parts: [
@@ -348,7 +351,7 @@ export const messageToEvent = (msg: AdkMessage): AdkEvent => {
     };
   }
 
-  const result: AdkEvent = { id: msg.id ?? uuidv4() };
+  const result: AdkEvent = { id: msg.id ?? generateId() };
   if (msg.author != null) result.author = msg.author;
   result.content = {
     role: "model",