@assistant-ui/react-google-adk 0.0.1

package/src/server/parseAdkRequest.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect } from "vitest";
+import { parseAdkRequest, toAdkContent } from "./parseAdkRequest";
+
+const makeRequest = (body: unknown) =>
+  new Request("http://localhost", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+describe("parseAdkRequest", () => {
+  it("parses a simple message request", async () => {
+    const result = await parseAdkRequest(makeRequest({ message: "Hello" }));
+    expect(result).toMatchObject({ type: "message", text: "Hello" });
+  });
+
+  it("parses a message request with runConfig and checkpointId", async () => {
+    const result = await parseAdkRequest(
+      makeRequest({
+        message: "Hello",
+        runConfig: { temperature: 0.5 },
+        checkpointId: "cp-123",
+      }),
+    );
+    expect(result.config).toMatchObject({
+      runConfig: { temperature: 0.5 },
+      checkpointId: "cp-123",
+    });
+  });
+
+  it("parses a message request with stateDelta", async () => {
+    const result = await parseAdkRequest(
+      makeRequest({ message: "Hello", stateDelta: { count: 1 } }),
+    );
+    expect(result).toMatchObject({ stateDelta: { count: 1 } });
+  });
+
+  it("parses a message request with parts (multimodal)", async () => {
+    const result = await parseAdkRequest(
+      makeRequest({
+        message: "Look at this",
+        parts: [
+          { text: "Look" },
+          { inlineData: { mimeType: "image/png", data: "abc" } },
+        ],
+      }),
+    );
+    if (result.type !== "message") throw new Error("Expected message type");
+    expect(result.parts).toHaveLength(2);
+  });
+
+  it("parses a tool-result request", async () => {
+    const result = await parseAdkRequest(
+      makeRequest({
+        type: "tool-result",
+        toolCallId: "tc-1",
+        toolName: "search",
+        result: { data: "found" },
+        isError: false,
+      }),
+    );
+    expect(result).toMatchObject({
+      type: "tool-result",
+      toolCallId: "tc-1",
+      toolName: "search",
+      result: { data: "found" },
+      isError: false,
+    });
+  });
+
+  it("defaults isError to false when missing", async () => {
+    const result = await parseAdkRequest(
+      makeRequest({
+        type: "tool-result",
+        toolCallId: "tc-1",
+        result: {},
+      }),
+    );
+    if (result.type !== "tool-result") throw new Error("Expected tool-result");
+    expect(result.isError).toBe(false);
+  });
+
+  it("throws on invalid JSON", async () => {
+    const req = new Request("http://localhost", {
+      method: "POST",
+      body: "not json",
+    });
+    await expect(parseAdkRequest(req)).rejects.toThrow();
+  });
+
+  it("throws on non-object body", async () => {
+    await expect(parseAdkRequest(makeRequest([1, 2, 3]))).rejects.toThrow(
+      "Request body must be a JSON object",
+    );
+  });
+});
+
+describe("toAdkContent", () => {
+  it("converts a text message to user content with text part", () => {
+    const content = toAdkContent({
+      type: "message",
+      text: "Hello",
+      config: {},
+    });
+    expect(content).toEqual({
+      role: "user",
+      parts: [{ text: "Hello" }],
+    });
+  });
+
+  it("converts a multimodal message using raw parts", () => {
+    const content = toAdkContent({
+      type: "message",
+      text: "",
+      parts: [
+        { text: "Look" },
+        { inlineData: { mimeType: "image/png", data: "abc" } },
+      ],
+      config: {},
+    });
+    expect(content).toEqual({
+      role: "user",
+      parts: [
+        { text: "Look" },
+        { inlineData: { mimeType: "image/png", data: "abc" } },
+      ],
+    });
+  });
+
+  it("converts a tool-result to user content with functionResponse part", () => {
+    const content = toAdkContent({
+      type: "tool-result",
+      toolCallId: "tc-1",
+      toolName: "search",
+      result: { found: true },
+      isError: false,
+      config: {},
+    });
+    expect(content).toEqual({
+      role: "user",
+      parts: [
+        {
+          functionResponse: {
+            name: "search",
+            id: "tc-1",
+            response: { found: true },
+          },
+        },
+      ],
+    });
+  });
+});

package/src/server/parseAdkRequest.ts

@@ -0,0 +1,122 @@
+import type { AdkSendMessageConfig } from "../types";
+
+type ParsedAdkRequest =
+  | {
+      type: "message";
+      text: string;
+      parts?: Array<Record<string, unknown>> | undefined;
+      config: AdkSendMessageConfig;
+      stateDelta?: Record<string, unknown> | undefined;
+    }
+  | {
+      type: "tool-result";
+      toolCallId: string;
+      toolName: string;
+      result: unknown;
+      isError: boolean;
+      config: AdkSendMessageConfig;
+      stateDelta?: Record<string, unknown> | undefined;
+    };
+
+/**
+ * Parses an incoming HTTP request into a structured ADK request.
+ *
+ * Supports two request shapes:
+ *
+ * 1. User message:
+ * ```json
+ * { "message": "Hello", "runConfig": {}, "stateDelta": {} }
+ * ```
+ *
+ * 2. Tool result:
+ * ```json
+ * {
+ *   "type": "tool-result",
+ *   "toolCallId": "call_123",
+ *   "toolName": "search",
+ *   "result": { ... },
+ *   "isError": false
+ * }
+ * ```
+ */
+export const parseAdkRequest = async (
+  request: Request,
+): Promise<ParsedAdkRequest> => {
+  let body: Record<string, unknown>;
+  try {
+    body = (await request.json()) as Record<string, unknown>;
+  } catch {
+    throw new Error("Invalid JSON in request body");
+  }
+
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw new Error("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 stateDelta = body.stateDelta as Record<string, unknown> | undefined;
+
+  if (body.type === "tool-result") {
+    return {
+      type: "tool-result",
+      toolCallId: (body.toolCallId as string) ?? "",
+      toolName: (body.toolName as string) ?? "",
+      result: body.result,
+      isError: (body.isError as boolean) ?? false,
+      config,
+      ...(stateDelta != null && { stateDelta }),
+    };
+  }
+
+  return {
+    type: "message",
+    text: (body.message as string) ?? "",
+    ...(body.parts != null && {
+      parts: body.parts as Array<Record<string, unknown>>,
+    }),
+    config,
+    ...(stateDelta != null && { stateDelta }),
+  };
+};
+
+/**
+ * Converts a parsed ADK request into a Google GenAI Content object
+ * suitable for `Runner.runAsync({ newMessage })`.
+ *
+ * @example
+ * ```ts
+ * const parsed = await parseAdkRequest(req);
+ * const newMessage = toAdkContent(parsed);
+ * const events = runner.runAsync({ userId, sessionId, newMessage, stateDelta: parsed.stateDelta });
+ * return adkEventStream(events);
+ * ```
+ */
+export const toAdkContent = (
+  parsed: ParsedAdkRequest,
+): { role: string; parts: Array<Record<string, unknown>> } => {
+  if (parsed.type === "tool-result") {
+    return {
+      role: "user",
+      parts: [
+        {
+          functionResponse: {
+            name: parsed.toolName,
+            id: parsed.toolCallId,
+            response: parsed.result,
+          },
+        },
+      ],
+    };
+  }
+
+  // If raw parts are provided (multimodal), use them directly
+  if (parsed.parts?.length) {
+    return { role: "user", parts: parsed.parts };
+  }
+
+  return { role: "user", parts: [{ text: parsed.text }] };
+};

package/src/structuredEvents.ts

@@ -0,0 +1,81 @@
+import type { AdkEvent, AdkStructuredEvent } from "./types";
+import { isFinalResponse } from "./AdkEventAccumulator";
+
+/**
+ * Converts a raw `AdkEvent` into an array of structured, typed events.
+ * Useful for building custom event renderers.
+ */
+export function toAdkStructuredEvents(event: AdkEvent): AdkStructuredEvent[] {
+  const result: AdkStructuredEvent[] = [];
+
+  if (event.errorCode || event.errorMessage) {
+    const err: AdkStructuredEvent & { type: "error" } = { type: "error" };
+    if (event.errorCode != null) err.errorCode = event.errorCode;
+    if (event.errorMessage != null) err.errorMessage = event.errorMessage;
+    result.push(err);
+  }
+
+  const parts = event.content?.parts;
+  if (parts) {
+    for (const part of parts) {
+      if (part.text != null) {
+        if (part.thought) {
+          result.push({ type: "thought", content: part.text });
+        } else {
+          result.push({ type: "content", content: part.text });
+        }
+      }
+      if (part.functionCall) {
+        const call: AdkStructuredEvent & { type: "tool_call" } = {
+          type: "tool_call",
+          call: { name: part.functionCall.name, args: part.functionCall.args },
+        };
+        if (part.functionCall.id != null) call.call.id = part.functionCall.id;
+        result.push(call);
+      }
+      if (part.functionResponse) {
+        const tr: AdkStructuredEvent & { type: "tool_result" } = {
+          type: "tool_result",
+          result: {
+            name: part.functionResponse.name,
+            response: part.functionResponse.response,
+          },
+        };
+        if (part.functionResponse.id != null)
+          tr.result.id = part.functionResponse.id;
+        result.push(tr);
+      }
+      if (part.executableCode) {
+        const ce: AdkStructuredEvent & { type: "call_code" } = {
+          type: "call_code",
+          code: { code: part.executableCode.code },
+        };
+        if (part.executableCode.language != null)
+          ce.code.language = part.executableCode.language;
+        result.push(ce);
+      }
+      if (part.codeExecutionResult) {
+        const cr: AdkStructuredEvent & { type: "code_result" } = {
+          type: "code_result",
+          result: { output: part.codeExecutionResult.output },
+        };
+        if (part.codeExecutionResult.outcome != null)
+          cr.result.outcome = part.codeExecutionResult.outcome;
+        result.push(cr);
+      }
+    }
+  }
+
+  if (event.actions?.requestedToolConfirmations) {
+    result.push({
+      type: "tool_confirmation",
+      confirmations: event.actions.requestedToolConfirmations,
+    });
+  }
+
+  if (isFinalResponse(event) && result.length === 0) {
+    result.push({ type: "finished" });
+  }
+
+  return result;
+}

package/src/types.ts

@@ -0,0 +1,265 @@
+import type { MessageStatus } from "@assistant-ui/core";
+import type { ReadonlyJSONObject } from "assistant-stream/utils";
+
+// ── ADK Event wire types (lightweight, no @google/adk dependency) ──
+
+export type AdkEventPart = {
+  text?: string;
+  thought?: boolean;
+  functionCall?: {
+    name: string;
+    id?: string;
+    args: Record<string, unknown>;
+  };
+  functionResponse?: {
+    name: string;
+    id?: string;
+    response: unknown;
+  };
+  executableCode?: {
+    code: string;
+    language?: string;
+  };
+  codeExecutionResult?: {
+    output: string;
+    outcome?: string;
+  };
+  inlineData?: {
+    mimeType: string;
+    data: string;
+  };
+  fileData?: {
+    fileUri: string;
+    mimeType?: string;
+  };
+};
+
+export type AdkEventActions = {
+  stateDelta?: Record<string, unknown> | undefined;
+  artifactDelta?: Record<string, number> | undefined;
+  transferToAgent?: string | undefined;
+  escalate?: boolean | undefined;
+  skipSummarization?: boolean | undefined;
+  requestedAuthConfigs?: Record<string, unknown> | undefined;
+  requestedToolConfirmations?: Record<string, unknown> | undefined;
+};
+
+export type AdkEvent = {
+  id: string;
+  invocationId?: string | undefined;
+  author?: string | undefined;
+  branch?: string | undefined;
+  partial?: boolean | undefined;
+  turnComplete?: boolean | undefined;
+  interrupted?: boolean | undefined;
+  finishReason?: string | undefined;
+  timestamp?: number | undefined;
+  content?:
+    | {
+        role?: string | undefined;
+        parts?: AdkEventPart[] | undefined;
+      }
+    | undefined;
+  actions?: AdkEventActions | undefined;
+  longRunningToolIds?: string[] | undefined;
+  errorCode?: string | undefined;
+  errorMessage?: string | undefined;
+  groundingMetadata?: unknown;
+  citationMetadata?: unknown;
+  usageMetadata?: unknown;
+  customMetadata?: Record<string, unknown> | undefined;
+};
+
+// ── ADK Message types (accumulated from events) ──
+
+export type AdkToolCall = {
+  id: string;
+  name: string;
+  args: ReadonlyJSONObject;
+  argsText?: string;
+};
+
+export type AdkMessage =
+  | {
+      id: string;
+      type: "human";
+      content: string | AdkMessageContentPart[];
+    }
+  | {
+      id: string;
+      type: "ai";
+      content: string | AdkMessageContentPart[];
+      tool_calls?: AdkToolCall[] | undefined;
+      author?: string | undefined;
+      branch?: string | undefined;
+      status?: MessageStatus | undefined;
+    }
+  | {
+      id: string;
+      type: "tool";
+      content: string;
+      tool_call_id: string;
+      name: string;
+      status?: "success" | "error" | undefined;
+      artifact?: unknown;
+    };
+
+export type AdkMessageContentPart =
+  | { type: "text"; text: string }
+  | { type: "reasoning"; text: string }
+  | { type: "image"; mimeType: string; data: string }
+  | { type: "image_url"; url: string }
+  | { type: "code"; code: string; language: string }
+  | { type: "code_result"; output: string; outcome: string }
+  | { type: "activity"; message: string };
+
+// ── ADK-specific state types ──
+
+export type AdkToolConfirmation = {
+  toolCallId: string;
+  toolName: string;
+  args: Record<string, unknown>;
+  hint: string;
+  confirmed: boolean;
+  payload?: unknown;
+};
+
+export type AdkAuthCredentialType =
+  | "apiKey"
+  | "http"
+  | "oauth2"
+  | "openIdConnect"
+  | "serviceAccount";
+
+export type AdkAuthCredential = {
+  authType: AdkAuthCredentialType;
+  resourceRef?: string | undefined;
+  apiKey?: string | undefined;
+  http?:
+    | {
+        scheme: string;
+        credentials: {
+          username?: string;
+          password?: string;
+          token?: string;
+        };
+      }
+    | undefined;
+  oauth2?:
+    | {
+        clientId?: string;
+        clientSecret?: string;
+        authUri?: string;
+        state?: string;
+        redirectUri?: string;
+        authResponseUri?: string;
+        authCode?: string;
+        accessToken?: string;
+        refreshToken?: string;
+        expiresAt?: number;
+        expiresIn?: number;
+      }
+    | undefined;
+  serviceAccount?: unknown;
+};
+
+export type AdkAuthRequest = {
+  toolCallId: string;
+  authConfig: unknown;
+};
+
+export type AdkMessageMetadata = {
+  groundingMetadata?: unknown;
+  citationMetadata?: unknown;
+  usageMetadata?: unknown;
+};
+
+// ── RunConfig ──
+
+export type AdkRunConfig = {
+  streamingMode?: "none" | "sse" | "bidi" | undefined;
+  pauseOnToolCalls?: boolean | undefined;
+  maxLlmCalls?: number | undefined;
+  saveInputBlobsAsArtifacts?: boolean | undefined;
+  supportCfc?: boolean | undefined;
+  speechConfig?: unknown;
+  responseModalities?: string[] | undefined;
+  outputAudioTranscription?: unknown;
+  inputAudioTranscription?: unknown;
+  enableAffectiveDialog?: boolean | undefined;
+  proactivity?: unknown;
+  realtimeInputConfig?: unknown;
+};
+
+// ── Stream callback types ──
+
+export type AdkSendMessageConfig = {
+  /**
+   * ADK RunConfig. Typed as `unknown` for compatibility with
+   * assistant-ui core's RunConfig type. Use `AdkRunConfig` when
+   * constructing configs manually for type safety.
+   */
+  runConfig?: unknown;
+  checkpointId?: string | undefined;
+  stateDelta?: Record<string, unknown> | undefined;
+};
+
+// ── Structured events ──
+
+export const AdkEventType = {
+  THOUGHT: "thought",
+  CONTENT: "content",
+  TOOL_CALL: "tool_call",
+  TOOL_RESULT: "tool_result",
+  CALL_CODE: "call_code",
+  CODE_RESULT: "code_result",
+  ERROR: "error",
+  ACTIVITY: "activity",
+  TOOL_CONFIRMATION: "tool_confirmation",
+  FINISHED: "finished",
+} as const;
+
+export type AdkStructuredEvent =
+  | { type: "thought"; content: string }
+  | { type: "content"; content: string }
+  | {
+      type: "tool_call";
+      call: { name: string; id?: string; args: Record<string, unknown> };
+    }
+  | {
+      type: "tool_result";
+      result: { name: string; id?: string; response: unknown };
+    }
+  | { type: "call_code"; code: { code: string; language?: string } }
+  | { type: "code_result"; result: { output: string; outcome?: string } }
+  | { type: "error"; errorCode?: string; errorMessage?: string }
+  | { type: "activity"; message: string }
+  | {
+      type: "tool_confirmation";
+      confirmations: Record<string, unknown>;
+    }
+  | { type: "finished" };
+
+export type AdkStreamCallback = (
+  messages: AdkMessage[],
+  config: AdkSendMessageConfig & {
+    abortSignal: AbortSignal;
+    initialize: () => Promise<{
+      remoteId: string;
+      externalId: string | undefined;
+    }>;
+  },
+) => Promise<AsyncGenerator<AdkEvent>> | AsyncGenerator<AdkEvent>;
+
+// ── Event handler callbacks ──
+
+export type OnAdkErrorCallback = (error: unknown) => void | Promise<void>;
+
+export type OnAdkCustomEventCallback = (
+  type: string,
+  data: unknown,
+) => void | Promise<void>;
+
+export type OnAdkAgentTransferCallback = (
+  toAgent: string,
+) => void | Promise<void>;