@google/adk 0.2.5 → 0.4.0

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

@@ -0,0 +1,87 @@
+/**
+ * @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) {
+  let driver;
+  if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
+    driver = PostgreSqlDriver;
+  } else if (uri.startsWith("mysql://")) {
+    driver = MySqlDriver;
+  } else if (uri.startsWith("mariadb://")) {
+    driver = MariaDbDriver;
+  } else if (uri.startsWith("sqlite://")) {
+    driver = SqliteDriver;
+  } else if (uri.startsWith("mssql://")) {
+    driver = MsSqlDriver;
+  } else {
+    throw new Error(`Unsupported database URI: ${uri}`);
+  }
+  if (uri === "sqlite://:memory:") {
+    return {
+      entities: ENTITIES,
+      dbName: ":memory:",
+      driver
+    };
+  }
+  const { host, port, username, password, pathname } = new URL(uri);
+  const hostName = host.split(":")[0];
+  return {
+    entities: ENTITIES,
+    dbName: pathname.slice(1),
+    host: hostName,
+    port: port ? parseInt(port) : void 0,
+    user: username,
+    password,
+    driver
+  };
+}
+async function ensureDatabaseCreated(ormOrUrlOrOptions) {
+  let orm;
+  if (ormOrUrlOrOptions instanceof MikroORM) {
+    orm = ormOrUrlOrOptions;
+  } else if (typeof ormOrUrlOrOptions === "string") {
+    orm = await MikroORM.init(getConnectionOptionsFromUri(ormOrUrlOrOptions));
+  } else {
+    orm = await MikroORM.init(ormOrUrlOrOptions);
+  }
+  await orm.schema.ensureDatabase();
+  await orm.schema.updateSchema();
+}
+async function validateDatabaseSchemaVersion(orm) {
+  const em = orm.em.fork();
+  const existing = await em.findOne(StorageMetadata, {
+    key: SCHEMA_VERSION_KEY
+  });
+  if (existing) {
+    if (existing.value !== SCHEMA_VERSION_1_JSON) {
+      throw new Error(
+        `ADK Database schema version ${existing.value} is not compatible.`
+      );
+    }
+    return;
+  }
+  const newVersion = em.create(StorageMetadata, {
+    key: SCHEMA_VERSION_KEY,
+    value: SCHEMA_VERSION_1_JSON
+  });
+  await em.persist(newVersion).flush();
+}
+export {
+  ensureDatabaseCreated,
+  getConnectionOptionsFromUri,
+  validateDatabaseSchemaVersion
+};

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

@@ -0,0 +1,172 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Entity, JsonType, PrimaryKey, Property } from "@mikro-orm/core";
+import {
+  transformToCamelCaseEvent,
+  transformToSnakeCaseEvent
+} from "../../events/event.js";
+const SCHEMA_VERSION_KEY = "schema_version";
+const SCHEMA_VERSION_1_JSON = "1";
+class CamelCaseToSnakeCaseJsonType extends JsonType {
+  convertToDatabaseValue(value) {
+    return JSON.stringify(transformToSnakeCaseEvent(value));
+  }
+  convertToJSValue(value) {
+    if (typeof value === "string") {
+      return transformToCamelCaseEvent(JSON.parse(value));
+    }
+    return transformToCamelCaseEvent(value);
+  }
+}
+let StorageMetadata = class {
+};
+__decorateClass([
+  PrimaryKey({ type: "string" })
+], StorageMetadata.prototype, "key", 2);
+__decorateClass([
+  Property({ type: "string" })
+], StorageMetadata.prototype, "value", 2);
+StorageMetadata = __decorateClass([
+  Entity({ tableName: "adk_internal_metadata" })
+], StorageMetadata);
+let StorageAppState = class {
+  constructor() {
+    this.updateTime = /* @__PURE__ */ new Date();
+  }
+};
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "app_name" })
+], StorageAppState.prototype, "appName", 2);
+__decorateClass([
+  Property({ type: "json" })
+], StorageAppState.prototype, "state", 2);
+__decorateClass([
+  Property({
+    type: "datetime",
+    fieldName: "update_time",
+    onCreate: () => /* @__PURE__ */ new Date(),
+    onUpdate: () => /* @__PURE__ */ new Date()
+  })
+], StorageAppState.prototype, "updateTime", 2);
+StorageAppState = __decorateClass([
+  Entity({ tableName: "app_states" })
+], StorageAppState);
+PrimaryKey.name;
+let StorageUserState = class {
+  constructor() {
+    this.updateTime = /* @__PURE__ */ new Date();
+  }
+};
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "app_name" })
+], StorageUserState.prototype, "appName", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "user_id" })
+], StorageUserState.prototype, "userId", 2);
+__decorateClass([
+  Property({ type: "json" })
+], StorageUserState.prototype, "state", 2);
+__decorateClass([
+  Property({
+    type: "datetime",
+    fieldName: "update_time",
+    onCreate: () => /* @__PURE__ */ new Date(),
+    onUpdate: () => /* @__PURE__ */ new Date()
+  })
+], StorageUserState.prototype, "updateTime", 2);
+StorageUserState = __decorateClass([
+  Entity({ tableName: "user_states" })
+], StorageUserState);
+PrimaryKey.name;
+let StorageSession = class {
+  constructor() {
+    this.createTime = /* @__PURE__ */ new Date();
+    this.updateTime = /* @__PURE__ */ new Date();
+  }
+};
+__decorateClass([
+  PrimaryKey({ type: "string" })
+], StorageSession.prototype, "id", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "app_name" })
+], StorageSession.prototype, "appName", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "user_id" })
+], StorageSession.prototype, "userId", 2);
+__decorateClass([
+  Property({ type: "json" })
+], StorageSession.prototype, "state", 2);
+__decorateClass([
+  Property({
+    type: "datetime",
+    fieldName: "create_time",
+    onCreate: () => /* @__PURE__ */ new Date()
+  })
+], StorageSession.prototype, "createTime", 2);
+__decorateClass([
+  Property({
+    type: "datetime",
+    fieldName: "update_time",
+    onCreate: () => /* @__PURE__ */ new Date()
+  })
+], StorageSession.prototype, "updateTime", 2);
+StorageSession = __decorateClass([
+  Entity({ tableName: "sessions" })
+], StorageSession);
+PrimaryKey.name;
+let StorageEvent = class {
+};
+__decorateClass([
+  PrimaryKey({ type: "string" })
+], StorageEvent.prototype, "id", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "app_name" })
+], StorageEvent.prototype, "appName", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "user_id" })
+], StorageEvent.prototype, "userId", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "session_id" })
+], StorageEvent.prototype, "sessionId", 2);
+__decorateClass([
+  Property({ type: "string", fieldName: "invocation_id" })
+], StorageEvent.prototype, "invocationId", 2);
+__decorateClass([
+  Property({ type: "datetime" })
+], StorageEvent.prototype, "timestamp", 2);
+__decorateClass([
+  Property({ type: CamelCaseToSnakeCaseJsonType, fieldName: "event_data" })
+], StorageEvent.prototype, "eventData", 2);
+StorageEvent = __decorateClass([
+  Entity({ tableName: "events" })
+], StorageEvent);
+const ENTITIES = [
+  StorageMetadata,
+  StorageAppState,
+  StorageUserState,
+  StorageSession,
+  StorageEvent
+];
+export {
+  ENTITIES,
+  SCHEMA_VERSION_1_JSON,
+  SCHEMA_VERSION_KEY,
+  StorageAppState,
+  StorageEvent,
+  StorageMetadata,
+  StorageSession,
+  StorageUserState
+};

