@google/adk 1.5.0 → 2.0.0

package/dist/esm/agents/framework_function_calls.js

@@ -0,0 +1,34 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+const REQUEST_CREDENTIAL_FUNCTION_CALL_NAME = "adk_request_credential";
+const REQUEST_INPUT_FUNCTION_CALL_NAME = "adk_request_input";
+const RESERVED_FUNCTION_CALL_NAMES = /* @__PURE__ */ new Set([
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME
+]);
+function reservedFunctionCallName(content) {
+  var _a, _b;
+  for (const part of (_a = content == null ? void 0 : content.parts) != null ? _a : []) {
+    const name = (_b = part.functionCall) == null ? void 0 : _b.name;
+    if (name && RESERVED_FUNCTION_CALL_NAMES.has(name)) {
+      return name;
+    }
+  }
+  return void 0;
+}
+__name(reservedFunctionCallName, "reservedFunctionCallName");
+export {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME,
+  reservedFunctionCallName
+};

package/dist/esm/agents/functions.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -16,18 +18,31 @@ import {
 import { mergeEventActions } from "../events/event_actions.js";
 import { logger } from "../utils/logger.js";
 import { Context } from "./context.js";
+import {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME
+} from "./framework_function_calls.js";
 import {
   traceMergedToolCalls,
   tracer,
   traceToolCall
 } from "../telemetry/tracing.js";
+function toolEventAuthor(invocationContext) {
+  var _a, _b;
+  return (_b = (_a = invocationContext.agent) == null ? void 0 : _a.name) != null ? _b : "";
+}
+__name(toolEventAuthor, "toolEventAuthor");
 import {
   AF_FUNCTION_CALL_ID_PREFIX,
   generateClientFunctionCallId as generateClientFunctionCallId2,
   populateClientFunctionCallId
 } from "../events/event.js";
-const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
-const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+import {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME as REQUEST_CONFIRMATION_FUNCTION_CALL_NAME2,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME as REQUEST_CREDENTIAL_FUNCTION_CALL_NAME2,
+  REQUEST_INPUT_FUNCTION_CALL_NAME,
+  reservedFunctionCallName
+} from "./framework_function_calls.js";
 const functionsExportedForTestingOnly = {
   handleFunctionCallList,
   generateAuthEvent,
@@ -42,6 +57,7 @@ function getLongRunningFunctionCalls(functionCalls, toolsDict) {
   }
   return longRunningToolIds;
 }
+__name(getLongRunningFunctionCalls, "getLongRunningFunctionCalls");
 function generateAuthEvent(invocationContext, functionResponseEvent) {
   var _a;
   if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedAuthConfigs) || isEmpty(functionResponseEvent.actions.requestedAuthConfigs)) {
@@ -52,20 +68,20 @@ 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: REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
       args: {
         "function_call_id": functionCallId,
         "auth_config": authConfig
       },
       id: generateClientFunctionCallId()
     };
