@assistant-ui/react-google-adk 0.0.5 → 0.0.7

package/src/AdkEventAccumulator.ts

@@ -166,7 +166,7 @@ export class AdkEventAccumulator {
     branch?: string | undefined;
   } = {};
   private lastTransferToAgent: string | undefined;
-  private pendingLongRunningToolIds: string[] = [];
+  private pendingLongRunningToolIds = new Set<string>();
   private toolConfirmations: AdkToolConfirmation[] = [];
   private authRequests: AdkAuthRequest[] = [];
   private escalated = false;
@@ -202,9 +202,13 @@ export class AdkEventAccumulator {
       this.lastTransferToAgent = event.actions.transferToAgent;
     }
 
-    // Track long-running tool IDs
+    // Track long-running tool IDs. Accumulate across events so that multiple
+    // HITL interrupts emitted in the same turn are all tracked — a
+    // single-event replacement would drop earlier ids.
     if (event.longRunningToolIds?.length) {
-      this.pendingLongRunningToolIds = event.longRunningToolIds;
+      for (const id of event.longRunningToolIds) {
+        this.pendingLongRunningToolIds.add(id);
+      }
     }
 
     // Track tool confirmations from actions
@@ -284,6 +288,41 @@ export class AdkEventAccumulator {
       return this.getMessages();
     }
 