package/dist/esm/sessions/in_memory_session_service.js

@@ -6,9 +6,15 @@
 import { cloneDeep } from "lodash-es";
 import { randomUUID } from "../utils/env_aware_utils.js";
 import { logger } from "../utils/logger.js";
-import { BaseSessionService } from "./base_session_service.js";
+import {
+  BaseSessionService,
+  mergeStates
+} from "./base_session_service.js";
 import { createSession } from "./session.js";
 import { State } from "./state.js";
+function isInMemoryConnectionString(uri) {
+  return uri === "memory://";
+}
 class InMemorySessionService extends BaseSessionService {
   constructor() {
     super(...arguments);
@@ -26,7 +32,13 @@ class InMemorySessionService extends BaseSessionService {
      */
     this.appState = {};
   }
-  createSession({ appName, userId, state, sessionId }) {
+  async createSession({
+    appName,
+    userId,
+    state,
+    sessionId
+  }) {
+    var _a;
     const session = createSession({
       id: sessionId || randomUUID(),
       appName,
@@ -42,11 +54,21 @@ class InMemorySessionService extends BaseSessionService {
       this.sessions[appName][userId] = {};
     }
     this.sessions[appName][userId][session.id] = session;
-    return Promise.resolve(
-      this.mergeState(appName, userId, cloneDeep(session))
+    const copiedSession = cloneDeep(session);
+    copiedSession.state = mergeStates(
+      this.appState[appName],
+      (_a = this.userState[appName]) == null ? void 0 : _a[userId],
+      copiedSession.state
     );
+    return copiedSession;
   }
-  getSession({ appName, userId, sessionId, config }) {
+  async getSession({
+    appName,
+    userId,
+    sessionId,
+    config
+  }) {
+    var _a;
     if (!this.sessions[appName] || !this.sessions[appName][userId] || !this.sessions[appName][userId][sessionId]) {
       return Promise.resolve(void 0);
     }
@@ -54,7 +76,9 @@ class InMemorySessionService extends BaseSessionService {
     const copiedSession = cloneDeep(session);
     if (config) {
       if (config.numRecentEvents) {
-        copiedSession.events = copiedSession.events.slice(-config.numRecentEvents);
+        copiedSession.events = copiedSession.events.slice(
+          -config.numRecentEvents
+        );
       }
       if (config.afterTimestamp) {
         let i = copiedSession.events.length - 1;
@@ -69,33 +93,50 @@ class InMemorySessionService extends BaseSessionService {
         }
       }
     }
-    return Promise.resolve(this.mergeState(appName, userId, copiedSession));
+    copiedSession.state = mergeStates(
+      this.appState[appName],
+      (_a = this.userState[appName]) == null ? void 0 : _a[userId],
+      copiedSession.state
+    );
+    return copiedSession;
   }
-  listSessions({ appName, userId }) {
+  listSessions({
+    appName,
+    userId
+  }) {
     if (!this.sessions[appName] || !this.sessions[appName][userId]) {
       return Promise.resolve({ sessions: [] });
     }
     const sessionsWithoutEvents = [];
     for (const session of Object.values(this.sessions[appName][userId])) {
-      sessionsWithoutEvents.push(createSession({
-        id: session.id,
-        appName: session.appName,
-        userId: session.userId,
-        state: {},
-        events: [],
-        lastUpdateTime: session.lastUpdateTime
-      }));
+      sessionsWithoutEvents.push(
+        createSession({
+          id: session.id,
+          appName: session.appName,
+          userId: session.userId,
+          state: {},
+          events: [],
+          lastUpdateTime: session.lastUpdateTime
+        })
+      );
     }
     return Promise.resolve({ sessions: sessionsWithoutEvents });
   }
-  async deleteSession({ appName, userId, sessionId }) {
+  async deleteSession({
+    appName,
+    userId,
+    sessionId
+  }) {
     const session = await this.getSession({ appName, userId, sessionId });
     if (!session) {
       return;
     }
     delete this.sessions[appName][userId][sessionId];
   }
-  async appendEvent({ session, event }) {
+  async appendEvent({
+    session,
+    event
+  }) {
     await super.appendEvent({ session, event });
     session.lastUpdateTime = event.timestamp;
     const appName = session.appName;
@@ -134,21 +175,8 @@ class InMemorySessionService extends BaseSessionService {
     storageSession.lastUpdateTime = event.timestamp;
     return event;
   }
-  mergeState(appName, userId, copiedSession) {
-    if (this.appState[appName]) {
-      for (const key of Object.keys(this.appState[appName])) {
-        copiedSession.state[State.APP_PREFIX + key] = this.appState[appName][key];
-      }
-    }
-    if (!this.userState[appName] || !this.userState[appName][userId]) {
-      return copiedSession;
-    }
-    for (const key of Object.keys(this.userState[appName][userId])) {
-      copiedSession.state[State.USER_PREFIX + key] = this.userState[appName][userId][key];
-    }
-    return copiedSession;
-  }
 }
 export {
-  InMemorySessionService
+  InMemorySessionService,
+  isInMemoryConnectionString
 };

package/dist/esm/sessions/registry.js

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  DatabaseSessionService,
+  isDatabaseConnectionString
+} from "./database_session_service.js";
+import {
+  InMemorySessionService,
+  isInMemoryConnectionString
+} from "./in_memory_session_service.js";
+function getSessionServiceFromUri(uri) {
+  if (isInMemoryConnectionString(uri)) {
+    return new InMemorySessionService();
+  }
+  if (isDatabaseConnectionString(uri)) {
+    return new DatabaseSessionService(uri);
+  }
+  throw new Error(`Unsupported session service URI: ${uri}`);
+}
+export {
+  getSessionServiceFromUri
+};

package/dist/esm/telemetry/google_cloud.js

@@ -3,13 +3,13 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { GoogleAuth } from "google-auth-library";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { detectResources } from "@opentelemetry/resources";
-import { gcpDetector } from "@opentelemetry/resource-detector-gcp";
+import { MetricExporter } from "@google-cloud/opentelemetry-cloud-monitoring-exporter";
 import { TraceExporter } from "@google-cloud/opentelemetry-cloud-trace-exporter";
+import { gcpDetector } from "@opentelemetry/resource-detector-gcp";
+import { detectResources } from "@opentelemetry/resources";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { MetricExporter } from "@google-cloud/opentelemetry-cloud-monitoring-exporter";
+import { GoogleAuth } from "google-auth-library";
 import { logger } from "../utils/logger.js";
 const GCP_PROJECT_ERROR_MESSAGE = "Cannot determine GCP Project. OTel GCP Exporters cannot be set up. Please make sure to log into correct GCP Project.";
 async function getGcpProjectId() {
@@ -17,7 +17,7 @@ async function getGcpProjectId() {
     const auth = new GoogleAuth();
     const projectId = await auth.getProjectId();
     return projectId || void 0;
-  } catch (error) {
+  } catch (_e) {
     return void 0;
   }
 }
@@ -33,9 +33,7 @@ async function getGcpExporters(config = {}) {
     return {};
   }
   return {
-    spanProcessors: enableTracing ? [
-      new BatchSpanProcessor(new TraceExporter({ projectId }))
-    ] : [],
+    spanProcessors: enableTracing ? [new BatchSpanProcessor(new TraceExporter({ projectId }))] : [],
     metricReaders: enableMetrics ? [
       new PeriodicExportingMetricReader({
         exporter: new MetricExporter({ projectId }),

package/dist/esm/telemetry/setup.js

@@ -3,22 +3,32 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { trace, metrics } from "@opentelemetry/api";
+import { metrics, trace } from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
-import { LoggerProvider, BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
-import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { detectResources } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 function maybeSetOtelProviders(otelHooksToSetup = [], otelResource) {
   const resource = otelResource || getOtelResource();
   const allHooks = [...otelHooksToSetup, getOtelExporters()];
-  const spanProcessors = allHooks.flatMap((hooks) => hooks.spanProcessors || []);
+  const spanProcessors = allHooks.flatMap(
+    (hooks) => hooks.spanProcessors || []
+  );
   const metricReaders = allHooks.flatMap((hooks) => hooks.metricReaders || []);
-  const logRecordProcessors = allHooks.flatMap((hooks) => hooks.logRecordProcessors || []);
+  const logRecordProcessors = allHooks.flatMap(
+    (hooks) => hooks.logRecordProcessors || []
+  );
   if (spanProcessors.length > 0) {
     const tracerProvider = new NodeTracerProvider({
       resource,
@@ -58,7 +68,11 @@ function getOtelExporters(config = getOtelExportersConfig()) {
   const { enableTracing, enableMetrics, enableLogging } = config;
   return {
     spanProcessors: enableTracing ? [new BatchSpanProcessor(new OTLPTraceExporter())] : [],
-    metricReaders: enableMetrics ? [new PeriodicExportingMetricReader({ exporter: new OTLPMetricExporter() })] : [],
+    metricReaders: enableMetrics ? [
+      new PeriodicExportingMetricReader({
+        exporter: new OTLPMetricExporter()
+      })
+    ] : [],
     logRecordProcessors: enableLogging ? [new BatchLogRecordProcessor(new OTLPLogExporter())] : []
   };
 }

package/dist/esm/telemetry/tracing.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { trace, context } from "@opentelemetry/api";
+import { context, trace } from "@opentelemetry/api";
 import { version } from "../version.js";
 const GEN_AI_AGENT_DESCRIPTION = "gen_ai.agent.description";
 const GEN_AI_AGENT_NAME = "gen_ai.agent.name";
@@ -13,14 +13,11 @@ const GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
 const GEN_AI_TOOL_DESCRIPTION = "gen_ai.tool.description";
 const GEN_AI_TOOL_NAME = "gen_ai.tool.name";
 const GEN_AI_TOOL_TYPE = "gen_ai.tool.type";
-const tracer = trace.getTracer(
-  "gcp.vertex.agent",
-  version
-);
+const tracer = trace.getTracer("gcp.vertex.agent", version);
 function safeJsonSerialize(obj) {
   try {
     return JSON.stringify(obj);
-  } catch (error) {
+  } catch (_e) {
     return "<not serializable>";
   }
 }
@@ -97,7 +94,10 @@ function traceMergedToolCalls({
     "gcp.vertex.agent.llm_request": "{}",
     "gcp.vertex.agent.llm_response": "{}"
   });
-  span.setAttribute("gcp.vertex.agent.tool_response", shouldAddRequestResponseToSpans() ? safeJsonSerialize(functionResponseEvent) : "{}");
+  span.setAttribute(
+    "gcp.vertex.agent.tool_response",
+    shouldAddRequestResponseToSpans() ? safeJsonSerialize(functionResponseEvent) : "{}"
+  );
 }
 function traceCallLlm({
   invocationContext,
@@ -121,14 +121,26 @@ function traceCallLlm({
     span.setAttribute("gen_ai.request.top_p", llmRequest.config.topP);
   }
   if (((_b = llmRequest.config) == null ? void 0 : _b.maxOutputTokens) !== void 0) {
-    span.setAttribute("gen_ai.request.max_tokens", llmRequest.config.maxOutputTokens);
+    span.setAttribute(
+      "gen_ai.request.max_tokens",
+      llmRequest.config.maxOutputTokens
+    );
   }
-  span.setAttribute("gcp.vertex.agent.llm_response", shouldAddRequestResponseToSpans() ? safeJsonSerialize(llmResponse) : "{}");
+  span.setAttribute(
+    "gcp.vertex.agent.llm_response",
+    shouldAddRequestResponseToSpans() ? safeJsonSerialize(llmResponse) : "{}"
+  );
   if (llmResponse.usageMetadata) {
-    span.setAttribute("gen_ai.usage.input_tokens", llmResponse.usageMetadata.promptTokenCount || 0);
+    span.setAttribute(
+      "gen_ai.usage.input_tokens",
+      llmResponse.usageMetadata.promptTokenCount || 0
+    );
   }
   if ((_c = llmResponse.usageMetadata) == null ? void 0 : _c.candidatesTokenCount) {
-    span.setAttribute("gen_ai.usage.output_tokens", llmResponse.usageMetadata.candidatesTokenCount);
+    span.setAttribute(
+      "gen_ai.usage.output_tokens",
+      llmResponse.usageMetadata.candidatesTokenCount
+    );
   }
   if (llmResponse.finishReason) {
     const finishReasonValue = typeof llmResponse.finishReason === "string" ? llmResponse.finishReason.toLowerCase() : String(llmResponse.finishReason).toLowerCase();
@@ -146,7 +158,10 @@ function traceSendData({
     "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
     "gcp.vertex.agent.event_id": eventId
   });
-  span.setAttribute("gcp.vertex.agent.data", shouldAddRequestResponseToSpans() ? safeJsonSerialize(data) : "{}");
+  span.setAttribute(
+    "gcp.vertex.agent.data",
+    shouldAddRequestResponseToSpans() ? safeJsonSerialize(data) : "{}"
+  );
 }
 function buildLlmRequestForTrace(llmRequest) {
   const result = {
@@ -166,7 +181,7 @@ function buildLlmRequestForTrace(llmRequest) {
   });
   return result;
 }
-function bindAsyncGenerator(ctx, generator) {
+function bindOtelContextToAsyncGenerator(ctx, generator) {
   return {
     // Bind the next() method to execute within the provided context
     next: context.bind(ctx, generator.next.bind(generator)),
@@ -176,16 +191,23 @@ function bindAsyncGenerator(ctx, generator) {
     throw: context.bind(ctx, generator.throw.bind(generator)),
     // Ensure the async iterator symbol also returns a context-bound generator
     [Symbol.asyncIterator]() {
-      return bindAsyncGenerator(ctx, generator[Symbol.asyncIterator]());
+      return bindOtelContextToAsyncGenerator(
+        ctx,
+        generator[Symbol.asyncIterator]()
+      );
     }
   };
 }
+function runAsyncGeneratorWithOtelContext(otelContext, generatorFnContext, generatorFn) {
+  const generator = generatorFn.call(generatorFnContext);
+  return bindOtelContextToAsyncGenerator(otelContext, generator);
+}
 function shouldAddRequestResponseToSpans() {
   const envValue = process.env.ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS || "true";
   return envValue === "true" || envValue === "1";
 }
 export {
-  bindAsyncGenerator,
+  runAsyncGeneratorWithOtelContext,
   traceAgentInvocation,
   traceCallLlm,
   traceMergedToolCalls,

package/dist/esm/tools/agent_tool.js

@@ -18,9 +18,10 @@ function isAgentTool(obj) {
 }
 class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
   constructor(config) {
-    super(
-      { name: config.agent.name, description: config.agent.description || "" }
-    );
+    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;
@@ -58,7 +59,10 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
     }
     return declaration;
   }
-  async runAsync({ args, toolContext }) {
+  async runAsync({
+    args,
+    toolContext
+  }) {
     var _a2, _b2;
     if (this.skipSummarization) {
       toolContext.actions.skipSummarization = true;