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

package/src/AdkEventAccumulator.test.ts

@@ -246,6 +246,78 @@ describe("AdkEventAccumulator - function calls", () => {
     );
     expect(acc.getToolConfirmations()).toHaveLength(0);
   });
+
+  const requestEvent = (name: string) =>
+    makeEvent({
+      author: "agent",
+      content: {
+        role: "model",
+        parts: [{ functionCall: { name, id: "rc-1" } }, { text: "still here" }],
+      },
+    });
+
+  it("keeps an args-less confirmation call answerable", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(requestEvent("adk_request_confirmation"));
+
+    expect(acc.getToolConfirmations()).toEqual([
+      {
+        toolCallId: "rc-1",
+        toolName: "",
+        args: {},
+        hint: "",
+        confirmed: false,
+      },
+    ]);
+    expect((msgs[0] as AdkMessage & { type: "ai" }).tool_calls).toEqual([
+      {
+        id: "rc-1",
+        name: "adk_request_confirmation",
+        args: {},
+        argsText: "{}",
+      },
+    ]);
+    expect(msgs[0]).toMatchObject({
+      content: [{ type: "text", text: "still here" }],
+    });
+  });
+
+  it("keeps an args-less credential call answerable", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(requestEvent("adk_request_credential"));
+
+    expect(acc.getAuthRequests()).toEqual([
+      { toolCallId: "rc-1", authConfig: undefined },
+    ]);
+    expect((msgs[0] as AdkMessage & { type: "ai" }).tool_calls).toEqual([
+      {
+        id: "rc-1",
+        name: "adk_request_credential",
+        args: {},
+        argsText: "{}",
+      },
+    ]);
+    expect(msgs[0]).toMatchObject({
+      content: [{ type: "text", text: "still here" }],
+    });
+  });
+
+  it("defaults an ordinary call without args to empty args", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        content: {
+          role: "model",
+          parts: [{ functionCall: { name: "search", id: "tc-1" } }],
+        },
+      }),
+    );
+
+    expect((msgs[0] as AdkMessage & { type: "ai" }).tool_calls).toEqual([
+      { id: "tc-1", name: "search", args: {}, argsText: "{}" },
+    ]);
+  });
 });
 
 describe("AdkEventAccumulator - function responses", () => {
@@ -1102,21 +1174,176 @@ describe("AdkEventAccumulator - special function calls", () => {
     });
   });
 
