@assistant-ui/react-google-adk 0.0.1

package/src/convertAdkMessages.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect } from "vitest";
+import { convertAdkMessage } from "./convertAdkMessages";
+import type { AdkMessage } from "./types";
+
+describe("convertAdkMessage - human messages", () => {
+  it("converts a human message with string content to user role", () => {
+    const msg: AdkMessage = { id: "m1", type: "human", content: "Hello" };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      role: "user",
+      id: "m1",
+      content: [{ type: "text", text: "Hello" }],
+    });
+  });
+
+  it("converts a human message with text content parts", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "human",
+      content: [{ type: "text", text: "Hello" }],
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      role: "user",
+      content: [{ type: "text", text: "Hello" }],
+    });
+  });
+});
+
+describe("convertAdkMessage - ai messages", () => {
+  it("converts an ai message with text content", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "ai",
+      content: [{ type: "text", text: "Hi there" }],
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      role: "assistant",
+      id: "m1",
+      content: [{ type: "text", text: "Hi there" }],
+    });
+  });
+
+  it("converts reasoning content parts", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "ai",
+      content: [{ type: "reasoning", text: "Let me think..." }],
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      content: [{ type: "reasoning", text: "Let me think..." }],
+    });
+  });
+
+  it("converts image content parts to data URI", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "ai",
+      content: [{ type: "image", mimeType: "image/png", data: "abc123" }],
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      content: [{ type: "image", image: "data:image/png;base64,abc123" }],
+    });
+  });
+
+  it("converts image_url content parts", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "ai",
+      content: [{ type: "image_url", url: "https://example.com/img.png" }],
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      content: [{ type: "image", image: "https://example.com/img.png" }],
+    });
+  });
+
+  it("converts code content parts to data parts", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "ai",
+      content: [{ type: "code", code: "print(1)", language: "python" }],
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      content: [
+        {
+          type: "data",
+          name: "executable_code",
+          data: { code: "print(1)", language: "python" },
+        },
+      ],
+    });
+  });
+
+  it("converts code_result content parts to data parts", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "ai",
+      content: [{ type: "code_result", output: "1", outcome: "OUTCOME_OK" }],
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      content: [
+        {
+          type: "data",
+          name: "code_execution_result",
+          data: { output: "1", outcome: "OUTCOME_OK" },
+        },
+      ],
+    });
+  });
+
+  it("converts tool_calls to tool-call content parts", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "ai",
+      content: [],
+      tool_calls: [{ id: "tc-1", name: "search", args: { q: "test" } }],
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "tc-1",
+          toolName: "search",
+          args: { q: "test" },
+        },
+      ],
+    });
+  });
+
+  it("includes status when present", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "ai",
+      content: [{ type: "text", text: "done" }],
+      status: { type: "complete", reason: "stop" },
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      status: { type: "complete", reason: "stop" },
+    });
+  });
+
+  it("includes author/branch metadata when author is set", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "ai",
+      content: [{ type: "text", text: "hi" }],
+      author: "search_agent",
+      branch: "root.search_agent",
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      metadata: {
+        custom: { author: "search_agent", branch: "root.search_agent" },
+      },
+    });
+  });
+
+  it("omits metadata when author is not set", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "ai",
+      content: [{ type: "text", text: "hi" }],
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).not.toHaveProperty("metadata");
+  });
+});
+
+describe("convertAdkMessage - tool messages", () => {
+  it("converts a tool message to tool role", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "tool",
+      tool_call_id: "tc-1",
+      name: "search",
+      content: '{"results":[]}',
+      status: "success",
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({
+      role: "tool",
+      toolCallId: "tc-1",
+      toolName: "search",
+      result: '{"results":[]}',
+      isError: false,
+    });
+  });
+
+  it("sets isError to true when status is error", () => {
+    const msg: AdkMessage = {
+      id: "m1",
+      type: "tool",
+      tool_call_id: "tc-1",
+      name: "search",
+      content: "Failed",
+      status: "error",
+    };
+    const result = convertAdkMessage(msg);
+    expect(result).toMatchObject({ isError: true });
+  });
+});

package/src/convertAdkMessages.ts

