@assistant-ui/react-google-adk 0.0.25 → 0.0.27

package/src/convertToAdkMessages.ts

@@ -0,0 +1,139 @@
+import {
+  generateId,
+  getExternalStoreMessages,
+  type AppendMessage,
+  type ThreadMessage,
+} from "@assistant-ui/core";
+import {
+  createToolCallCancellationStub,
+  parseDataUrl,
+  resolveFilePartSource,
+  scanPendingToolCalls,
+} from "@assistant-ui/core/internal";
+import type { AdkMessage } from "./types";
+
+/** Exported for unit tests. */
+export const getMessageContent = (msg: AppendMessage) => {
+  const allContent = [
+    ...msg.content,
+    ...(msg.attachments?.flatMap((a) => a.content) ?? []),
+  ];
+  const content = allContent.flatMap((part) => {
+    const type = part.type;
+    switch (type) {
+      case "text":
+        return { type: "text" as const, text: part.text };
+      case "image":
+        return { type: "image_url" as const, url: part.image };
+      case "file": {
+        const source = resolveFilePartSource(part);
+        if (source.kind === "url") {
+          return {
+            type: "file_url" as const,
+            url: source.url,
+            mimeType: part.mimeType,
+          };
+        }
+        return {
+          type: "file" as const,
+          mimeType: part.mimeType,
+          // Lands in Gemini `inlineData.data`, which takes bare base64, so a
+          // data URL envelope is stripped rather than forwarded.
+          data: source.data,
+          ...(part.filename != null && { filename: part.filename }),
+        };
+      }
+      case "audio": {
+        const parsed = parseDataUrl(part.audio.data);
+        return {
+          type: "file" as const,
+          mimeType: `audio/${part.audio.format}`,
+          data: parsed?.data ?? part.audio.data,
+        };
+      }
+      case "data":
+        return [];
+
+      case "tool-call":
+        throw new Error("Tool call appends are not supported.");
+
+      default: {
+        const _exhaustiveCheck: "reasoning" | "source" | "generative-ui" = type;
+        throw new Error(
+          `Unsupported append message part type: ${_exhaustiveCheck}`,
+        );
+      }
+    }
+  });
+
+  if (content.length === 1 && content[0]?.type === "text") {
+    return content[0].text ?? "";
+  }
+
+  return content;
+};
+
+/** Exported for unit tests. */
+export const getPendingToolCalls = (messages: AdkMessage[]) => {
+  return scanPendingToolCalls(
+    messages,
+    (message) => {
+      if (message.type === "ai") {
+        return { toolCalls: message.tool_calls ?? [] };
+      }
+      if (message.type === "tool") {
+        return { toolCallId: message.tool_call_id };
+      }
+      return undefined;
+    },
+    (toolCall) => toolCall.id,
+  );
+};
+
+/**
+ * Exported for unit tests.
+ *
+ * Returns `{cancelled: true}` tool responses for pending tool calls when the
+ * user sends a new turn, EXCEPT for HITL interrupts marked via
+ * `long_running_tool_ids` (`adk_request_input`, `adk_request_confirmation`,
+ * `adk_request_credential`). Those must be answered through a dedicated tool
+ * UI + submit helper, not auto-cancelled.
+ */
+export const getPendingCancellations = (
+  messages: AdkMessage[],
+  longRunningToolIds: readonly string[],
+): Array<AdkMessage & { type: "tool" }> => {
+  const longRunningSet = new Set(longRunningToolIds);
+  return getPendingToolCalls(messages)
+    .filter((t) => !longRunningSet.has(t.id))
+    .map(
+      (t) =>
+        ({
+          id: generateId(),
+          ...createToolCallCancellationStub(t),
+        }) satisfies AdkMessage & { type: "tool" },
+    );
+};
+
+export const truncateAdkMessages = (
+  threadMessages: readonly ThreadMessage[],
+  parentId: string | null,
+): AdkMessage[] => {
+  if (parentId === null) return [];
+  const parentIndex = threadMessages.findIndex((m) => m.id === parentId);
+  if (parentIndex === -1) return [];
+  const truncated: AdkMessage[] = [];
+  for (let i = 0; i <= parentIndex && i < threadMessages.length; i++) {
+    truncated.push(...getExternalStoreMessages<AdkMessage>(threadMessages[i]!));
+  }
+  return truncated;
+};
+
+export const toAdkUserMessage = (
+  msg: AppendMessage,
+  id = generateId(),
+): AdkMessage & { type: "human"; id: string } => ({
+  id,
+  type: "human",
+  content: getMessageContent(msg),
+});

