@google/adk 1.6.0 → 2.1.0

package/dist/cjs/agents/functions.js

@@ -9,6 +9,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -25,36 +26,47 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var functions_exports = {};
 __export(functions_exports, {
   AF_FUNCTION_CALL_ID_PREFIX: () => import_event2.AF_FUNCTION_CALL_ID_PREFIX,
-  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME: () => REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
-  REQUEST_EUC_FUNCTION_CALL_NAME: () => REQUEST_EUC_FUNCTION_CALL_NAME,
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME: () => import_framework_function_calls2.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME: () => import_framework_function_calls2.REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME: () => import_framework_function_calls2.REQUEST_INPUT_FUNCTION_CALL_NAME,
   findEventByFunctionCallId: () => findEventByFunctionCallId,
   findMatchingFunctionCall: () => findMatchingFunctionCall,
   functionsExportedForTestingOnly: () => functionsExportedForTestingOnly,
   generateAuthEvent: () => generateAuthEvent,
   generateClientFunctionCallId: () => import_event2.generateClientFunctionCallId,
   generateRequestConfirmationEvent: () => generateRequestConfirmationEvent,
+  getConflictingFunctionResponseAuthors: () => getConflictingFunctionResponseAuthors,
   getLongRunningFunctionCalls: () => getLongRunningFunctionCalls,
   handleFunctionCallList: () => handleFunctionCallList,
   handleFunctionCallsAsync: () => handleFunctionCallsAsync,
+  isToolNotFound: () => isToolNotFound,
   mergeParallelFunctionResponseEvents: () => mergeParallelFunctionResponseEvents,
-  populateClientFunctionCallId: () => import_event2.populateClientFunctionCallId
+  populateClientFunctionCallId: () => import_event2.populateClientFunctionCallId,
+  reservedFunctionCallName: () => import_framework_function_calls2.reservedFunctionCallName
 });
 module.exports = __toCommonJS(functions_exports);
 var import_genai = require("@google/genai");
 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_logger = require("../utils/logger.js");
 var import_context = require("./context.js");
+var import_framework_function_calls = require("./framework_function_calls.js");
 var import_tracing = require("../telemetry/tracing.js");
 var import_event2 = require("../events/event.js");
+var import_framework_function_calls2 = require("./framework_function_calls.js");
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
-const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+var _a, _b;
+function toolEventAuthor(invocationContext) {
+  var _a2, _b2;
+  return (_b2 = (_a2 = invocationContext.agent) == null ? void 0 : _a2.name) != null ? _b2 : "";
+}
+__name(toolEventAuthor, "toolEventAuthor");
 const functionsExportedForTestingOnly = {
   handleFunctionCallList,
   generateAuthEvent,
@@ -69,9 +81,10 @@ function getLongRunningFunctionCalls(functionCalls, toolsDict) {
   }
   return longRunningToolIds;
 }
