@assistant-ui/react-google-adk 0.0.4 → 0.0.6

package/src/AdkEventAccumulator.test.ts

@@ -399,7 +399,7 @@ describe("AdkEventAccumulator - isFinalResponse logic", () => {
     });
   });
 
-  it("marks as final when longRunningToolIds is non-empty", () => {
+  it("HITL event leaves status undefined for auto-status", () => {
     const acc = new AdkEventAccumulator();
     const msgs = acc.processEvent(
       makeEvent({
@@ -413,10 +413,283 @@ describe("AdkEventAccumulator - isFinalResponse logic", () => {
         },
       }),
     );
+    expect((msgs[0] as AdkMessage & { type: "ai" }).status).toBeUndefined();
+  });
+});
+
+describe("AdkEventAccumulator - HITL requires-action", () => {
+  const makeHitlEvent = (
+    toolCallId: string,
+    overrides: Partial<AdkEvent> = {},
+  ): AdkEvent =>
+    makeEvent({
+      author: "agent",
+      longRunningToolIds: [toolCallId],
+      content: {
+        parts: [
+          {
+            functionCall: {
+              id: toolCallId,
+              name: "adk_request_input",
+              args: { message: "What's the forecast period?" },
+            },
+          },
+        ],
+      },
+      ...overrides,
+    });
+
+  it("produces an AI message with tool call and no manual status", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(makeHitlEvent("tc-1"));
+
+    expect(msgs).toHaveLength(1);
+    const aiMsg = msgs[0] as AdkMessage & { type: "ai" };
+    expect(aiMsg.type).toBe("ai");
+    expect(aiMsg.tool_calls).toHaveLength(1);
+    expect(aiMsg.tool_calls![0]!.id).toBe("tc-1");
+    expect(aiMsg.tool_calls![0]!.name).toBe("adk_request_input");
+    expect(aiMsg.status).toBeUndefined();
+  });
+
+  it("matches tool call id to the longRunningToolIds entry", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(makeHitlEvent("tc-1"));
+    const aiMsg = msgs[0] as AdkMessage & { type: "ai" };
+    expect(aiMsg.tool_calls![0]!.id).toBe("tc-1");
+  });
+
+  it("stays pending across a subsequent bookkeeping event", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(makeHitlEvent("tc-1", { author: "WorkflowA" }));
+
+    const msgs = acc.processEvent(
+      makeEvent({
+        id: "evt-bookkeeping",
+        author: "WorkflowA",
+        actions: { stateDelta: { waiting_for_user: true } },
+      }),
+    );
+
+    const aiMsg = msgs.find(
+      (m): m is AdkMessage & { type: "ai" } =>
+        m.type === "ai" && (m.tool_calls?.length ?? 0) > 0,
+    );
+    expect(aiMsg).toBeDefined();
+    expect(aiMsg!.tool_calls![0]!.id).toBe("tc-1");
+    expect(aiMsg!.status).toBeUndefined();
+  });
+
+  it("assigns manual complete status on non-HITL final event", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        content: { role: "model", parts: [{ text: "Done." }] },
+      }),
+    );
+
     expect(msgs[0]).toMatchObject({
       status: { type: "complete", reason: "stop" },
     });
   });