package/src/hooks.ts

@@ -1,7 +1,8 @@
+import { generateId } from "@assistant-ui/core";
 import { useAui } from "@assistant-ui/store";
-import { v4 as uuidv4 } from "uuid";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import { adkExtras } from "./adkExtras";
+import { toAdkConfirmationReply } from "./adkToolApproval";
 import type {
   AdkMessage,
   AdkSendMessageConfig,
@@ -66,22 +67,9 @@ export const useAdkConfirmTool = () => {
     confirmed: boolean,
     payload?: ReadonlyJSONValue,
   ) =>
-    adkExtras.get(aui).send(
-      [
-        {
-          id: uuidv4(),
-          type: "tool",
-          tool_call_id: toolCallId,
-          name: "adk_request_confirmation",
-          content: JSON.stringify({
-            confirmed,
-            ...(payload != null && { payload }),
-          }),
-          status: "success",
-        },
-      ],
-      {},
-    );
+    adkExtras
+      .get(aui)
+      .send([toAdkConfirmationReply(toolCallId, confirmed, payload)], {});
 };
 
 /** Returns a function to submit auth credentials for a pending auth request. */
@@ -91,7 +79,7 @@ export const useAdkSubmitAuth = () => {
     adkExtras.get(aui).send(
       [
         {
-          id: uuidv4(),
+          id: generateId(),
           type: "tool",
           tool_call_id: toolCallId,
           name: "adk_request_credential",
@@ -110,7 +98,7 @@ export const useAdkSubmitInput = () => {
     adkExtras.get(aui).send(
       [
         {
-          id: uuidv4(),
+          id: generateId(),
           type: "tool",
           tool_call_id: toolCallId,
           name: "adk_request_input",

package/src/parseAdkEvent.ts

@@ -0,0 +1,40 @@
+import type { AdkEvent } from "./types";
+
+export function parseAdkEventValue(
+  value: unknown,
+  errorPrefix: string,
+): AdkEvent {
+  if (
+    typeof value !== "object" ||
+    value === null ||
+    Array.isArray(value) ||
+    Object.keys(value).length === 0
+  ) {
+    throw new Error(`${errorPrefix}: expected a non-empty object.`);
+  }
+
+  const { id: rawId, ...event } = value as Record<string, unknown>;
+  if (
+    rawId != null &&
+    typeof rawId !== "string" &&
+    (typeof rawId !== "number" || !Number.isFinite(rawId))
+  ) {
+    throw new Error(
+      `${errorPrefix}: expected "id" to be a string or finite number when present.`,
+    );
+  }
+
+  const errorMessage =
+    "error" in event && typeof event.error === "string"
+      ? event.error
+      : undefined;
+  return {
+    ...event,
+    ...(rawId != null && { id: String(rawId) }),
+    ...(errorMessage !== undefined &&
+      !("errorMessage" in event) &&
+      !("error_message" in event) && {
+        errorMessage,
+      }),
+  } as AdkEvent;
+}

package/src/server/parseAdkRequest.test.ts

@@ -49,6 +49,33 @@ describe("parseAdkRequest", () => {
     expect(result.parts).toHaveLength(2);
   });
 
+  it("parses each supported ADK part shape", async () => {
+    const parts = [
+      { text: "Hello", thought: true },
+      { functionCall: { name: "search", id: "call-1", args: {} } },
+      {
+        functionResponse: {
+          name: "search",
+          id: "call-1",
+          response: null,
+        },
+      },
+      { executableCode: { code: "print('hello')", language: "python" } },
+      { codeExecutionResult: { output: "hello", outcome: "ok" } },
+      { inlineData: { mimeType: "image/png", data: "abc" } },
+      {
+        fileData: {
+          fileUri: "https://example.com/file",
+          mimeType: "text/plain",
+        },
+      },
+    ];
+
+    await expect(
+      parseAdkRequest(makeRequest({ parts })),
+    ).resolves.toMatchObject({ parts });
+  });
+
   it("parses a tool-result request", async () => {
     const result = await parseAdkRequest(
       makeRequest({
@@ -73,6 +100,7 @@ describe("parseAdkRequest", () => {
       makeRequest({
         type: "tool-result",
         toolCallId: "tc-1",
+        toolName: "search",
         result: {},
       }),
     );
@@ -95,6 +123,119 @@ describe("parseAdkRequest", () => {
       "Google ADK proxy request body must be a JSON object",
     );
   });
+
+  it.each([
+    [{ message: 42 }, 'field "message"'],
+    [{ parts: {} }, 'field "parts"'],
+    [{ parts: [null] }, 'field "parts"'],
+    [{ type: "unknown", message: "hello" }, 'field "type"'],
+    [{ message: "hello", checkpointId: 42 }, 'field "checkpointId"'],
+    [{ message: "hello", stateDelta: [] }, 'field "stateDelta"'],
+  ])("rejects malformed message requests %#", async (body, error) => {
+    await expect(parseAdkRequest(makeRequest(body))).rejects.toThrow(error);
+  });
+
+  it.each([
+    [{ parts: [{}] }, 'field "parts[0]"'],
+    [{ parts: [{ text: 42 }] }, 'field "parts[0].text"'],
+    [
+      { parts: [{ inlineData: { mimeType: "image/png", data: 42 } }] },
+      'field "parts[0].inlineData.data"',
+    ],
+    [
+      { parts: [{ functionCall: { name: "search", args: [] } }] },
+      'field "parts[0].functionCall.args"',
+    ],
+    [
+      { parts: [{ functionResponse: { name: 42 } }] },
+      'field "parts[0].functionResponse.name"',
+    ],
+  ])("rejects malformed nested ADK parts %#", async (body, error) => {
+    await expect(parseAdkRequest(makeRequest(body))).rejects.toThrow(error);
+  });
+
+  it("accepts exclude_none and unknown part shapes", async () => {
+    const parts = [
+      { functionCall: { name: "get_time", id: "call-1" } },
+      { functionResponse: { name: "search", id: "call-1" } },
+      { text: "hi", inlineData: { mimeType: "image/png", data: "abc" } },
+      { videoMetadata: { fps: 1 } },
+      { text: "hello", thoughtSignature: "sig" },
+    ];
+
+    await expect(
+      parseAdkRequest(makeRequest({ parts })),
+    ).resolves.toMatchObject({ parts });
+  });
+
+  it("requires message content", async () => {
+    await expect(parseAdkRequest(makeRequest({}))).rejects.toThrow(
+      'expected a "message" string or a "parts" array',
+    );
+  });
+
+  it.each([
+    [
+      { type: "message", message: "hello" },
+      { type: "message", text: "hello", config: {} },
+    ],
+    [{ parts: [] }, { type: "message", text: "", parts: [], config: {} }],
+  ])(
+    "preserves supported empty and explicit message shapes %#",
+    async (body, expected) => {
+      await expect(parseAdkRequest(makeRequest(body))).resolves.toEqual(
+        expected,
+      );
+    },
+  );
+
+  it("accepts empty tool identifiers emitted by id-less ADK calls", async () => {
+    await expect(
+      parseAdkRequest(
+        makeRequest({
+          type: "tool-result",
+          toolCallId: "",
+          toolName: "",
+          result: {},
+        }),
+      ),
+    ).resolves.toMatchObject({
+      type: "tool-result",
+      toolCallId: "",
+      toolName: "",
+    });
+  });
+
+  it.each([
+    [
+      { type: "tool-result", toolName: "search", result: {} },
+      'field "toolCallId"',
+    ],
+    [
+      { type: "tool-result", toolCallId: "tc-1", result: {} },
+      'field "toolName"',
+    ],
+    [
+      { type: "tool-result", toolCallId: 42, toolName: "search", result: {} },
+      'field "toolCallId"',
+    ],
+    [
+      {
+        type: "tool-result",
+        toolCallId: "tc-1",
+        toolName: "search",
+        result: {},
+        isError: "false",
+      },
+      'field "isError"',
+    ],
+    [
+      { type: "tool-result", toolCallId: "tc-1", toolName: "search" },
+      'field "result"',
+    ],
+  ])("rejects malformed tool-result requests %#", async (body, error) => {
+    await expect(parseAdkRequest(makeRequest(body))).rejects.toThrow(error);
+  });
 });
 
 describe("toAdkContent", () => {

package/src/server/parseAdkRequest.ts

@@ -1,3 +1,4 @@
+import { isRecord } from "@assistant-ui/core/internal";
 import type { AdkSendMessageConfig } from "../types";
 
 type ParsedAdkRequest =
@@ -18,6 +19,107 @@ type ParsedAdkRequest =
       stateDelta?: Record<string, unknown> | undefined;
     };
 
+const invalidField = (field: string, expectation: string): Error =>
+  new Error(
+    `Invalid Google ADK proxy request field "${field}": expected ${expectation}.`,
+  );
+
+const readString = (body: Record<string, unknown>, field: string): string => {
+  const value = body[field];
+  if (typeof value !== "string") throw invalidField(field, "a string");
+  return value;
+};
+
+const readOptionalString = (
+  body: Record<string, unknown>,
+  field: string,
+): string | undefined => {
+  const value = body[field];
+  if (value === undefined) return undefined;
+  if (typeof value !== "string") throw invalidField(field, "a string");
+  return value;
+};
+
+const validateOptionalPartString = (
+  part: Record<string, unknown>,
+  key: string,
+  field: string,
+) => {
+  if (part[key] !== undefined && typeof part[key] !== "string") {
+    throw invalidField(field, "a string");
+  }
+};
+
+// Nested fields are validated only when present: ADK serializes with
+// exclude_none semantics and the Part vocabulary grows upstream, so absent
+// fields and unknown part kinds pass through to the runner untouched.
+const validatePart = (part: Record<string, unknown>, index: number) => {
+  const field = (name: string) => `parts[${index}].${name}`;
+  if (Object.keys(part).length === 0) {
+    throw invalidField(`parts[${index}]`, "a non-empty part object");
+  }
+  if (part.thought !== undefined && typeof part.thought !== "boolean") {
+    throw invalidField(field("thought"), "a boolean");
+  }
+  if (part.text !== undefined && typeof part.text !== "string") {
+    throw invalidField(field("text"), "a string");
+  }
+
+  const validateRecordField = (
+    key: string,
+    validateContent: (content: Record<string, unknown>) => void,
+  ) => {
+    const value = part[key];
+    if (value === undefined) return;
+    if (!isRecord(value)) throw invalidField(field(key), "an object");
+    validateContent(value);
+  };
+
+  validateRecordField("functionCall", (content) => {
+    validateOptionalPartString(content, "name", field("functionCall.name"));
+    validateOptionalPartString(content, "id", field("functionCall.id"));
+    if (content.args !== undefined && !isRecord(content.args)) {
+      throw invalidField(field("functionCall.args"), "an object");
+    }
+  });
+  validateRecordField("functionResponse", (content) => {
+    validateOptionalPartString(content, "name", field("functionResponse.name"));
+    validateOptionalPartString(content, "id", field("functionResponse.id"));
+  });
+  validateRecordField("executableCode", (content) => {
+    validateOptionalPartString(content, "code", field("executableCode.code"));
+    validateOptionalPartString(
+      content,
+      "language",
+      field("executableCode.language"),
+    );
+  });
+  validateRecordField("codeExecutionResult", (content) => {
+    validateOptionalPartString(
+      content,
+      "output",
+      field("codeExecutionResult.output"),
+    );
+    validateOptionalPartString(
+      content,
+      "outcome",
+      field("codeExecutionResult.outcome"),
+    );
+  });
+  validateRecordField("inlineData", (content) => {
+    validateOptionalPartString(
+      content,
+      "mimeType",
+      field("inlineData.mimeType"),
+    );
+    validateOptionalPartString(content, "data", field("inlineData.data"));
+  });
+  validateRecordField("fileData", (content) => {
+    validateOptionalPartString(content, "fileUri", field("fileData.fileUri"));
+    validateOptionalPartString(content, "mimeType", field("fileData.mimeType"));
+  });
+};
+
 /**
  * Parses an incoming HTTP request into a structured ADK request.
  *
@@ -42,44 +144,74 @@ type ParsedAdkRequest =
 export const parseAdkRequest = async (
   request: Request,
 ): Promise<ParsedAdkRequest> => {
-  let body: Record<string, unknown>;
+  let body: unknown;
   try {
-    body = (await request.json()) as Record<string, unknown>;
+    body = await request.json();
   } catch {
     throw new Error(
       'Invalid JSON in Google ADK proxy request body. Expected a JSON object like {"message":"Hello"} or {"type":"tool-result",...}.',
     );
   }
 
-  if (!body || typeof body !== "object" || Array.isArray(body)) {
+  if (!isRecord(body)) {
     throw new Error("Google ADK proxy request body must be a JSON object");
   }
 
   const config: AdkSendMessageConfig = {};
   if (body.runConfig !== undefined) config.runConfig = body.runConfig;
-  if (body.checkpointId !== undefined)
-    config.checkpointId = body.checkpointId as string;
+  const checkpointId = readOptionalString(body, "checkpointId");
+  if (checkpointId !== undefined) config.checkpointId = checkpointId;
 
-  const stateDelta = body.stateDelta as Record<string, unknown> | undefined;
+  const stateDelta = body.stateDelta;
+  if (stateDelta !== undefined && !isRecord(stateDelta)) {
+    throw invalidField("stateDelta", "an object");
+  }
 
   if (body.type === "tool-result") {
+    if (!("result" in body)) {
+      throw invalidField("result", "a value");
+    }
+    if (body.isError !== undefined && typeof body.isError !== "boolean") {
+      throw invalidField("isError", "a boolean");
+    }
     return {
       type: "tool-result",
-      toolCallId: (body.toolCallId as string) ?? "",
-      toolName: (body.toolName as string) ?? "",
+      toolCallId: readString(body, "toolCallId"),
+      toolName: readString(body, "toolName"),
       result: body.result,
-      isError: (body.isError as boolean) ?? false,
+      isError: body.isError ?? false,
       config,
       ...(stateDelta != null && { stateDelta }),
     };
   }
 
+  if (body.type !== undefined && body.type !== "message") {
+    throw invalidField("type", '"message", "tool-result", or omitted');
+  }
+
+  const text = body.message;
+  if (text !== undefined && typeof text !== "string") {
+    throw invalidField("message", "a string");
+  }
+
+  const parts = body.parts;
+  if (
+    parts !== undefined &&
+    (!Array.isArray(parts) || !parts.every(isRecord))
+  ) {
+    throw invalidField("parts", "an array of objects");
+  }
+  parts?.forEach(validatePart);
+  if (!("message" in body) && !("parts" in body)) {
+    throw new Error(
+      'Invalid Google ADK proxy request: expected a "message" string or a "parts" array.',
+    );
+  }
+
   return {
     type: "message",
-    text: (body.message as string) ?? "",
-    ...(body.parts != null && {
-      parts: body.parts as Array<Record<string, unknown>>,
-    }),
+    text: text ?? "",
+    ...(parts !== undefined && { parts }),
     config,
     ...(stateDelta != null && { stateDelta }),
   };