@assistant-ui/react-google-adk 0.0.29 → 0.0.31

package/src/server/parseAdkRequest.test.ts

@@ -239,6 +239,41 @@ describe("parseAdkRequest", () => {
 });
 
 describe("toAdkContent", () => {
+  it.each([
+    ["permission denied", { error: "permission denied" }],
+    [
+      { message: "permission denied" },
+      { error: { message: "permission denied" } },
+    ],
+    [["denied"], { error: ["denied"] }],
+    [null, { error: null }],
+    [false, { error: false }],
+    [0, { error: 0 }],
+    ["", { error: "" }],
+    [
+      { error: "denied", output: "partial" },
+      { error: "denied", output: "partial" },
+    ],
+  ])(
+    "preserves explicit tool failure %j in the function response",
+    async (result, response) => {
+      const parsed = await parseAdkRequest(
+        makeRequest({
+          type: "tool-result",
+          toolCallId: "tc-1",
+          toolName: "search",
+          result,
+          isError: true,
+        }),
+      );
+      expect(toAdkContent(parsed).parts).toEqual([
+        {
+          functionResponse: { name: "search", id: "tc-1", response },
+        },
+      ]);
+    },
+  );
+
   it("converts a text message to user content with text part", () => {
     const content = toAdkContent({
       type: "message",
@@ -292,4 +327,32 @@ describe("toAdkContent", () => {
       ],
     });
   });
+
+  it.each([
+    [false, { result: false }],
+    [0, { result: 0 }],
+    [null, { result: null }],
+    ["done", { result: "done" }],
+    [[1, 2], { results: [1, 2] }],
+  ])(
+    "wraps scalar or array tool result %j in a function response object",
+    (result, response) => {
+      const content = toAdkContent({
+        type: "tool-result",
+        toolCallId: "tc-1",
+        toolName: "search",
+        result,
+        isError: false,
+        config: {},
+      });
+
+      expect(content.parts[0]).toEqual({
+        functionResponse: {
+          name: "search",
+          id: "tc-1",
+          response,
+        },
+      });
+    },
+  );
 });

package/src/server/parseAdkRequest.ts

@@ -1,5 +1,6 @@
 import { isRecord } from "@assistant-ui/core/internal";
 import type { AdkSendMessageConfig } from "../types";
+import { toAdkFunctionResponse } from "../toAdkFunctionResponse";
 
 type ParsedAdkRequest =
   | {
@@ -240,7 +241,7 @@ export const toAdkContent = (
           functionResponse: {
             name: parsed.toolName,
             id: parsed.toolCallId,
-            response: parsed.result,
+            response: toAdkFunctionResponse(parsed.result, parsed.isError),
           },
         },
       ],

package/src/structuredEvents.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { toAdkStructuredEvents } from "./structuredEvents";
+import type { AdkEvent } from "./types";
+
+const makeEvent = (overrides: Partial<AdkEvent> = {}): AdkEvent => ({
+  id: "evt-1",
+  ...overrides,
+});
+
+describe("toAdkStructuredEvents", () => {
+  it("converts a function call with args", () => {
+    expect(
+      toAdkStructuredEvents(
+        makeEvent({
+          author: "agent",
+          content: {
+            role: "model",
+            parts: [
+              {
+                functionCall: { name: "search", id: "tc-1", args: { q: "x" } },
+              },
+            ],
+          },
+        }),
+      ),
+    ).toEqual([
+      {
+        type: "tool_call",
+        call: { name: "search", id: "tc-1", args: { q: "x" } },
+      },
+    ]);
+  });
+
+  it("defaults a function call without args to empty args", () => {
+    expect(
+      toAdkStructuredEvents(
+        makeEvent({
+          author: "agent",
+          content: {
+            role: "model",
+            parts: [{ functionCall: { name: "search", id: "tc-1" } }],
+          },
+        }),
+      ),
+    ).toEqual([
+      { type: "tool_call", call: { name: "search", id: "tc-1", args: {} } },
+    ]);
+  });
+
+  it("keeps the other parts of an event carrying a call without args", () => {
+    expect(
+      toAdkStructuredEvents(
+        makeEvent({
+          author: "agent",
+          content: {
+            role: "model",
+            parts: [
+              { functionCall: { name: "search" } },
+              { text: "still here" },
+            ],
+          },
+        }),
+      ),
+    ).toEqual([
+      { type: "tool_call", call: { name: "search", args: {} } },
+      { type: "content", content: "still here" },
+    ]);
+  });
+});

package/src/structuredEvents.ts

@@ -28,7 +28,10 @@ export function toAdkStructuredEvents(event: AdkEvent): AdkStructuredEvent[] {
       if (part.functionCall) {
         const call: AdkStructuredEvent & { type: "tool_call" } = {
           type: "tool_call",
-          call: { name: part.functionCall.name, args: part.functionCall.args },
+          call: {
+            name: part.functionCall.name,
+            args: part.functionCall.args ?? {},
+          },
         };
         if (part.functionCall.id != null) call.call.id = part.functionCall.id;
         result.push(call);

package/src/toAdkFunctionResponse.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import {
+  isAdkFunctionError,
+  toAdkFunctionResponse,
+} from "./toAdkFunctionResponse";
+
+describe("ADK function response errors", () => {
+  it("retains an existing error envelope without mutating or nesting it", () => {
+    const response = Object.freeze({ error: "denied", output: "partial" });
+    expect(toAdkFunctionResponse(response, true)).toBe(response);
+  });
+
+  it("preserves a failure with no details through JSON serialization", () => {
+    const response = JSON.parse(
+      JSON.stringify(toAdkFunctionResponse(undefined, true)),
+    );
+    expect(response).toEqual({ error: null });
+    expect(isAdkFunctionError(response)).toBe(true);
+  });
+
+  it("does not classify an undefined error field as an on-wire error", () => {
+    expect(isAdkFunctionError({ error: undefined })).toBe(false);
+    expect(
+      isAdkFunctionError(JSON.parse(JSON.stringify({ error: undefined }))),
+    ).toBe(false);
+  });
+
+  it("does not classify inherited error fields as an on-wire error", () => {
+    const response = Object.create({ error: "inherited" });
+    response.output = "done";
+    expect(isAdkFunctionError(response)).toBe(false);
+  });
+
+  it.each([
+    ["done", { result: "done" }],
+    [[1, 2], { results: [1, 2] }],
+    [
+      { output: { error: "application data" } },
+      { output: { error: "application data" } },
+    ],
+    [null, { result: null }],
+  ])("leaves successful result %j unchanged", (result, expected) => {
+    expect(toAdkFunctionResponse(result)).toEqual(expected);
+    expect(isAdkFunctionError(toAdkFunctionResponse(result))).toBe(false);
+  });
+});

package/src/toAdkFunctionResponse.ts

@@ -0,0 +1,18 @@
+import { isRecord } from "@assistant-ui/core/internal";
+
+export const isAdkFunctionError = (response: unknown): boolean =>
+  isRecord(response) &&
+  Object.hasOwn(response, "error") &&
+  response.error !== undefined;
+
+export const toAdkFunctionResponse = (
+  result: unknown,
+  isError = false,
+): Record<string, unknown> => {
+  if (isError && !isAdkFunctionError(result)) return { error: result ?? null };
+  return Array.isArray(result)
+    ? { results: result }
+    : isRecord(result)
+      ? result
+      : { result };
+};

package/src/types.ts

@@ -9,7 +9,7 @@ export type AdkEventPart = {
   functionCall?: {
     name: string;
     id?: string;
-    args: Record<string, unknown>;
+    args?: Record<string, unknown>;
   };
   functionResponse?: {
     name: string;

package/src/useAdkMessages.test.ts

@@ -17,11 +17,11 @@ import {
   messageToEvent,
   messagesToEvents,
   useAdkMessages,
-  type UseAdkMessagesOptions,
 } from "./useAdkMessages";
 import { projectAdkToolApprovals } from "./adkToolApproval";
 import { createAdkStream } from "./AdkClient";
 import { AdkEventAccumulator } from "./AdkEventAccumulator";
+import { getPendingCancellations } from "./convertToAdkMessages";
 import type { AdkEvent, AdkMessage, AdkStreamCallback } from "./types";
 
 afterEach(() => {
@@ -29,6 +29,53 @@ afterEach(() => {
   vi.unstubAllGlobals();
 });
 
+describe("optimistic tool outcomes", () => {
+  it.each([false, true])(
+    "preserves failures alongside successful results (batch: %s)",
+    (batch) => {
+      const failed: AdkMessage = {
+        id: "failed",
+        type: "tool",
+        name: "search",
+        tool_call_id: "tc-error",
+        content: "denied",
+        status: "error",
+      };
+      const succeeded: AdkMessage = {
+        id: "succeeded",
+        type: "tool",
+        name: "search",
+        tool_call_id: "tc-ok",
+        content: "found",
+        status: "success",
+      };
+      const events = batch
+        ? messagesToEvents([
+            failed,
+            succeeded,
+            { id: "human", type: "human", content: "continue" },
+          ])
+        : [messageToEvent(failed), messageToEvent(succeeded)];
+      const acc = new AdkEventAccumulator();
+      for (const event of events) acc.processEvent(event);
+      expect(
+        acc.getMessages().filter((message) => message.type === "tool"),
+      ).toMatchObject([
+        {
+          tool_call_id: "tc-error",
+          status: "error",
+          content: JSON.stringify({ error: "denied" }),
+        },
+        {
+          tool_call_id: "tc-ok",
+          status: "success",
+          content: JSON.stringify({ result: "found" }),
+        },
+      ]);
+    },
+  );
+});
+
 describe("ADK runtime callbacks", () => {
   it.each(["onAgentTransfer", "onCustomEvent", "onError"] as const)(
     "continues streaming when %s throws",
@@ -65,7 +112,7 @@ describe("ADK runtime callbacks", () => {
       };
       const eventHandlers = {
         [callbackName]: callback,
-      } as UseAdkMessagesOptions["eventHandlers"];
+      };
       const { result } = renderHook(() =>
         useAdkMessages({ stream, eventHandlers }),
       );
@@ -315,6 +362,86 @@ describe("optimistic confirmation replies", () => {
     return result;
   };
 
+  it("preserves an unanswered gate across a reply run", async () => {
+    let run = 0;
+    const stream: AdkStreamCallback = async function* () {
+      run += 1;
+      if (run === 1) {
+        yield {
+          id: "gates",
+          author: "agent",
+          longRunningToolIds: ["conf-a", "conf-b"],
+          content: {
+            role: "model",
+            parts: [
+              {
+                functionCall: {
+                  id: "conf-a",
+                  name: "adk_request_confirmation",
+                  args: {},
+                },
+              },
+              {
+                functionCall: {
+                  id: "conf-b",
+                  name: "adk_request_confirmation",
+                  args: {},
+                },
+              },
+            ],
+          },
+        } satisfies AdkEvent;
+      } else {
+        yield {
+          id: "rerun",
+          author: "agent",
+          content: {
+            role: "user",
+            parts: [
+              {
+                functionResponse: {
+                  id: "orig-conf-a",
+                  name: "delete_file",
+                  response: { result: "deleted" },
+                },
+              },
+            ],
+          },
+        } satisfies AdkEvent;
+      }
+    };
+    const { result } = renderHook(() => useAdkMessages({ stream }));
+
+    await act(async () => {
+      await result.current.sendMessage(
+        [{ id: "user-1", type: "human", content: "start" }],
+        {},
+      );
+    });
+    expect(result.current.longRunningToolIds).toEqual(["conf-a", "conf-b"]);
+
+    await act(async () => {
+      await result.current.sendMessage(
+        [
+          confirmationReply(
+            "reply-a",
+            "conf-a",
+            JSON.stringify({ confirmed: true }),
+          ),
+        ],
+        {},
+      );
+    });
+
+    expect(result.current.longRunningToolIds).toEqual(["conf-b"]);
+    expect(
+      getPendingCancellations(
+        result.current.messages,
+        result.current.longRunningToolIds,
+      ),
+    ).toEqual([]);
+  });
+
   it("keeps both gates pending when one send carries an unreadable reply", async () => {
     const result = await renderWithGates();
 
@@ -338,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 () => {
@@ -394,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: [] });
   });
 });
 
@@ -538,6 +765,26 @@ describe("optimistic multi-message sends", () => {
 });
 
 describe("messageToEvent (contentToParts)", () => {
+  it.each([
+    ["scalar", "false", { result: false }],
+    ["array", "[1,2]", { results: [1, 2] }],
+  ])(
+    "normalizes an optimistic %s tool response",
+    (_label, content, response) => {
+      const event = messageToEvent({
+        id: "tool-1",
+        type: "tool",
+        content,
+        tool_call_id: "call-1",
+        name: "search",
+      });
+
+      expect(event.content?.parts?.[0]?.functionResponse?.response).toEqual(
+        response,
+      );
+    },
+  );
+
   it("serializes a file content part as inlineData", () => {
     const msg: AdkMessage = {
       id: "m1",

package/src/useAdkMessages.ts

@@ -15,6 +15,7 @@ import {
 } from "@assistant-ui/core/internal";
 import { AdkEventAccumulator } from "./AdkEventAccumulator";
 import { contentToParts } from "./contentToParts";
+import { toAdkFunctionResponse } from "./toAdkFunctionResponse";
 import type {
   AdkEvent,
   AdkMessage,
@@ -58,7 +59,7 @@ export const useAdkMessages = ({
     name?: string | undefined;
     branch?: string | undefined;
   }>({});
-  const [longRunningToolIds, setLongRunningToolIds] = useState<string[]>([]);
+  const [longRunningToolIds, _setLongRunningToolIds] = useState<string[]>([]);
   const [artifactDelta, setArtifactDelta] = useState<Record<string, number>>(
     {},
   );
@@ -71,9 +72,9 @@ 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.
+  // setMessagesImmediate and setLongRunningToolIds are the only writers of their state and publish these refs with it, so neither ref trails a commit.
   const messagesRef = useRef(messages);
+  const longRunningToolIdsRef = useRef(longRunningToolIds);
   const stateDeltaRef = useRef(stateDelta);
   useInsertionEffect(() => {
     stateDeltaRef.current = stateDelta;
@@ -91,6 +92,10 @@ export const useAdkMessages = ({
     messagesRef.current = msgs;
     _setMessages(msgs);
   }, []);
+  const setLongRunningToolIds = useCallback((ids: string[]) => {
+    longRunningToolIdsRef.current = ids;
+    _setLongRunningToolIds(ids);
+  }, []);
 
   /**
    * Swap the thread over to a loaded snapshot in one commit. Unlike
@@ -110,7 +115,7 @@ export const useAdkMessages = ({
       setArtifactDelta(snapshot.artifactDelta ?? {});
       setAgentInfo(snapshot.agentInfo ?? {});
     },
-    [setMessagesImmediate],
+    [setLongRunningToolIds, setMessagesImmediate],
   );
 
   // Replace the message list AND reset derived per-turn HITL state.
@@ -126,7 +131,7 @@ export const useAdkMessages = ({
       setEscalated(false);
       setMessageMetadata(new Map());
     },
-    [setMessagesImmediate],
+    [setLongRunningToolIds, setMessagesImmediate],
   );
 
   const abortControllerRef = useRef<AbortController | null>(null);
@@ -148,13 +153,25 @@ export const useAdkMessages = ({
       // with the originals would leave every later staged id beside the merged
       // copy of itself.
       const resentIds = new Set(newMessagesWithId.map((m) => m.id));
+      // The optimistic event for a tool-only batch carries no author, so the accumulator cannot settle the calls this send answers.
+      const answeredToolCallIds = new Set(
+        newMessagesWithId.flatMap((m) =>
+          m.type === "tool" ? [m.tool_call_id] : [],
+        ),
+      );
       const accumulator = new AdkEventAccumulator(
         messagesRef.current.filter((m) => !resentIds.has(m.id)),
+        longRunningToolIdsRef.current.filter(
+          (id) => !answeredToolCallIds.has(id),
+        ),
       );
       for (const event of messagesToEvents(newMessagesWithId)) {
         accumulator.processEvent(event);
       }
       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();
@@ -255,6 +272,7 @@ export const useAdkMessages = ({
     [
       aui,
       setMessagesImmediate,
+      setLongRunningToolIds,
       stream,
       onError,
       onCustomEvent,
@@ -363,7 +381,7 @@ export const messageToEvent = (msg: AdkMessage): AdkEvent => {
             functionResponse: {
               name: msg.name,
               id: msg.tool_call_id,
-              response,
+              response: toAdkFunctionResponse(response, msg.status === "error"),
             },
           },
         ],