+
+  it("assigns manual complete status on skipSummarization final event", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        actions: { skipSummarization: true },
+        content: { role: "model", parts: [{ text: "skipped" }] },
+      }),
+    );
+
+    expect(msgs[0]).toMatchObject({
+      status: { type: "complete", reason: "stop" },
+    });
+  });
+
+  it("prioritizes skipSummarization over longRunningToolIds", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        longRunningToolIds: ["lrt-both"],
+        actions: { skipSummarization: true },
+        content: {
+          role: "model",
+          parts: [
+            { functionCall: { name: "slow_tool", id: "lrt-both", args: {} } },
+          ],
+        },
+      }),
+    );
+
+    expect(msgs[0]).toMatchObject({
+      status: { type: "complete", reason: "stop" },
+    });
+  });
+
+  it("ignores empty longRunningToolIds array for HITL guard", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        longRunningToolIds: [],
+        content: { role: "model", parts: [{ text: "Done." }] },
+      }),
+    );
+
+    expect(msgs[0]).toMatchObject({
+      status: { type: "complete", reason: "stop" },
+    });
+  });
+
+  it("preserves text and skips status when partial text precedes HITL event", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(
+      makeEvent({
+        author: "ClarifyAgent",
+        partial: true,
+        content: {
+          role: "model",
+          parts: [{ text: "Let me ask about " }],
+        },
+      }),
+    );
+
+    const msgs = acc.processEvent(
+      makeHitlEvent("tc-1", { author: "ClarifyAgent" }),
+    );
+
+    const aiMsg = msgs.find(
+      (m): m is AdkMessage & { type: "ai" } =>
+        m.type === "ai" && (m.tool_calls?.length ?? 0) > 0,
+    );
+    expect(aiMsg).toBeDefined();
+    expect(aiMsg!.tool_calls).toHaveLength(1);
+    expect(
+      aiMsg!.content.some(
+        (c) => c.type === "text" && c.text.includes("Let me ask"),
+      ),
+    ).toBe(true);
+    expect(aiMsg!.status).toBeUndefined();
+  });
+
+  it("keeps status undefined for mixed text and functionCall content", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        longRunningToolIds: ["mixed-tc-1"],
+        content: {
+          role: "model",
+          parts: [
+            { text: "I need some clarification." },
+            {
+              functionCall: {
+                id: "mixed-tc-1",
+                name: "adk_request_input",
+                args: { message: "Which region?" },
+              },
+            },
+          ],
+        },
+      }),
+    );
+
+    const aiMsg = msgs[0] as AdkMessage & { type: "ai" };
+    expect(aiMsg.content.some((c) => c.type === "text")).toBe(true);
+    expect(aiMsg.tool_calls).toHaveLength(1);
+    expect(aiMsg.tool_calls![0]!.id).toBe("mixed-tc-1");
+    expect(aiMsg.status).toBeUndefined();
+  });
+
+  it("handles multiple tool calls with partial longRunningToolIds overlap", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "agent",
+        longRunningToolIds: ["tc-hitl"],
+        content: {
+          role: "model",
+          parts: [
+            {
+              functionCall: {
+                id: "tc-hitl",
+                name: "adk_request_input",
+                args: { message: "Confirm?" },
+              },
+            },
+            {
+              functionCall: {
+                id: "tc-regular",
+                name: "fetch_data",
+                args: { url: "https://example.com" },
+              },
+            },
+          ],
+        },
+      }),
+    );
+
+    const aiMsg = msgs[0] as AdkMessage & { type: "ai" };
+    expect(aiMsg.tool_calls).toHaveLength(2);
+    expect(aiMsg.tool_calls!.map((tc) => tc.id).sort()).toEqual(
+      ["tc-hitl", "tc-regular"].sort(),
+    );
+    expect(aiMsg.status).toBeUndefined();
+  });
+
+  it("does not override HITL guard with explicit finishReason", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeHitlEvent("tc-fr", { finishReason: "STOP" }),
+    );
+
+    const aiMsg = msgs[0] as AdkMessage & { type: "ai" };
+    expect(aiMsg.status).toBeUndefined();
+  });
+
+  it("produces separate messages without status for sequential HITL events", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(
+      makeHitlEvent("tc-seq-1", { id: "evt-1", author: "WorkflowA" }),
+    );
+
+    const msgs = acc.processEvent(
+      makeEvent({
+        id: "evt-2",
+        author: "WorkflowB",
+        longRunningToolIds: ["tc-seq-2"],
+        content: {
+          role: "model",
+          parts: [
+            {
+              functionCall: {
+                id: "tc-seq-2",
+                name: "adk_request_confirmation",
+                args: {
+                  originalFunctionCall: { name: "delete_all", args: {} },
+                  toolConfirmation: { hint: "Sure?", payload: {} },
+                },
+              },
+            },
+          ],
+        },
+      }),
+    );
+
+    const hitlMsgs = msgs.filter(
+      (m): m is AdkMessage & { type: "ai" } =>
+        m.type === "ai" && (m.tool_calls?.length ?? 0) > 0,
+    );
+    expect(hitlMsgs).toHaveLength(2);
+    expect(hitlMsgs[0]!.status).toBeUndefined();
+    expect(hitlMsgs[1]!.status).toBeUndefined();
+    expect(hitlMsgs[0]!.tool_calls![0]!.id).toBe("tc-seq-1");
+    expect(hitlMsgs[1]!.tool_calls![0]!.id).toBe("tc-seq-2");
+  });
 });
 
 describe("AdkEventAccumulator - actions tracking", () => {
@@ -487,6 +760,44 @@ describe("AdkEventAccumulator - actions tracking", () => {
     );
     expect(acc.getLongRunningToolIds()).toEqual(["lrt-1", "lrt-2"]);
   });
+
+  it("unions longRunningToolIds across multiple events", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(
+      makeEvent({
+        longRunningToolIds: ["lrt-1"],
+        author: "agent",
+        content: { parts: [{ text: "x" }] },
+      }),
+    );
+    acc.processEvent(
+      makeEvent({
+        longRunningToolIds: ["lrt-2"],
+        author: "agent",
+        content: { parts: [{ text: "y" }] },
+      }),
+    );
+    expect(acc.getLongRunningToolIds()).toEqual(["lrt-1", "lrt-2"]);
+  });
+
+  it("deduplicates repeated longRunningToolIds", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(
+      makeEvent({
+        longRunningToolIds: ["lrt-1"],
+        author: "agent",
+        content: { parts: [{ text: "x" }] },
+      }),
+    );
+    acc.processEvent(
+      makeEvent({
+        longRunningToolIds: ["lrt-1"],
+        author: "agent",
+        content: { parts: [{ text: "y" }] },
+      }),
+    );
+    expect(acc.getLongRunningToolIds()).toEqual(["lrt-1"]);
+  });
 });
 
 describe("AdkEventAccumulator - special function calls", () => {
@@ -576,7 +887,12 @@ describe("AdkEventAccumulator - author/agent tracking", () => {
 
   it("does not track user as agent info", () => {
     const acc = new AdkEventAccumulator();
-    acc.processEvent(makeTextEvent("hello", false, "user"));
+    acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: { role: "user", parts: [{ text: "hello" }] },
+      }),
+    );
     expect(acc.getAgentInfo()).toEqual({});
   });
 
@@ -667,3 +983,206 @@ describe("AdkEventAccumulator - initial messages", () => {
     expect(msgs).toHaveLength(2);
   });
 });
