@google/adk 0.2.4 → 0.2.5

package/dist/esm/plugins/base_plugin.js

@@ -19,13 +19,13 @@ class BasePlugin {
    * This callback helps logging and modifying the user message before the
    * runner starts the invocation.
    *
-   * @param invocationContext The context for the entire invocation.
-   * @param userMessage The message content input by user.
+   * @param params.invocationContext The context for the entire invocation.
+   * @param params.userMessage The message content input by user.
    * @returns An optional `Content` to be returned to the ADK. Returning a
    *     value to replace the user message. Returning `undefined` to proceed
    *     normally.
    */
-  async onUserMessageCallback({ invocationContext, userMessage }) {
+  async onUserMessageCallback(params) {
     return;
   }
   /**
@@ -34,13 +34,13 @@ class BasePlugin {
    * This is the first callback to be called in the lifecycle, ideal for global
    * setup or initialization tasks.
    *
-   * @param invocationContext The context for the entire invocation, containing
+   * @param params.invocationContext The context for the entire invocation, containing
    *     session information, the root agent, etc.
    * @returns An optional `Event` to be returned to the ADK. Returning a value
    *     to halt execution of the runner and ends the runner with that event.
    *     Return `undefined` to proceed normally.
    */
-  async beforeRunCallback({ invocationContext }) {
+  async beforeRunCallback(params) {
     return;
   }
   /**
@@ -49,13 +49,13 @@ class BasePlugin {
    * This is the ideal place to make modification to the event before the event
    * is handled by the underlying agent app.
    *
-   * @param invocationContext The context for the entire invocation.
-   * @param event The event raised by the runner.
+   * @param params.invocationContext The context for the entire invocation.
+   * @param params.event The event raised by the runner.
    * @returns An optional value. A non-`undefined` return may be used by the
    *     framework to modify or replace the response. Returning `undefined`
    *     allows the original response to be used.
    */
-  async onEventCallback({ invocationContext, event }) {
+  async onEventCallback(params) {
     return;
   }
   /**
@@ -64,10 +64,10 @@ class BasePlugin {
    * This is the final callback in the ADK lifecycle, suitable for cleanup,
    * final logging, or reporting tasks.
    *
-   * @param invocationContext The context for the entire invocation.
+   * @param params.invocationContext The context for the entire invocation.
    * @returns undefined
    */
-  async afterRunCallback({ invocationContext }) {
+  async afterRunCallback(params) {
     return;
   }
   /**
@@ -76,13 +76,13 @@ class BasePlugin {
    * This callback can be used for logging, setup, or to short-circuit the
    * agent's execution by returning a value.
    *
-   * @param agent The agent that is about to run.
-   * @param callbackContext The context for the agent invocation.
+   * @param params.agent The agent that is about to run.
+   * @param params.callbackContext The context for the agent invocation.
    * @returns An optional `Content` object. If a value is returned, it will
    *     bypass the agent's callbacks and its execution, and return this value
    *     directly. Returning `undefined` allows the agent to proceed normally.
    */
-  async beforeAgentCallback({ agent, callbackContext }) {
+  async beforeAgentCallback(params) {
     return;
   }
   /**
@@ -91,13 +91,13 @@ class BasePlugin {
    * This callback can be used to inspect, log, or modify the agent's final
    * result before it is returned.
    *
-   * @param agent The agent that has just run.
-   * @param callbackContext The context for the agent invocation.
+   * @param params.agent The agent that has just run.
+   * @param params.callbackContext The context for the agent invocation.
    * @returns An optional `Content` object. If a value is returned, it will
    *     replace the agent's original result. Returning `undefined` uses the
    *     original, unmodified result.
    */
-  async afterAgentCallback({ agent, callbackContext }) {
+  async afterAgentCallback(params) {
     return;
   }
   /**
@@ -107,13 +107,13 @@ class BasePlugin {
    * object. It can also be used to implement caching by returning a cached
    * `LlmResponse`, which would skip the actual model call.
    *
-   * @param callbackContext The context for the current agent call.
-   * @param llmRequest The prepared request object to be sent to the model.
+   * @param params.callbackContext The context for the current agent call.
+   * @param params.llmRequest The prepared request object to be sent to the model.
    * @returns An optional value. The interpretation of a non-`undefined`
    *     trigger an early exit and returns the response immediately. Returning
    *     `undefined` allows the LLM request to proceed normally.
    */
-  async beforeModelCallback({ callbackContext, llmRequest }) {
+  async beforeModelCallback(params) {
     return;
   }
   /**
@@ -122,13 +122,13 @@ class BasePlugin {
    * This is the ideal place to log model responses, collect metrics on token
    * usage, or perform post-processing on the raw `LlmResponse`.
    *
-   * @param callbackContext The context for the current agent call.
-   * @param llmResponse The response object received from the model.
+   * @param params.callbackContext The context for the current agent call.
+   * @param params.llmResponse The response object received from the model.
    * @returns An optional value. A non-`undefined` return may be used by the
    *     framework to modify or replace the response. Returning `undefined`
    *     allows the original response to be used.
    */
-  async afterModelCallback({ callbackContext, llmResponse }) {
+  async afterModelCallback(params) {
     return;
   }
   /**
@@ -137,15 +137,15 @@ class BasePlugin {
    * This callback provides an opportunity to handle model errors gracefully,
    * potentially providing alternative responses or recovery mechanisms.
    *
-   * @param callbackContext The context for the current agent call.
-   * @param llmRequest The request that was sent to the model when the error
+   * @param params.callbackContext The context for the current agent call.
+   * @param params.llmRequest The request that was sent to the model when the error
    *     occurred.
-   * @param error The exception that was raised during model execution.
+   * @param params.error The exception that was raised during model execution.
    * @returns An optional LlmResponse. If an LlmResponse is returned, it will be
    *     used instead of propagating the error. Returning `undefined` allows
    *     the original error to be raised.
    */
-  async onModelErrorCallback({ callbackContext, llmRequest, error }) {
+  async onModelErrorCallback(params) {
     return;
   }
   /**
@@ -154,15 +154,15 @@ class BasePlugin {
    * This callback is useful for logging tool usage, input validation, or
    * modifying the arguments before they are passed to the tool.
    *
-   * @param tool The tool instance that is about to be executed.
-   * @param toolArgs The dictionary of arguments to be used for invoking the
+   * @param params.tool The tool instance that is about to be executed.
+   * @param params.toolArgs The dictionary of arguments to be used for invoking the
    *     tool.
-   * @param toolContext The context specific to the tool execution.
+   * @param params.toolContext The context specific to the tool execution.
    * @returns An optional dictionary. If a dictionary is returned, it will stop
    *     the tool execution and return this response immediately. Returning
    *     `undefined` uses the original, unmodified arguments.
    */
-  async beforeToolCallback({ tool, toolArgs, toolContext }) {
+  async beforeToolCallback(params) {
     return;
   }
   /**
@@ -171,33 +171,43 @@ class BasePlugin {
    * This callback allows for inspecting, logging, or modifying the result
    * returned by a tool.
    *
-   * @param tool The tool instance that has just been executed.
-   * @param toolArgs The original arguments that were passed to the tool.
-   * @param toolContext The context specific to the tool execution.
-   * @param result The dictionary returned by the tool invocation.
+   * @param params.tool The tool instance that has just been executed.
+   * @param params.toolArgs The original arguments that were passed to the tool.
+   * @param params.toolContext The context specific to the tool execution.
+   * @param params.result The dictionary returned by the tool invocation.
    * @returns An optional dictionary. If a dictionary is returned, it will
    *     **replace** the original result from the tool. This allows for
    *     post-processing or altering tool outputs. Returning `undefined` uses
    *     the original, unmodified result.
    */
-  async afterToolCallback({ tool, toolArgs, toolContext, result }) {
+  async afterToolCallback(params) {
     return;
   }
   /**
-   * Callback executed when a tool call encounters an error.
-   *
-   * This callback provides an opportunity to handle tool errors gracefully,
-   * potentially providing alternative responses or recovery mechanisms.
-   *
-   * @param tool The tool instance that encountered an error.
-   * @param toolArgs The arguments that were passed to the tool.
-   * @param toolContext The context specific to the tool execution.
-   * @param error The exception that was raised during tool execution.
-   * @returns An optional dictionary. If a dictionary is returned, it will be
-   *     used as the tool response instead of propagating the error. Returning
-   *     `undefined` allows the original error to be raised.
-   */
-  async onToolErrorCallback({ tool, toolArgs, toolContext, error }) {
+     * Callback executed when a tool call encounters an error.
+      tool: BaseTool;
+      toolArgs: Record<string, unknown>;
+      toolContext: ToolContext;
+      result: Record<string, unknown>;
+    }): Promise<Record<string, unknown> | undefined> {
+      return;
+    }
+  
+    /**
+     * Callback executed when a tool call encounters an error.
+     *
+     * This callback provides an opportunity to handle tool errors gracefully,
+     * potentially providing alternative responses or recovery mechanisms.
+     *
+     * @param params.tool The tool instance that encountered an error.
+     * @param params.toolArgs The arguments that were passed to the tool.
+     * @param params.toolContext The context specific to the tool execution.
+     * @param params.error The exception that was raised during tool execution.
+     * @returns An optional dictionary. If a dictionary is returned, it will be
+     *     used as the tool response instead of propagating the error. Returning
+     *     `undefined` allows the original error to be raised.
+     */
+  async onToolErrorCallback(params) {
     return;
   }
 }

package/dist/esm/plugins/security_plugin.js

@@ -79,7 +79,10 @@ class SecurityPlugin extends BasePlugin {
     toolArgs,
     toolContext
   }) {
-    const policyCheckResult = await this.policyEngine.evaluate({ tool, toolArgs });
+    const policyCheckResult = await this.policyEngine.evaluate({
+      tool,
+      toolArgs
+    });
     this.setToolCallCheckState(toolContext, policyCheckResult.outcome);
     switch (policyCheckResult.outcome) {
       case "DENY" /* DENY */:

package/dist/esm/runner/runner.js

@@ -5,10 +5,16 @@
  */
 import { createPartFromText } from "@google/genai";
 import { trace } from "@opentelemetry/api";
-import { InvocationContext, newInvocationContextId } from "../agents/invocation_context.js";
-import { LlmAgent } from "../agents/llm_agent.js";
+import {
+  InvocationContext,
+  newInvocationContextId
+} from "../agents/invocation_context.js";
+import { isLlmAgent } from "../agents/llm_agent.js";
 import { createRunConfig } from "../agents/run_config.js";
-import { BuiltInCodeExecutor } from "../code_executors/built_in_code_executor.js";
+import {
+  BuiltInCodeExecutor,
+  isBuiltInCodeExecutor
+} from "../code_executors/built_in_code_executor.js";
 import { createEvent, getFunctionCalls } from "../events/event.js";
 import { createEventActions } from "../events/event_actions.js";
 import { PluginManager } from "../plugins/plugin_manager.js";
@@ -29,26 +35,26 @@ class Runner {
    * Runs the agent with the given message, and returns an async generator of
    * events.
    *
-   * @param userId The user ID of the session.
-   * @param sessionId The session ID of the session.
-   * @param newMessage A new message to append to the session.
-   * @param stateDelta An optional state delta to apply to the session.
-   * @param runConfig The run config for the agent.
+   * @param params.userId The user ID of the session.
+   * @param params.sessionId The session ID of the session.
+   * @param params.newMessage A new message to append to the session.
+   * @param params.stateDelta An optional state delta to apply to the session.
+   * @param params.runConfig The run config for the agent.
    * @yields The events generated by the agent.
    */
   // TODO - b/425992518: user, sessionId, and runConfig can be internalized.
-  async *runAsync({
-    userId,
-    sessionId,
-    newMessage,
-    stateDelta,
-    runConfig
-  }) {
+  async *runAsync(params) {
     var _a;
-    runConfig = createRunConfig(runConfig);
+    const { userId, sessionId, stateDelta } = params;
+    const runConfig = createRunConfig(params.runConfig);
+    let newMessage = params.newMessage;
     const span = trace.getTracer("gcp.vertex.agent").startSpan("invocation");
     try {
-      const session = await this.sessionService.getSession({ appName: this.appName, userId, sessionId });
+      const session = await this.sessionService.getSession({
+        appName: this.appName,
+        userId,
+        sessionId
+      });
       if (!session) {
         if (!this.appName) {
           throw new Error(
@@ -57,12 +63,14 @@ class Runner {
         }
         throw new Error(`Session not found: ${sessionId}`);
       }
-      if (runConfig.supportCfc && this.agent instanceof LlmAgent) {
+      if (runConfig.supportCfc && isLlmAgent(this.agent)) {
         const modelName = this.agent.canonicalModel.model;
         if (!isGemini2OrAbove(modelName)) {
-          throw new Error(`CFC is not supported for model: ${modelName} in agent: ${this.agent.name}`);
+          throw new Error(
+            `CFC is not supported for model: ${modelName} in agent: ${this.agent.name}`
+          );
         }
-        if (!(this.agent.codeExecutor instanceof BuiltInCodeExecutor)) {
+        if (!isBuiltInCodeExecutor(this.agent.codeExecutor)) {
           this.agent.codeExecutor = new BuiltInCodeExecutor();
         }
       }
@@ -107,7 +115,10 @@ class Runner {
           })
         });
       }
-      invocationContext.agent = this.determineAgentForResumption(session, this.agent);
+      invocationContext.agent = this.determineAgentForResumption(
+        session,
+        this.agent
+      );
       const beforeRunCallbackResponse = await this.pluginManager.runBeforeRunCallback({ invocationContext });
       if (beforeRunCallbackResponse) {
         const earlyExitEvent = createEvent({
@@ -124,9 +135,10 @@ class Runner {
           if (!event.partial) {
             await this.sessionService.appendEvent({ session, event });
           }
-          const modifiedEvent = await this.pluginManager.runOnEventCallback(
-            { invocationContext, event }
-          );
+          const modifiedEvent = await this.pluginManager.runOnEventCallback({
+            invocationContext,
+            event
+          });
           if (modifiedEvent) {
             yield modifiedEvent;
           } else {
@@ -193,7 +205,9 @@ class Runner {
       }
       const agent = rootAgent.findSubAgent(event2.author);
       if (!agent) {
-        logger.warn(`Event from an unknown agent: ${event2.author}, event id: ${event2.id}`);
+        logger.warn(
+          `Event from an unknown agent: ${event2.author}, event id: ${event2.id}`
+        );
         continue;
       }
       if (this.isRoutableLlmAgent(agent)) {
@@ -216,7 +230,7 @@ class Runner {
   isRoutableLlmAgent(agentToRun) {
     let agent = agentToRun;
     while (agent) {
-      if (!(agent instanceof LlmAgent)) {
+      if (!isLlmAgent(agent)) {
         return false;
       }
       if (agent.disallowTransferToParent) {
@@ -234,7 +248,9 @@ function findEventByLastFunctionResponseId(events) {
     return null;
   }
   const lastEvent = events[events.length - 1];
-  const functionCallId = (_d = (_c = (_b = (_a = lastEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.find((part) => part.functionResponse)) == null ? void 0 : _c.functionResponse) == null ? void 0 : _d.id;
+  const functionCallId = (_d = (_c = (_b = (_a = lastEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.find(
+    (part) => part.functionResponse
+  )) == null ? void 0 : _c.functionResponse) == null ? void 0 : _d.id;
   if (!functionCallId) {
     return null;
   }

package/dist/esm/tools/agent_tool.js

@@ -3,25 +3,32 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a, _b;
 import { Type } from "@google/genai";
-import { LlmAgent } from "../agents/llm_agent.js";
+import { isLlmAgent } from "../agents/llm_agent.js";
 import { InMemoryMemoryService } from "../memory/in_memory_memory_service.js";
 import { Runner } from "../runner/runner.js";
 import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
 import { GoogleLLMVariant } from "../utils/variant_utils.js";
 import { BaseTool } from "./base_tool.js";
 import { ForwardingArtifactService } from "./forwarding_artifact_service.js";
-class AgentTool extends BaseTool {
+const AGENT_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.agentTool");
+function isAgentTool(obj) {
+  return typeof obj === "object" && obj !== null && AGENT_TOOL_SIGNATURE_SYMBOL in obj && obj[AGENT_TOOL_SIGNATURE_SYMBOL] === true;
+}
+class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
   constructor(config) {
     super(
       { name: config.agent.name, description: config.agent.description || "" }
     );
+    /** A unique symbol to identify ADK agent tool class. */
+    this[_a] = true;
     this.agent = config.agent;
     this.skipSummarization = config.skipSummarization || false;
   }
   _getDeclaration() {
     let declaration;
-    if (this.agent instanceof LlmAgent && this.agent.inputSchema) {
+    if (isLlmAgent(this.agent) && this.agent.inputSchema) {
       declaration = {
         name: this.name,
         description: this.description,
@@ -46,17 +53,17 @@ class AgentTool extends BaseTool {
       };
     }
     if (this.apiVariant !== GoogleLLMVariant.GEMINI_API) {
-      const hasOutputSchema = this.agent instanceof LlmAgent && this.agent.outputSchema;
+      const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;
       declaration.response = hasOutputSchema ? { type: Type.OBJECT } : { type: Type.STRING };
     }
     return declaration;
   }
   async runAsync({ args, toolContext }) {
-    var _a, _b;
+    var _a2, _b2;
     if (this.skipSummarization) {
       toolContext.actions.skipSummarization = true;
     }
-    const hasInputSchema = this.agent instanceof LlmAgent && this.agent.inputSchema;
+    const hasInputSchema = isLlmAgent(this.agent) && this.agent.inputSchema;
     const content = {
       role: "user",
       parts: [
@@ -91,14 +98,15 @@ class AgentTool extends BaseTool {
       }
       lastEvent = event;
     }
-    if (!((_b = (_a = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
+    if (!((_b2 = (_a2 = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b2.length)) {
       return "";
     }
-    const hasOutputSchema = this.agent instanceof LlmAgent && this.agent.outputSchema;
+    const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;
     const mergedText = lastEvent.content.parts.map((part) => part.text).filter((text) => text).join("\n");
     return hasOutputSchema ? JSON.parse(mergedText) : mergedText;
   }
 }
 export {
-  AgentTool
+  AgentTool,
+  isAgentTool
 };

package/dist/esm/tools/base_tool.js

@@ -3,7 +3,13 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
 import { getGoogleLlmVariant } from "../utils/variant_utils.js";
+const BASE_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseTool");
+function isBaseTool(obj) {
+  return typeof obj === "object" && obj !== null && BASE_TOOL_SIGNATURE_SYMBOL in obj && obj[BASE_TOOL_SIGNATURE_SYMBOL] === true;
+}
+_a = BASE_TOOL_SIGNATURE_SYMBOL;
 class BaseTool {
   /**
    * Base constructor for a tool.
@@ -11,10 +17,12 @@ class BaseTool {
    * @param params The parameters for `BaseTool`.
    */
   constructor(params) {
-    var _a;
+    /** A unique symbol to identify ADK base tool class. */
+    this[_a] = true;
+    var _a2;
     this.name = params.name;
     this.description = params.description;
-    this.isLongRunning = (_a = params.isLongRunning) != null ? _a : false;
+    this.isLongRunning = (_a2 = params.isLongRunning) != null ? _a2 : false;
   }
   /**
    * Gets the OpenAPI specification of this tool in the form of a
@@ -69,9 +77,10 @@ class BaseTool {
   }
 }
 function findToolWithFunctionDeclarations(llmRequest) {
-  var _a;
-  return (((_a = llmRequest.config) == null ? void 0 : _a.tools) || []).find((tool) => "functionDeclarations" in tool);
+  var _a2;
+  return (((_a2 = llmRequest.config) == null ? void 0 : _a2.tools) || []).find((tool) => "functionDeclarations" in tool);
 }
 export {
-  BaseTool
+  BaseTool,
+  isBaseTool
 };

package/dist/esm/tools/function_tool.js

@@ -3,10 +3,9 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a, _b;
 import { Type } from "@google/genai";
-import {
-  ZodObject
-} from "zod";
+import { ZodObject } from "zod";
 import { isZodObject, zodObjectToSchema } from "../utils/simple_zod_to_json.js";
 import { BaseTool } from "./base_tool.js";
 function toSchema(parameters) {
@@ -18,14 +17,18 @@ function toSchema(parameters) {
   }
   return parameters;
 }
-class FunctionTool extends BaseTool {
+const FUNCTION_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.functionTool");
+function isFunctionTool(obj) {
+  return typeof obj === "object" && obj !== null && FUNCTION_TOOL_SIGNATURE_SYMBOL in obj && obj[FUNCTION_TOOL_SIGNATURE_SYMBOL] === true;
+}
+class FunctionTool extends (_b = BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL, _b) {
   /**
    * The constructor acts as the user-friendly factory.
    * @param options The configuration for the tool.
    */
   constructor(options) {
-    var _a;
-    const name = (_a = options.name) != null ? _a : options.execute.name;
+    var _a2;
+    const name = (_a2 = options.name) != null ? _a2 : options.execute.name;
     if (!name) {
       throw new Error(
         "Tool name cannot be empty. Either name the `execute` function or provide a `name`."
@@ -36,6 +39,8 @@ class FunctionTool extends BaseTool {
       description: options.description,
       isLongRunning: options.isLongRunning
     });
+    /** A unique symbol to identify ADK function tool class. */
+    this[_a] = true;
     this.execute = options.execute;
     this.parameters = options.parameters;
   }
@@ -69,5 +74,6 @@ class FunctionTool extends BaseTool {
   }
 }
 export {
-  FunctionTool
+  FunctionTool,
+  isFunctionTool
 };

package/dist/esm/tools/google_search_tool.js

@@ -4,7 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { isGemini1Model, isGeminiModel } from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
+import {
+  BaseTool
+} from "./base_tool.js";
 class GoogleSearchTool extends BaseTool {
   constructor() {
     super({ name: "google_search", description: "Google Search Tool" });
@@ -12,7 +14,10 @@ class GoogleSearchTool extends BaseTool {
   runAsync(request) {
     return Promise.resolve();
   }
-  async processLlmRequest({ toolContext, llmRequest }) {
+  async processLlmRequest({
+    toolContext,
+    llmRequest
+  }) {
     if (!llmRequest.model) {
       return;
     }
@@ -42,5 +47,6 @@ class GoogleSearchTool extends BaseTool {
 }
 const GOOGLE_SEARCH = new GoogleSearchTool();
 export {
-  GOOGLE_SEARCH
+  GOOGLE_SEARCH,
+  GoogleSearchTool
 };

package/dist/esm/tools/tool_context.js

@@ -18,15 +18,10 @@ class ToolContext extends CallbackContext {
    * @param params.toolConfirmation The tool confirmation of the current tool
    *     call.
    */
-  constructor({
-    invocationContext,
-    eventActions,
-    functionCallId,
-    toolConfirmation
-  }) {
-    super({ invocationContext, eventActions });
-    this.functionCallId = functionCallId;
-    this.toolConfirmation = toolConfirmation;
+  constructor(params) {
+    super(params);
+    this.functionCallId = params.functionCallId;
+    this.toolConfirmation = params.toolConfirmation;
   }
   get actions() {
     return this.eventActions;

package/dist/esm/utils/gemini_schema_util.js

@@ -11,6 +11,7 @@ const MCPToolSchema = z.object({
   required: z.string().array().optional()
 });
 function toGeminiType(mcpType) {
+  if (!mcpType) return Type.TYPE_UNSPECIFIED;
   switch (mcpType.toLowerCase()) {
     case "text":
     case "string":

package/dist/esm/version.js

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

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

@@ -7,9 +7,20 @@ import { Content } from '@google/genai';
 import { Event } from '../events/event.js';
 import { CallbackContext } from './callback_context.js';
 import { InvocationContext } from './invocation_context.js';
-type SingleAgentCallback = (context: CallbackContext) => Promise<Content | undefined> | (Content | undefined);
-type BeforeAgentCallback = SingleAgentCallback | SingleAgentCallback[];
-type AfterAgentCallback = SingleAgentCallback | SingleAgentCallback[];
+/**
+ * A single callback function for an agent.
+ */
+export type SingleAgentCallback = (context: CallbackContext) => Promise<Content | undefined> | (Content | undefined);
+/**
+ * Type for before agent callbacks, which can be a single callback or
+ * an array of callbacks.
+ */
+export type BeforeAgentCallback = SingleAgentCallback | SingleAgentCallback[];
+/**
+ * Type for after agent callbacks, which can be a single callback or
+ * an array of callbacks.
+ */
+export type AfterAgentCallback = SingleAgentCallback | SingleAgentCallback[];
 /**
  * The config of a base agent.
  */

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

@@ -15,7 +15,10 @@ import { BaseAgent } from './base_agent.js';
 import { LiveRequestQueue } from './live_request_queue.js';
 import { RunConfig } from './run_config.js';
 import { TranscriptionEntry } from './transcription_entry.js';
-interface InvocationContextParams {
+/**
+ * The parameters for creating an invocation context.
+ */
+export interface InvocationContextParams {
     artifactService?: BaseArtifactService;
     sessionService?: BaseSessionService;
     memoryService?: BaseMemoryService;
@@ -152,4 +155,3 @@ export declare class InvocationContext {
     incrementLlmCallCount(): void;
 }
 export declare function newInvocationContextId(): string;
-export {};