@@ -0,0 +1,93 @@
+"use client";
+
+import type { ToolCallMessagePart } from "@assistant-ui/core";
+import { useExternalMessageConverter } from "@assistant-ui/core/react";
+import type { AdkMessage, AdkMessageContentPart } from "./types";
+
+type ContentPart =
+  | { type: "text"; text: string }
+  | { type: "reasoning"; text: string }
+  | { type: "image"; image: string }
+  | { type: "data"; name: string; data: unknown };
+
+const contentToParts = (content: AdkMessage["content"]): ContentPart[] => {
+  if (typeof content === "string")
+    return [{ type: "text" as const, text: content }];
+
+  return (content as AdkMessageContentPart[])
+    .map((part): ContentPart | null => {
+      switch (part.type) {
+        case "text":
+          return { type: "text", text: part.text };
+        case "reasoning":
+          return { type: "reasoning", text: part.text };
+        case "image":
+          return {
+            type: "image",
+            image: `data:${part.mimeType};base64,${part.data}`,
+          };
+        case "image_url":
+          return { type: "image", image: part.url };
+        case "code":
+          return {
+            type: "data",
+            name: "executable_code",
+            data: { code: part.code, language: part.language },
+          };
+        case "code_result":
+          return {
+            type: "data",
+            name: "code_execution_result",
+            data: { output: part.output, outcome: part.outcome },
+          };
+        default:
+          return null;
+      }
+    })
+    .filter((p): p is NonNullable<typeof p> => p !== null);
+};
+
+export const convertAdkMessage: useExternalMessageConverter.Callback<
+  AdkMessage
+> = (message) => {
+  switch (message.type) {
+    case "human":
+      return {
+        role: "user",
+        id: message.id,
+        content: contentToParts(message.content),
+      };
+
+    case "ai": {
+      const toolCallParts: ToolCallMessagePart[] =
+        message.tool_calls?.map((tc) => ({
+          type: "tool-call",
+          toolCallId: tc.id,
+          toolName: tc.name,
+          args: tc.args,
+          argsText: tc.argsText ?? JSON.stringify(tc.args),
+        })) ?? [];
+
+      return {
+        role: "assistant",
+        id: message.id,
+        content: [...contentToParts(message.content), ...toolCallParts],
+        ...(message.status && { status: message.status }),
+        ...(message.author && {
+          metadata: {
+            custom: { author: message.author, branch: message.branch },
+          },
+        }),
+      };
+    }
+
+    case "tool":
+      return {
+        role: "tool",
+        toolCallId: message.tool_call_id,
+        toolName: message.name,
+        result: message.content,
+        isError: message.status === "error",
+      };
+  }
+};

package/src/hooks.ts

