@google/adk 2.4.0 → 2.5.0

package/dist/cjs/utils/model_name.js

@@ -26,6 +26,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var model_name_exports = {};
 __export(model_name_exports, {
   extractModelName: () => extractModelName,
+  getGeminiMajorVersion: () => getGeminiMajorVersion,
   isGemini1Model: () => isGemini1Model,
   isGemini2OrAbove: () => isGemini2OrAbove,
   isGemini35LiveTranslate: () => isGemini35LiveTranslate,
@@ -68,6 +69,19 @@ function parseVersion(versionString) {
   };
 }
 __name(parseVersion, "parseVersion");
+function getGeminiMajorVersion(modelString) {
+  if (!modelString) {
+    return void 0;
+  }
+  const modelName = extractModelName(modelString);
+  if (!modelName.startsWith("gemini-")) {
+    return void 0;
+  }
+  const versionString = modelName.slice("gemini-".length).split("-", 1)[0];
+  const parsedVersion = parseVersion(versionString);
+  return parsedVersion.valid ? parsedVersion.major : void 0;
+}
+__name(getGeminiMajorVersion, "getGeminiMajorVersion");
 function isGemini1Model(modelString) {
   const modelName = extractModelName(modelString);
   return modelName.startsWith("gemini-1");
@@ -112,6 +126,7 @@ __name(isGeminiModelIdCheckDisabled, "isGeminiModelIdCheckDisabled");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   extractModelName,
+  getGeminiMajorVersion,
   isGemini1Model,
   isGemini2OrAbove,
   isGemini35LiveTranslate,

package/dist/cjs/utils/simple_zod_to_json.js

@@ -35,6 +35,7 @@ module.exports = __toCommonJS(simple_zod_to_json_exports);
 var import_genai = require("@google/genai");
 var import_zod_to_json_schema = require("zod-to-json-schema");
 var import_v4 = require("zod/v4");
+var import_gemini_schema_util = require("./gemini_schema_util.js");
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -86,21 +87,10 @@ function zodObjectToSchema(schema) {
         if (jsonSchema.readOnly !== void 0) {
           delete jsonSchema.readOnly;
         }
-        if (jsonSchema.maxItems !== void 0) {
-          jsonSchema.maxItems = jsonSchema.maxItems.toString();
-        }
-        if (jsonSchema.format === "email" || jsonSchema.format === "uuid") {
-          delete jsonSchema.pattern;
-        }
-        if (jsonSchema.minItems !== void 0) {
-          jsonSchema.minItems = jsonSchema.minItems.toString();
-        }
-        if (jsonSchema.minLength !== void 0) {
-          jsonSchema.minLength = jsonSchema.minLength.toString();
-        }
-        if (jsonSchema.maxLength !== void 0) {
-          jsonSchema.maxLength = jsonSchema.maxLength.toString();
-        }
+        (0, import_gemini_schema_util.copySchemaConstraints)(
+          jsonSchema,
+          jsonSchema
+        );
         if (((_a = jsonSchema.enum) == null ? void 0 : _a.length) === 1 && jsonSchema.enum[0] === null) {
           jsonSchema.type = import_genai.Type.NULL;
           delete jsonSchema.enum;
@@ -121,32 +111,24 @@ function zodObjectToSchema(schema) {
       $refStrategy: "none",
       emailStrategy: "format:email",
       postProcess: /* @__PURE__ */ __name((jsonSchema) => {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c;
         if (!jsonSchema) {
           return;
         }
         if (jsonSchema.additionalProperties !== void 0) {
           delete jsonSchema.additionalProperties;
         }
-        if (jsonSchema.maxItems !== void 0) {
-          jsonSchema.maxItems = (_a = jsonSchema.maxItems) == null ? void 0 : _a.toString();
-        }
-        if (jsonSchema.minItems !== void 0) {
-          jsonSchema.minItems = (_b = jsonSchema.minItems) == null ? void 0 : _b.toString();
-        }
-        if (jsonSchema.minLength !== void 0) {
-          jsonSchema.minLength = (_c = jsonSchema.minLength) == null ? void 0 : _c.toString();
-        }
-        if (jsonSchema.maxLength !== void 0) {
-          jsonSchema.maxLength = (_d = jsonSchema.maxLength) == null ? void 0 : _d.toString();
-        }
-        if (((_e = jsonSchema.enum) == null ? void 0 : _e.length) === 1 && jsonSchema.enum[0] === "null") {
+        (0, import_gemini_schema_util.copySchemaConstraints)(
+          jsonSchema,
+          jsonSchema
+        );
+        if (((_a = jsonSchema.enum) == null ? void 0 : _a.length) === 1 && jsonSchema.enum[0] === "null") {
           jsonSchema.type = import_genai.Type.NULL;
           delete jsonSchema.enum;
         }
         if (jsonSchema.type === "integer" && jsonSchema.format !== "int64") {
-          (_f = jsonSchema.minimum) != null ? _f : jsonSchema.minimum = Number.MIN_SAFE_INTEGER;
-          (_g = jsonSchema.maximum) != null ? _g : jsonSchema.maximum = Number.MAX_SAFE_INTEGER;
+          (_b = jsonSchema.minimum) != null ? _b : jsonSchema.minimum = Number.MIN_SAFE_INTEGER;
+          (_c = jsonSchema.maximum) != null ? _c : jsonSchema.maximum = Number.MAX_SAFE_INTEGER;
         }
         if (jsonSchema.type !== void 0) {
           jsonSchema.type = jsonSchema.type.toUpperCase();

package/dist/cjs/utils/ssrf_guard.js

@@ -5,9 +5,11 @@
   */
 
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -22,10 +24,19 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ssrf_guard_exports = {};
 __export(ssrf_guard_exports, {
   isHttpUrl: () => isHttpUrl,
+  isIpAddress: () => isIpAddress,
   isLinkLocalAddress: () => isLinkLocalAddress,
   isLocalhostHostname: () => isLocalhostHostname,
   isNonGlobalAddress: () => isNonGlobalAddress,
@@ -33,13 +44,13 @@ __export(ssrf_guard_exports, {
   resolveHostAddresses: () => resolveHostAddresses
 });
 module.exports = __toCommonJS(ssrf_guard_exports);
-var import_promises = require("node:dns/promises");
-var import_node_net = require("node:net");
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const DNS_MODULE = "node:dns/promises";
+const IPV6_CHARACTERS = /^[0-9a-f:.]+$/i;
 const HTTP_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
 const NON_GLOBAL_IPV4_CIDRS = [
   "0.0.0.0/8",
@@ -118,11 +129,16 @@ function isLinkLocalAddress(address) {
   return classifyAddress(address, isLinkLocalIpv4, isLinkLocalIpv6);
 }
 __name(isLinkLocalAddress, "isLinkLocalAddress");
+function isIpAddress(address) {
+  return parseIpv4(address) !== null || isIpv6Literal(address);
+}
+__name(isIpAddress, "isIpAddress");
 async function resolveHostAddresses(hostname) {
-  if ((0, import_node_net.isIP)(hostname) !== 0) {
+  if (isIpAddress(hostname)) {
     return [hostname];
   }
-  const records = await (0, import_promises.lookup)(hostname, { all: true });
+  const { lookup } = await Promise.resolve().then(() => __toESM(require(DNS_MODULE)));
+  const records = await lookup(hostname, { all: true });
   const addresses = [...new Set(records.map((record) => record.address))];
   if (addresses.length === 0) {
     throw new Error(`Unable to resolve host: ${hostname}`);
@@ -154,8 +170,20 @@ function parseIpv4(address) {
   return octets;
 }
 __name(parseIpv4, "parseIpv4");
+function isIpv6Literal(address) {
+  if (!address.includes(":") || !IPV6_CHARACTERS.test(address)) {
+    return false;
+  }
+  try {
+    new URL(`http://[${address}]/`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isIpv6Literal, "isIpv6Literal");
 function parseIpv6(address) {
-  if ((0, import_node_net.isIP)(address) !== 6) {
+  if (!isIpv6Literal(address)) {
     return null;
   }
   const [head, tail] = address.split("::");
@@ -182,14 +210,6 @@ function ipv4ToInt(octets) {
   return (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
 }
 __name(ipv4ToInt, "ipv4ToInt");
-function hextetsToBigInt(hextets) {
-  let value = 0n;
-  for (const hextet of hextets) {
-    value = value << 16n | BigInt(hextet);
-  }
-  return value;
-}
-__name(hextetsToBigInt, "hextetsToBigInt");
 function parseIpv4Cidr(cidr) {
   const [address, prefix] = cidr.split("/");
   const mask = 4294967295 << 32 - Number(prefix) >>> 0;
@@ -198,7 +218,7 @@ function parseIpv4Cidr(cidr) {
 __name(parseIpv4Cidr, "parseIpv4Cidr");
 function parseIpv6Cidr(cidr) {
   const [address, prefix] = cidr.split("/");
-  return { base: hextetsToBigInt(parseIpv6(address)), prefix: Number(prefix) };
+  return { base: parseIpv6(address), prefix: Number(prefix) };
 }
 __name(parseIpv6Cidr, "parseIpv6Cidr");
 function matchesIpv4Cidr(octets, { base, mask }) {
@@ -206,8 +226,17 @@ function matchesIpv4Cidr(octets, { base, mask }) {
 }
 __name(matchesIpv4Cidr, "matchesIpv4Cidr");
 function matchesIpv6Cidr(hextets, { base, prefix }) {
-  const shift = BigInt(128 - prefix);
-  return hextetsToBigInt(hextets) >> shift === base >> shift;
+  for (let i = 0; i < base.length; i++) {
+    const bits = Math.min(16, prefix - i * 16);
+    if (bits <= 0) {
+      return true;
+    }
+    const mask = 65535 << 16 - bits & 65535;
+    if ((hextets[i] & mask) !== (base[i] & mask)) {
+      return false;
+    }
+  }
+  return true;
 }
 __name(matchesIpv6Cidr, "matchesIpv6Cidr");
 function embeddedIpv4(hextets) {
@@ -254,6 +283,7 @@ __name(isLinkLocalIpv6, "isLinkLocalIpv6");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   isHttpUrl,
+  isIpAddress,
   isLinkLocalAddress,
   isLocalhostHostname,
   isNonGlobalAddress,

package/dist/cjs/version.js

@@ -32,7 +32,7 @@ module.exports = __toCommonJS(version_exports);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "2.4.0";
+const version = "2.5.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version

package/dist/cjs/workflow/index.js

@@ -55,6 +55,7 @@ __export(workflow_exports, {
   isNodeSchemaValidationError: () => import_errors.isNodeSchemaValidationError,
   isNodeState: () => import_node_state.isNodeState,
   isNodeTimeoutError: () => import_errors.isNodeTimeoutError,
+  isParallelWorker: () => import_parallel_worker.isParallelWorker,
   isRequestInput: () => import_request_input.isRequestInput,
   isRunnableRoot: () => import_run_node_as_invocation.isRunnableRoot,
   isWorkflow: () => import_workflow.isWorkflow,
@@ -121,6 +122,7 @@ var import_node_error_event = require("./node_error_event.js");
   isNodeSchemaValidationError,
   isNodeState,
   isNodeTimeoutError,
+  isParallelWorker,
   isRequestInput,
   isRunnableRoot,
   isWorkflow,

package/dist/cjs/workflow/node_runner.js

@@ -28,11 +28,9 @@ __export(node_runner_exports, {
   executeChildNode: () => executeChildNode
 });
 module.exports = __toCommonJS(node_runner_exports);
-var import_api = require("@opentelemetry/api");
 var import_invocation_context = require("../agents/invocation_context.js");
 var import_event = require("../events/event.js");
-var import_tracing = require("../telemetry/tracing.js");
-var import_error_utils = require("../utils/error_utils.js");
+var import_instrumentation = require("../telemetry/api/instrumentation.js");
 var import_branch_path = require("./branch_path.js");
 var import_errors = require("./errors.js");
 var import_node_context = require("./node_context.js");
@@ -50,11 +48,12 @@ function executeChildNode(params) {
   const { parent, node, options = {} } = params;
   const nodeName = (_a = options.nodeName) != null ? _a : node.name;
   const nodePath = (_b = options.overrideNodePath) != null ? _b : parent.nodePath ? `${parent.nodePath}.${nodeName}` : nodeName;
-  const span = import_tracing.tracer.startSpan(`execute_node ${nodeName}`);
-  return import_api.context.with(
-    import_api.trace.setSpan(import_api.context.active(), span),
-    () => runChildNode({ params, nodeName, nodePath, span })
-  );
+  const scope = (0, import_instrumentation.recordNodeInvocation)({
+    node,
+    nodeName,
+    sessionId: parent.invocationContext.session.id
+  });
+  return scope.run(() => runChildNode({ params, nodeName, nodePath, scope }));
 }
 __name(executeChildNode, "executeChildNode");
 async function runChildNode({
@@ -69,7 +68,7 @@ async function runChildNode({
   },
   nodeName,
   nodePath,
-  span
+  scope
 }) {
   var _a, _b, _c, _d;
   const runId = (_a = options.runId) != null ? _a : nodeName;
@@ -123,13 +122,6 @@ async function runChildNode({
       });
       if (skipOutput !== void 0) {
         child.output = skipOutput;
-        (0, import_tracing.traceNodeExecution)({
-          nodePath,
-          runId,
-          attempt: nodeState.attemptCount,
-          status: "completed",
-          interruptCount: child.interruptIds.length
-        });
         if (options.useAsOutput) {
           parent.output = child.output;
           parent.route = child.route;
@@ -143,16 +135,14 @@ async function runChildNode({
       resetState(child);
       child.attemptCount = nodeState.attemptCount;
       try {
-        inputRecorded = await runAttempt({
+        inputRecorded = await runOnce({
           node,
           child,
           input,
           nodeName,
           branch,
           isolationScope,
-          nodePath,
-          runId,
-          attempt: nodeState.attemptCount
+          scope
         });
         failIfNodeReportedError(child, nodeName);
         succeeded = true;
@@ -179,13 +169,6 @@ async function runChildNode({
     if (!inputRecorded && child.interruptIds.length > 0) {
       recordInputForResume({ child, nodeName, branch, isolationScope, input });
     }
-    (0, import_tracing.traceNodeExecution)({
-      nodePath,
-      runId,
-      attempt: nodeState.attemptCount,
-      status: child.interruptIds.length > 0 ? "waiting" : "completed",
-      interruptCount: child.interruptIds.length
-    });
     if (pluginManager == null ? void 0 : pluginManager.hasPlugins) {
       const replacedOutput = await pluginManager.runAfterNodeCallback({
         node,
@@ -203,58 +186,13 @@ async function runChildNode({
     }
     return child;
   } catch (err) {
-    (0, import_tracing.traceNodeExecution)({
-      nodePath,
-      runId,
-      attempt: nodeState.attemptCount,
-      status: "failed",
-      interruptCount: child.interruptIds.length
-    });
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: (0, import_error_utils.formatError)(err) });
+    scope.end(err);
     throw err;
   } finally {
-    span.end();
+    scope.end();
   }
 }
 __name(runChildNode, "runChildNode");
-function runAttempt(params) {
-  const { node, nodePath, runId, attempt } = params;
-  if (!node.preparedRetryConfig) {
-    return runOnce(params);
-  }
-  return import_tracing.tracer.startActiveSpan(
-    `execute_node_attempt ${params.nodeName}`,
-    async (span) => {
-      try {
-        const inputRecorded = await runOnce(params);
-        (0, import_tracing.traceNodeExecution)({
-          nodePath,
-          runId,
-          attempt,
-          status: params.child.interruptIds.length > 0 ? "waiting" : "completed",
-          interruptCount: params.child.interruptIds.length
-        });
-        return inputRecorded;
-      } catch (err) {
-        (0, import_tracing.traceNodeExecution)({
-          nodePath,
-          runId,
-          attempt,
-          status: "failed",
-          interruptCount: params.child.interruptIds.length
-        });
-        span.setStatus({
-          code: import_api.SpanStatusCode.ERROR,
-          message: (0, import_error_utils.formatError)(err)
-        });
-        throw err;
-      } finally {
-        span.end();
-      }
-    }
-  );
-}
-__name(runAttempt, "runAttempt");
 function failIfNodeReportedError(child, nodeName) {
   const reported = child.reportedError;
   if (!reported || child.output !== void 0 || child.route !== void 0 || child.interruptIds.length > 0) {
@@ -281,11 +219,12 @@ async function runOnce({
   input,
   nodeName,
   branch,
-  isolationScope
+  isolationScope,
+  scope
 }) {
   var _a;
   let inputRecorded = false;
-  const consume = /* @__PURE__ */ __name((event) => {
+  const consume = /* @__PURE__ */ __name(async (event) => {
     var _a2, _b, _c;
     enrichEvent({ event, child, nodeName, branch, isolationScope });
     const emittedDelta = (_a2 = event.actions) == null ? void 0 : _a2.stateDelta;
@@ -324,13 +263,18 @@ async function runOnce({
       };
       inputRecorded = true;
     }
-    child.channel.push(event);
+    scope.recordEvent(event);
+    if (event.partial) {
+      child.channel.push(event);
+    } else {
+      await child.channel.pushAndWait(event);
+    }
   }, "consume");
   const parentSignal = child.invocationContext.abortSignal;
   const hasTimeout = typeof node.timeout === "number" && node.timeout > 0;
   if (!hasTimeout && !parentSignal) {
     for await (const event of node.run(child, input)) {
-      consume(event);
+      await consume(event);
     }
     return inputRecorded;
   }
@@ -338,7 +282,7 @@ async function runOnce({
     child.abortSignal = parentSignal;
     try {
       for await (const event of node.run(child, input)) {
-        consume(event);
+        await consume(event);
       }
     } finally {
       child.abortSignal = void 0;
@@ -378,7 +322,7 @@ async function runOnce({
   try {
     let result = await Promise.race([iterator.next(), aborted]);
     while (!result.done) {
-      consume(result.value);
+      await Promise.race([consume(result.value), aborted]);
       result = await Promise.race([iterator.next(), aborted]);
     }
   } finally {

package/dist/cjs/workflow/nodes/parallel_worker.js

@@ -25,7 +25,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var parallel_worker_exports = {};
 __export(parallel_worker_exports, {
-  ParallelWorker: () => ParallelWorker
+  ParallelWorker: () => ParallelWorker,
+  isParallelWorker: () => isParallelWorker
 });
 module.exports = __toCommonJS(parallel_worker_exports);
 var import_base_node = require("../base_node.js");
@@ -36,11 +37,16 @@ var import_workflow_graph_utils = require("../utils/workflow_graph_utils.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a, _b;
 const DEFAULT_MAX_PARALLEL_WORKERS = 8;
-const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode {
+const PARALLEL_WORKER_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.workflow.parallelWorker"
+);
+const _ParallelWorker = class _ParallelWorker extends (_b = import_base_node.BaseNode, _a = PARALLEL_WORKER_SIGNATURE_SYMBOL, _b) {
   constructor(inner, config = {}) {
     const built = (0, import_workflow_graph_utils.buildNode)(inner);
     super({ name: built.name, rerunOnResume: true });
+    this[_a] = true;
     if (config.maxParallelWorkers !== void 0 && config.maxParallelWorkers < 1) {
       throw new Error("maxParallelWorkers must be greater than or equal to 1.");
     }
@@ -48,7 +54,7 @@ const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode
     this.maxParallelWorkers = config.maxParallelWorkers;
   }
   async *runImpl(ctx, input) {
-    var _a;
+    var _a2;
     const items = Array.isArray(input) ? input : [input];
     if (items.length === 0) {
       yield [];
@@ -56,7 +62,7 @@ const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode
     }
     const results = new Array(items.length);
     const poolSize = Math.min(
-      (_a = this.maxParallelWorkers) != null ? _a : DEFAULT_MAX_PARALLEL_WORKERS,
+      (_a2 = this.maxParallelWorkers) != null ? _a2 : DEFAULT_MAX_PARALLEL_WORKERS,
       items.length
     );
     let nextIndex = 0;
@@ -65,8 +71,8 @@ const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode
     let interrupted = false;
     const interruptIds = [];
     const isAborted = /* @__PURE__ */ __name(() => {
-      var _a2, _b;
-      return ((_a2 = ctx.abortSignal) == null ? void 0 : _a2.aborted) === true || ((_b = ctx.invocationContext.abortSignal) == null ? void 0 : _b.aborted) === true;
+      var _a3, _b2;
+      return ((_a3 = ctx.abortSignal) == null ? void 0 : _a3.aborted) === true || ((_b2 = ctx.invocationContext.abortSignal) == null ? void 0 : _b2.aborted) === true;
     }, "isAborted");
     const worker = /* @__PURE__ */ __name(async () => {
       while (!failed && !interrupted && !isAborted()) {
@@ -123,7 +129,12 @@ const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode
 };
 __name(_ParallelWorker, "ParallelWorker");
 let ParallelWorker = _ParallelWorker;
+function isParallelWorker(value) {
+  return typeof value === "object" && value !== null && PARALLEL_WORKER_SIGNATURE_SYMBOL in value && value[PARALLEL_WORKER_SIGNATURE_SYMBOL] === true;
+}
+__name(isParallelWorker, "isParallelWorker");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ParallelWorker
+  ParallelWorker,
+  isParallelWorker
 });

package/dist/cjs/workflow/run_llm_agent_as_node.js

@@ -42,9 +42,7 @@ async function* runLlmAgentAsNode(agent, ctx, nodeInput) {
   if (!isTaskMode && !agent.includeContentsExplicit) {
     agent.includeContents = "none";
   }
-  if (!isTaskMode) {
-    await appendNodeInputAsUserTurn(ctx, nodeInput);
-  }
+  const inputEvent = isTaskMode ? void 0 : pushNodeInputAsUserTurn(ctx, nodeInput);
   const agentIc = withWorkflowInstructionScope(ctx.getInvocationContext(), {
     input: nodeInput,
     outputsByNode: collectPredecessorOutputs(ctx)
@@ -53,15 +51,19 @@ async function* runLlmAgentAsNode(agent, ctx, nodeInput) {
     yield* runTaskMode(ctx, agentIc, agent);
     return;
   }
-  for await (const event of agent.runAsync(agentIc)) {
-    maybeSetOutput(agent, event);
-    yield event;
+  try {
+    for await (const event of agent.runAsync(agentIc)) {
+      maybeSetOutput(agent, event);
+      yield event;
+    }
+  } finally {
+    removeEvent(ctx.session.events, inputEvent);
   }
 }
 __name(runLlmAgentAsNode, "runLlmAgentAsNode");
-async function appendNodeInputAsUserTurn(ctx, nodeInput) {
+function pushNodeInputAsUserTurn(ctx, nodeInput) {
   if (nodeInput === void 0 || nodeInput === null) {
-    return;
+    return void 0;
   }
   const userEvent = (0, import_event.createEvent)({
     author: "user",
@@ -72,14 +74,17 @@ async function appendNodeInputAsUserTurn(ctx, nodeInput) {
   if (ctx.isolationScope !== void 0) {
     userEvent.isolationScope = ctx.isolationScope;
   }
-  const sessionService = ctx.invocationContext.sessionService;
-  if (sessionService) {
-    await sessionService.appendEvent({ session: ctx.session, event: userEvent });
-  } else {
-    ctx.session.events.push(userEvent);
+  ctx.session.events.push(userEvent);
+  return userEvent;
+}
+__name(pushNodeInputAsUserTurn, "pushNodeInputAsUserTurn");
+function removeEvent(events, event) {
+  const index = event ? events.indexOf(event) : -1;
+  if (index !== -1) {
+    events.splice(index, 1);
   }
 }
-__name(appendNodeInputAsUserTurn, "appendNodeInputAsUserTurn");
+__name(removeEvent, "removeEvent");
 async function* runTaskMode(ctx, agentIc, agent) {
   var _a, _b;
   const finishTool = agent.finishTaskTool;

package/dist/cjs/workflow/utils/retry_utils.js

@@ -42,7 +42,7 @@ const DEFAULT_MAX_DELAY_SECONDS = 60;
 const DEFAULT_BACKOFF_FACTOR = 2;
 const DEFAULT_JITTER = 1;
 function errorNames(error) {
-  var _a;
+  var _a, _b, _c;
   if (error instanceof Error) {
     const names = [(_a = error.constructor) == null ? void 0 : _a.name, error.name].filter(
       (name) => !!name
@@ -50,7 +50,7 @@ function errorNames(error) {
     return [...new Set(names)];
   }
   if (typeof error === "object" && error !== null) {
-    return [error.constructor.name];
+    return [(_c = (_b = error.constructor) == null ? void 0 : _b.name) != null ? _c : "Object"];
   }
   return [typeof error];
 }

package/dist/cjs/workflow/workflow.js

@@ -37,8 +37,7 @@ __export(workflow_exports, {
   isWorkflow: () => isWorkflow
 });
 module.exports = __toCommonJS(workflow_exports);
-var import_api = require("@opentelemetry/api");
-var import_tracing = require("../telemetry/tracing.js");
+var import_instrumentation = require("../telemetry/api/instrumentation.js");
 var import_experimental = require("../utils/experimental.js");
 var import_base_node = require("./base_node.js");
 var import_branch_path = require("./branch_path.js");
@@ -111,19 +110,20 @@ let Workflow = class extends (_b = import_base_node.BaseNode, _a = WORKFLOW_SIGN
       dynamicState,
       abort.controller.signal
     );
-    const span = import_tracing.tracer.startSpan(`invoke_workflow ${this.name}`);
+    const telemetryScope = (0, import_instrumentation.recordWorkflowInvocation)({
+      workflow: this,
+      sessionId: ctx.invocationContext.session.id
+    });
     try {
-      await import_api.context.with(import_api.trace.setSpan(import_api.context.active(), span), () => {
-        (0, import_tracing.traceWorkflowInvocation)({
-          workflowName: this.name,
-          nodePath: ctx.nodePath,
-          sessionId: ctx.invocationContext.session.id
-        });
-        return this.orchestrate(ctx, nodeInput, dynamicState, abort.controller);
-      });
+      await telemetryScope.run(
+        () => this.orchestrate(ctx, nodeInput, dynamicState, abort.controller)
+      );
+    } catch (error) {
+      telemetryScope.end(error);
+      throw error;
     } finally {
       abort.dispose();
-      span.end();
+      telemetryScope.end();
     }
   }
   /**