@google/adk 0.2.5 → 0.4.0

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/object_notation_utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Converts an object with snake_case keys to camelCase keys.
+ *
+ * @param obj The object to convert.
+ * @param preserveKeys Keys to preserve in their original form.
+ * @returns The object with camelCase keys.
+ */
+export declare function toCamelCase(obj: unknown, preserveKeys?: string[]): unknown;
+/**
+ * Converts an object with camelCase keys to snake_case keys.
+ *
+ * @param obj The object to convert.
+ * @param preserveKeys Keys to preserve in their original form.
+ * @returns The object with snake_case keys.
+ */
+export declare function toSnakeCase(obj: unknown, preserveKeys?: string[]): unknown;

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.4.0";

package/dist/web/a2a/part_converter_utils.js

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var MetadataKeys = /* @__PURE__ */ ((MetadataKeys2) => {
+  MetadataKeys2["TYPE"] = "adk_type";
+  MetadataKeys2["LONG_RUNNING"] = "adk_is_long_running";
+  MetadataKeys2["THOUGHT"] = "adk_thought";
+  return MetadataKeys2;
+})(MetadataKeys || {});
+var DataPartType = /* @__PURE__ */ ((DataPartType2) => {
+  DataPartType2["FUNCTION_CALL"] = "function_call";
+  DataPartType2["FUNCTION_RESPONSE"] = "function_response";
+  DataPartType2["CODE_EXEC_RESULT"] = "code_execution_result";
+  DataPartType2["CODE_EXECUTABLE_CODE"] = "executable_code";
+  return DataPartType2;
+})(DataPartType || {});
+function toA2AParts(parts, longRunningToolIDs = []) {
+  return parts.map((part) => toA2APart(part, longRunningToolIDs));
+}
+function toA2APart(part, longRunningToolIDs) {
+  if (part.text !== void 0 && part.text !== null) {
+    return toA2ATextPart(part);
+  }
+  if (part.inlineData || part.fileData) {
+    return toA2AFilePart(part);
+  }
+  return toA2ADataPart(part, longRunningToolIDs);
+}
+function toA2ATextPart(part) {
+  const a2aPart = { kind: "text", text: part.text || "" };
+  if ("thought" in part && part["thought"]) {
+    a2aPart.metadata = {
+      ["adk_thought" /* THOUGHT */]: true
+    };
+  }
+  return a2aPart;
+}
+function toA2AFilePart(part) {
+  if (part.fileData) {
+    return {
+      kind: "file",
+      file: {
+        uri: part.fileData.fileUri || "",
+        mimeType: part.fileData.mimeType
+      },
+      metadata: {}
+    };
+  }
+  if (part.inlineData) {
+    return {
+      kind: "file",
+      file: {
+        bytes: part.inlineData.data || "",
+        mimeType: part.inlineData.mimeType
+      },
+      metadata: {}
+    };
+  }
+  throw new Error("Not a file part: ".concat(JSON.stringify(part)));
+}
+function toA2ADataPart(part, longRunningToolIDs = []) {
+  let type;
+  let data;
+  if (part.functionCall) {
+    type = "function_call" /* FUNCTION_CALL */;
+    data = part.functionCall;
+  } else if (part.functionResponse) {
+    type = "function_response" /* FUNCTION_RESPONSE */;
+    data = part.functionResponse;
+  } else if (part.executableCode) {
+    type = "executable_code" /* CODE_EXECUTABLE_CODE */;
+    data = part.executableCode;
+  } else if (part.codeExecutionResult) {
+    type = "code_execution_result" /* CODE_EXEC_RESULT */;
+    data = part.codeExecutionResult;
+  } else {
+    throw new Error("Unknown part type: ".concat(JSON.stringify(part)));
+  }
+  const metadata = {
+    ["adk_type" /* TYPE */]: type
+  };
+  if (part.functionCall && part.functionCall.name && longRunningToolIDs.includes(part.functionCall.name)) {
+    metadata["adk_is_long_running" /* LONG_RUNNING */] = true;
+  }
+  if (part.functionResponse && part.functionResponse.name && longRunningToolIDs.includes(part.functionResponse.name)) {
+    metadata["adk_is_long_running" /* LONG_RUNNING */] = true;
+  }
+  return {
+    kind: "data",
+    data,
+    metadata
+  };
+}
+function toGenAIParts(a2aParts) {
+  return a2aParts.map((a2aPart) => toGenAIPart(a2aPart));
+}
+function toGenAIPart(a2aPart) {
+  if (a2aPart.kind === "text") {
+    return toGenAIPartText(a2aPart);
+  }
+  if (a2aPart.kind === "file") {
+    return toGenAIPartFile(a2aPart);
+  }
+  if (a2aPart.kind === "data") {
+    return toGenAIPartData(a2aPart);
+  }
+  throw new Error("Unknown part kind: ".concat(JSON.stringify(a2aPart)));
+}
+function toGenAIPartText(a2aPart) {
+  var _a;
+  return {
+    text: a2aPart.text,
+    thought: !!((_a = a2aPart.metadata) == null ? void 0 : _a["adk_thought" /* THOUGHT */])
+  };
+}
+function toGenAIPartFile(a2aPart) {
+  if ("bytes" in a2aPart.file) {
+    return {
+      inlineData: {
+        data: a2aPart.file.bytes,
+        mimeType: a2aPart.file.mimeType || ""
+      }
+    };
+  }
+  if ("uri" in a2aPart.file) {
+    return {
+      fileData: {
+        fileUri: a2aPart.file.uri,
+        mimeType: a2aPart.file.mimeType || ""
+      }
+    };
+  }
+  throw new Error("Not a file part: ".concat(JSON.stringify(a2aPart)));
+}
+function toGenAIPartData(a2aPart) {
+  var _a;
+  if (!a2aPart.data) {
+    throw new Error("No data in part: ".concat(JSON.stringify(a2aPart)));
+  }
+  const data = a2aPart.data;
+  const type = (_a = a2aPart.metadata) == null ? void 0 : _a["adk_type" /* TYPE */];
+  if (type === "function_call" /* FUNCTION_CALL */) {
+    return { functionCall: data };
+  }
+  if (type === "function_response" /* FUNCTION_RESPONSE */) {
+    return { functionResponse: data };
+  }
+  if (type === "executable_code" /* CODE_EXECUTABLE_CODE */) {
+    return { executableCode: data };
+  }
+  if (type === "code_execution_result" /* CODE_EXEC_RESULT */) {
+    return { codeExecutionResult: data };
+  }
+  return {
+    text: JSON.stringify(a2aPart.data)
+  };
+}
+export {
+  toA2ADataPart,
+  toA2AFilePart,
+  toA2APart,
+  toA2AParts,
+  toA2ATextPart,
+  toGenAIPart,
+  toGenAIPartData,
+  toGenAIPartFile,
+  toGenAIPartText,
+  toGenAIParts
+};

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();
@@ -250,7 +311,7 @@ class BaseAgent {
 function validateAgentName(name) {
   if (!isIdentifier(name)) {
     throw new Error(
-      'Found invalid agent name: "'.concat(name, '". Agent name must be a valid identifier. It should start with a letter (a-z, A-Z) or an underscore (_), and can only contain letters, digits (0-9), and underscores.')
+      'Found invalid agent name: "'.concat(name, '". Agent name must be a valid identifier. It should start with a letter (a-z, A-Z) or an underscore (_), and can only contain letters, digits (0-9), underscores, and hyphens.')
     );
   }
   if (name === "user") {
@@ -261,7 +322,7 @@ function validateAgentName(name) {
   return name;
 }
 function isIdentifier(str) {
-  return new RegExp("^[\\p{ID_Start}$_][\\p{ID_Continue}$_]*$", "u").test(str);
+  return new RegExp("^[\\p{ID_Start}$_][\\p{ID_Continue}$_-]*$", "u").test(str);
 }
 function getRootAgent(rootAgent) {
   while (rootAgent.parentAgent) {

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(

package/dist/web/agents/content_processor_utils.js

@@ -4,8 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { cloneDeep } from "lodash-es";
-import { createEvent, getFunctionCalls, getFunctionResponses } from "../events/event.js";
-import { removeClientFunctionCallId, REQUEST_CONFIRMATION_FUNCTION_CALL_NAME, REQUEST_EUC_FUNCTION_CALL_NAME } from "./functions.js";
+import {
+  createEvent,
+  getFunctionCalls,
+  getFunctionResponses
+} from "../events/event.js";
+import {
+  removeClientFunctionCallId,
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_EUC_FUNCTION_CALL_NAME
+} from "./functions.js";
 function getContents(events, agentName, currentBranch) {
   var _a, _b, _c;
   const filteredEvents = [];
@@ -79,9 +87,11 @@ function convertForeignEvent(event) {
   }
   const content = {
     role: "user",
-    parts: [{
-      text: "For context:"
-    }]
+    parts: [
+      {
+        text: "For context:"
+      }
+    ]
   };
   for (const part of event.content.parts) {
     if (part.text && !part.thought) {
@@ -183,10 +193,14 @@ function rearrangeEventsForLatestFunctionResponse(events) {
         const functionCallIds = new Set(
           functionCalls.map((fc) => fc.id).filter((id) => !!id)
         );
-        const isSubset = Array.from(functionResponsesIds).every((id) => functionCallIds.has(id));
+        const isSubset = Array.from(functionResponsesIds).every(
+          (id) => functionCallIds.has(id)
+        );
         if (!isSubset) {
           throw new Error(
-            "Last response event should only contain the responses for the function calls in the same function call event. Function" + " call ids found : ".concat(Array.from(functionCallIds).join(", "), ", function response") + " ids provided: ".concat(Array.from(functionResponsesIds).join(", "))
+            "Last response event should only contain the responses for the function calls in the same function call event. Function" + " call ids found : ".concat(Array.from(functionCallIds).join(
+              ", "
+            ), ", function response") + " ids provided: ".concat(Array.from(functionResponsesIds).join(", "))
           );
         }
         functionResponsesIds = functionCallIds;
@@ -254,7 +268,9 @@ function rearrangeEventsForAsyncFunctionResponsesInHistory(events) {
         const [responseIndex] = [...functionResponseEventsIndices];
         resultEvents.push(events[responseIndex]);
       } else {
-        const indicesArray = Array.from(functionResponseEventsIndices).sort((a, b) => a - b);
+        const indicesArray = Array.from(functionResponseEventsIndices).sort(
+          (a, b) => a - b
+        );
         const eventsToMerge = indicesArray.map((index) => events[index]);
         resultEvents.push(mergeFunctionResponseEvents(eventsToMerge));
       }
@@ -270,7 +286,7 @@ function safeStringify(obj) {
   }
   try {
     return JSON.stringify(obj);
-  } catch (e) {
+  } catch (_e) {
     return String(obj);
   }
 }

package/dist/web/agents/functions.js

@@ -10,6 +10,11 @@ import { mergeEventActions } from "../events/event_actions.js";
 import { ToolContext } from "../tools/tool_context.js";
 import { randomUUID } from "../utils/env_aware_utils.js";
 import { logger } from "../utils/logger.js";
+import {
+  traceMergedToolCalls,
+  tracer,
+  traceToolCall
+} from "../telemetry/tracing.js";
 const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
 const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
 const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
@@ -123,12 +128,56 @@ function generateRequestConfirmationEvent({
       parts,
       role: functionResponseEvent.content.role
     },
+    actions: functionResponseEvent.actions,
     longRunningToolIds: Array.from(longRunningToolIds)
   });
 }
 async function callToolAsync(tool, args, toolContext) {
-  logger.debug("callToolAsync ".concat(tool.name));
-  return await tool.runAsync({ args, toolContext });
+  return tracer.startActiveSpan("execute_tool ".concat(tool.name), async (span) => {
+    try {
+      logger.debug("callToolAsync ".concat(tool.name));
+      const result = await tool.runAsync({ args, toolContext });
+      traceToolCall({
+        tool,
+        args,
+        functionResponseEvent: buildResponseEvent(
+          tool,
+          result,
+          toolContext,
+          toolContext.invocationContext
+        )
+      });
+      return result;
+    } finally {
+      span.end();
+    }
+  });
+}
+function buildResponseEvent(tool, functionResult, toolContext, invocationContext) {
+  let responseResult;
+  if (typeof functionResult !== "object" || functionResult == null) {
+    responseResult = { result: functionResult };
+  } else {
+    responseResult = functionResult;
+  }
+  const partFunctionResponse = {
+    functionResponse: {
+      name: tool.name,
+      response: responseResult,
+      id: toolContext.functionCallId
+    }
+  };
+  const content = {
+    role: "user",
+    parts: [partFunctionResponse]
+  };
+  return createEvent({
+    invocationId: invocationContext.invocationId,
+    author: invocationContext.agent.name,
+    content,
+    actions: toolContext.actions,
+    branch: invocationContext.branch
+  });
 }
 async function handleFunctionCallsAsync({
   invocationContext,
@@ -169,14 +218,12 @@ async function handleFunctionCallList({
     if (toolConfirmationDict && functionCall.id) {
       toolConfirmation = toolConfirmationDict[functionCall.id];
     }
-    const { tool, toolContext } = getToolAndContext(
-      {
-        invocationContext,
-        functionCall,
-        toolsDict,
-        toolConfirmation
-      }
-    );
+    const { tool, toolContext } = getToolAndContext({
+      invocationContext,
+      functionCall,
+      toolsDict,
+      toolConfirmation
+    });
     logger.debug("execute_tool ".concat(tool.name));
     const functionArgs = (_a = functionCall.args) != null ? _a : {};
     let functionResponse = null;
@@ -200,21 +247,15 @@ async function handleFunctionCallList({
     }
     if (functionResponse == null) {
       try {
-        functionResponse = await callToolAsync(
-          tool,
-          functionArgs,
-          toolContext
-        );
+        functionResponse = await callToolAsync(tool, functionArgs, toolContext);
       } catch (e) {
         if (e instanceof Error) {
-          const onToolErrorResponse = await invocationContext.pluginManager.runOnToolErrorCallback(
-            {
-              tool,
-              toolArgs: functionArgs,
-              toolContext,
-              error: e
-            }
-          );
+          const onToolErrorResponse = await invocationContext.pluginManager.runOnToolErrorCallback({
+            tool,
+            toolArgs: functionArgs,
+            toolContext,
+            error: e
+          });
           if (onToolErrorResponse) {
             functionResponse = onToolErrorResponse;
           } else {
@@ -278,12 +319,24 @@ async function handleFunctionCallList({
   if (!functionResponseEvents.length) {
     return null;
   }
-  const mergedEvent = mergeParallelFunctionResponseEvents(functionResponseEvents);
+  const mergedEvent = mergeParallelFunctionResponseEvents(
+    functionResponseEvents
+  );
   if (functionResponseEvents.length > 1) {
-    logger.debug("execute_tool (merged)");
-    logger.debug("traceMergedToolCalls", {
-      responseEventId: mergedEvent.id,
-      functionResponseEvent: mergedEvent.id
+    tracer.startActiveSpan("execute_tool (merged)", (span) => {
+      try {
+        logger.debug("execute_tool (merged)");
+        logger.debug("traceMergedToolCalls", {
+          responseEventId: mergedEvent.id,
+          functionResponseEvent: mergedEvent.id
+        });
+        traceMergedToolCalls({
+          responseEventId: mergedEvent.id,
+          functionResponseEvent: mergedEvent
+        });
+      } finally {
+        span.end();
+      }
     });
   }
   return mergedEvent;
@@ -321,7 +374,9 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
     }
   }
   const baseEvent = functionResponseEvents[0];
-  const actionsList = functionResponseEvents.map((event) => event.actions || {});
+  const actionsList = functionResponseEvents.map(
+    (event) => event.actions || {}
+  );
   const mergedActions = mergeEventActions(actionsList);
   return createEvent({
     author: baseEvent.author,