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

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/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/useAdkMessages.test.ts

@@ -22,6 +22,7 @@ import {
 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 +30,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",
@@ -315,6 +363,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();
 
@@ -538,6 +666,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,23 @@ 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());
 
       // Google ADK replaces active runs, while React LangGraph queues sends.
       abortControllerRef.current?.abort();
@@ -255,6 +270,7 @@ export const useAdkMessages = ({
     [
       aui,
       setMessagesImmediate,
+      setLongRunningToolIds,
       stream,
       onError,
       onCustomEvent,
@@ -363,7 +379,7 @@ export const messageToEvent = (msg: AdkMessage): AdkEvent => {
             functionResponse: {
               name: msg.name,
               id: msg.tool_call_id,
-              response,
+              response: toAdkFunctionResponse(response, msg.status === "error"),
             },
           },
         ],

package/src/useAdkRuntime.ts

@@ -57,6 +57,7 @@ import {
   toAdkToolConfirmationReply,
 } from "./adkToolApproval";
 import { adkExtras } from "./adkExtras";
+import { ADK_SDK } from "./sdkIdentity";
 
 export type UseAdkRuntimeOptions = ExternalStoreSharedOptions & {
   stream: AdkStreamCallback;
@@ -504,6 +505,7 @@ export const useAdkRuntime = ({
 }: UseAdkRuntimeOptions) => {
   const aui = useAui();
   const cloudAdapter = useCloudThreadListAdapter({
+    sdk: ADK_SDK,
     cloud,
     create: createCloudThreadListAdapterCreateFallback(
       create,

package/src/useAdkRuntimeApproval.test.tsx

@@ -97,7 +97,6 @@ const approvalPart = () =>
 afterEach(() => {
   mocks.adapters.length = 0;
   mocks.messages = [];
-  vi.clearAllMocks();
 });
 
 describe("useAdkRuntime tool approvals", () => {