@google/adk 2.2.1 → 2.3.0

package/dist/cjs/a2a/a2a_remote_agent.js

@@ -63,7 +63,10 @@ const _RemoteA2AAgent = class _RemoteA2AAgent extends import_base_agent.BaseAgen
       this.client = this.a2aConfig.client;
     }
     if (this.a2aConfig.agentCard) {
-      this.card = await (0, import_agent_card.resolveAgentCard)(this.a2aConfig.agentCard);
+      this.card = await (0, import_agent_card.resolveAgentCard)(
+        this.a2aConfig.agentCard,
+        this.a2aConfig.resolveAgentCardOptions
+      );
       if (!this.client) {
         const factory = this.a2aConfig.clientFactory || new import_client.ClientFactory();
         this.client = await factory.createFromAgentCard(this.card);

package/dist/cjs/a2a/agent_card.js

@@ -59,19 +59,21 @@ var import_workflow = require("../workflow/workflow.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const WINDOWS_DRIVE_PROTOCOL = /^[a-z]:$/i;
-async function resolveAgentCard(agentCard) {
+async function resolveAgentCard(agentCard, options = {}) {
   if (typeof agentCard === "object") {
     return agentCard;
   }
-  const url = parseCardUrl(agentCard);
-  if (url && (0, import_ssrf_guard.isHttpUrl)(url)) {
-    await assertHostAllowed(url);
+  const source = agentCard;
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    await refuseLinkLocalHost(source);
     const resolver = new import_client.DefaultAgentCardResolver({
-      fetchImpl: noRedirectFetch(agentCard)
+      fetchImpl: refuseRedirectFetch
     });
-    return resolver.resolve(agentCard);
+    const card = await resolver.resolve(source);
+    validateCardRpcTargets(card, source, options);
+    return card;
   }
+  const url = parseCardUrl(source);
   if (url && url.protocol !== "file:") {
     throw new Error(
       `Unsupported agent card URL scheme "${url.protocol}": ${agentCard}. Use http://, https:// or file://, or pass a filesystem path with no scheme.`
@@ -80,6 +82,31 @@ async function resolveAgentCard(agentCard) {
   return readAgentCardFile(agentCard, url);
 }
 __name(resolveAgentCard, "resolveAgentCard");
+const WINDOWS_DRIVE_PROTOCOL = /^[a-z]:$/i;
+async function refuseLinkLocalHost(source) {
+  const hostname = (0, import_ssrf_guard.normalizeHost)(new URL(source).hostname);
+  if ((0, import_ssrf_guard.isLocalhostHostname)(hostname)) {
+    return;
+  }
+  const addresses = await (0, import_ssrf_guard.resolveHostAddresses)(hostname);
+  if (addresses.some((address) => (0, import_ssrf_guard.isLinkLocalAddress)(address))) {
+    throw new Error(
+      `Refusing to fetch agent card from a link-local address: ${hostname}`
+    );
+  }
+}
+__name(refuseLinkLocalHost, "refuseLinkLocalHost");
+async function refuseRedirectFetch(url, init) {
+  const response = await fetch(url, { ...init, redirect: "manual" });
+  if (response.status === 0 || response.status >= 300 && response.status < 400) {
+    const location = response.headers.get("location");
+    throw new Error(
+      `Refusing to follow a redirect from the agent card endpoint (status ${response.status}, location ${location}): ${url}`
+    );
+  }
+  return response;
+}
+__name(refuseRedirectFetch, "refuseRedirectFetch");
 function parseCardUrl(source) {
   let url;
   try {
@@ -102,32 +129,81 @@ async function readAgentCardFile(source, url) {
   }
 }
 __name(readAgentCardFile, "readAgentCardFile");
-function noRedirectFetch(source) {
-  return async (input, init) => {
-    const response = await fetch(input, { ...init, redirect: "manual" });
-    if (isRedirect(response.status)) {
+function validateCardRpcTargets(card, source, options) {
+  var _a;
+  let parsedSource;
+  try {
+    parsedSource = new URL(source);
+  } catch (err) {
+    throw new Error(
+      `Invalid agent card source URL: ${source}: ${err.message}`
+    );
+  }
+  const rpcUrls = [
+    card.url,
+    ...((_a = card.additionalInterfaces) != null ? _a : []).map((i) => i.url)
+  ];
+  for (const rpcUrl of rpcUrls) {
+    let parsed;
+    try {
+      parsed = new URL(rpcUrl);
+    } catch (err) {
       throw new Error(
-        `Refusing to follow a redirect while fetching the agent card from ${source} (status ${response.status}, location ${response.headers.get("location")}). Configure the final URL instead.`
+        `Invalid RPC URL in agent card: ${rpcUrl}: ${err.message}`
       );
     }
-    return response;
-  };
+    if (parsed.protocol !== "https:" && !isLoopbackHost(parsed.hostname)) {
+      if (options.allowInsecureRpc === true) {
+        import_logger.logger.warn(
+          `SECURITY WARNING: accepting a plaintext http RPC URL on a non-loopback host because \`allowInsecureRpc: true\` was set: ${rpcUrl}. This connection can be intercepted or altered by anything on the network path.`
+        );
+      } else {
+        throw new Error(
+          `Agent card RPC URL must use https, or http on a loopback host: ${rpcUrl}`
+        );
+      }
+    }
+    if (!sameOriginForRpc(parsedSource, parsed)) {
+      if (options.allowCrossOriginRpc === true) {
+        import_logger.logger.warn(
+          `SECURITY WARNING: accepting an agent card RPC URL whose origin differs from the location the card was fetched from because \`allowCrossOriginRpc: true\` was set (fetched from ${source}): ${rpcUrl}.`
+        );
+      } else {
+        throw new Error(
+          `Agent card RPC URL must have the same origin as the location the card was fetched from (${source}): ${rpcUrl}`
+        );
+      }
+    }
+  }
 }
-__name(noRedirectFetch, "noRedirectFetch");
-function isRedirect(status) {
-  return status === 0 || status >= 300 && status < 400;
+__name(validateCardRpcTargets, "validateCardRpcTargets");
+function sameOriginForRpc(source, rpc) {
+  const sourceIsLoopback = isLoopbackHost(source.hostname);
+  const rpcIsLoopback = isLoopbackHost(rpc.hostname);
+  if (sourceIsLoopback && rpcIsLoopback) {
+    return source.protocol === rpc.protocol && effectivePort(source) === effectivePort(rpc);
+  }
+  return source.origin === rpc.origin;
 }
-__name(isRedirect, "isRedirect");
-async function assertHostAllowed(url) {
-  const host = (0, import_ssrf_guard.normalizeHost)(url.hostname);
-  const addresses = await (0, import_ssrf_guard.resolveHostAddresses)(host);
-  if (addresses.some(import_ssrf_guard.isLinkLocalAddress)) {
-    throw new Error(
-      `Refusing to fetch agent card from a link-local address: ${host}`
-    );
+__name(sameOriginForRpc, "sameOriginForRpc");
+function effectivePort(url) {
+  if (url.port) {
+    return url.port;
+  }
+  if (url.protocol === "https:") {
+    return "443";
   }
+  if (url.protocol === "http:") {
+    return "80";
+  }
+  return url.port;
+}
+__name(effectivePort, "effectivePort");
+function isLoopbackHost(hostname) {
+  const bare = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  return bare === "localhost" || bare === "127.0.0.1" || bare === "::1" || bare === "0.0.0.0" || bare === "::" || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(bare);
 }
-__name(assertHostAllowed, "assertHostAllowed");
+__name(isLoopbackHost, "isLoopbackHost");
 async function getA2AAgentCard(agent, transports) {
   return {
     name: agent.name,

package/dist/cjs/a2a/agent_to_a2a.js

@@ -87,7 +87,7 @@ async function toA2a(agent, options = {}) {
   const protocol = (_c = options.protocol) != null ? _c : "http";
   const basePath = options.basePath || "";
   const rpcUrl = `${protocol}://${host}:${port}${basePath}`;
-  const agentCard = options.agentCard ? await (0, import_agent_card.resolveAgentCard)(options.agentCard) : await (0, import_agent_card.getA2AAgentCard)(agent, [
+  const agentCard = options.agentCard ? await (0, import_agent_card.resolveAgentCard)(options.agentCard, options.resolveAgentCardOptions) : await (0, import_agent_card.getA2AAgentCard)(agent, [
     {
       url: `${rpcUrl}/jsonrpc`,
       transport: "JSONRPC"

package/dist/cjs/agents/functions.js

@@ -39,6 +39,7 @@ __export(functions_exports, {
   getLongRunningFunctionCalls: () => getLongRunningFunctionCalls,
   handleFunctionCallList: () => handleFunctionCallList,
   handleFunctionCallsAsync: () => handleFunctionCallsAsync,
+  handleFunctionCallsLive: () => handleFunctionCallsLive,
   isToolNotFound: () => isToolNotFound,
   mergeParallelFunctionResponseEvents: () => mergeParallelFunctionResponseEvents,
   populateClientFunctionCallId: () => import_event2.populateClientFunctionCallId,
@@ -50,7 +51,10 @@ var import_lodash_es = require("lodash-es");
 var import_event = require("../events/event.js");
 var import_event_actions = require("../events/event_actions.js");
 var import_base_tool = require("../tools/base_tool.js");
+var import_function_tool = require("../tools/function_tool.js");
 var import_logger = require("../utils/logger.js");
+var import_task = require("../utils/task.js");
+var import_active_streaming_tool = require("./active_streaming_tool.js");
 var import_context = require("./context.js");
 var import_framework_function_calls = require("./framework_function_calls.js");
 var import_tracing = require("../telemetry/tracing.js");
@@ -69,6 +73,8 @@ function toolEventAuthor(invocationContext) {
 __name(toolEventAuthor, "toolEventAuthor");
 const functionsExportedForTestingOnly = {
   handleFunctionCallList,
+  handleFunctionCallsLive,
+  processFunctionLiveHelper,
   generateAuthEvent,
   generateRequestConfirmationEvent
 };
@@ -171,7 +177,8 @@ async function callToolAsync(tool, args, toolContext) {
           result,
           toolContext,
           toolContext.invocationContext
-        )
+        ),
+        invocationContext: toolContext.invocationContext
       });
       return result;
     } finally {
@@ -232,6 +239,30 @@ async function handleFunctionCallsAsync({
   });
 }
 __name(handleFunctionCallsAsync, "handleFunctionCallsAsync");
+async function handleFunctionCallsLive({
+  invocationContext,
+  functionCallEvent,
+  toolsDict,
+  beforeToolCallbacks,
+  afterToolCallbacks,
+  filters,
+  toolConfirmationDict,
+  resumeInputsDict
+}) {
+  const functionCalls = (0, import_event.getFunctionCalls)(functionCallEvent);
+  return handleFunctionCallList({
+    invocationContext,
+    functionCalls,
+    toolsDict,
+    beforeToolCallbacks,
+    afterToolCallbacks,
+    filters,
+    toolConfirmationDict,
+    resumeInputsDict,
+    isLive: true
+  });
+}
+__name(handleFunctionCallsLive, "handleFunctionCallsLive");
 function normalizeCallbackResponse(response) {
   if (response == null) {
     return void 0;
@@ -317,7 +348,8 @@ async function handleFunctionCallList({
   afterToolCallbacks,
   filters,
   toolConfirmationDict,
-  resumeInputsDict
+  resumeInputsDict,
+  isLive = false
 }) {
   var _a2;
   const functionResponseEvents = [];
@@ -354,7 +386,6 @@ async function handleFunctionCallList({
     import_logger.logger.debug(`execute_tool ${tool.name}`);
     const functionArgs = (_a2 = functionCall.args) != null ? _a2 : {};
     let functionResponse = null;
-    let functionResponseError;
     functionResponse = await invocationContext.pluginManager.runBeforeToolCallback({
       tool,
       toolArgs: functionArgs,
@@ -375,7 +406,18 @@ async function handleFunctionCallList({
     functionResponse = normalizeCallbackResponse(functionResponse);
     if (functionResponse == null) {
       try {
-        functionResponse = await callToolAsync(tool, functionArgs, toolContext);
+        const rawFunctionResponse = isLive ? await processFunctionLiveHelper({
+          tool,
+          toolContext,
+          functionCall,
+          functionArgs,
+          invocationContext
+        }) : await callToolAsync(tool, functionArgs, toolContext);
+        if (rawFunctionResponse == null && !tool.isLongRunning) {
+          functionResponse = { result: rawFunctionResponse };
+        } else {
+          functionResponse = normalizeCallbackResponse(rawFunctionResponse);
+        }
       } catch (e) {
         if (e instanceof Error) {
           const onToolErrorResponse = await invocationContext.pluginManager.runOnToolErrorCallback({
@@ -387,18 +429,19 @@ async function handleFunctionCallList({
           if (onToolErrorResponse != null) {
             functionResponse = normalizeCallbackResponse(onToolErrorResponse);
           } else {
-            functionResponseError = e.message;
+            functionResponse = { error: e.message };
           }
         } else {
-          functionResponseError = e;
+          functionResponse = { error: e };
         }
       }
     }
+    const callbackResult = functionResponse != null ? functionResponse : {};
     let alteredFunctionResponse = await invocationContext.pluginManager.runAfterToolCallback({
       tool,
       toolArgs: functionArgs,
       toolContext,
-      result: functionResponse
+      result: callbackResult
     });
     if (alteredFunctionResponse == null) {
       for (const callback of afterToolCallbacks) {
@@ -406,7 +449,7 @@ async function handleFunctionCallList({
           tool,
           args: functionArgs,
           context: toolContext,
-          response: functionResponse
+          response: callbackResult
         });
         if (alteredFunctionResponse) {
           break;
@@ -429,13 +472,6 @@ async function handleFunctionCallList({
       }
       continue;
     }
-    if (functionResponseError) {
-      functionResponse = { error: functionResponseError };
-    } else if (functionResponse == null) {
-      functionResponse = { result: functionResponse };
-    } else {
-      functionResponse = normalizeCallbackResponse(functionResponse);
-    }
     const functionResponseEvent = (0, import_event.createEvent)({
       invocationId: invocationContext.invocationId,
       author: toolEventAuthor(invocationContext),
@@ -449,11 +485,6 @@ async function handleFunctionCallList({
       actions: toolContext.actions,
       branch: invocationContext.branch
     });
-    import_logger.logger.debug("traceToolCall", {
-      tool: tool.name,
-      args: functionArgs,
-      functionResponseEvent: functionResponseEvent.id
-    });
     functionResponseEvents.push(functionResponseEvent);
   }
   if (!functionResponseEvents.length) {
@@ -466,13 +497,10 @@ async function handleFunctionCallList({
     import_tracing.tracer.startActiveSpan("execute_tool (merged)", (span) => {
       try {
         import_logger.logger.debug("execute_tool (merged)");
-        import_logger.logger.debug("traceMergedToolCalls", {
-          responseEventId: mergedEvent.id,
-          functionResponseEvent: mergedEvent.id
-        });
         (0, import_tracing.traceMergedToolCalls)({
           responseEventId: mergedEvent.id,
-          functionResponseEvent: mergedEvent
+          functionResponseEvent: mergedEvent,
+          invocationContext
         });
       } finally {
         span.end();
@@ -510,6 +538,151 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
   });
 }
 __name(mergeParallelFunctionResponseEvents, "mergeParallelFunctionResponseEvents");
+function isAsyncGeneratorFunction(fn) {
+  return typeof fn === "function" && Object.prototype.toString.call(fn) === "[object AsyncGeneratorFunction]";
+}
+__name(isAsyncGeneratorFunction, "isAsyncGeneratorFunction");
+function isStreamingTool(tool) {
+  const candidate = tool;
+  if (typeof candidate._callLive !== "function") {
+    return false;
+  }
+  if ((0, import_function_tool.isFunctionTool)(tool)) {
+    return isAsyncGeneratorFunction(candidate.execute);
+  }
+  return isAsyncGeneratorFunction(candidate.execute) || isAsyncGeneratorFunction(candidate.func) || isAsyncGeneratorFunction(candidate._callLive);
+}
+__name(isStreamingTool, "isStreamingTool");
+async function* callToolLive({
+  tool,
+  args,
+  toolContext,
+  invocationContext
+}) {
+  const results = tool._callLive({
+    args,
+    toolContext,
+    invocationContext
+  });
+  for await (const result of results) {
+    yield result;
+  }
+}
+__name(callToolLive, "callToolLive");
+async function waitForTaskWithTimeout(task, timeoutMs) {
+  let timeoutId;
+  const timeoutPromise = new Promise((resolve) => {
+    timeoutId = setTimeout(resolve, timeoutMs);
+  });
+  try {
+    await Promise.race([
+      task.promise.then(
+        () => void 0,
+        () => void 0
+      ),
+      timeoutPromise
+    ]);
+  } finally {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+__name(waitForTaskWithTimeout, "waitForTaskWithTimeout");
+const STOP_STREAMING_FUNCTION_NAME = "stop_streaming";
+const STOP_STREAMING_TIMEOUT_MS = 1e3;
+async function processFunctionLiveHelper({
+  tool,
+  toolContext,
+  functionCall,
+  functionArgs,
+  invocationContext
+}) {
+  var _a2, _b2;
+  let functionResponse = void 0;
+  const targetFunctionName = typeof functionArgs["function_name"] === "string" ? functionArgs["function_name"] : typeof functionArgs["functionName"] === "string" ? functionArgs["functionName"] : void 0;
+  if (functionCall.name === STOP_STREAMING_FUNCTION_NAME && targetFunctionName !== void 0) {
+    const activeTasks = invocationContext.activeStreamingTools;
+    const activeTask = (_a2 = activeTasks == null ? void 0 : activeTasks[targetFunctionName]) == null ? void 0 : _a2.task;
+    if (activeTasks && activeTask && !activeTask.done()) {
+      activeTask.cancel();
+      await waitForTaskWithTimeout(activeTask, STOP_STREAMING_TIMEOUT_MS);
+      if (!activeTask.done()) {
+        import_logger.logger.warn(`The task for ${targetFunctionName} is not cancelled yet.`);
+        functionResponse = {
+          status: `The task is not cancelled yet for ${targetFunctionName}.`
+        };
+      } else {
+        activeTasks[targetFunctionName].task = void 0;
+        functionResponse = {
+          status: `Successfully stopped streaming function ${targetFunctionName}`
+        };
+      }
+    } else {
+      functionResponse = {
+        status: `No active streaming function named ${targetFunctionName} found`
+      };
+    }
+  } else if (isStreamingTool(tool)) {
+    const task = new import_task.Task(async (abortSignal) => {
+      var _a3, _b3;
+      const generator = callToolLive({
+        tool,
+        args: functionArgs,
+        toolContext,
+        invocationContext
+      });
+      let abortCleanup;
+      const abortPromise = new Promise(
+        (resolve) => {
+          if (abortSignal.aborted) {
+            resolve({ value: void 0, done: true });
+            return;
+          }
+          const onAbort = /* @__PURE__ */ __name(() => {
+            resolve({ value: void 0, done: true });
+          }, "onAbort");
+          abortSignal.addEventListener("abort", onAbort, { once: true });
+          abortCleanup = /* @__PURE__ */ __name(() => abortSignal.removeEventListener("abort", onAbort), "abortCleanup");
+        }
+      );
+      try {
+        while (!abortSignal.aborted) {
+          const nextResult = await Promise.race([
+            generator.next(),
+            abortPromise
+          ]);
+          if (abortSignal.aborted || nextResult.done) {
+            break;
+          }
+          const result = nextResult.value;
+          const updatedContent = (0, import_genai.createUserContent)(
+            `Function ${tool.name} returned: ${String(result)}`
+          );
+          (_a3 = invocationContext.liveRequestQueue) == null ? void 0 : _a3.sendContent(updatedContent);
+        }
+      } finally {
+        abortCleanup == null ? void 0 : abortCleanup();
+        if (abortSignal.aborted) {
+          void ((_b3 = generator.return) == null ? void 0 : _b3.call(generator, void 0));
+        }
+      }
+    });
+    (_b2 = invocationContext.activeStreamingTools) != null ? _b2 : invocationContext.activeStreamingTools = {};
+    if (tool.name in invocationContext.activeStreamingTools) {
+      invocationContext.activeStreamingTools[tool.name].task = task;
+    } else {
+      invocationContext.activeStreamingTools[tool.name] = new import_active_streaming_tool.ActiveStreamingTool({ task });
+    }
+    functionResponse = {
+      status: "The function is running asynchronously and the results are pending."
+    };
+  } else {
+    functionResponse = await callToolAsync(tool, functionArgs, toolContext);
+  }
+  return functionResponse;
+}
+__name(processFunctionLiveHelper, "processFunctionLiveHelper");
 function findEventByFunctionCallId(events, functionCallId, endIndex = events.length) {
   for (let i = endIndex - 1; i >= 0; i--) {
     const event = events[i];
@@ -579,6 +752,7 @@ __name(getConflictingFunctionResponseAuthors, "getConflictingFunctionResponseAut
   getLongRunningFunctionCalls,
   handleFunctionCallList,
   handleFunctionCallsAsync,
+  handleFunctionCallsLive,
   isToolNotFound,
   mergeParallelFunctionResponseEvents,
   populateClientFunctionCallId,

package/dist/cjs/agents/instructions.js

@@ -117,7 +117,10 @@ async function injectSessionState(template, readonlyContext) {
     resolved: resolveSourceNode(match[0], match[1], match[2], scope)
   })) : [];
   const pattern = /\{+[^{}]*}+/g;
-  const matches = Array.from(template.matchAll(pattern));
+  const matches = Array.from(template.matchAll(pattern)).filter((match) => {
+    const previous = template[match.index - 1];
+    return previous !== "$" && previous !== "\\";
+  });
   if (matches.length === 0 && sourceMatches.length === 0) {
     return template;
   }

package/dist/cjs/agents/invocation_context.js

@@ -26,6 +26,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var invocation_context_exports = {};
 __export(invocation_context_exports, {
   InvocationContext: () => InvocationContext,
+  LlmCallsLimitExceededError: () => LlmCallsLimitExceededError,
+  isLlmCallsLimitExceededError: () => isLlmCallsLimitExceededError,
   newInvocationContextId: () => newInvocationContextId,
   requireAgent: () => requireAgent
 });
@@ -36,6 +38,24 @@ var import_env_aware_utils = require("../utils/env_aware_utils.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a, _b;
+const LLM_CALLS_LIMIT_EXCEEDED_ERROR_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.llmCallsLimitExceededError"
+);
+const _LlmCallsLimitExceededError = class _LlmCallsLimitExceededError extends (_b = Error, _a = LLM_CALLS_LIMIT_EXCEEDED_ERROR_SIGNATURE_SYMBOL, _b) {
+  constructor(message) {
+    super(message);
+    this[_a] = true;
+    this.name = "LlmCallsLimitExceededError";
+    Object.setPrototypeOf(this, _LlmCallsLimitExceededError.prototype);
+  }
+};
+__name(_LlmCallsLimitExceededError, "LlmCallsLimitExceededError");
+let LlmCallsLimitExceededError = _LlmCallsLimitExceededError;
+function isLlmCallsLimitExceededError(obj) {
+  return typeof obj === "object" && obj !== null && LLM_CALLS_LIMIT_EXCEEDED_ERROR_SIGNATURE_SYMBOL in obj && obj[LLM_CALLS_LIMIT_EXCEEDED_ERROR_SIGNATURE_SYMBOL] === true;
+}
+__name(isLlmCallsLimitExceededError, "isLlmCallsLimitExceededError");
 const _InvocationCostManager = class _InvocationCostManager {
   constructor() {
     this.numberOfLlmCalls = 0;
@@ -49,7 +69,7 @@ const _InvocationCostManager = class _InvocationCostManager {
   incrementAndEnforceLlmCallsLimit(runConfig) {
     this.numberOfLlmCalls++;
     if (runConfig && runConfig.maxLlmCalls > 0 && this.numberOfLlmCalls > runConfig.maxLlmCalls) {
-      throw new Error(
+      throw new LlmCallsLimitExceededError(
         `Max number of llm calls limit of ${runConfig.maxLlmCalls} exceeded`
       );
     }
@@ -62,7 +82,7 @@ const _InvocationContext = class _InvocationContext {
    * @param params The parameters for creating an invocation context.
    */
   constructor(params) {
-    var _a, _b;
+    var _a2, _b2;
     this.artifactService = params.artifactService;
     this.sessionService = params.sessionService;
     this.memoryService = params.memoryService;
@@ -79,9 +99,9 @@ const _InvocationContext = class _InvocationContext {
     this.abortSignal = params.abortSignal;
     this.workflowInstructionScope = params.workflowInstructionScope;
     this.isolationScope = params.isolationScope;
-    this.nodeToolDepth = (_a = params.nodeToolDepth) != null ? _a : 0;
+    this.nodeToolDepth = (_a2 = params.nodeToolDepth) != null ? _a2 : 0;
     this.a2aMetadata = params.a2aMetadata;
-    this.invocationCostManager = (_b = params.invocationCostManager) != null ? _b : new InvocationCostManager();
+    this.invocationCostManager = (_b2 = params.invocationCostManager) != null ? _b2 : new InvocationCostManager();
     this.liveRequestQueue = params.liveRequestQueue;
     this.liveSessionResumptionHandle = params.liveSessionResumptionHandle;
   }
@@ -136,6 +156,8 @@ __name(requireAgent, "requireAgent");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InvocationContext,
+  LlmCallsLimitExceededError,
+  isLlmCallsLimitExceededError,
   newInvocationContextId,
   requireAgent
 });