+    // User-authored events → create human message, not AI.
+    // Without this, user events fall through to processPart →
+    // getOrCreateAiMessage, producing type:"ai" messages that
+    // convertAdkMessage maps to role:"assistant".
+    if (event.author === "user") {
+      this.finalizeCurrentMessage();
+      const humanParts: AdkMessageContentPart[] = [];
+      for (const part of parts) {
+        if (part.text != null && !part.thought) {
+          humanParts.push({ type: "text", text: part.text });
+        } else if (part.inlineData) {
+          humanParts.push({
+            type: "image",
+            mimeType: part.inlineData.mimeType,
+            data: part.inlineData.data,
+          });
+        } else if (part.fileData) {
+          humanParts.push({
+            type: "image_url",
+            url: part.fileData.fileUri,
+          });
+        }
+      }
+      if (humanParts.length > 0) {
+        const id = event.id ?? uuidv4();
+        const first = humanParts[0];
+        const content: string | AdkMessageContentPart[] =
+          humanParts.length === 1 && first?.type === "text"
+            ? first.text
+            : humanParts;
+        this.messagesMap.set(id, { id, type: "human", content });
+      }
+      return this.getMessages();
+    }
+
     // If author changed, finalize previous message
     if (this.currentMessageId && event.author && event.author !== "user") {
       const current = this.messagesMap.get(this.currentMessageId);
@@ -302,7 +341,13 @@ export class AdkEventAccumulator {
     // Check isFinalResponse (can be true even for partial events via skipSummarization/longRunningToolIds)
     if (isFinalResponse(event) && this.currentMessageId) {
       const msg = this.messagesMap.get(this.currentMessageId);
-      if (msg && msg.type === "ai" && !msg.status) {
+      // Skip manual "complete" when longRunningToolIds is the sole reason for
+      // isFinalResponse — let auto-status apply requires-action for pending tool calls.
+      const isHitlOnly =
+        event.longRunningToolIds &&
+        event.longRunningToolIds.length > 0 &&
+        !event.actions?.skipSummarization;
+      if (msg && msg.type === "ai" && !msg.status && !isHitlOnly) {
         const status = finishReasonToStatus(event.finishReason);
         const updated: InProgressMessage = {
           ...msg,

package/src/AdkSessionAdapter.test.ts

@@ -126,7 +126,7 @@ describe("createAdkSessionAdapter - initialize", () => {
     });
     expect(JSON.parse(init?.body as string)).toEqual({});
     expect(result).toMatchObject({
-      remoteId: "thread-1",
+      remoteId: "new-session-1",
       externalId: "new-session-1",
     });
   });

package/src/AdkSessionAdapter.ts

@@ -1,4 +1,4 @@
-import { AssistantStream, AssistantStreamChunk } from "assistant-stream";
+import type { AssistantStream, AssistantStreamChunk } from "assistant-stream";
 import type {
   RemoteThreadInitializeResponse,
   RemoteThreadListAdapter,
@@ -112,7 +112,7 @@ export function createAdkSessionAdapter(
     },
 
     async initialize(
-      threadId: string,
+      _threadId: string,
     ): Promise<RemoteThreadInitializeResponse> {
       const headers = await getHeaders();
       const res = await fetch(baseUrl, {
@@ -124,7 +124,7 @@ export function createAdkSessionAdapter(
         throw new Error(`Failed to create session: ${res.status}`);
       }
       const session = (await res.json()) as { id: string };
-      return { remoteId: threadId, externalId: session.id };
+      return { remoteId: session.id, externalId: session.id };
     },
 
     async delete(remoteId: string): Promise<void> {

package/src/convertAdkMessages.ts

@@ -1,7 +1,7 @@
 "use client";
 
 import type { ToolCallMessagePart } from "@assistant-ui/core";
-import { useExternalMessageConverter } from "@assistant-ui/core/react";
+import type { useExternalMessageConverter } from "@assistant-ui/core/react";
 import type { AdkMessage, AdkMessageContentPart } from "./types";
 
 type ContentPart =

package/src/hooks.ts

@@ -2,6 +2,7 @@
 
 import { useAui, useAuiState } from "@assistant-ui/store";
 import { v4 as uuidv4 } from "uuid";
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import type {
   AdkMessage,
   AdkSendMessageConfig,
@@ -126,7 +127,11 @@ export const useAdkMessageMetadata = () => {
 /** Returns a function to confirm or deny a pending tool confirmation. */
 export const useAdkConfirmTool = () => {
   const aui = useAui();
-  return (toolCallId: string, confirmed: boolean, payload?: unknown) => {
+  return (
+    toolCallId: string,
+    confirmed: boolean,
+    payload?: ReadonlyJSONValue,
+  ) => {
     const extras = aui.thread().getState().extras;
     const { send } = asAdkRuntimeExtras(extras);
     return send(
@@ -170,6 +175,28 @@ export const useAdkSubmitAuth = () => {
   };
 };
 
+/** Returns a function to submit the user's answer for a pending `adk_request_input` HITL interrupt. */
+export const useAdkSubmitInput = () => {
+  const aui = useAui();
+  return (toolCallId: string, result: ReadonlyJSONValue) => {
+    const extras = aui.thread().getState().extras;
+    const { send } = asAdkRuntimeExtras(extras);
+    return send(
+      [
+        {
+          id: uuidv4(),
+          type: "tool",
+          tool_call_id: toolCallId,
+          name: "adk_request_input",
+          content: JSON.stringify({ result }),
+          status: "success",
+        },
+      ],
+      {},
+    );
+  };
+};
+
 // ── State prefix helpers ──
 
 const APP_PREFIX = "app:";

package/src/index.ts

@@ -60,6 +60,7 @@ export {
   useAdkMessageMetadata,
   useAdkConfirmTool,
   useAdkSubmitAuth,
+  useAdkSubmitInput,
   useAdkAppState,
   useAdkUserState,
   useAdkTempState,

package/src/useAdkMessages.ts

@@ -64,6 +64,22 @@ export const useAdkMessages = ({
     _setMessages(msgs);
   }, []);
 
+  // Replace the message list AND reset derived per-turn HITL state.
+  // Used by truncation paths (edit, reload, load) so that stale interrupt
+  // markers and per-message metadata from the removed messages don't leak
+  // into the next turn.
+  const replaceMessages = useCallback(
+    (msgs: AdkMessage[]) => {
+      setMessagesImmediate(msgs);
+      setLongRunningToolIds([]);
+      setToolConfirmations([]);
+      setAuthRequests([]);
+      setEscalated(false);
+      setMessageMetadata(new Map());
+    },
+    [setMessagesImmediate],
+  );
+
   const abortControllerRef = useRef<AbortController | null>(null);
 
   const { onError, onCustomEvent, onAgentTransfer } = useMemo(
@@ -180,6 +196,7 @@ export const useAdkMessages = ({
     sendMessage,
     cancel,
     setMessages: setMessagesImmediate,
+    replaceMessages,
   };
 };
 

package/src/useAdkRuntime.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect } from "vitest";
+import { getPendingCancellations, getPendingToolCalls } from "./useAdkRuntime";
+import type { AdkMessage } from "./types";
+
+const aiWithToolCalls = (
+  id: string,
+  toolCalls: Array<{ id: string; name: string }>,
+): AdkMessage => ({
+  id,
+  type: "ai",
+  content: [],
+  tool_calls: toolCalls.map((tc) => ({
+    id: tc.id,
+    name: tc.name,
+    args: {},
+    argsText: "{}",
+  })),
+});
+
+const toolResponse = (
+  id: string,
+  toolCallId: string,
+  name: string,
+): AdkMessage => ({
+  id,
+  type: "tool",
+  tool_call_id: toolCallId,
+  name,
+  content: JSON.stringify({ ok: true }),
+  status: "success",
+});
+
+describe("getPendingToolCalls", () => {
+  it("returns tool calls without matching tool responses", () => {
+    const messages: AdkMessage[] = [
+      aiWithToolCalls("ai-1", [
+        { id: "tc-1", name: "tool_a" },
+        { id: "tc-2", name: "tool_b" },
+      ]),
+    ];
+    expect(getPendingToolCalls(messages)).toEqual([
+      { id: "tc-1", name: "tool_a", args: {}, argsText: "{}" },
+      { id: "tc-2", name: "tool_b", args: {}, argsText: "{}" },
+    ]);
+  });
+
+  it("excludes tool calls that have a matching tool response", () => {
+    const messages: AdkMessage[] = [
+      aiWithToolCalls("ai-1", [
+        { id: "tc-1", name: "tool_a" },
+        { id: "tc-2", name: "tool_b" },
+      ]),
+      toolResponse("t-1", "tc-1", "tool_a"),
+    ];
+    expect(getPendingToolCalls(messages)).toEqual([
+      { id: "tc-2", name: "tool_b", args: {}, argsText: "{}" },
+    ]);
+  });
+
+  it("returns empty for threads with no ai messages", () => {
+    expect(getPendingToolCalls([])).toEqual([]);
+  });
+});
+
+describe("getPendingCancellations", () => {
+  it("emits a {cancelled:true} tool message for every pending tool call", () => {
+    const messages: AdkMessage[] = [
+      aiWithToolCalls("ai-1", [{ id: "tc-1", name: "tool_a" }]),
+    ];
+    const result = getPendingCancellations(messages, []);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      type: "tool",
+      name: "tool_a",
+      tool_call_id: "tc-1",
+      content: JSON.stringify({ cancelled: true }),
+      status: "error",
+    });
+  });
+
+  it("skips tool calls whose id is in longRunningToolIds", () => {
+    const messages: AdkMessage[] = [
+      aiWithToolCalls("ai-1", [
+        { id: "lrt-1", name: "adk_request_input" },
+        { id: "tc-2", name: "regular_tool" },
+      ]),
+    ];
+    const result = getPendingCancellations(messages, ["lrt-1"]);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      type: "tool",
+      name: "regular_tool",
+      tool_call_id: "tc-2",
+    });
+  });
+
+  it("skips all three HITL interrupt types", () => {
+    const messages: AdkMessage[] = [
+      aiWithToolCalls("ai-1", [
+        { id: "lrt-1", name: "adk_request_input" },
+        { id: "lrt-2", name: "adk_request_confirmation" },
+        { id: "lrt-3", name: "adk_request_credential" },
+      ]),
+    ];
+    const result = getPendingCancellations(messages, [
+      "lrt-1",
+      "lrt-2",
+      "lrt-3",
+    ]);
+    expect(result).toEqual([]);
+  });
+
+  it("returns empty when no tool calls are pending", () => {
+    const messages: AdkMessage[] = [
+      aiWithToolCalls("ai-1", [{ id: "tc-1", name: "tool_a" }]),
+      toolResponse("t-1", "tc-1", "tool_a"),
+    ];
+    expect(getPendingCancellations(messages, [])).toEqual([]);
+  });
+
+  it("cancels regular tool calls even when HITL interrupts are resolved", () => {
+    const messages: AdkMessage[] = [
+      aiWithToolCalls("ai-1", [
+        { id: "lrt-1", name: "adk_request_input" },
+        { id: "tc-2", name: "regular_tool" },
+      ]),
+      toolResponse("t-1", "lrt-1", "adk_request_input"),
+    ];
+    // lrt-1 lingering in longRunningToolIds is harmless because
+    // getPendingToolCalls already excluded it via the tool response.
+    const result = getPendingCancellations(messages, ["lrt-1"]);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      tool_call_id: "tc-2",
+      name: "regular_tool",
+    });
+  });
+});

package/src/useAdkRuntime.ts

@@ -53,12 +53,13 @@ const getMessageContent = (msg: AppendMessage) => {
       case "tool-call":
         throw new Error("Tool call appends are not supported.");
 
-      default:
+      default: {
         const _exhaustiveCheck: "reasoning" | "source" | "audio" | "data" =
           type;
         throw new Error(
           `Unsupported append message part type: ${_exhaustiveCheck}`,
         );
+      }
     }
   });
 
@@ -69,7 +70,8 @@ const getMessageContent = (msg: AppendMessage) => {
   return content;
 };
 
-const getPendingToolCalls = (messages: AdkMessage[]) => {
+/** @internal — exported for unit tests. */
+export const getPendingToolCalls = (messages: AdkMessage[]) => {
   const pending = new Map<string, { id: string; name: string }>();
   for (const msg of messages) {
     if (msg.type === "ai" && msg.tool_calls) {
@@ -84,6 +86,35 @@ const getPendingToolCalls = (messages: AdkMessage[]) => {
   return [...pending.values()];
 };
 
+/**
+ * @internal — 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: uuidv4(),
+          type: "tool",
+          name: t.name,
+          tool_call_id: t.id,
+          content: JSON.stringify({ cancelled: true }),
+          status: "error",
+        }) satisfies AdkMessage & { type: "tool" },
+    );
+};
+
 const truncateAdkMessages = (
   threadMessages: readonly ThreadMessage[],
   parentId: string | null,
@@ -140,6 +171,7 @@ const useAdkRuntimeImpl = ({
   getCheckpointId,
   eventHandlers,
 }: UseAdkRuntimeOptions) => {
+  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const aui = useAui();
   const {
     messages,
@@ -153,13 +185,16 @@ const useAdkRuntimeImpl = ({
     messageMetadata,
     sendMessage,
     cancel,
-    setMessages,
+    replaceMessages,
+    // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   } = useAdkMessages({
     stream,
     ...(eventHandlers && { eventHandlers }),
   });
 
+  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const [isRunning, setIsRunning] = useState(false);
+  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const [toolStatuses, setToolStatuses] = useState<
     Record<string, ToolExecutionStatus>
   >({});
@@ -180,21 +215,25 @@ const useAdkRuntimeImpl = ({
     }
   };
 
+  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const threadMessages = useExternalMessageConverter({
     callback: convertAdkMessage,
     messages,
     isRunning: effectiveIsRunning,
   });
 
+  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const threadMessagesRef = useRef(threadMessages);
   threadMessagesRef.current = threadMessages;
 
+  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const [runtimeRef] = useState(() => ({
     get current() {
       return runtime;
     },
   }));
 
+  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const toolInvocations = useToolInvocations({
     state: { messages: threadMessages, isRunning: effectiveIsRunning },
     getTools: () => runtimeRef.current.thread.getModelContext().tools,
@@ -218,6 +257,7 @@ const useAdkRuntimeImpl = ({
     setToolStatuses,
   });
 
+  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const runtime = useExternalStoreRuntime({
     isRunning: effectiveIsRunning,
     messages: threadMessages,
@@ -239,17 +279,7 @@ const useAdkRuntimeImpl = ({
 
       const cancellations =
         autoCancelPendingToolCalls !== false
-          ? getPendingToolCalls(messages).map(
-              (t) =>
-                ({
-                  id: uuidv4(),
-                  type: "tool",
-                  name: t.name,
-                  tool_call_id: t.id,
-                  content: JSON.stringify({ cancelled: true }),
-                  status: "error",
-                }) satisfies AdkMessage & { type: "tool" },
-            )
+          ? getPendingCancellations(messages, longRunningToolIds)
           : [];
 
       return handleSendMessage(
@@ -271,7 +301,7 @@ const useAdkRuntimeImpl = ({
             threadMessagesRef.current,
             msg.parentId,
           );
-          setMessages(truncated);
+          replaceMessages(truncated);
           const externalId = aui.threadListItem().getState().externalId;
           const checkpointId = externalId
             ? await getCheckpointId(externalId, truncated)
@@ -298,7 +328,7 @@ const useAdkRuntimeImpl = ({
             threadMessagesRef.current,
             parentId,
           );
-          setMessages(truncated);
+          replaceMessages(truncated);
           const externalId = aui.threadListItem().getState().externalId;
           const checkpointId = externalId
             ? await getCheckpointId(externalId, truncated)
@@ -342,11 +372,14 @@ const useAdkRuntimeImpl = ({
   });
 
   {
+    // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
     const loadRef = useRef(load);
+    // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
     useEffect(() => {
       loadRef.current = load;
     });
 
+    // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
     useEffect(() => {
       const loadFn = loadRef.current;
       if (!loadFn) return;
@@ -356,13 +389,13 @@ const useAdkRuntimeImpl = ({
 
       loadFn(externalId).then(
         ({ messages: msgs }) => {
-          setMessages(msgs);
+          replaceMessages(msgs);
         },
         (e) => {
           console.warn("Failed to load ADK session:", e);
         },
       );
-    }, [aui, setMessages]);
+    }, [aui, replaceMessages]);
   }
 
   return runtime;
@@ -390,6 +423,7 @@ export const useAdkRuntime = ({
 
   return useRemoteThreadListRuntime({
     runtimeHook: function RuntimeHook() {
+      // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
       return useAdkRuntimeImpl(options);
     },
     adapter,