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

package/src/useAdkMessages.test.ts

@@ -17,7 +17,6 @@ import {
   messageToEvent,
   messagesToEvents,
   useAdkMessages,
-  type UseAdkMessagesOptions,
 } from "./useAdkMessages";
 import { projectAdkToolApprovals } from "./adkToolApproval";
 import { createAdkStream } from "./AdkClient";
@@ -113,7 +112,7 @@ describe("ADK runtime callbacks", () => {
       };
       const eventHandlers = {
         [callbackName]: callback,
-      } as UseAdkMessagesOptions["eventHandlers"];
+      };
       const { result } = renderHook(() =>
         useAdkMessages({ stream, eventHandlers }),
       );
@@ -466,6 +465,10 @@ describe("optimistic confirmation replies", () => {
         projectAdkToolApprovals(result.current.messages).approvals.values(),
       ),
     ]).toEqual([{ id: "conf-a" }, { id: "conf-b" }]);
+    expect(result.current.toolConfirmations.map((c) => c.toolCallId)).toEqual([
+      "conf-a",
+      "conf-b",
+    ]);
   });
 
   it("keeps both gates pending when an ai message sits between the replies", async () => {
@@ -522,6 +525,102 @@ describe("optimistic confirmation replies", () => {
         projectAdkToolApprovals(result.current.messages).approvals.values(),
       ),
     ]).toEqual([{ id: "conf-a", approved: true }, { id: "conf-b" }]);
+    expect(result.current.toolConfirmations.map((c) => c.toolCallId)).toEqual([
+      "conf-b",
+    ]);
+  });
+});
+
+describe("pending requests across sends", () => {
+  it("keeps an unanswered request listed across sends until its reply is sent", async () => {
+    let run = 0;
+    const stream: AdkStreamCallback = async function* () {
+      run += 1;
+      if (run === 1) {
+        yield {
+          id: "requests",
+          author: "agent",
+          longRunningToolIds: ["conf-1", "cred-1"],
+          content: {
+            role: "model",
+            parts: [
+              {
+                functionCall: {
+                  id: "conf-1",
+                  name: "adk_request_confirmation",
+                  args: {
+                    originalFunctionCall: { id: "gated-1", name: "transfer" },
+                    toolConfirmation: { hint: "Transfer?" },
+                  },
+                },
+              },
+              {
+                functionCall: {
+                  id: "cred-1",
+                  name: "adk_request_credential",
+                  args: {
+                    function_call_id: "gated-2",
+                    auth_config: { credentialKey: "k" },
+                  },
+                },
+              },
+            ],
+          },
+        } satisfies AdkEvent;
+      } else if (run === 2) {
+        yield {
+          id: "answer",
+          author: "agent",
+          content: { role: "model", parts: [{ text: "still waiting" }] },
+        } satisfies AdkEvent;
+      }
+    };
+    const { result } = renderHook(() => useAdkMessages({ stream }));
+    const pending = () => ({
+      confirmations: result.current.toolConfirmations.map((c) => c.toolCallId),
+      authRequests: result.current.authRequests.map((r) => r.toolCallId),
+    });
+
+    await act(async () => {
+      await result.current.sendMessage(
+        [{ id: "user-1", type: "human", content: "start" }],
+        {},
+      );
+    });
+    expect(pending()).toEqual({
+      confirmations: ["conf-1"],
+      authRequests: ["cred-1"],
+    });
+
+    await act(async () => {
+      await result.current.sendMessage(
+        [{ id: "user-2", type: "human", content: "any news?" }],
+        {},
+      );
+    });
+    expect(pending()).toEqual({
+      confirmations: ["conf-1"],
+      authRequests: ["cred-1"],
+    });
+
+    await act(async () => {
+      await result.current.sendMessage(
+        [
+          {
+            id: "reply",
+            type: "tool",
+            tool_call_id: "cred-1",
+            name: "adk_request_credential",
+            content: JSON.stringify({
+              exchangedAuthCredential: { authType: "apiKey" },
+            }),
+            status: "success",
+          },
+        ],
+        {},
+      );
+    });
+    expect(pending()).toEqual({ confirmations: ["conf-1"], authRequests: [] });
   });
 });
 
@@ -680,7 +779,7 @@ describe("messageToEvent (contentToParts)", () => {
         name: "search",
       });
 
-      expect(event.content?.parts[0]?.functionResponse?.response).toEqual(
+      expect(event.content?.parts?.[0]?.functionResponse?.response).toEqual(
         response,
       );
     },

package/src/useAdkMessages.ts

@@ -170,6 +170,8 @@ export const useAdkMessages = ({
       }
       setMessagesImmediate(accumulator.getMessages());
       setLongRunningToolIds(accumulator.getLongRunningToolIds());
+      setToolConfirmations(accumulator.getToolConfirmations());
+      setAuthRequests(accumulator.getAuthRequests());
 
       // Google ADK replaces active runs, while React LangGraph queues sends.
       abortControllerRef.current?.abort();

package/src/useAdkRuntime.replacement.test.tsx

@@ -62,10 +62,12 @@ describe("useAdkRuntime replacement runs", () => {
     },
   ])("ignores superseded run $label", async ({ cancelFirst, failFirst }) => {
     const gates = [deferred(), deferred()];
+    const resumed = [deferred(), deferred()];
     let calls = 0;
     const stream = vi.fn(async function* (): AsyncGenerator<AdkEvent> {
       const call = calls++;
       await gates[call]!.promise;
+      resumed[call]!.resolve();
       if (call === 0 && failFirst) throw new Error("stale run failed");
       yield {
         id: `event-${call}`,
@@ -84,7 +86,11 @@ describe("useAdkRuntime replacement runs", () => {
         unstable_allowCancellation: true,
       });
       capture.runtime = runtime;
-      return <AssistantRuntimeProvider runtime={runtime} />;
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          {null}
+        </AssistantRuntimeProvider>
+      );
     };
 
     await act(async () => {
@@ -95,19 +101,17 @@ describe("useAdkRuntime replacement runs", () => {
       await capture.runtime!.threads.switchToThread("adk-1");
     });
 
-    let firstSend!: Promise<void>;
     act(() => {
-      firstSend = capture.runtime!.thread.append({
+      capture.runtime!.thread.append({
         role: "user",
         content: [{ type: "text", text: "first" }],
       });
     });
     await waitFor(() => expect(stream).toHaveBeenCalledTimes(1));
 
-    let secondSend!: Promise<void>;
     await act(async () => {
       if (cancelFirst) await capture.runtime!.thread.cancelRun();
-      secondSend = capture.runtime!.thread.append({
+      capture.runtime!.thread.append({
         role: "user",
         content: [{ type: "text", text: "second" }],
       });
@@ -116,7 +120,7 @@ describe("useAdkRuntime replacement runs", () => {
 
     await act(async () => {
       gates[0]!.resolve();
-      await firstSend;
+      await resumed[0]!.promise;
     });
 
     const messagesAfterFirstSettles = JSON.stringify(
@@ -128,7 +132,7 @@ describe("useAdkRuntime replacement runs", () => {
 
     await act(async () => {
       gates[1]!.resolve();
-      await secondSend;
+      await resumed[1]!.promise;
     });
     expect(
       JSON.stringify(capture.runtime!.thread.getState().messages),