-  it("records auth request from adk_request_credential", () => {
+  it.each([
+    [
+      "snake_case",
+      { function_call_id: "tc-original", auth_config: { type: "oauth2" } },
+    ],
+    [
+      "camelCase",
+      { functionCallId: "tc-original", authConfig: { type: "oauth2" } },
+    ],
+  ])(
+    "records an auth request under its adk_request_credential call id (%s args)",
+    (_, args) => {
+      const acc = new AdkEventAccumulator();
+      acc.processEvent(
+        makeEvent({
+          author: "agent",
+          content: {
+            role: "model",
+            parts: [
+              {
+                functionCall: {
+                  name: "adk_request_credential",
+                  id: "cred-1",
+                  args,
+                },
+              },
+            ],
+          },
+        }),
+      );
+      expect(acc.getAuthRequests()).toEqual([
+        { toolCallId: "cred-1", authConfig: { type: "oauth2" } },
+      ]);
+    },
+  );
+});
+
+describe.each([
+  {
+    name: "adk_request_confirmation",
+    args: {
+      originalFunctionCall: { id: "gated", name: "transfer", args: {} },
+      toolConfirmation: { hint: "Transfer?" },
+    },
+    actions: {
+      requestedToolConfirmations: { gated: { hint: "Transfer?" } },
+    },
+    reply: { confirmed: true },
+    pending: (acc: AdkEventAccumulator) =>
+      acc.getToolConfirmations().map((c) => c.toolCallId),
+  },
+  {
+    name: "adk_request_credential",
+    args: { function_call_id: "gated", auth_config: { credentialKey: "k" } },
+    actions: {
+      requestedAuthConfigs: {
+        gated: { credentialKey: "k" },
+        "gated-2": { credentialKey: "k" },
+      },
+    },
+    reply: { exchangedAuthCredential: { authType: "apiKey", apiKey: "key" } },
+    pending: (acc: AdkEventAccumulator) =>
+      acc.getAuthRequests().map((r) => r.toolCallId),
+  },
+])("AdkEventAccumulator - pending $name requests", (request) => {
+  const requestEvents: AdkEvent[] = [
+    makeEvent({
+      id: "call",
+      author: "agent",
+      content: {
+        role: "model",
+        parts: [
+          { functionCall: { name: "transfer", id: "gated", args: {} } },
+          { functionCall: { name: "transfer", id: "gated-2", args: {} } },
+        ],
+      },
+    }),
+    makeEvent({
+      id: "request",
+      author: "agent",
+      longRunningToolIds: ["req"],
+      actions: request.actions,
+      content: {
+        role: "user",
+        parts: [
+          {
+            functionCall: { name: request.name, id: "req", args: request.args },
+          },
+        ],
+      },
+    }),
+    makeEvent({
+      id: "interim",
+      author: "agent",
+      actions: request.actions,
+      content: {
+        role: "user",
+        parts: [
+          {
+            functionResponse: {
+              id: "gated",
+              name: "transfer",
+              response: { status: "pending" },
+            },
+          },
+        ],
+      },
+    }),
+  ];
+  const replyPart = {
+    functionResponse: {
+      id: "req",
+      name: request.name,
+      response: request.reply,
+    },
+  };
+
+  it("lists the request once, under its call, until the user replies to that call", () => {
+    const acc = new AdkEventAccumulator();
+    for (const event of requestEvents) acc.processEvent(event);
+    expect(request.pending(acc)).toEqual(["req"]);
+
+    acc.processEvent(
+      makeEvent({
+        id: "reply",
+        author: "user",
+        content: { role: "user", parts: [replyPart] },
+      }),
+    );
+    expect(request.pending(acc)).toEqual([]);
+  });
+
+  it("carries the request into an accumulator seeded with the thread, which an optimistic reply settles", () => {
+    const replayed = new AdkEventAccumulator();
+    let messages: AdkMessage[] = [];
+    for (const event of requestEvents) messages = replayed.processEvent(event);
+
+    const acc = new AdkEventAccumulator(messages);
+    expect(request.pending(acc)).toEqual(["req"]);
+
+    acc.processEvent(
+      makeEvent({
+        id: "optimistic",
+        content: { role: "user", parts: [replyPart] },
+      }),
+    );
+    expect(request.pending(acc)).toEqual([]);
+  });
+});
+
+describe("AdkEventAccumulator - confirmation replies", () => {
+  it.each([
+    [["req"], "an unreadable reply", { response: "not json" }],
+    [[], "a denial", { confirmed: false }],
+  ])("lists %j after %s", (pending, _, response) => {
     const acc = new AdkEventAccumulator();
     acc.processEvent(
       makeEvent({
+        id: "request",
         author: "agent",
+        longRunningToolIds: ["req"],
         content: {
           role: "model",
           parts: [
             {
               functionCall: {
-                name: "adk_request_credential",
-                id: "cred-1",
+                name: "adk_request_confirmation",
+                id: "req",
                 args: {
-                  function_call_id: "tc-original",
-                  auth_config: { type: "oauth2" },
+                  originalFunctionCall: { id: "gated", name: "transfer" },
                 },
               },
             },
@@ -1124,12 +1351,27 @@ describe("AdkEventAccumulator - special function calls", () => {
         },
       }),
     );
-    const reqs = acc.getAuthRequests();
-    expect(reqs).toHaveLength(1);
-    expect(reqs[0]).toMatchObject({
-      toolCallId: "tc-original",
-      authConfig: { type: "oauth2" },
-    });
+    acc.processEvent(
+      makeEvent({
+        id: "reply",
+        author: "user",
+        content: {
+          role: "user",
+          parts: [
+            {
+              functionResponse: {
+                id: "req",
+                name: "adk_request_confirmation",
+                response,
+              },
+            },
+          ],
+        },
+      }),
+    );
+    expect(acc.getToolConfirmations().map((c) => c.toolCallId)).toEqual(
+      pending,
+    );
   });
 });
 
@@ -1691,6 +1933,65 @@ describe("AdkEventAccumulator - user message handling", () => {
     });
   });
 
+  it.each([
+    {
+      name: "inlineData without mimeType",
+      part: { inlineData: { data: "abc123" } },
+    },
+    {
+      name: "inlineData without data",
+      part: { inlineData: { mimeType: "image/png" } },
+    },
+    {
+      name: "fileData without fileUri",
+      part: { fileData: { mimeType: "image/png" } },
+    },
+  ])("skips malformed $name while preserving valid content", ({ part }) => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        content: {
+          role: "model",
+          parts: [part as any, { text: "still here" }],
+        },
+      }),
+    );
+
+    expect(msgs).toMatchObject([
+      { type: "ai", content: [{ type: "text", text: "still here" }] },
+    ]);
+  });
+
+  it("skips malformed user media without creating an empty human message", () => {
+    const acc = new AdkEventAccumulator();
+    const malformedMedia = [
+      { inlineData: { data: "abc123" } },
+      { fileData: { mimeType: "application/pdf" } },
+    ] as any[];
+
+    expect(
+      acc.processEvent(
+        makeEvent({
+          author: "user",
+          content: { role: "user", parts: malformedMedia },
+        }),
+      ),
+    ).toEqual([]);
+
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: {
+          role: "user",
+          parts: [...malformedMedia, { text: "still here" }],
+        },
+      }),
+    );
+
+    expect(msgs).toMatchObject([{ type: "human", content: "still here" }]);
+  });
+
   it("tool result events (no author, role:'user') still create tool messages", () => {
     // Regression: the user-author check must not hijack tool events.
     // messageToEvent for `type:'tool'` emits events without `author`,

package/src/AdkEventAccumulator.ts

@@ -12,6 +12,8 @@ import type {
   AdkMessageMetadata,
 } from "./types";
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
+import { normalizeAdkPart } from "./normalizeAdkPart";
+import { projectAdkToolApprovals } from "./adkToolApproval";
 import { isAdkFunctionError } from "./toAdkFunctionResponse";
 
 type InProgressMessage = AdkMessage & { type: "ai" };
@@ -99,56 +101,27 @@ const finishReasonToStatus = (
   return { type: "complete", reason: "stop" };
 };
 
-const inlineDataToPart = (
-  mimeType: string,
-  data: string,
-): AdkMessageContentPart =>
-  mimeType.startsWith("image/")
-    ? { type: "image", mimeType, data }
-    : { type: "file", mimeType, data };
-
-const fileDataToPart = (
-  fileUri: string,
-  mimeType: string | undefined,
-): AdkMessageContentPart =>
-  mimeType == null || mimeType.startsWith("image/")
+const mediaToContentPart = ({
+  inlineData,
+  fileData,
+}: Record<string, unknown>): AdkMessageContentPart | undefined => {
+  if (isRecord(inlineData)) {
+    const { mimeType, data } = inlineData;
+    if (typeof mimeType !== "string" || typeof data !== "string") return;
+    return mimeType.startsWith("image/")
+      ? { type: "image", mimeType, data }
+      : { type: "file", mimeType, data };
+  }
+  if (!isRecord(fileData)) return;
+  const { fileUri, mimeType } = fileData;
+  if (typeof fileUri !== "string") return;
+  return typeof mimeType !== "string" || mimeType.startsWith("image/")
     ? { type: "image_url", url: fileUri }
     : { type: "file_url", url: fileUri, mimeType };
+};
 
 // ── Snake_case normalization ──
 
-const normalizeEventPart = (part: AdkEventPart): AdkEventPart => {
-  const p = part as Record<string, unknown>;
-  const result: Record<string, unknown> = { ...p };
-  if ("function_call" in p && !("functionCall" in p))
-    result.functionCall = p.function_call;
-  if ("function_response" in p && !("functionResponse" in p))
-    result.functionResponse = p.function_response;
-  if ("inline_data" in p && !("inlineData" in p))
-    result.inlineData = p.inline_data;
-  if ("file_data" in p && !("fileData" in p)) result.fileData = p.file_data;
-  if (isRecord(result.inlineData)) {
-    const data = result.inlineData;
-    if ("mime_type" in data && !("mimeType" in data))
-      result.inlineData = { ...data, mimeType: data.mime_type };
-  }
-  if (isRecord(result.fileData)) {
-    const data = result.fileData;
-    result.fileData = {
-      ...data,
-      ...("mime_type" in data &&
-        !("mimeType" in data) && { mimeType: data.mime_type }),
-      ...("file_uri" in data &&
-        !("fileUri" in data) && { fileUri: data.file_uri }),
-    };
-  }
-  if ("executable_code" in p && !("executableCode" in p))
-    result.executableCode = p.executable_code;
-  if ("code_execution_result" in p && !("codeExecutionResult" in p))
-    result.codeExecutionResult = p.code_execution_result;
-  return result as AdkEventPart;
-};
-
 const normalizeEvent = (event: AdkEvent): AdkEvent => {
   const e = event as Record<string, unknown>;
   const result: Record<string, unknown> = { ...e };
@@ -195,8 +168,8 @@ const normalizeEvent = (event: AdkEvent): AdkEvent => {
 
   if (result.content && (result.content as Record<string, unknown>).parts) {
     const content = result.content as Record<string, unknown>;
-    const parts = content.parts as AdkEventPart[];
-    result.content = { ...content, parts: parts.map(normalizeEventPart) };
+    const parts = content.parts as Record<string, unknown>[];
+    result.content = { ...content, parts: parts.map(normalizeAdkPart) };
   }
 
   return result as AdkEvent;
@@ -220,8 +193,6 @@ export class AdkEventAccumulator {
   } = {};
   private lastTransferToAgent: string | undefined;
   private pendingLongRunningToolIds = new Set<string>();
-  private toolConfirmations: AdkToolConfirmation[] = [];
-  private authRequests: AdkAuthRequest[] = [];
   private escalated = false;
   private messageMetadataMap = new Map<string, AdkMessageMetadata>();
   // How many assistant messages each event has opened, so a replay of that
@@ -273,32 +244,6 @@ export class AdkEventAccumulator {
       }
     }
 
-    // Track tool confirmations from actions
-    if (event.actions?.requestedToolConfirmations) {
-      for (const [tcId, conf] of Object.entries(
-        event.actions.requestedToolConfirmations,
-      )) {
-        const c = conf as Record<string, unknown>;
-        this.toolConfirmations.push({
-          toolCallId: tcId,
-          toolName: "",
-          args: {},
-          hint: (c.hint as string) ?? "",
-          confirmed: false,
-          payload: c.payload,
-        });
-      }
-    }
-
-    // Track auth requests from actions
-    if (event.actions?.requestedAuthConfigs) {
-      for (const [tcId, authConf] of Object.entries(
-        event.actions.requestedAuthConfigs,
-      )) {
-        this.authRequests.push({ toolCallId: tcId, authConfig: authConf });
-      }
-    }
-
     // Track agent info
     if (event.author && event.author !== "user") {
       this.lastAgentInfo = {
@@ -361,14 +306,9 @@ export class AdkEventAccumulator {
       for (const [index, part] of parts.entries()) {
         if (part.text != null && !part.thought) {
           humanParts.push({ type: "text", text: part.text });
-        } else if (part.inlineData) {
-          humanParts.push(
-            inlineDataToPart(part.inlineData.mimeType, part.inlineData.data),
-          );
-        } else if (part.fileData) {
-          humanParts.push(
-            fileDataToPart(part.fileData.fileUri, part.fileData.mimeType),
-          );
+        } else if (part.inlineData || part.fileData) {
+          const mediaPart = mediaToContentPart(part);
+          if (mediaPart) humanParts.push(mediaPart);
         } else if (part.functionResponse?.id) {
           // ADK records tool confirmation and other client-supplied tool
           // results as user-authored function responses, and its request
@@ -462,45 +402,6 @@ export class AdkEventAccumulator {
     event: AdkEvent,
     partIndex: number,
   ): void {
-    // Detect special ADK function calls
-    if (part.functionCall && !event.partial) {
-      const name = part.functionCall.name;
-
-      // Tool confirmation request
-      if (name === ADK_REQUEST_CONFIRMATION) {
-        const callArgs = part.functionCall.args;
-        // ADK JS: args keys are "originalFunctionCall" and "toolConfirmation"
-        // ADK Python: args keys are "original_function_call" and "tool_confirmation"
-        const original =
-          (callArgs.originalFunctionCall as Record<string, unknown>) ??
-          (callArgs.original_function_call as Record<string, unknown>);
-        const conf =
-          (callArgs.toolConfirmation as Record<string, unknown>) ??
-          (callArgs.tool_confirmation as Record<string, unknown>);
-        this.toolConfirmations.push({
-          toolCallId: part.functionCall.id ?? "",
-          toolName: (original?.name as string) ?? "",
-          args: (original?.args as Record<string, unknown>) ?? {},
-          hint: (conf?.hint as string) ?? "",
-          confirmed: false,
-          payload: conf?.payload,
-        });
-      }
-
-      // Auth credential request
-      if (name === ADK_REQUEST_CREDENTIAL) {
-        const credArgs = part.functionCall.args;
-        // ADK JS: args keys are "function_call_id" and "auth_config"
-        const originalToolCallId =
-          (credArgs.function_call_id as string) ?? part.functionCall.id ?? "";
-        const authConfig = credArgs.auth_config ?? credArgs;
-        this.authRequests.push({
-          toolCallId: originalToolCallId,
-          authConfig,
-        });
-      }
-    }
-
     // Text with thought=true → reasoning (accumulated)
     if (part.text != null && part.thought) {
       const msg = this.getOrCreateAiMessage(event);
@@ -540,8 +441,8 @@ export class AdkEventAccumulator {
       const toolCall: AdkToolCall = {
         id: part.functionCall.id ?? generateId(),
         name: part.functionCall.name,
-        args: part.functionCall.args as ReadonlyJSONObject,
-        argsText: JSON.stringify(part.functionCall.args),
+        args: (part.functionCall.args ?? {}) as ReadonlyJSONObject,
+        argsText: JSON.stringify(part.functionCall.args ?? {}),
       };
       const existing = [...(msg.tool_calls ?? [])];
       const idx = existing.findIndex((tc) => tc.id === toolCall.id);
@@ -598,22 +499,10 @@ export class AdkEventAccumulator {
       return;
     }
 
-    if (part.inlineData) {
-      const msg = this.getOrCreateAiMessage(event);
-      this.appendContent(
-        msg,
-        inlineDataToPart(part.inlineData.mimeType, part.inlineData.data),
-      );
-      return;
-    }
-
-    if (part.fileData) {
-      const msg = this.getOrCreateAiMessage(event);
-      this.appendContent(
-        msg,
-        fileDataToPart(part.fileData.fileUri, part.fileData.mimeType),
-      );
-    }
+    const mediaPart = mediaToContentPart(part);
+    if (!mediaPart) return;
+    const msg = this.getOrCreateAiMessage(event);
+    this.appendContent(msg, mediaPart);
   }
 
   private trackMessageMetadata(event: AdkEvent): void {
@@ -708,6 +597,18 @@ export class AdkEventAccumulator {
     this.currentMessageId = null;
   }
 
+  // ADK resumes a confirmation or credential request only on a reply that quotes its synthetic call's id, so those calls are the whole record; requestedToolConfirmations and requestedAuthConfigs key the gated call instead, which no reply answers.
+  private getRequestCalls(name: string): AdkToolCall[] {
+    const calls = new Map<string, AdkToolCall>();
+    for (const msg of this.messagesMap.values()) {
+      if (msg.type !== "ai") continue;
+      for (const call of msg.tool_calls ?? []) {
+        if (call.name === name && !calls.has(call.id)) calls.set(call.id, call);
+      }
+    }
+    return [...calls.values()];
+  }
+
   getMessages(): AdkMessage[] {
     return [...this.messagesMap.values()];
   }
@@ -733,11 +634,36 @@ export class AdkEventAccumulator {
   }
 
   getToolConfirmations(): AdkToolConfirmation[] {
-    return [...this.toolConfirmations];
+    const { approvals } = projectAdkToolApprovals(this.getMessages());
+    return this.getRequestCalls(ADK_REQUEST_CONFIRMATION)
+      .filter(({ id }) => approvals.get(id)?.approved === undefined)
+      .map(({ id, args = {} }) => {
+        const original = (args.originalFunctionCall ??
+          args.original_function_call) as Record<string, unknown> | undefined;
+        const confirmation = (args.toolConfirmation ??
+          args.tool_confirmation) as Record<string, unknown> | undefined;
+        return {
+          toolCallId: id,
+          toolName: (original?.name as string) ?? "",
+          args: (original?.args as Record<string, unknown>) ?? {},
+          hint: (confirmation?.hint as string) ?? "",
+          confirmed: false,
+          payload: confirmation?.payload,
+        };
+      });
   }
 
   getAuthRequests(): AdkAuthRequest[] {
-    return [...this.authRequests];
+    const answered = new Set<string>();
+    for (const msg of this.messagesMap.values()) {
+      if (msg.type === "tool") answered.add(msg.tool_call_id);
+    }
+    return this.getRequestCalls(ADK_REQUEST_CREDENTIAL)
+      .filter(({ id }) => !answered.has(id))
+      .map(({ id, args = {} }) => ({
+        toolCallId: id,
+        authConfig: args.auth_config ?? args.authConfig,
+      }));
   }
 
   isEscalated(): boolean {