@@ -0,0 +1,217 @@
+/// <reference types="@assistant-ui/core/store" />
+
+import { useAui, useAuiState } from "@assistant-ui/store";
+import { v4 as uuidv4 } from "uuid";
+import type {
+  AdkMessage,
+  AdkSendMessageConfig,
+  AdkToolConfirmation,
+  AdkAuthCredential,
+  AdkAuthRequest,
+  AdkMessageMetadata,
+} from "./types";
+
+export const symbolAdkRuntimeExtras = Symbol("adk-runtime-extras");
+
+export type AdkRuntimeExtras = {
+  [symbolAdkRuntimeExtras]: true;
+  send: (messages: AdkMessage[], config: AdkSendMessageConfig) => Promise<void>;
+  agentInfo: { name?: string | undefined; branch?: string | undefined };
+  stateDelta: Record<string, unknown>;
+  artifactDelta: Record<string, number>;
+  longRunningToolIds: string[];
+  toolConfirmations: AdkToolConfirmation[];
+  authRequests: AdkAuthRequest[];
+  escalated: boolean;
+  messageMetadata: Map<string, AdkMessageMetadata>;
+};
+
+const asAdkRuntimeExtras = (extras: unknown): AdkRuntimeExtras => {
+  if (
+    typeof extras !== "object" ||
+    extras == null ||
+    !(symbolAdkRuntimeExtras in extras)
+  )
+    throw new Error(
+      "This method can only be called when you are using useAdkRuntime",
+    );
+
+  return extras as AdkRuntimeExtras;
+};
+
+/** Returns the name and branch of the currently active ADK agent. */
+export const useAdkAgentInfo = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return undefined;
+    return asAdkRuntimeExtras(extras).agentInfo;
+  });
+};
+
+/** Returns the accumulated session state delta from ADK events. */
+export const useAdkSessionState = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return {};
+    return asAdkRuntimeExtras(extras).stateDelta;
+  });
+};
+
+/** Returns a function to send raw ADK messages. */
+export const useAdkSend = () => {
+  const aui = useAui();
+  return (messages: AdkMessage[], config: AdkSendMessageConfig) => {
+    const extras = aui.thread().getState().extras;
+    const { send } = asAdkRuntimeExtras(extras);
+    return send(messages, config);
+  };
+};
+
+/** Returns the IDs of long-running tools awaiting external input. */
+export const useAdkLongRunningToolIds = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return [];
+    return asAdkRuntimeExtras(extras).longRunningToolIds;
+  });
+};
+
+/** Returns pending tool confirmation requests (from SecurityPlugin etc). */
+export const useAdkToolConfirmations = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return [];
+    return asAdkRuntimeExtras(extras).toolConfirmations;
+  });
+};
+
+/** Returns pending auth credential requests from tools. */
+export const useAdkAuthRequests = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return [];
+    return asAdkRuntimeExtras(extras).authRequests;
+  });
+};
+
+/** Returns the accumulated artifact delta (filename → version). */
+export const useAdkArtifacts = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return {};
+    return asAdkRuntimeExtras(extras).artifactDelta;
+  });
+};
+
+/** Returns whether any agent has escalated (requested human handoff). */
+export const useAdkEscalation = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return false;
+    return asAdkRuntimeExtras(extras).escalated;
+  });
+};
+
+/** Returns per-message metadata (grounding, citation, usage). Keyed by message ID. */
+export const useAdkMessageMetadata = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return new Map<string, AdkMessageMetadata>();
+    return asAdkRuntimeExtras(extras).messageMetadata;
+  });
+};
+
+// ── Convenience helpers for interactive flows ──
+
+/** Returns a function to confirm or deny a pending tool confirmation. */
+export const useAdkConfirmTool = () => {
+  const aui = useAui();
+  return (toolCallId: string, confirmed: boolean, payload?: unknown) => {
+    const extras = aui.thread().getState().extras;
+    const { send } = asAdkRuntimeExtras(extras);
+    return send(
+      [
+        {
+          id: uuidv4(),
+          type: "tool",
+          tool_call_id: toolCallId,
+          name: "adk_request_confirmation",
+          content: JSON.stringify({
+            confirmed,
+            ...(payload != null && { payload }),
+          }),
+          status: "success",
+        },
+      ],
+      {},
+    );
+  };
+};
+
+/** Returns a function to submit auth credentials for a pending auth request. */
+export const useAdkSubmitAuth = () => {
+  const aui = useAui();
+  return (toolCallId: string, credential: AdkAuthCredential) => {
+    const extras = aui.thread().getState().extras;
+    const { send } = asAdkRuntimeExtras(extras);
+    return send(
+      [
+        {
+          id: uuidv4(),
+          type: "tool",
+          tool_call_id: toolCallId,
+          name: "adk_request_credential",
+          content: JSON.stringify(credential),
+          status: "success",
+        },
+      ],
+      {},
+    );
+  };
+};
+
+// ── State prefix helpers ──
+
+const APP_PREFIX = "app:";
+const USER_PREFIX = "user:";
+const TEMP_PREFIX = "temp:";
+
+const filterByPrefix = (
+  state: Record<string, unknown>,
+  prefix: string,
+): Record<string, unknown> => {
+  const result: Record<string, unknown> = {};
+  for (const key of Object.keys(state)) {
+    if (key.startsWith(prefix)) {
+      result[key.slice(prefix.length)] = state[key];
+    }
+  }
+  return result;
+};
+
+/** Returns app-level state (keys prefixed with `app:`, prefix stripped). */
+export const useAdkAppState = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return {};
+    return filterByPrefix(asAdkRuntimeExtras(extras).stateDelta, APP_PREFIX);
+  });
+};
+
+/** Returns user-level state (keys prefixed with `user:`, prefix stripped). */
+export const useAdkUserState = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return {};
+    return filterByPrefix(asAdkRuntimeExtras(extras).stateDelta, USER_PREFIX);
+  });
+};
+
+/** Returns temp state (keys prefixed with `temp:`, prefix stripped). Not persisted. */
+export const useAdkTempState = () => {
+  return useAuiState((s) => {
+    const extras = s.thread.extras;
+    if (!extras) return {};
+    return filterByPrefix(asAdkRuntimeExtras(extras).stateDelta, TEMP_PREFIX);
+  });
+};

package/src/index.ts