+
+describe("AdkEventAccumulator - user message handling", () => {
+  it("creates a human message for user-authored text events", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: { role: "user", parts: [{ text: "hello" }] },
+      }),
+    );
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatchObject({
+      type: "human",
+      content: "hello",
+    });
+  });
+
+  it("creates separate human and AI messages for a user/agent turn", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(
+      makeEvent({
+        id: "u1",
+        author: "user",
+        content: { role: "user", parts: [{ text: "help" }] },
+      }),
+    );
+    const msgs = acc.processEvent(makeTextEvent("How can I help?"));
+    expect(msgs).toHaveLength(2);
+    expect(msgs[0]).toMatchObject({ type: "human", content: "help" });
+    expect(msgs[1]).toMatchObject({
+      type: "ai",
+      content: [{ type: "text", text: "How can I help?" }],
+    });
+  });
+
+  it("handles multiple user/agent turns with correct message types", () => {
+    const acc = new AdkEventAccumulator();
+    acc.processEvent(
+      makeEvent({
+        id: "u1",
+        author: "user",
+        content: { role: "user", parts: [{ text: "hello" }] },
+      }),
+    );
+    acc.processEvent(makeTextEvent("Hi there!"));
+    acc.processEvent(
+      makeEvent({
+        id: "u2",
+        author: "user",
+        content: { role: "user", parts: [{ text: "help" }] },
+      }),
+    );
+    const msgs = acc.processEvent(makeTextEvent("How can I help?"));
+    expect(msgs).toHaveLength(4);
+    expect(msgs[0]).toMatchObject({ type: "human", content: "hello" });
+    expect(msgs[1]).toMatchObject({ type: "ai" });
+    expect(msgs[2]).toMatchObject({ type: "human", content: "help" });
+    expect(msgs[3]).toMatchObject({ type: "ai" });
+  });
+
+  it("creates human message with image content", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: {
+          role: "user",
+          parts: [{ inlineData: { mimeType: "image/png", data: "abc123" } }],
+        },
+      }),
+    );
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatchObject({
+      type: "human",
+      content: [{ type: "image", mimeType: "image/png", data: "abc123" }],
+    });
+  });
+
+  it("creates human message with mixed text and image content", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: {
+          role: "user",
+          parts: [
+            { text: "Look at this" },
+            { inlineData: { mimeType: "image/png", data: "abc123" } },
+          ],
+        },
+      }),
+    );
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatchObject({
+      type: "human",
+      content: [
+        { type: "text", text: "Look at this" },
+        { type: "image", mimeType: "image/png", data: "abc123" },
+      ],
+    });
+  });
+
+  it("creates human message with fileData content", () => {
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        author: "user",
+        content: {
+          role: "user",
+          parts: [{ fileData: { fileUri: "gs://bucket/image.png" } }],
+        },
+      }),
+    );
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatchObject({
+      type: "human",
+      content: [{ type: "image_url", url: "gs://bucket/image.png" }],
+    });
+  });
+
+  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`,
+    // with content.role:'user' and a functionResponse part.
+    const acc = new AdkEventAccumulator();
+    const msgs = acc.processEvent(
+      makeEvent({
+        content: {
+          role: "user",
+          parts: [
+            {
+              functionResponse: {
+                name: "get_weather",
+                id: "call_1",
+                response: { temp: 72 },
+              },
+            },
+          ],
+        },
+      }),
+    );
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatchObject({
+      type: "tool",
+      name: "get_weather",
+      tool_call_id: "call_1",
+      content: JSON.stringify({ temp: 72 }),
+    });
+  });
+
+  it("session replay produces correct message types", () => {
+    // Simulate loading a session with alternating user/agent events
+    const acc = new AdkEventAccumulator();
+    const events: AdkEvent[] = [
+      makeEvent({
+        id: "e1",
+        author: "user",
+        content: { role: "user", parts: [{ text: "good morning" }] },
+      }),
+      // Workflow state-only events (no content)
+      makeEvent({
+        id: "e2",
+        author: "WorkflowAgent",
+        actions: { stateDelta: { intent: "greeting" } },
+      }),
+      // Final response with content
+      makeEvent({
+        id: "e3",
+        author: "WorkflowAgent",
+        content: { role: "model", parts: [{ text: "Hello! How can I help?" }] },
+      }),
+      // Second turn
+      makeEvent({
+        id: "e4",
+        author: "user",
+        content: { role: "user", parts: [{ text: "help" }] },
+      }),
+      makeEvent({
+        id: "e5",
+        author: "WorkflowAgent",
+        content: {
+          role: "model",
+          parts: [{ text: "What do you need help with?" }],
+        },
+      }),
+    ];
+    let msgs: AdkMessage[] = [];
+    for (const event of events) {
+      msgs = acc.processEvent(event);
+    }
+    expect(msgs).toHaveLength(4);
+    expect(msgs[0]).toMatchObject({ type: "human", content: "good morning" });
+    expect(msgs[1]).toMatchObject({
+      type: "ai",
+      content: [{ type: "text", text: "Hello! How can I help?" }],
+    });
+    expect(msgs[2]).toMatchObject({ type: "human", content: "help" });
+    expect(msgs[3]).toMatchObject({
+      type: "ai",
+      content: [{ type: "text", text: "What do you need help with?" }],
+    });
+  });
+});

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/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,