-    longRunningToolIds.add(requestEucFunctionCall.id);
-    parts.push({ functionCall: requestEucFunctionCall });
+    longRunningToolIds.add(requestCredentialFunctionCall.id);
+    parts.push({ functionCall: requestCredentialFunctionCall });
   }
   return createEvent({
     invocationId: invocationContext.invocationId,
-    author: invocationContext.agent.name,
+    author: toolEventAuthor(invocationContext),
     branch: invocationContext.branch,
     content: {
       parts,
@@ -74,6 +90,7 @@ function generateAuthEvent(invocationContext, functionResponseEvent) {
     longRunningToolIds: Array.from(longRunningToolIds)
   });
 }
+__name(generateAuthEvent, "generateAuthEvent");
 function generateRequestConfirmationEvent({
   invocationContext,
   functionCallEvent,
@@ -106,7 +123,7 @@ function generateRequestConfirmationEvent({
   }
   return createEvent({
     invocationId: invocationContext.invocationId,
-    author: invocationContext.agent.name,
+    author: toolEventAuthor(invocationContext),
     branch: invocationContext.branch,
     content: {
       parts,
@@ -116,6 +133,7 @@ function generateRequestConfirmationEvent({
     longRunningToolIds: Array.from(longRunningToolIds)
   });
 }
+__name(generateRequestConfirmationEvent, "generateRequestConfirmationEvent");
 async function callToolAsync(tool, args, toolContext) {
   return tracer.startActiveSpan(`execute_tool ${tool.name}`, async (span) => {
     try {
@@ -137,6 +155,7 @@ async function callToolAsync(tool, args, toolContext) {
     }
   });
 }
+__name(callToolAsync, "callToolAsync");
 function buildResponseEvent(tool, functionResult, toolContext, invocationContext) {
   let responseResult;
   if (typeof functionResult !== "object" || functionResult == null) {
@@ -159,12 +178,13 @@ function buildResponseEvent(tool, functionResult, toolContext, invocationContext
   };
   return 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,
@@ -185,6 +205,20 @@ async function handleFunctionCallsAsync({
     toolConfirmationDict
   });
 }
+__name(handleFunctionCallsAsync, "handleFunctionCallsAsync");
+function normalizeCallbackResponse(response) {
+  if (response == null) {
+    return void 0;
+  }
+  if (typeof response !== "object") {
+    return { result: response };
+  }
+  if (Array.isArray(response)) {
+    return { results: response };
+  }
+  return response;
+}
+__name(normalizeCallbackResponse, "normalizeCallbackResponse");
 async function handleFunctionCallList({
   invocationContext,
   functionCalls,
@@ -231,6 +265,7 @@ async function handleFunctionCallList({
         }
       }
     }
+    functionResponse = normalizeCallbackResponse(functionResponse);
     if (functionResponse == null) {
       try {
         functionResponse = await callToolAsync(tool, functionArgs, toolContext);
@@ -242,8 +277,8 @@ async function handleFunctionCallList({
             toolContext,
             error: e
           });
-          if (onToolErrorResponse) {
-            functionResponse = onToolErrorResponse;
+          if (onToolErrorResponse != null) {
+            functionResponse = normalizeCallbackResponse(onToolErrorResponse);
           } else {
             functionResponseError = e.message;
           }
@@ -272,21 +307,21 @@ async function handleFunctionCallList({
       }
     }
     if (alteredFunctionResponse != null) {
-      functionResponse = alteredFunctionResponse;
+      functionResponse = normalizeCallbackResponse(alteredFunctionResponse);
     }
-    if (tool.isLongRunning && !functionResponse) {
+    if (tool.isLongRunning && functionResponse == null) {
       continue;
     }
     if (functionResponseError) {
       functionResponse = { error: functionResponseError };
-    } else if (typeof functionResponse !== "object" || functionResponse == null) {
+    } else if (functionResponse == null) {
       functionResponse = { result: functionResponse };
-    } else if (Array.isArray(functionResponse)) {
-      functionResponse = { results: functionResponse };
+    } else {
+      functionResponse = normalizeCallbackResponse(functionResponse);
     }
     const functionResponseEvent = createEvent({
       invocationId: invocationContext.invocationId,
-      author: invocationContext.agent.name,
+      author: toolEventAuthor(invocationContext),
       content: createUserContent({
         functionResponse: {
           id: toolContext.functionCallId,
@@ -329,6 +364,7 @@ async function handleFunctionCallList({
   }
   return mergedEvent;
 }
+__name(handleFunctionCallList, "handleFunctionCallList");
 function getToolAndContext({
   invocationContext,
   functionCall,
@@ -348,6 +384,7 @@ function getToolAndContext({
   const tool = toolsDict[functionCall.name];
   return { tool, toolContext };
 }
+__name(getToolAndContext, "getToolAndContext");
 function mergeParallelFunctionResponseEvents(functionResponseEvents) {
   if (!functionResponseEvents.length) {
     throw new Error("No function response events provided.");
@@ -375,6 +412,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];
@@ -387,6 +425,7 @@ function findEventByFunctionCallId(events, functionCallId, endIndex = events.len
   }
   return void 0;
 }
+__name(findEventByFunctionCallId, "findEventByFunctionCallId");
 function findMatchingFunctionCall(events) {
   if (!events.length) {
     return void 0;
@@ -402,10 +441,12 @@ function findMatchingFunctionCall(events) {
     events.length - 1
   );
 }
+__name(findMatchingFunctionCall, "findMatchingFunctionCall");
 export {
   AF_FUNCTION_CALL_ID_PREFIX,
-  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
-  REQUEST_EUC_FUNCTION_CALL_NAME,
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME2 as REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME2 as REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME,
   findEventByFunctionCallId,
   findMatchingFunctionCall,
   functionsExportedForTestingOnly,
@@ -416,5 +457,6 @@ export {
   handleFunctionCallList,
   handleFunctionCallsAsync,
   mergeParallelFunctionResponseEvents,
-  populateClientFunctionCallId
+  populateClientFunctionCallId,
+  reservedFunctionCallName
 };

package/dist/esm/agents/instructions.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -7,6 +9,17 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { State } from "../sessions/state.js";
 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)) {
@@ -25,17 +38,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;
@@ -57,10 +82,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) => {
@@ -70,7 +102,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,
@@ -105,11 +137,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 {
@@ -120,6 +157,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_]*$/;
 })();
@@ -129,6 +167,7 @@ function isIdentifier(s) {
   }
   return isIdentifierPattern.test(s);
 }
+__name(isIdentifier, "isIdentifier");
 const VALID_PREFIXES = [State.APP_PREFIX, State.USER_PREFIX, State.TEMP_PREFIX];
 function isValidStateName(variableName) {
   const parts = variableName.split(":");
@@ -143,6 +182,7 @@ function isValidStateName(variableName) {
   }
   return false;
 }
+__name(isValidStateName, "isValidStateName");
 export {
   injectSessionState
 };

package/dist/esm/agents/invocation_context.js

@@ -1,12 +1,14 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { randomUUID } from "../utils/env_aware_utils.js";
-class InvocationCostManager {
+const _InvocationCostManager = class _InvocationCostManager {
   constructor() {
     this.numberOfLlmCalls = 0;
   }
@@ -24,13 +26,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;
@@ -45,7 +49,12 @@ 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.invocationCostManager = (_b = params.invocationCostManager) != null ? _b : new InvocationCostManager();
+    this.liveRequestQueue = params.liveRequestQueue;
+    this.liveSessionResumptionHandle = params.liveSessionResumptionHandle;
   }
   /**
    * The app name of the current session.
@@ -67,11 +76,36 @@ 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-${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");
 export {
   InvocationContext,
-  newInvocationContextId
+  newInvocationContextId,
+  requireAgent
 };

package/dist/esm/agents/live_request_queue.js

@@ -1,11 +1,13 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class LiveRequestQueue {
+const _LiveRequestQueue = class _LiveRequestQueue {
   constructor() {
     // Keeps track of the data that are waiting to be sent.
     this.queue = [];
@@ -32,17 +34,38 @@ class LiveRequestQueue {
   /**
    * Retrieves a request from the queue. If the queue is empty, it will
    * wait until a request is available.
+   *
+   * @param abortSignal When provided, a parked (pending) read is released by
+   *     rejecting with an abort error once the signal fires. The live send
+   *     loop passes the connection's abort signal so a waiter is not stranded
+   *     across reconnect/teardown, where it could otherwise steal a request
+   *     from the next connection's send loop.
    * @returns A promise that resolves with the next available request.
    */
-  async get() {
+  async get(abortSignal) {
     if (this.queue.length > 0) {
       return this.queue.shift();
     }
     if (this.isClosed) {
       return { close: true };
     }
-    return new Promise((resolve) => {
-      this.resolveFnFifoQueue.push(resolve);
+    if (abortSignal == null ? void 0 : abortSignal.aborted) {
+      throw new Error("LiveRequestQueue.get() was aborted.");
+    }
+    return new Promise((resolve, reject) => {
+      const onAbort = /* @__PURE__ */ __name(() => {
+        const index = this.resolveFnFifoQueue.indexOf(resolveFn);
+        if (index !== -1) {
+          this.resolveFnFifoQueue.splice(index, 1);
+        }
+        reject(new Error("LiveRequestQueue.get() was aborted."));
+      }, "onAbort");
+      const resolveFn = /* @__PURE__ */ __name((req) => {
+        abortSignal == null ? void 0 : abortSignal.removeEventListener("abort", onAbort);
+        resolve(req);
+      }, "resolveFn");
+      this.resolveFnFifoQueue.push(resolveFn);
+      abortSignal == null ? void 0 : abortSignal.addEventListener("abort", onAbort, { once: true });
     });
   }
   /**
@@ -102,7 +125,9 @@ class LiveRequestQueue {
       }
     }
   }
-}
+};
+__name(_LiveRequestQueue, "LiveRequestQueue");
+let LiveRequestQueue = _LiveRequestQueue;
 export {
   LiveRequestQueue
 };