+__name(getLongRunningFunctionCalls, "getLongRunningFunctionCalls");
 function generateAuthEvent(invocationContext, functionResponseEvent) {
-  var _a;
-  if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedAuthConfigs) || (0, import_lodash_es.isEmpty)(functionResponseEvent.actions.requestedAuthConfigs)) {
+  var _a2, _b2, _c;
+  if (!((_a2 = functionResponseEvent.actions) == null ? void 0 : _a2.requestedAuthConfigs) || (0, import_lodash_es.isEmpty)(functionResponseEvent.actions.requestedAuthConfigs)) {
     return void 0;
   }
   const parts = [];
@@ -79,35 +92,36 @@ function generateAuthEvent(invocationContext, functionResponseEvent) {
   for (const [functionCallId, authConfig] of Object.entries(
     functionResponseEvent.actions.requestedAuthConfigs
   )) {
-    const requestEucFunctionCall = {
-      name: REQUEST_EUC_FUNCTION_CALL_NAME,
+    const requestCredentialFunctionCall = {
+      name: import_framework_function_calls.REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
       args: {
         "function_call_id": functionCallId,
         "auth_config": authConfig
       },
       id: (0, import_event.generateClientFunctionCallId)()
     };
-    longRunningToolIds.add(requestEucFunctionCall.id);
-    parts.push({ functionCall: requestEucFunctionCall });
+    longRunningToolIds.add(requestCredentialFunctionCall.id);
+    parts.push({ functionCall: requestCredentialFunctionCall });
   }
   return (0, import_event.createEvent)({
     invocationId: invocationContext.invocationId,
-    author: invocationContext.agent.name,
+    author: toolEventAuthor(invocationContext),
     branch: invocationContext.branch,
     content: {
       parts,
-      role: functionResponseEvent.content.role
+      role: (_c = (_b2 = functionResponseEvent.content) == null ? void 0 : _b2.role) != null ? _c : "user"
     },
     longRunningToolIds: Array.from(longRunningToolIds)
   });
 }
+__name(generateAuthEvent, "generateAuthEvent");
 function generateRequestConfirmationEvent({
   invocationContext,
   functionCallEvent,
   functionResponseEvent
 }) {
-  var _a, _b;
-  if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedToolConfirmations) || (0, import_lodash_es.isEmpty)(functionResponseEvent.actions.requestedToolConfirmations)) {
+  var _a2, _b2, _c, _d;
+  if (!((_a2 = functionResponseEvent.actions) == null ? void 0 : _a2.requestedToolConfirmations) || (0, import_lodash_es.isEmpty)(functionResponseEvent.actions.requestedToolConfirmations)) {
     return;
   }
   const parts = [];
@@ -116,12 +130,12 @@ function generateRequestConfirmationEvent({
   for (const [functionCallId, toolConfirmation] of Object.entries(
     functionResponseEvent.actions.requestedToolConfirmations
   )) {
-    const originalFunctionCall = (_b = functionCalls.find((call) => call.id === functionCallId)) != null ? _b : void 0;
+    const originalFunctionCall = (_b2 = functionCalls.find((call) => call.id === functionCallId)) != null ? _b2 : void 0;
     if (!originalFunctionCall) {
       continue;
     }
     const requestConfirmationFunctionCall = {
-      name: REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+      name: import_framework_function_calls.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
       args: {
         "originalFunctionCall": originalFunctionCall,
         "toolConfirmation": toolConfirmation
@@ -133,16 +147,17 @@ function generateRequestConfirmationEvent({
   }
   return (0, import_event.createEvent)({
     invocationId: invocationContext.invocationId,
-    author: invocationContext.agent.name,
+    author: toolEventAuthor(invocationContext),
     branch: invocationContext.branch,
     content: {
       parts,
-      role: functionResponseEvent.content.role
+      role: (_d = (_c = functionResponseEvent.content) == null ? void 0 : _c.role) != null ? _d : "user"
     },
     actions: functionResponseEvent.actions,
     longRunningToolIds: Array.from(longRunningToolIds)
   });
 }
+__name(generateRequestConfirmationEvent, "generateRequestConfirmationEvent");
 async function callToolAsync(tool, args, toolContext) {
   return import_tracing.tracer.startActiveSpan(`execute_tool ${tool.name}`, async (span) => {
     try {
@@ -164,6 +179,7 @@ async function callToolAsync(tool, args, toolContext) {
     }
   });
 }
+__name(callToolAsync, "callToolAsync");
 function buildResponseEvent(tool, functionResult, toolContext, invocationContext) {
   let responseResult;
   if (typeof functionResult !== "object" || functionResult == null) {
@@ -186,12 +202,13 @@ function buildResponseEvent(tool, functionResult, toolContext, invocationContext
   };
   return (0, import_event.createEvent)({
     invocationId: invocationContext.invocationId,
-    author: invocationContext.agent.name,
+    author: toolEventAuthor(invocationContext),
     content,
     actions: toolContext.actions,
     branch: invocationContext.branch
   });
 }
+__name(buildResponseEvent, "buildResponseEvent");
 async function handleFunctionCallsAsync({
   invocationContext,
   functionCallEvent,
@@ -199,7 +216,8 @@ async function handleFunctionCallsAsync({
   beforeToolCallbacks,
   afterToolCallbacks,
   filters,
-  toolConfirmationDict
+  toolConfirmationDict,
+  resumeInputsDict
 }) {
   const functionCalls = (0, import_event.getFunctionCalls)(functionCallEvent);
   return await handleFunctionCallList({
@@ -209,9 +227,11 @@ async function handleFunctionCallsAsync({
     beforeToolCallbacks,
     afterToolCallbacks,
     filters,
-    toolConfirmationDict
+    toolConfirmationDict,
+    resumeInputsDict
   });
 }
+__name(handleFunctionCallsAsync, "handleFunctionCallsAsync");
 function normalizeCallbackResponse(response) {
   if (response == null) {
     return void 0;
@@ -224,6 +244,71 @@ function normalizeCallbackResponse(response) {
   }
   return response;
 }
+__name(normalizeCallbackResponse, "normalizeCallbackResponse");
+const RESOLUTION_FAILURE_CAUSES = `Possible causes:
+  1. The model hallucinated the name.
+  2. The tool is not registered on this agent, or a plugin filtered it out of this request.
+  3. The name does not match the registered tool's name exactly.
+  4. The tool is registered but never enters the toolsDict, because its \`_getDeclaration()\` returns undefined (as prompt-injecting tools like \`ExampleTool\` and \`PreloadMemoryTool\` do).`;
+const TOOL_NOT_FOUND_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.toolNotFound");
+function isToolNotFound(tool) {
+  return typeof tool === "object" && tool !== null && tool[TOOL_NOT_FOUND_SYMBOL] === true;
+}
+__name(isToolNotFound, "isToolNotFound");
+const _ToolNotFoundPlaceholder = class _ToolNotFoundPlaceholder extends (_b = import_base_tool.BaseTool, _a = TOOL_NOT_FOUND_SYMBOL, _b) {
+  constructor(name, resolutionError) {
+    super({ name, description: "Tool not found" });
+    this.resolutionError = resolutionError;
+    this[_a] = true;
+  }
+  async runAsync() {
+    throw this.resolutionError;
+  }
+};
+__name(_ToolNotFoundPlaceholder, "ToolNotFoundPlaceholder");
+let ToolNotFoundPlaceholder = _ToolNotFoundPlaceholder;
+async function answerUnresolvableCall({
+  invocationContext,
+  functionCall,
+  toolsDict,
+  toolContext
+}) {
+  return import_tracing.tracer.startActiveSpan(
+    `execute_tool ${functionCall.name || "<unnamed>"}`,
+    async (span) => {
+      var _a2, _b2;
+      try {
+        const toolName = functionCall.name || "<unnamed>";
+        const error = new Error(
+          `Function ${toolName} is not found in the toolsDict.`
+        );
+        const tool = new ToolNotFoundPlaceholder(toolName, error);
+        const onToolErrorResponse = await invocationContext.pluginManager.runOnToolErrorCallback({
+          tool,
+          toolArgs: (_a2 = functionCall.args) != null ? _a2 : {},
+          toolContext,
+          error
+        });
+        if (onToolErrorResponse == null) {
+          const callableTools = Object.keys(toolsDict);
+          import_logger.logger.warn(
+            `Could not resolve tool '${toolName}' for function call '${(_b2 = functionCall.id) != null ? _b2 : ""}'. Callable tools: ${callableTools.length ? callableTools.join(", ") : "(none)"}.
+` + RESOLUTION_FAILURE_CAUSES
+          );
+        }
+        return buildResponseEvent(
+          tool,
+          onToolErrorResponse != null ? onToolErrorResponse : { error: error.message },
+          toolContext,
+          invocationContext
+        );
+      } finally {
+        span.end();
+      }
+    }
+  );
+}
+__name(answerUnresolvableCall, "answerUnresolvableCall");
 async function handleFunctionCallList({
   invocationContext,
   functionCalls,
@@ -231,9 +316,10 @@ async function handleFunctionCallList({
   beforeToolCallbacks,
   afterToolCallbacks,
   filters,
-  toolConfirmationDict
+  toolConfirmationDict,
+  resumeInputsDict
 }) {
-  var _a;
+  var _a2;
   const functionResponseEvents = [];
   const filteredFunctionCalls = functionCalls.filter((functionCall) => {
     return !filters || functionCall.id && filters.has(functionCall.id);
@@ -243,14 +329,30 @@ async function handleFunctionCallList({
     if (toolConfirmationDict && functionCall.id) {
       toolConfirmation = toolConfirmationDict[functionCall.id];
     }
-    const { tool, toolContext } = getToolAndContext({
+    let resumeInputs = void 0;
+    if (resumeInputsDict && functionCall.id) {
+      resumeInputs = resumeInputsDict[functionCall.id];
+    }
+    const toolContext = new import_context.Context({
       invocationContext,
-      functionCall,
-      toolsDict,
-      toolConfirmation
+      functionCallId: functionCall.id || void 0,
+      toolConfirmation,
+      resumeInputs
     });
+    const tool = functionCall.name && Object.hasOwn(toolsDict, functionCall.name) ? toolsDict[functionCall.name] : void 0;
+    if (!tool) {
+      functionResponseEvents.push(
+        await answerUnresolvableCall({
+          invocationContext,
+          functionCall,
+          toolsDict,
+          toolContext
+        })
+      );
+      continue;
+    }
     import_logger.logger.debug(`execute_tool ${tool.name}`);
-    const functionArgs = (_a = functionCall.args) != null ? _a : {};
+    const functionArgs = (_a2 = functionCall.args) != null ? _a2 : {};
     let functionResponse = null;
     let functionResponseError;
     functionResponse = await invocationContext.pluginManager.runBeforeToolCallback({
@@ -315,6 +417,16 @@ async function handleFunctionCallList({
       functionResponse = normalizeCallbackResponse(alteredFunctionResponse);
     }
     if (tool.isLongRunning && functionResponse == null) {
+      if (!(0, import_event_actions.isDefaultEventActions)(toolContext.actions)) {
+        functionResponseEvents.push(
+          (0, import_event.createEvent)({
+            invocationId: invocationContext.invocationId,
+            author: toolEventAuthor(invocationContext),
+            actions: toolContext.actions,
+            branch: invocationContext.branch
+          })
+        );
+      }
       continue;
     }
     if (functionResponseError) {
@@ -326,7 +438,7 @@ async function handleFunctionCallList({
     }
     const functionResponseEvent = (0, import_event.createEvent)({
       invocationId: invocationContext.invocationId,
-      author: invocationContext.agent.name,
+      author: toolEventAuthor(invocationContext),
       content: (0, import_genai.createUserContent)({
         functionResponse: {
           id: toolContext.functionCallId,
@@ -369,25 +481,7 @@ async function handleFunctionCallList({
   }
   return mergedEvent;
 }
-function getToolAndContext({
-  invocationContext,
-  functionCall,
-  toolsDict,
-  toolConfirmation
-}) {
-  if (!functionCall.name || !(functionCall.name in toolsDict)) {
-    throw new Error(
-      `Function ${functionCall.name} is not found in the toolsDict.`
-    );
-  }
-  const toolContext = new import_context.Context({
-    invocationContext,
-    functionCallId: functionCall.id || void 0,
-    toolConfirmation
-  });
-  const tool = toolsDict[functionCall.name];
-  return { tool, toolContext };
-}
+__name(handleFunctionCallList, "handleFunctionCallList");
 function mergeParallelFunctionResponseEvents(functionResponseEvents) {
   if (!functionResponseEvents.length) {
     throw new Error("No function response events provided.");
@@ -415,6 +509,7 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
     timestamp: baseEvent.timestamp
   });
 }
+__name(mergeParallelFunctionResponseEvents, "mergeParallelFunctionResponseEvents");
 function findEventByFunctionCallId(events, functionCallId, endIndex = events.length) {
   for (let i = endIndex - 1; i >= 0; i--) {
     const event = events[i];
@@ -427,35 +522,65 @@ function findEventByFunctionCallId(events, functionCallId, endIndex = events.len
   }
   return void 0;
 }
-function findMatchingFunctionCall(events) {
+__name(findEventByFunctionCallId, "findEventByFunctionCallId");
+function resolveFunctionResponseMatch(events) {
+  var _a2, _b2;
   if (!events.length) {
-    return void 0;
+    return { resolved: void 0, conflictingAuthors: void 0 };
   }
   const lastEvent = events[events.length - 1];
   const functionResponses = (0, import_event.getFunctionResponses)(lastEvent);
-  if (!functionResponses.length || !functionResponses[0].id) {
-    return void 0;
+  if (!functionResponses.length) {
+    return { resolved: void 0, conflictingAuthors: void 0 };
   }
-  return findEventByFunctionCallId(
-    events,
-    functionResponses[0].id,
-    events.length - 1
-  );
+  let resolved;
+  let conflictingAuthors;
+  for (const functionResponse of functionResponses) {
+    if (!functionResponse.id) {
+      continue;
+    }
+    const match = findEventByFunctionCallId(
+      events,
+      functionResponse.id,
+      events.length - 1
+    );
+    if (!match) {
+      continue;
+    }
+    if (!conflictingAuthors && resolved && resolved.author !== match.author) {
+      conflictingAuthors = [(_a2 = resolved.author) != null ? _a2 : "", (_b2 = match.author) != null ? _b2 : ""];
+    }
+    resolved = match;
+  }
+  return { resolved, conflictingAuthors };
+}
+__name(resolveFunctionResponseMatch, "resolveFunctionResponseMatch");
+function findMatchingFunctionCall(events) {
+  return resolveFunctionResponseMatch(events).resolved;
+}
+__name(findMatchingFunctionCall, "findMatchingFunctionCall");
+function getConflictingFunctionResponseAuthors(events) {
+  return resolveFunctionResponseMatch(events).conflictingAuthors;
 }
+__name(getConflictingFunctionResponseAuthors, "getConflictingFunctionResponseAuthors");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AF_FUNCTION_CALL_ID_PREFIX,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
-  REQUEST_EUC_FUNCTION_CALL_NAME,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME,
   findEventByFunctionCallId,
   findMatchingFunctionCall,
   functionsExportedForTestingOnly,
   generateAuthEvent,
   generateClientFunctionCallId,
   generateRequestConfirmationEvent,
+  getConflictingFunctionResponseAuthors,
   getLongRunningFunctionCalls,
   handleFunctionCallList,
   handleFunctionCallsAsync,
+  isToolNotFound,
   mergeParallelFunctionResponseEvents,
-  populateClientFunctionCallId
+  populateClientFunctionCallId,
+  reservedFunctionCallName
 });

package/dist/cjs/agents/instructions.js

@@ -9,6 +9,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -34,6 +35,17 @@ var import_state = require("../sessions/state.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 const ARTIFACT_PREFIX = "artifact.";
+const WORKFLOW_FIELD_KEY = /^[A-Za-z_]\w*\.[A-Za-z_]\w*$/;
+const SOURCE_NODE_PLACEHOLDER = /<\s*[A-Za-z_]\w*\.([A-Za-z_]\w*)\s+from\s+([A-Za-z_]\w*)\s*>/g;
+function resolveSourceNode(raw, field, nodeName, scope) {
+  var _a;
+  const out = (_a = scope.outputsByNode) == null ? void 0 : _a[nodeName];
+  if (out && typeof out === "object" && field in out) {
+    return formatValue(out[field], false);
+  }
+  return raw;
+}
+__name(resolveSourceNode, "resolveSourceNode");
 async function resolveKey(key, isOptional, rawMatch, readonlyContext) {
   const invocationContext = readonlyContext.invocationContext;
   if (key.startsWith(ARTIFACT_PREFIX)) {
@@ -52,17 +64,29 @@ async function resolveKey(key, isOptional, rawMatch, readonlyContext) {
     }
     return formatValue(artifact, true);
   }
-  if (!isValidStateName(key)) {
-    return rawMatch;
-  }
-  if (key in invocationContext.session.state) {
-    return formatValue(invocationContext.session.state[key], false);
+  if (isValidStateName(key)) {
+    if (key in invocationContext.session.state) {
+      return formatValue(invocationContext.session.state[key], false);
+    }
+    if (isOptional) {
+      return "";
+    }
+    throw new Error(`Context variable not found: \`${key}\`.`);
   }
-  if (isOptional) {
-    return "";
+  const scope = invocationContext.workflowInstructionScope;
+  if (scope && WORKFLOW_FIELD_KEY.test(key)) {
+    const field = key.slice(key.indexOf(".") + 1);
+    const input = scope.input;
+    if (input && typeof input === "object" && field in input) {
+      return formatValue(input[field], false);
+    }
+    if (isOptional) {
+      return "";
+    }
   }
-  throw new Error(`Context variable not found: \`${key}\`.`);
+  return rawMatch;
 }
+__name(resolveKey, "resolveKey");
 function formatValue(value, isArtifact = false) {
   if (typeof value === "string") {
     return value;
@@ -84,10 +108,17 @@ function formatValue(value, isArtifact = false) {
   }
   return String(value);
 }
+__name(formatValue, "formatValue");
 async function injectSessionState(template, readonlyContext) {
+  const scope = readonlyContext.invocationContext.workflowInstructionScope;
+  const sourceMatches = scope ? Array.from(template.matchAll(SOURCE_NODE_PLACEHOLDER)).map((match) => ({
+    raw: match[0],
+    index: match.index,
+    resolved: resolveSourceNode(match[0], match[1], match[2], scope)
+  })) : [];
   const pattern = /\{+[^{}]*}+/g;
   const matches = Array.from(template.matchAll(pattern));
-  if (matches.length === 0) {
+  if (matches.length === 0 && sourceMatches.length === 0) {
     return template;
   }
   const parsedMatches = matches.map((match) => {
@@ -97,7 +128,7 @@ async function injectSessionState(template, readonlyContext) {
     if (isOptional) {
       key = key.slice(0, -1);
     }
-    const isValid = key.startsWith(ARTIFACT_PREFIX) || isValidStateName(key);
+    const isValid = key.startsWith(ARTIFACT_PREFIX) || isValidStateName(key) || !!scope && WORKFLOW_FIELD_KEY.test(key);
     return {
       raw,
       key,
@@ -132,11 +163,16 @@ async function injectSessionState(template, readonlyContext) {
     );
   }
   await Promise.all(resolutions.values());
+  const allMatches = [...parsedMatches, ...sourceMatches].sort(
+    (a, b) => a.index - b.index
+  );
   const result = [];
   let lastEnd = 0;
-  for (const pm of parsedMatches) {
+  for (const pm of allMatches) {
     result.push(template.slice(lastEnd, pm.index));
-    if (pm.isValid) {
+    if ("resolved" in pm) {
+      result.push(pm.resolved);
+    } else if (pm.isValid) {
       const replacement = await resolutions.get(pm.key);
       result.push(replacement);
     } else {
@@ -147,6 +183,7 @@ async function injectSessionState(template, readonlyContext) {
   result.push(template.slice(lastEnd));
   return result.join("");
 }
+__name(injectSessionState, "injectSessionState");
 const isIdentifierPattern = /* @__PURE__ */ (() => {
   return /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 })();
@@ -156,6 +193,7 @@ function isIdentifier(s) {
   }
   return isIdentifierPattern.test(s);
 }
+__name(isIdentifier, "isIdentifier");
 const VALID_PREFIXES = [import_state.State.APP_PREFIX, import_state.State.USER_PREFIX, import_state.State.TEMP_PREFIX];
 function isValidStateName(variableName) {
   const parts = variableName.split(":");
@@ -170,6 +208,7 @@ function isValidStateName(variableName) {
   }
   return false;
 }
+__name(isValidStateName, "isValidStateName");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   injectSessionState

package/dist/cjs/agents/invocation_context.js

@@ -9,6 +9,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -25,7 +26,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var invocation_context_exports = {};
 __export(invocation_context_exports, {
   InvocationContext: () => InvocationContext,
-  newInvocationContextId: () => newInvocationContextId
+  newInvocationContextId: () => newInvocationContextId,
+  requireAgent: () => requireAgent
 });
 module.exports = __toCommonJS(invocation_context_exports);
 var import_env_aware_utils = require("../utils/env_aware_utils.js");
@@ -34,7 +36,7 @@ var import_env_aware_utils = require("../utils/env_aware_utils.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class InvocationCostManager {
+const _InvocationCostManager = class _InvocationCostManager {
   constructor() {
     this.numberOfLlmCalls = 0;
   }
@@ -52,13 +54,15 @@ class InvocationCostManager {
       );
     }
   }
-}
-class InvocationContext {
+};
+__name(_InvocationCostManager, "InvocationCostManager");
+let InvocationCostManager = _InvocationCostManager;
+const _InvocationContext = class _InvocationContext {
   /**
    * @param params The parameters for creating an invocation context.
    */
   constructor(params) {
-    var _a;
+    var _a, _b;
     this.artifactService = params.artifactService;
     this.sessionService = params.sessionService;
     this.memoryService = params.memoryService;
@@ -73,7 +77,13 @@ class InvocationContext {
     this.activeStreamingTools = params.activeStreamingTools;
     this.pluginManager = params.pluginManager;
     this.abortSignal = params.abortSignal;
-    this.invocationCostManager = (_a = params.invocationCostManager) != null ? _a : new InvocationCostManager();
+    this.workflowInstructionScope = params.workflowInstructionScope;
+    this.isolationScope = params.isolationScope;
+    this.nodeToolDepth = (_a = params.nodeToolDepth) != null ? _a : 0;
+    this.a2aMetadata = params.a2aMetadata;
+    this.invocationCostManager = (_b = params.invocationCostManager) != null ? _b : new InvocationCostManager();
+    this.liveRequestQueue = params.liveRequestQueue;
+    this.liveSessionResumptionHandle = params.liveSessionResumptionHandle;
   }
   /**
    * The app name of the current session.
@@ -95,12 +105,37 @@ class InvocationContext {
   incrementLlmCallCount() {
     this.invocationCostManager.incrementAndEnforceLlmCallsLimit(this.runConfig);
   }
-}
+  /**
+   * Returns a copy of this context with `overrides` applied. The spread carries
+   * every own field over (including the shared cost manager), so the copy keeps
+   * a single LLM-call counter for the invocation.
+   *
+   * Note: this copies own enumerable fields by value — scalar mutable fields
+   * (e.g. `endInvocation`) are decoupled from the original, while object-valued
+   * fields (`session`, …) stay shared by reference.
+   */
+  clone(overrides = {}) {
+    return new _InvocationContext({ ...this, ...overrides });
+  }
+};
+__name(_InvocationContext, "InvocationContext");
+let InvocationContext = _InvocationContext;
 function newInvocationContextId() {
   return `e-${(0, import_env_aware_utils.randomUUID)()}`;
 }
+__name(newInvocationContextId, "newInvocationContextId");
+function requireAgent(ctx) {
+  if (!ctx.agent) {
+    throw new Error(
+      "InvocationContext.agent is not set: this invocation is running a node directly, so there is no agent at this level."
+    );
+  }
+  return ctx.agent;
+}
+__name(requireAgent, "requireAgent");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InvocationContext,
-  newInvocationContextId
+  newInvocationContextId,
+  requireAgent
 });