@google/adk 0.2.5 → 0.3.0

package/dist/types/plugins/logging_plugin.d.ts

@@ -46,53 +46,53 @@ export declare class LoggingPlugin extends BasePlugin {
      * @param name The name of the plugin instance.
      */
     constructor(name?: string);
-    onUserMessageCallback({ invocationContext, userMessage }: {
+    onUserMessageCallback({ invocationContext, userMessage, }: {
         invocationContext: InvocationContext;
         userMessage: Content;
     }): Promise<Content | undefined>;
-    beforeRunCallback({ invocationContext }: {
+    beforeRunCallback({ invocationContext, }: {
         invocationContext: InvocationContext;
     }): Promise<Content | undefined>;
-    onEventCallback({ invocationContext, event }: {
+    onEventCallback({ event, }: {
         invocationContext: InvocationContext;
         event: Event;
     }): Promise<Event | undefined>;
-    afterRunCallback({ invocationContext }: {
+    afterRunCallback({ invocationContext, }: {
         invocationContext: InvocationContext;
     }): Promise<void>;
-    beforeAgentCallback({ agent, callbackContext }: {
+    beforeAgentCallback({ callbackContext, }: {
         agent: BaseAgent;
         callbackContext: CallbackContext;
     }): Promise<Content | undefined>;
-    afterAgentCallback({ agent, callbackContext }: {
+    afterAgentCallback({ callbackContext, }: {
         agent: BaseAgent;
         callbackContext: CallbackContext;
     }): Promise<Content | undefined>;
-    beforeModelCallback({ callbackContext, llmRequest }: {
+    beforeModelCallback({ callbackContext, llmRequest, }: {
         callbackContext: CallbackContext;
         llmRequest: LlmRequest;
     }): Promise<LlmResponse | undefined>;
-    afterModelCallback({ callbackContext, llmResponse }: {
+    afterModelCallback({ callbackContext, llmResponse, }: {
         callbackContext: CallbackContext;
         llmResponse: LlmResponse;
     }): Promise<LlmResponse | undefined>;
-    beforeToolCallback({ tool, toolArgs, toolContext }: {
+    beforeToolCallback({ tool, toolArgs, toolContext, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;
     }): Promise<Record<string, unknown> | undefined>;
-    afterToolCallback({ tool, toolArgs, toolContext, result }: {
+    afterToolCallback({ tool, toolContext, result, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;
         result: Record<string, unknown>;
     }): Promise<Record<string, unknown> | undefined>;
-    onModelErrorCallback({ callbackContext, llmRequest, error }: {
+    onModelErrorCallback({ callbackContext, error, }: {
         callbackContext: CallbackContext;
         llmRequest: LlmRequest;
         error: Error;
     }): Promise<LlmResponse | undefined>;
-    onToolErrorCallback({ tool, toolArgs, toolContext, error }: {
+    onToolErrorCallback({ tool, toolArgs, toolContext, error, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;

package/dist/types/plugins/plugin_manager.d.ts

@@ -67,47 +67,47 @@ export declare class PluginManager {
     /**
      * Runs the `onUserMessageCallback` for all plugins.
      */
-    runOnUserMessageCallback({ userMessage, invocationContext }: {
+    runOnUserMessageCallback({ userMessage, invocationContext, }: {
         userMessage: Content;
         invocationContext: InvocationContext;
     }): Promise<Content | undefined>;
     /**
      * Runs the `beforeRunCallback` for all plugins.
      */
-    runBeforeRunCallback({ invocationContext }: {
+    runBeforeRunCallback({ invocationContext, }: {
         invocationContext: InvocationContext;
     }): Promise<Content | undefined>;
     /**
      * Runs the `afterRunCallback` for all plugins.
      */
-    runAfterRunCallback({ invocationContext }: {
+    runAfterRunCallback({ invocationContext, }: {
         invocationContext: InvocationContext;
     }): Promise<void>;
     /**
      * Runs the `onEventCallback` for all plugins.
      */
-    runOnEventCallback({ invocationContext, event }: {
+    runOnEventCallback({ invocationContext, event, }: {
         invocationContext: InvocationContext;
         event: Event;
     }): Promise<Event | undefined>;
     /**
      * Runs the `beforeAgentCallback` for all plugins.
      */
-    runBeforeAgentCallback({ agent, callbackContext }: {
+    runBeforeAgentCallback({ agent, callbackContext, }: {
         agent: BaseAgent;
         callbackContext: CallbackContext;
     }): Promise<Content | undefined>;
     /**
      * Runs the `afterAgentCallback` for all plugins.
      */
-    runAfterAgentCallback({ agent, callbackContext }: {
+    runAfterAgentCallback({ agent, callbackContext, }: {
         agent: BaseAgent;
         callbackContext: CallbackContext;
     }): Promise<Content | undefined>;
     /**
      * Runs the `beforeToolCallback` for all plugins.
      */
-    runBeforeToolCallback({ tool, toolArgs, toolContext }: {
+    runBeforeToolCallback({ tool, toolArgs, toolContext, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;
@@ -115,7 +115,7 @@ export declare class PluginManager {
     /**
      * Runs the `afterToolCallback` for all plugins.
      */
-    runAfterToolCallback({ tool, toolArgs, toolContext, result }: {
+    runAfterToolCallback({ tool, toolArgs, toolContext, result, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;
@@ -124,7 +124,7 @@ export declare class PluginManager {
     /**
      * Runs the `onModelErrorCallback` for all plugins.
      */
-    runOnModelErrorCallback({ callbackContext, llmRequest, error }: {
+    runOnModelErrorCallback({ callbackContext, llmRequest, error, }: {
         callbackContext: CallbackContext;
         llmRequest: LlmRequest;
         error: Error;
@@ -132,21 +132,21 @@ export declare class PluginManager {
     /**
      * Runs the `beforeModelCallback` for all plugins.
      */
-    runBeforeModelCallback({ callbackContext, llmRequest }: {
+    runBeforeModelCallback({ callbackContext, llmRequest, }: {
         callbackContext: CallbackContext;
         llmRequest: LlmRequest;
     }): Promise<LlmResponse | undefined>;
     /**
      * Runs the `afterModelCallback` for all plugins.
      */
-    runAfterModelCallback({ callbackContext, llmResponse }: {
+    runAfterModelCallback({ callbackContext, llmResponse, }: {
         callbackContext: CallbackContext;
         llmResponse: LlmResponse;
     }): Promise<LlmResponse | undefined>;
     /**
      * Runs the `onToolErrorCallback` for all plugins.
      */
-    runOnToolErrorCallback({ tool, toolArgs, toolContext, error }: {
+    runOnToolErrorCallback({ tool, toolArgs, toolContext, error, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;

package/dist/types/plugins/security_plugin.d.ts

@@ -29,7 +29,7 @@ export interface BasePolicyEngine {
     evaluate(context: ToolCallPolicyContext): Promise<PolicyCheckResult>;
 }
 export declare class InMemoryPolicyEngine implements BasePolicyEngine {
-    evaluate(context: ToolCallPolicyContext): Promise<PolicyCheckResult>;
+    evaluate(): Promise<PolicyCheckResult>;
 }
 /**
  *  Security Plugin for running Orcas agents.

package/dist/types/runner/runner.d.ts

@@ -55,7 +55,7 @@ export declare class Runner {
         userId: string;
         sessionId: string;
         newMessage: Content;
-        stateDelta?: Record<string, any>;
+        stateDelta?: Record<string, unknown>;
         runConfig?: RunConfig;
     }): AsyncGenerator<Event, void, undefined>;
     /**

package/dist/types/sessions/in_memory_session_service.d.ts

@@ -18,10 +18,10 @@ export declare class InMemorySessionService extends BaseSessionService {
      * A map from app name to a map from key to the value.
      */
     private appState;
-    createSession({ appName, userId, state, sessionId }: CreateSessionRequest): Promise<Session>;
-    getSession({ appName, userId, sessionId, config }: GetSessionRequest): Promise<Session | undefined>;
-    listSessions({ appName, userId }: ListSessionsRequest): Promise<ListSessionsResponse>;
-    deleteSession({ appName, userId, sessionId }: DeleteSessionRequest): Promise<void>;
-    appendEvent({ session, event }: AppendEventRequest): Promise<Event>;
+    createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
+    getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
+    listSessions({ appName, userId, }: ListSessionsRequest): Promise<ListSessionsResponse>;
+    deleteSession({ appName, userId, sessionId, }: DeleteSessionRequest): Promise<void>;
+    appendEvent({ session, event, }: AppendEventRequest): Promise<Event>;
     private mergeState;
 }

package/dist/types/telemetry/setup.d.ts

@@ -3,9 +3,9 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { Resource } from '@opentelemetry/resources';
 import { LogRecordProcessor } from '@opentelemetry/sdk-logs';
 import { MetricReader } from '@opentelemetry/sdk-metrics';
-import { Resource } from '@opentelemetry/resources';
 import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
 export interface OtelExportersConfig {
     enableTracing?: boolean;

package/dist/types/telemetry/tracing.d.ts

@@ -101,11 +101,12 @@ export interface TraceSendDataParams {
  */
 export declare function traceSendData({ invocationContext, eventId, data, }: TraceSendDataParams): void;
 /**
- * Binds an async generator to OpenTelemetry context for trace propagation.
- * This is a temporary solution.
- * @param ctx - The OpenTelemetry context to bind the generator to
- * @param generator - The async generator to be bound to the context
+ * Runs an async generator function with both OTEL context and JavaScript 'this' context.
  *
- * @returns A new async generator that executes all operations within the provided context
+ * @param otelContext - The OpenTelemetry context to bind the generator to
+ * @param generatorFnContext - The 'this' context to bind to the generator function
+ * @param generatorFn - The generator function to execute
+ *
+ * @returns A new async generator that executes within both contexts
  */
-export declare function bindAsyncGenerator<T = unknown, TReturn = any, TNext = unknown>(ctx: Context, generator: AsyncGenerator<T, TReturn, TNext>): AsyncGenerator<T, TReturn, TNext>;
+export declare function runAsyncGeneratorWithOtelContext<TThis, T>(otelContext: Context, generatorFnContext: TThis, generatorFn: (this: TThis) => AsyncGenerator<T, void, void>): AsyncGenerator<T, void, void>;

package/dist/types/tools/agent_tool.d.ts

@@ -46,6 +46,6 @@ export declare class AgentTool extends BaseTool {
     private readonly skipSummarization;
     constructor(config: AgentToolConfig);
     _getDeclaration(): FunctionDeclaration;
-    runAsync({ args, toolContext }: RunAsyncToolRequest): Promise<unknown>;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
 }
 export {};

package/dist/types/tools/base_tool.d.ts

@@ -89,7 +89,7 @@ export declare abstract class BaseTool {
      *
      * @param request The request to process the LLM request.
      */
-    processLlmRequest({ toolContext, llmRequest }: ToolProcessLlmRequest): Promise<void>;
+    processLlmRequest({ llmRequest }: ToolProcessLlmRequest): Promise<void>;
     /**
      * The Google API LLM variant to use.
      */

package/dist/types/tools/base_toolset.d.ts

@@ -60,5 +60,6 @@ export declare abstract class BaseToolset {
      * @param toolContext The context of the tool.
      * @param llmRequest The outgoing LLM request, mutable this method.
      */
-    processLlmRequest(toolContext: ToolContext, llmRequest: LlmRequest): Promise<void>;
+    processLlmRequest(toolContext: ToolContext, // eslint-disable-line @typescript-eslint/no-unused-vars
+    llmRequest: LlmRequest): Promise<void>;
 }

package/dist/types/tools/forwarding_artifact_service.d.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Part } from '@google/genai';
-import { BaseArtifactService, DeleteArtifactRequest, ListArtifactKeysRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from '../artifacts/base_artifact_service.js';
+import { BaseArtifactService, DeleteArtifactRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from '../artifacts/base_artifact_service.js';
 import { ToolContext } from './tool_context.js';
 /**
  * Artifact service that forwards to the parent tool context.
@@ -15,7 +15,7 @@ export declare class ForwardingArtifactService implements BaseArtifactService {
     constructor(toolContext: ToolContext);
     saveArtifact(request: SaveArtifactRequest): Promise<number>;
     loadArtifact(request: LoadArtifactRequest): Promise<Part | undefined>;
-    listArtifactKeys(request: ListArtifactKeysRequest): Promise<string[]>;
+    listArtifactKeys(): Promise<string[]>;
     deleteArtifact(request: DeleteArtifactRequest): Promise<void>;
     listVersions(request: ListVersionsRequest): Promise<number[]>;
 }

package/dist/types/tools/function_tool.d.ts

@@ -4,14 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { FunctionDeclaration, Schema } from '@google/genai';
-import { type infer as zInfer, ZodObject, type ZodRawShape } from 'zod';
+import { z as z3 } from 'zod/v3';
+import { z as z4 } from 'zod/v4';
 import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
 import { ToolContext } from './tool_context.js';
 /**
  * Input parameters of the function tool.
  */
-export type ToolInputParameters = undefined | ZodObject<ZodRawShape> | Schema;
-export type ToolExecuteArgument<TParameters extends ToolInputParameters> = TParameters extends ZodObject<infer T, infer U, infer V> ? zInfer<ZodObject<T, U, V>> : TParameters extends Schema ? unknown : string;
+export type ToolInputParameters = z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape> | Schema | undefined;
+export type ToolExecuteArgument<TParameters extends ToolInputParameters> = TParameters extends z3.ZodObject<infer T, infer U, infer V> ? z3.infer<z3.ZodObject<T, U, V>> : TParameters extends z4.ZodObject<infer T> ? z4.infer<z4.ZodObject<T>> : TParameters extends Schema ? unknown : string;
 export type ToolExecuteFunction<TParameters extends ToolInputParameters> = (input: ToolExecuteArgument<TParameters>, tool_context?: ToolContext) => Promise<unknown> | unknown;
 /**
  * The configuration options for creating a function-based tool.

package/dist/types/tools/google_search_tool.d.ts

@@ -1,4 +1,4 @@
-import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
 /**
  * A built-in tool that is automatically invoked by Gemini 2 models to retrieve
  * search results from Google Search.
@@ -8,8 +8,8 @@ import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_too
  */
 export declare class GoogleSearchTool extends BaseTool {
     constructor();
-    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
-    processLlmRequest({ toolContext, llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+    runAsync(): Promise<unknown>;
+    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
 }
 /**
  * A global instance of {@link GoogleSearchTool}.

package/dist/types/tools/mcp/mcp_session_manager.d.ts

@@ -5,6 +5,7 @@
  */
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 /**
  * Defines the parameters for establishing a connection to an MCP server using
  * standard input/output (stdio). This is typically used for running MCP servers
@@ -13,7 +14,7 @@ import { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js
 export interface StdioConnectionParams {
     type: 'StdioConnectionParams';
     serverParams: StdioServerParameters;
-    timeout?: Number;
+    timeout?: number;
 }
 /**
  * Defines the parameters for establishing a connection to an MCP server over
@@ -28,10 +29,16 @@ export interface StdioConnectionParams {
 export interface StreamableHTTPConnectionParams {
     type: 'StreamableHTTPConnectionParams';
     url: string;
+    /**
+     * @deprecated
+     * Use transportOptions.requestInit.headers instead.
+     * This field will be ignored if transportOptions is provided even if no headers are specified in transportOptions.
+     */
     header?: Record<string, unknown>;
-    timeout?: Number;
-    sseReadTimeout?: Number;
+    timeout?: number;
+    sseReadTimeout?: number;
     terminateOnClose?: boolean;
+    transportOptions?: StreamableHTTPClientTransportOptions;
 }
 /**
  * A union of all supported MCP connection parameter types.

package/dist/types/tools/mcp/mcp_toolset.d.ts

@@ -3,7 +3,6 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { ReadonlyContext } from '../../agents/readonly_context.js';
 import { BaseTool } from '../base_tool.js';
 import { BaseToolset, ToolPredicate } from '../base_toolset.js';
 import { MCPConnectionParams } from './mcp_session_manager.js';
@@ -34,6 +33,6 @@ import { MCPConnectionParams } from './mcp_session_manager.js';
 export declare class MCPToolset extends BaseToolset {
     private readonly mcpSessionManager;
     constructor(connectionParams: MCPConnectionParams, toolFilter?: ToolPredicate | string[]);
-    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    getTools(): Promise<BaseTool[]>;
     close(): Promise<void>;
 }

package/dist/types/utils/gemini_schema_util.d.ts

@@ -5,19 +5,11 @@
  */
 import { Schema } from '@google/genai';
 import { z } from 'zod';
-declare const MCPToolSchema: z.ZodObject<{
+declare const MCPToolSchemaObject: z.ZodObject<{
     type: z.ZodLiteral<"object">;
     properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    type: "object";
-    properties?: Record<string, unknown> | undefined;
-    required?: string[] | undefined;
-}, {
-    type: "object";
-    properties?: Record<string, unknown> | undefined;
-    required?: string[] | undefined;
-}>;
-type MCPToolSchema = z.infer<typeof MCPToolSchema>;
+    required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type MCPToolSchema = z.infer<typeof MCPToolSchemaObject>;
 export declare function toGeminiSchema(mcpSchema?: MCPToolSchema): Schema | undefined;
 export {};

package/dist/types/utils/logger.d.ts

@@ -25,17 +25,18 @@ export interface Logger {
  */
 export declare function setLogLevel(level: LogLevel): void;
 /**
- * Simple logger class for ADK.
+ * Sets a custom logger for ADK, or null to disable logging.
  */
-declare class SimpleLogger implements Logger {
-    log(level: LogLevel, ...args: unknown[]): void;
-    debug(...args: unknown[]): void;
-    info(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    error(...args: unknown[]): void;
-}
+export declare function setLogger(customLogger: Logger | null): void;
+/**
+ * Gets the current logger instance.
+ */
+export declare function getLogger(): Logger;
+/**
+ * Resets the logger to the default SimpleLogger.
+ */
+export declare function resetLogger(): void;
 /**
  * The logger instance for ADK.
  */
-export declare const logger: SimpleLogger;
-export {};
+export declare const logger: Logger;

package/dist/types/utils/simple_zod_to_json.d.ts

@@ -4,9 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Schema } from '@google/genai';
-import { ZodObject } from 'zod';
+import { z as z3 } from 'zod/v3';
+import { z as z4 } from 'zod/v4';
 /**
- * Returns true if the given object is a V3 ZodObject.
+ * Returns true if the given object is a ZodObject (supports both Zod v3 and v4).
  */
-export declare function isZodObject(obj: unknown): obj is ZodObject<any>;
-export declare function zodObjectToSchema(schema: ZodObject<any>): Schema;
+export declare function isZodObject(obj: unknown): obj is z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape>;
+export declare function zodObjectToSchema(schema: z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape>): Schema;

package/dist/types/version.d.ts

@@ -3,4 +3,4 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export declare const version = "0.2.5";
+export declare const version = "0.3.0";

package/dist/web/agents/base_agent.js

@@ -5,6 +5,9 @@ var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
@@ -33,6 +36,34 @@ var __asyncGenerator = (__this, __arguments, generator) => {
   }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
   return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
 };
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
 var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
 /**
  * @license
@@ -40,8 +71,13 @@ var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")])
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-import { trace } from "@opentelemetry/api";
+import { context, trace } from "@opentelemetry/api";
 import { createEvent } from "../events/event.js";
+import {
+  runAsyncGeneratorWithOtelContext,
+  traceAgentInvocation,
+  tracer
+} from "../telemetry/tracing.js";
 import { CallbackContext } from "./callback_context.js";
 import { InvocationContext } from "./invocation_context.js";
 const BASE_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseAgent");
@@ -59,13 +95,19 @@ class BaseAgent {
     this.description = config.description;
     this.parentAgent = config.parentAgent;
     this.subAgents = config.subAgents || [];
-    this.rootAgent = getRootAgent(this);
     this.beforeAgentCallback = getCannonicalCallback(
       config.beforeAgentCallback
     );
     this.afterAgentCallback = getCannonicalCallback(config.afterAgentCallback);
     this.setParentAgentForSubAgents();
   }
+  /**
+   * Root agent of this agent.
+   * Computed dynamically by traversing up the parent chain.
+   */
+  get rootAgent() {
+    return getRootAgent(this);
+  }
   /**
    * Entry method to run an agent via text-based conversation.
    *
@@ -75,38 +117,48 @@ class BaseAgent {
    */
   runAsync(parentContext) {
     return __asyncGenerator(this, null, function* () {
-      const span = trace.getTracer("gcp.vertex.agent").startSpan("agent_run [".concat(this.name, "]"));
+      const span = tracer.startSpan("invoke_agent ".concat(this.name));
+      const ctx = trace.setSpan(context.active(), span);
       try {
-        const context = this.createInvocationContext(parentContext);
-        const beforeAgentCallbackEvent = yield new __await(this.handleBeforeAgentCallback(context));
-        if (beforeAgentCallbackEvent) {
-          yield beforeAgentCallbackEvent;
-        }
-        if (context.endInvocation) {
-          return;
-        }
-        try {
-          for (var iter = __forAwait(this.runAsyncImpl(context)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-            const event = temp.value;
-            yield event;
+        yield* __yieldStar(runAsyncGeneratorWithOtelContext(
+          ctx,
+          this,
+          function() {
+            return __asyncGenerator(this, null, function* () {
+              const context2 = this.createInvocationContext(parentContext);
+              const beforeAgentCallbackEvent = yield new __await(this.handleBeforeAgentCallback(context2));
+              if (beforeAgentCallbackEvent) {
+                yield beforeAgentCallbackEvent;
+              }
+              if (context2.endInvocation) {
+                return;
+              }
+              traceAgentInvocation({ agent: this, invocationContext: context2 });
+              try {
+                for (var iter = __forAwait(this.runAsyncImpl(context2)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+                  const event = temp.value;
+                  yield event;
+                }
+              } catch (temp) {
+                error = [temp];
+              } finally {
+                try {
+                  more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+                } finally {
+                  if (error)
+                    throw error[0];
+                }
+              }
+              if (context2.endInvocation) {
+                return;
+              }
+              const afterAgentCallbackEvent = yield new __await(this.handleAfterAgentCallback(context2));
+              if (afterAgentCallbackEvent) {
+                yield afterAgentCallbackEvent;
+              }
+            });
           }
-        } catch (temp) {
-          error = [temp];
-        } finally {
-          try {
-            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-          } finally {
-            if (error)
-              throw error[0];
-          }
-        }
-        if (context.endInvocation) {
-          return;
-        }
-        const afterAgentCallbackEvent = yield new __await(this.handleAfterAgentCallback(context));
-        if (afterAgentCallbackEvent) {
-          yield afterAgentCallbackEvent;
-        }
+        ));
       } finally {
         span.end();
       }
@@ -121,8 +173,17 @@ class BaseAgent {
    */
   runLive(parentContext) {
     return __asyncGenerator(this, null, function* () {
-      const span = trace.getTracer("gcp.vertex.agent").startSpan("agent_run [".concat(this.name, "]"));
+      const span = tracer.startSpan("invoke_agent ".concat(this.name));
+      const ctx = trace.setSpan(context.active(), span);
       try {
+        yield* __yieldStar(runAsyncGeneratorWithOtelContext(
+          ctx,
+          this,
+          function() {
+            return __asyncGenerator(this, null, function* () {
+            });
+          }
+        ));
         throw new Error("Live mode is not implemented yet.");
       } finally {
         span.end();

package/dist/web/agents/callback_context.js

@@ -7,7 +7,10 @@ import { createEventActions } from "../events/event_actions.js";
 import { State } from "../sessions/state.js";
 import { ReadonlyContext } from "./readonly_context.js";
 class CallbackContext extends ReadonlyContext {
-  constructor({ invocationContext, eventActions }) {
+  constructor({
+    invocationContext,
+    eventActions
+  }) {
     super(invocationContext);
     this.eventActions = eventActions || createEventActions();
     this._state = new State(