@@ -0,0 +1,66 @@
+export {
+  useAdkRuntime,
+  type UseAdkRuntimeOptions,
+} from "./useAdkRuntime";
+
+export {
+  useAdkMessages,
+  type UseAdkMessagesOptions,
+} from "./useAdkMessages";
+
+export { convertAdkMessage } from "./convertAdkMessages";
+
+export type {
+  AdkEvent,
+  AdkEventPart,
+  AdkEventActions,
+  AdkMessage,
+  AdkMessageContentPart,
+  AdkToolCall,
+  AdkToolConfirmation,
+  AdkAuthCredential,
+  AdkAuthCredentialType,
+  AdkAuthRequest,
+  AdkMessageMetadata,
+  AdkRunConfig,
+  AdkSendMessageConfig,
+  AdkStreamCallback,
+  AdkStructuredEvent,
+  OnAdkErrorCallback,
+  OnAdkCustomEventCallback,
+  OnAdkAgentTransferCallback,
+} from "./types";
+
+export { AdkEventType } from "./types";
+
+export { toAdkStructuredEvents } from "./structuredEvents";
+
+export { AdkEventAccumulator } from "./AdkEventAccumulator";
+
+export {
+  createAdkStream,
+  type CreateAdkStreamOptions,
+} from "./AdkClient";
+
+export {
+  createAdkSessionAdapter,
+  type AdkSessionAdapterOptions,
+  type AdkArtifactData,
+} from "./AdkSessionAdapter";
+
+export {
+  useAdkAgentInfo,
+  useAdkSessionState,
+  useAdkSend,
+  useAdkLongRunningToolIds,
+  useAdkToolConfirmations,
+  useAdkAuthRequests,
+  useAdkArtifacts,
+  useAdkEscalation,
+  useAdkMessageMetadata,
+  useAdkConfirmTool,
+  useAdkSubmitAuth,
+  useAdkAppState,
+  useAdkUserState,
+  useAdkTempState,
+} from "./hooks";

package/src/server/adkEventStream.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, vi } from "vitest";
+import { adkEventStream } from "./adkEventStream";
+
+async function* yieldEvents(events: unknown[]) {
+  for (const event of events) {
+    yield event as any;
+  }
+}
+
+async function readSSE(response: Response): Promise<string> {
+  const reader = response.body!.getReader();
+  const decoder = new TextDecoder();
+  let result = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    result += decoder.decode(value, { stream: true });
+  }
+  return result;
+}
+
+describe("adkEventStream", () => {
+  it("returns a Response with text/event-stream content-type", () => {
+    const response = adkEventStream(yieldEvents([]));
+    expect(response.headers.get("Content-Type")).toBe("text/event-stream");
+  });
+
+  it("returns Cache-Control: no-cache header", () => {
+    const response = adkEventStream(yieldEvents([]));
+    expect(response.headers.get("Cache-Control")).toBe("no-cache");
+  });
+
+  it("emits an initial :ok SSE comment", async () => {
+    const response = adkEventStream(yieldEvents([]));
+    const text = await readSSE(response);
+    expect(text).toMatch(/^:ok\n\n/);
+  });
+
+  it("serializes events as SSE data lines", async () => {
+    const events = [
+      { id: "e1", content: { parts: [{ text: "hello" }] } },
+      { id: "e2", content: { parts: [{ text: "world" }] } },
+    ];
+    const response = adkEventStream(yieldEvents(events));
+    const text = await readSSE(response);
+    const lines = text.split("\n\n").filter((l) => l.startsWith("data: "));
+    expect(lines).toHaveLength(2);
+    expect(JSON.parse(lines[0]!.slice(6))).toMatchObject({ id: "e1" });
+    expect(JSON.parse(lines[1]!.slice(6))).toMatchObject({ id: "e2" });
+  });
+
+  it("emits an error event when the generator throws", async () => {
+    // biome-ignore lint/correctness/useYield: intentionally throws before yielding
+    async function* throwingGen() {
+      throw new Error("Test error");
+    }
+    const response = adkEventStream(throwingGen() as any);
+    const text = await readSSE(response);
+    const lines = text.split("\n\n").filter((l) => l.startsWith("data: "));
+    expect(lines).toHaveLength(1);
+    const errorEvent = JSON.parse(lines[0]!.slice(6));
+    expect(errorEvent).toMatchObject({
+      errorCode: "STREAM_ERROR",
+      errorMessage: "Test error",
+    });
+  });
+
+  it("calls onError callback when the generator throws", async () => {
+    const onError = vi.fn();
+    // biome-ignore lint/correctness/useYield: intentionally throws before yielding
+    async function* throwingGen() {
+      throw new Error("Test error");
+    }
+    const response = adkEventStream(throwingGen() as any, { onError });
+    await readSSE(response);
+    expect(onError).toHaveBeenCalledTimes(1);
+  });
+});