@google/adk 0.4.0 → 0.5.0

package/dist/esm/models/llm_response.js

@@ -12,6 +12,7 @@ function createLlmResponse(response) {
       return {
         content: candidate.content,
         groundingMetadata: candidate.groundingMetadata,
+        citationMetadata: candidate.citationMetadata,
         usageMetadata,
         finishReason: candidate.finishReason
       };
@@ -20,6 +21,7 @@ function createLlmResponse(response) {
       errorCode: candidate.finishReason,
       errorMessage: candidate.finishMessage,
       usageMetadata,
+      citationMetadata: candidate.citationMetadata,
       finishReason: candidate.finishReason
     };
   }

package/dist/esm/plugins/base_plugin.js

@@ -198,7 +198,7 @@ class BasePlugin {
      * Callback executed when a tool call encounters an error.
       tool: BaseTool;
       toolArgs: Record<string, unknown>;
-      toolContext: ToolContext;
+      toolContext: Context;
       result: Record<string, unknown>;
     }): Promise<Record<string, unknown> | undefined> {
       return;

package/dist/esm/runner/runner.js

@@ -244,7 +244,7 @@ class Runner {
       return rootAgent.findAgent(event.author) || rootAgent;
     }
     for (let i = session.events.length - 1; i >= 0; i--) {
-      logger.info("event: ", JSON.stringify(session.events[i]));
+      logger.info("event:", JSON.stringify(session.events[i]));
       const event2 = session.events[i];
       if (event2.author === "user" || !event2.author) {
         continue;

package/dist/esm/sessions/database_session_service.js

@@ -38,7 +38,7 @@ class DatabaseSessionService extends BaseSessionService {
     super();
     this.initialized = false;
     if (typeof connectionStringOrOptions === "string") {
-      this.options = getConnectionOptionsFromUri(connectionStringOrOptions);
+      this.connectionString = connectionStringOrOptions;
     } else {
       if (!connectionStringOrOptions.driver) {
         throw new Error("Driver is required when passing options object.");
@@ -53,6 +53,9 @@ class DatabaseSessionService extends BaseSessionService {
     if (this.initialized) {
       return;
     }
+    if (this.connectionString && (!this.options || !this.options.driver)) {
+      this.options = await getConnectionOptionsFromUri(this.connectionString);
+    }
     this.orm = await MikroORM.init(this.options);
     await ensureDatabaseCreated(this.orm);
     await validateDatabaseSchemaVersion(this.orm);

package/dist/esm/sessions/db/operations.js

@@ -1,31 +1,53 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { MikroORM } from "@mikro-orm/core";
-import { MariaDbDriver } from "@mikro-orm/mariadb";
-import { MsSqlDriver } from "@mikro-orm/mssql";
-import { MySqlDriver } from "@mikro-orm/mysql";
-import { PostgreSqlDriver } from "@mikro-orm/postgresql";
-import { SqliteDriver } from "@mikro-orm/sqlite";
 import {
   ENTITIES,
   SCHEMA_VERSION_1_JSON,
   SCHEMA_VERSION_KEY,
   StorageMetadata
 } from "./schema.js";
-function getConnectionOptionsFromUri(uri) {
+async function getConnectionOptionsFromUri(uri) {
   let driver;
   if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
+    const { PostgreSqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/postgresql"), 1));
     driver = PostgreSqlDriver;
   } else if (uri.startsWith("mysql://")) {
+    const { MySqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mysql"), 1));
     driver = MySqlDriver;
   } else if (uri.startsWith("mariadb://")) {
+    const { MariaDbDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mariadb"), 1));
     driver = MariaDbDriver;
   } else if (uri.startsWith("sqlite://")) {
+    const { SqliteDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/sqlite"), 1));
     driver = SqliteDriver;
   } else if (uri.startsWith("mssql://")) {
+    const { MsSqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mssql"), 1));
     driver = MsSqlDriver;
   } else {
     throw new Error(`Unsupported database URI: ${uri}`);
@@ -54,7 +76,9 @@ async function ensureDatabaseCreated(ormOrUrlOrOptions) {
   if (ormOrUrlOrOptions instanceof MikroORM) {
     orm = ormOrUrlOrOptions;
   } else if (typeof ormOrUrlOrOptions === "string") {
-    orm = await MikroORM.init(getConnectionOptionsFromUri(ormOrUrlOrOptions));
+    orm = await MikroORM.init(
+      await getConnectionOptionsFromUri(ormOrUrlOrOptions)
+    );
   } else {
     orm = await MikroORM.init(ormOrUrlOrOptions);
   }

package/dist/esm/tools/base_tool.js

@@ -54,6 +54,9 @@ class BaseTool {
     if (!functionDeclaration) {
       return;
     }
+    if (this.name in llmRequest.toolsDict) {
+      throw new Error(`Duplicate tool name: ${this.name}`);
+    }
     llmRequest.toolsDict[this.name] = this;
     const tool = findToolWithFunctionDeclarations(llmRequest);
     if (tool) {

package/dist/esm/tools/base_toolset.js

@@ -3,9 +3,17 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
+const BASE_TOOLSET_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseToolset");
+function isBaseToolset(obj) {
+  return typeof obj === "object" && obj !== null && BASE_TOOLSET_SIGNATURE_SYMBOL in obj && obj[BASE_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+_a = BASE_TOOLSET_SIGNATURE_SYMBOL;
 class BaseToolset {
-  constructor(toolFilter) {
+  constructor(toolFilter, prefix) {
     this.toolFilter = toolFilter;
+    this.prefix = prefix;
+    this[_a] = true;
   }
   /**
    * Returns whether the tool should be exposed to LLM.
@@ -42,5 +50,6 @@ class BaseToolset {
   }
 }
 export {
-  BaseToolset
+  BaseToolset,
+  isBaseToolset
 };

package/dist/esm/tools/exit_loop_tool.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseTool } from "./base_tool.js";
+class ExitLoopTool extends BaseTool {
+  constructor() {
+    super({
+      name: "exit_loop",
+      description: "Exits the loop.\n\nCall this function only when you are instructed to do so."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description
+    };
+  }
+  async runAsync({
+    toolContext
+  }) {
+    toolContext.actions.escalate = true;
+    toolContext.actions.skipSummarization = true;
+    return "";
+  }
+}
+const EXIT_LOOP = new ExitLoopTool();
+export {
+  EXIT_LOOP,
+  ExitLoopTool
+};

package/dist/esm/tools/mcp/mcp_toolset.js

@@ -8,8 +8,8 @@ import { BaseToolset } from "../base_toolset.js";
 import { MCPSessionManager } from "./mcp_session_manager.js";
 import { MCPTool } from "./mcp_tool.js";
 class MCPToolset extends BaseToolset {
-  constructor(connectionParams, toolFilter = []) {
-    super(toolFilter);
+  constructor(connectionParams, toolFilter = [], prefix) {
+    super(toolFilter, prefix);
     this.mcpSessionManager = new MCPSessionManager(connectionParams);
   }
   async getTools() {
@@ -19,9 +19,13 @@ class MCPToolset extends BaseToolset {
     for (const tool of listResult.tools) {
       logger.debug(`tool: ${tool.name}`);
     }
-    return listResult.tools.map(
-      (tool) => new MCPTool(tool, this.mcpSessionManager)
-    );
+    return listResult.tools.map((tool) => {
+      const toolWithPrefix = {
+        ...tool,
+        name: this.prefix ? `${this.prefix}_${tool.name}` : tool.name
+      };
+      return new MCPTool(toolWithPrefix, this.mcpSessionManager);
+    });
   }
   async close() {
   }

package/dist/esm/utils/logger.js

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import * as winston from "winston";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
   LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
@@ -10,58 +11,68 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
   return LogLevel2;
 })(LogLevel || {});
-let logLevel = 1 /* INFO */;
-function setLogLevel(level) {
-  logLevel = level;
-}
 class SimpleLogger {
-  log(level, ...args) {
-    if (level < logLevel) {
+  constructor() {
+    this.logLevel = 1 /* INFO */;
+    this.logger = winston.createLogger({
+      levels: {
+        "debug": 0 /* DEBUG */,
+        "info": 1 /* INFO */,
+        "warn": 2 /* WARN */,
+        "error": 3 /* ERROR */
+      },
+      format: winston.format.combine(
+        winston.format.label({ label: "ADK" }),
+        winston.format((info) => {
+          info.level = info.level.toUpperCase();
+          return info;
+        })(),
+        winston.format.colorize(),
+        winston.format.timestamp(),
+        winston.format.printf((info) => {
+          return `${info.level}: [${info.label}] ${info.timestamp} ${info.message}`;
+        })
+      ),
+      transports: [new winston.transports.Console()]
+    });
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  log(level, ...messages) {
+    if (this.logLevel > level) {
       return;
     }
-    switch (level) {
-      case 0 /* DEBUG */:
-        this.debug(...args);
-        break;
-      case 1 /* INFO */:
-        this.info(...args);
-        break;
-      case 2 /* WARN */:
-        this.warn(...args);
-        break;
-      case 3 /* ERROR */:
-        this.error(...args);
-        break;
-      default:
-        throw new Error(`Unsupported log level: ${level}`);
-    }
+    this.logger.log(level.toString(), messages.join(" "));
   }
-  debug(...args) {
-    if (logLevel > 0 /* DEBUG */) {
+  debug(...messages) {
+    if (this.logLevel > 0 /* DEBUG */) {
       return;
     }
-    console.debug(getColoredPrefix(0 /* DEBUG */), ...args);
+    this.logger.debug(messages.join(" "));
   }
-  info(...args) {
-    if (logLevel > 1 /* INFO */) {
+  info(...messages) {
+    if (this.logLevel > 1 /* INFO */) {
       return;
     }
-    console.info(getColoredPrefix(1 /* INFO */), ...args);
+    this.logger.info(messages.join(" "));
   }
-  warn(...args) {
-    if (logLevel > 2 /* WARN */) {
+  warn(...messages) {
+    if (this.logLevel > 2 /* WARN */) {
       return;
     }
-    console.warn(getColoredPrefix(2 /* WARN */), ...args);
+    this.logger.warn(messages.join(" "));
   }
-  error(...args) {
-    if (logLevel > 3 /* ERROR */) {
+  error(...messages) {
+    if (this.logLevel > 3 /* ERROR */) {
       return;
     }
-    console.error(getColoredPrefix(3 /* ERROR */), ...args);
+    this.logger.error(messages.join(" "));
   }
 }
 class NoOpLogger {
+  setLogLevel(_level) {
+  }
   log(_level, ..._args) {
   }
   debug(..._args) {
@@ -73,26 +84,6 @@ class NoOpLogger {
   error(..._args) {
   }
 }
-const LOG_LEVEL_STR = {
-  [0 /* DEBUG */]: "DEBUG",
-  [1 /* INFO */]: "INFO",
-  [2 /* WARN */]: "WARN",
-  [3 /* ERROR */]: "ERROR"
-};
-const CONSOLE_COLOR_MAP = {
-  [0 /* DEBUG */]: "\x1B[34m",
-  // Blue
-  [1 /* INFO */]: "\x1B[32m",
-  // Green
-  [2 /* WARN */]: "\x1B[33m",
-  // Yellow
-  [3 /* ERROR */]: "\x1B[31m"
-  // Red
-};
-const RESET_COLOR = "\x1B[0m";
-function getColoredPrefix(level) {
-  return `${CONSOLE_COLOR_MAP[level]}[ADK ${LOG_LEVEL_STR[level]}]:${RESET_COLOR}`;
-}
 let currentLogger = new SimpleLogger();
 function setLogger(customLogger) {
   currentLogger = customLogger != null ? customLogger : new NoOpLogger();
@@ -103,7 +94,13 @@ function getLogger() {
 function resetLogger() {
   currentLogger = new SimpleLogger();
 }
+function setLogLevel(level) {
+  logger.setLogLevel(level);
+}
 const logger = {
+  setLogLevel(level) {
+    currentLogger.setLogLevel(level);
+  },
   log(level, ...args) {
     currentLogger.log(level, ...args);
   },

package/dist/esm/version.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "0.4.0";
+const version = "0.5.0";
 export {
   version
 };

package/dist/types/a2a/a2a_event.d.ts

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part as A2APart, Message, Task, TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+/**
+ * Message roles.
+ */
+export declare enum MessageRole {
+    USER = "user",
+    AGENT = "agent"
+}
+/**
+ * A2A event.
+ */
+export type A2AEvent = Task | Message | TaskStatusUpdateEvent | TaskArtifactUpdateEvent;
+/**
+ * Checks if the event is an A2A TaskStatusUpdateEvent.
+ */
+export declare function isTaskStatusUpdateEvent(event: unknown): event is TaskStatusUpdateEvent;
+/**
+ * Checks if the event is an A2A TaskArtifactUpdateEvent.
+ */
+export declare function isTaskArtifactUpdateEvent(event: unknown): event is TaskArtifactUpdateEvent;
+/**
+ * Checks if the event is an A2A Message.
+ */
+export declare function isMessage(event: unknown): event is Message;
+/**
+ * Checks if the event is an A2A Task.
+ */
+export declare function isTask(event: unknown): event is Task;
+/**
+ * Gets the metadata from an A2A event.
+ */
+export declare function getEventMetadata(event: A2AEvent): Record<string, unknown>;
+/**
+ * Checks if the event is a failed task status update event.
+ */
+export declare function isFailedTaskStatusUpdateEvent(event: unknown): boolean;
+/**
+ * Checks if the event is a terminal task status update event.
+ */
+export declare function isTerminalTaskStatusUpdateEvent(event: unknown): boolean;
+/**
+ * Checks if the event is an input required task status update event.
+ */
+export declare function isInputRequiredTaskStatusUpdateEvent(event: unknown): boolean;
+/**
+ * Gets the error message from a failed task status update event.
+ */
+export declare function getFailedTaskStatusUpdateEventError(event: TaskStatusUpdateEvent | Task): string | undefined;
+/**
+ * Creates a task submitted event.
+ */
+export declare function createTaskSubmittedEvent({ taskId, contextId, message, }: {
+    taskId: string;
+    contextId: string;
+    message: Message;
+}): TaskStatusUpdateEvent;
+/**
+ * Creates a task with submitted status.
+ */
+export declare function createTask({ contextId, message, taskId, }: {
+    taskId: string;
+    contextId: string;
+    message: Message;
+}): Task;
+/**
+ * Creates a task working event.
+ */
+export declare function createTaskWorkingEvent({ taskId, contextId, message, }: {
+    taskId: string;
+    contextId: string;
+    message: Message;
+}): TaskStatusUpdateEvent;
+/**
+ * Creates a task completed event.
+ */
+export declare function createTaskCompletedEvent({ taskId, contextId, metadata, }: {
+    taskId: string;
+    contextId: string;
+    metadata?: Record<string, unknown>;
+}): TaskStatusUpdateEvent;
+/**
+ * Creates an artifact update event.
+ */
+export declare function createTaskArtifactUpdateEvent({ taskId, contextId, artifactId, parts, metadata, append, lastChunk, }: {
+    taskId: string;
+    contextId: string;
+    artifactId?: string;
+    parts?: A2APart[];
+    metadata?: Record<string, unknown>;
+    append?: boolean;
+    lastChunk?: boolean;
+}): TaskArtifactUpdateEvent;
+/**
+ * Creates an error message for task execution failure.
+ */
+export declare function createTaskFailedEvent({ taskId, contextId, error, metadata, }: {
+    taskId: string;
+    contextId: string;
+    error: Error;
+    metadata?: Record<string, unknown>;
+}): TaskStatusUpdateEvent;
+/**
+ * Creates an input required event.
+ */
+export declare function createTaskInputRequiredEvent({ taskId, contextId, parts, }: {
+    taskId: string;
+    contextId: string;
+    parts: A2APart[];
+}): TaskStatusUpdateEvent;
+/**
+ * Creates an error message for missing input for a function call.
+ */
+export declare function createInputMissingErrorEvent({ taskId, contextId, parts, }: {
+    parts: A2APart[];
+    taskId: string;
+    contextId: string;
+}): TaskStatusUpdateEvent;

package/dist/types/a2a/event_converter_utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Message } from '@a2a-js/sdk';
+import { Event as AdkEvent } from '../events/event.js';
+import { A2AEvent } from './a2a_event.js';
+/**
+ * Converts a session Event to an A2A Message.
+ */
+export declare function toA2AMessage(event: AdkEvent, { appName, userId, sessionId, }: {
+    appName: string;
+    userId: string;
+    sessionId: string;
+}): Message;
+/**
+ * Converts an A2A Event to a Session Event.
+ */
+export declare function toAdkEvent(event: A2AEvent, invocationId: string, agentName: string): AdkEvent | undefined;

package/dist/types/a2a/executor_context.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { RequestContext } from '@a2a-js/sdk/server';
+import { Content } from '@google/genai';
+import { Event } from '../events/event.js';
+import { Session } from '../sessions/session.js';
+/**
+ * The A2A Agent Executor context.
+ */
+export interface ExecutorContext {
+    userId: string;
+    sessionId: string;
+    agentName: string;
+    readonlyState: Record<string, unknown>;
+    events: Event[];
+    userContent: Content;
+    requestContext: RequestContext;
+}
+/**
+ * Creates an A2A Agent Executor context from the given parameters.
+ * @param session The session.
+ * @param userContent The content of the user.
+ * @param requestContext The request context.
+ * @returns The A2A Agent Executor context.
+ */
+export declare function createExecutorContext({ session, userContent, requestContext, }: {
+    session: Session;
+    userContent: Content;
+    requestContext: RequestContext;
+}): ExecutorContext;

package/dist/types/a2a/metadata_converter_utils.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event as AdkEvent } from '../events/event.js';
+import { EventActions as AdkEventActions } from '../events/event_actions.js';
+import { A2AEvent } from './a2a_event.js';
+/**
+ * Keys for metadata that will be stored in A2A message metadata and related to ADK events.
+ */
+export declare enum A2AMetadataKeys {
+    APP_NAME = "adk_app_name",
+    USER_ID = "adk_user_id",
+    SESSION_ID = "adk_session_id",
+    INVOCATION_ID = "adk_invocation_id",
+    AUTHOR = "adk_author",
+    BRANCH = "adk_branch",
+    DATA_PART_TYPE = "adk_type",
+    PARTIAL = "adk_partial",
+    ESCALATE = "adk_escalate",
+    TRANSFER_TO_AGENT = "adk_transfer_to_agent",
+    IS_LONG_RUNNING = "adk_is_long_running",
+    THOUGHT = "adk_thought",
+    ERROR_CODE = "adk_error_code",
+    ERROR_MESSAGE = "adk_error_message",
+    CITATION_METADATA = "adk_citation_metadata",
+    GROUNDING_METADATA = "adk_grounding_metadata",
+    USAGE_METADATA = "adk_usage_metadata",
+    CUSTOM_METADATA = "adk_custom_metadata"
+}
+/**
+ * Keys for metadata that will be stored in ADK event metadata and related to A2A messages.
+ */
+export declare enum AdkMetadataKeys {
+    TASK_ID = "a2a:task_id",
+    CONTEXT_ID = "a2a:context_id"
+}
+/**
+ * Creates ADK Event metadata from an A2A Event.
+ */
+export declare function getAdkEventMetadata(a2aEvent: A2AEvent): Record<string, unknown>;
+/**
+ * Creates A2A Event metadata from an ADK Event.
+ */
+export declare function getA2AEventMetadata(adkEvent: AdkEvent, { appName, userId, sessionId, }: {
+    appName: string;
+    userId: string;
+    sessionId: string;
+}): Record<string, unknown>;
+/**
+ * Creates A2A Session metadata from ADK Event invocation metadata.
+ */
+export declare function getA2ASessionMetadata({ appName, userId, sessionId, }: {
+    appName: string;
+    userId: string;
+    sessionId: string;
+}): Record<string, unknown>;
+/**
+ * Creates A2A Event metadata from ADK Event actions.
+ */
+export declare function getA2AEventMetadataFromActions(actions: AdkEventActions): Record<string, unknown>;

package/dist/types/a2a/part_converter_utils.d.ts

@@ -3,12 +3,12 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { DataPart as A2ADataPart, FilePart as A2AFilePart, Part as A2APart, TextPart as A2ATextPart } from '@a2a-js/sdk';
-import { Part as GenAIPart } from '@google/genai';
+import { DataPart as A2ADataPart, FilePart as A2AFilePart, Part as A2APart, TextPart as A2ATextPart, Message } from '@a2a-js/sdk';
+import { Content as GenAIContent, Part as GenAIPart } from '@google/genai';
 /**
  * Converts GenAI Parts to A2A Parts.
  */
-export declare function toA2AParts(parts: GenAIPart[], longRunningToolIDs?: string[]): A2APart[];
+export declare function toA2AParts(parts?: GenAIPart[], longRunningToolIDs?: string[]): A2APart[];
 /**
  * Converts a GenAI Part to an A2A Part.
  */
@@ -25,6 +25,7 @@ export declare function toA2AFilePart(part: GenAIPart): A2APart;
  * Converts a GenAI Data Part to an A2A Data Part.
  */
 export declare function toA2ADataPart(part: GenAIPart, longRunningToolIDs?: string[]): A2APart;
+export declare function toGenAIContent(a2aMessage: Message): GenAIContent;
 /**
  * Converts an A2A Part to a GenAI Part.
  */

package/dist/types/agents/base_agent.d.ts

@@ -5,12 +5,12 @@
  */
 import { Content } from '@google/genai';
 import { Event } from '../events/event.js';
-import { CallbackContext } from './callback_context.js';
+import { Context } from './context.js';
 import { InvocationContext } from './invocation_context.js';
 /**
  * A single callback function for an agent.
  */
-export type SingleAgentCallback = (context: CallbackContext) => Promise<Content | undefined> | (Content | undefined);
+export type SingleAgentCallback = (context: Context) => Promise<Content | undefined> | (Content | undefined);
 /**
  * Type for before agent callbacks, which can be a single callback or
  * an array of callbacks.