@google/adk 2.2.1 → 2.3.0

package/dist/cjs/cli/utils/evals.js

@@ -0,0 +1,137 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var evals_exports = {};
+__export(evals_exports, {
+  convertSessionToEvalFormat: () => convertSessionToEvalFormat,
+  createEmptyState: () => createEmptyState
+});
+module.exports = __toCommonJS(evals_exports);
+var import_llm_agent = require("../../agents/llm_agent.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function convertSessionToEvalFormat(session) {
+  var _a, _b, _c;
+  const events = session && session.events ? session.events : [];
+  const evalCases = [];
+  let i = 0;
+  while (i < events.length) {
+    const event = events[i];
+    if (event.author === "user") {
+      let userQuery = "";
+      if (event.content && event.content.parts) {
+        for (const part of event.content.parts) {
+          if (part.text) {
+            userQuery = part.text;
+            break;
+          }
+        }
+      }
+      const expectedToolUse = [];
+      const expectedIntermediateAgentResponses = [];
+      let finalResponse = "";
+      let j = i + 1;
+      while (j < events.length) {
+        const subsequentEvent = events[j];
+        if (subsequentEvent.author === "user") {
+          break;
+        }
+        if (subsequentEvent.content && subsequentEvent.content.parts) {
+          let hasToolAction = false;
+          for (const part of subsequentEvent.content.parts) {
+            if (part.functionCall) {
+              expectedToolUse.push({
+                tool_name: (_a = part.functionCall.name) != null ? _a : "",
+                tool_input: (_b = part.functionCall.args) != null ? _b : {}
+              });
+              hasToolAction = true;
+            } else if (part.functionResponse) {
+              hasToolAction = true;
+            }
+          }
+          if (!hasToolAction) {
+            expectedIntermediateAgentResponses.push([
+              (_c = subsequentEvent.author) != null ? _c : "",
+              subsequentEvent.content.parts
+            ]);
+          }
+        }
+        j += 1;
+      }
+      if (expectedIntermediateAgentResponses.length > 0) {
+        const lastResponse = expectedIntermediateAgentResponses.pop();
+        if (lastResponse) {
+          const [, lastParts] = lastResponse;
+          finalResponse = lastParts.filter((part) => Boolean(part.text)).map((part) => {
+            var _a2;
+            return (_a2 = part.text) != null ? _a2 : "";
+          }).join("");
+        }
+      }
+      evalCases.push({
+        query: userQuery,
+        expected_tool_use: expectedToolUse,
+        expected_intermediate_agent_responses: expectedIntermediateAgentResponses,
+        reference: finalResponse
+      });
+      i = j;
+    } else {
+      i += 1;
+    }
+  }
+  return evalCases;
+}
+__name(convertSessionToEvalFormat, "convertSessionToEvalFormat");
+function populateEmptyState(agent, allState) {
+  for (const subAgent of agent.subAgents) {
+    populateEmptyState(subAgent, allState);
+  }
+  if ((0, import_llm_agent.isLlmAgent)(agent) && agent.instruction && typeof agent.instruction === "string") {
+    const matches = agent.instruction.matchAll(/\{([\w]+)\}/g);
+    for (const match of matches) {
+      allState[match[1]] = "";
+    }
+  }
+}
+__name(populateEmptyState, "populateEmptyState");
+function createEmptyState(agent, initializedStates) {
+  const subAgentsState = {};
+  populateEmptyState(agent, subAgentsState);
+  if (initializedStates) {
+    for (const [k, v] of Object.entries(initializedStates)) {
+      subAgentsState[k] = v;
+    }
+  }
+  return subAgentsState;
+}
+__name(createEmptyState, "createEmptyState");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertSessionToEvalFormat,
+  createEmptyState
+});

package/dist/cjs/cli/utils/logs.js

@@ -0,0 +1,150 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"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) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 logs_exports = {};
+__export(logs_exports, {
+  LOGGING_FORMAT: () => LOGGING_FORMAT,
+  logToStderr: () => logToStderr,
+  logToTmpFolder: () => logToTmpFolder
+});
+module.exports = __toCommonJS(logs_exports);
+var fs = __toESM(require("node:fs"), 1);
+var os = __toESM(require("node:os"), 1);
+var path = __toESM(require("node:path"), 1);
+var util = __toESM(require("node:util"), 1);
+var import_logger = require("../../utils/logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const LOGGING_FORMAT = "%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s";
+const LOG_LEVEL_NAMES = {
+  [import_logger.LogLevel.DEBUG]: "DEBUG",
+  [import_logger.LogLevel.INFO]: "INFO",
+  [import_logger.LogLevel.WARN]: "WARNING",
+  [import_logger.LogLevel.ERROR]: "ERROR"
+};
+function formatDateTimestamp(date) {
+  const pad = /* @__PURE__ */ __name((n) => String(n).padStart(2, "0"), "pad");
+  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}_${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+}
+__name(formatDateTimestamp, "formatDateTimestamp");
+function formatLogLine(level, messages) {
+  var _a;
+  const iso = (/* @__PURE__ */ new Date()).toISOString();
+  const levelName = (_a = LOG_LEVEL_NAMES[level]) != null ? _a : "INFO";
+  const formattedMessage = messages.map((m) => typeof m === "string" ? m : util.inspect(m, { depth: null })).join(" ");
+  return `${iso} - ${levelName} - ${formattedMessage}`;
+}
+__name(formatLogLine, "formatLogLine");
+function createWriterLogger(initialLevel, writeLine) {
+  let currentLevel = initialLevel;
+  const logAt = /* @__PURE__ */ __name((targetLevel, messages) => {
+    if (currentLevel <= targetLevel) {
+      writeLine(formatLogLine(targetLevel, messages));
+    }
+  }, "logAt");
+  return {
+    setLogLevel(level) {
+      currentLevel = level;
+    },
+    log(level, ...messages) {
+      logAt(level, messages);
+    },
+    debug(...messages) {
+      logAt(import_logger.LogLevel.DEBUG, messages);
+    },
+    info(...messages) {
+      logAt(import_logger.LogLevel.INFO, messages);
+    },
+    warn(...messages) {
+      logAt(import_logger.LogLevel.WARN, messages);
+    },
+    error(...messages) {
+      logAt(import_logger.LogLevel.ERROR, messages);
+    }
+  };
+}
+__name(createWriterLogger, "createWriterLogger");
+function logToStderr(level = import_logger.LogLevel.INFO) {
+  (0, import_logger.setLogLevel)(level);
+  (0, import_logger.setLogger)(
+    createWriterLogger(level, (line) => {
+      process.stderr.write(`${line}
+`);
+    })
+  );
+}
+__name(logToStderr, "logToStderr");
+function logToTmpFolder(options = {}) {
+  const {
+    level = import_logger.LogLevel.INFO,
+    subFolder = "agents_log",
+    logFilePrefix = "agent",
+    logFileTimestamp = formatDateTimestamp(/* @__PURE__ */ new Date())
+  } = options;
+  const logDir = path.join(os.tmpdir(), subFolder);
+  fs.mkdirSync(logDir, { recursive: true });
+  const logFilename = `${logFilePrefix}.${logFileTimestamp}.log`;
+  const logFilepath = path.join(logDir, logFilename);
+  fs.writeFileSync(logFilepath, "", "utf-8");
+  (0, import_logger.setLogLevel)(level);
+  const fileLogger = createWriterLogger(level, (line) => {
+    fs.appendFileSync(logFilepath, `${line}
+`, "utf-8");
+  });
+  (0, import_logger.setLogger)(fileLogger);
+  const latestLogLink = path.join(logDir, `${logFilePrefix}.latest.log`);
+  try {
+    try {
+      fs.lstatSync(latestLogLink);
+      fs.unlinkSync(latestLogLink);
+    } catch {
+    }
+    fs.symlinkSync(logFilepath, latestLogLink);
+  } catch (e) {
+    fileLogger.warn(`Failed to create symlink to latest log: ${String(e)}`);
+  }
+  fileLogger.info(`Log setup complete: ${logFilepath}`);
+  return logFilepath;
+}
+__name(logToTmpFolder, "logToTmpFolder");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOGGING_FORMAT,
+  logToStderr,
+  logToTmpFolder
+});

package/dist/cjs/code_executors/agent_engine_sandbox_code_executor.js

@@ -43,6 +43,7 @@ var import_file_utils = require("../utils/file_utils.js");
 var import_logger = require("../utils/logger.js");
 var import_base_code_executor = require("./base_code_executor.js");
 var import_code_execution_utils = require("./code_execution_utils.js");
+var import_code_executor_context = require("./code_executor_context.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -231,12 +232,14 @@ let AgentEngineSandboxCodeExecutor = class extends import_base_code_executor.Bas
     return this.agentEngineCreationPromise;
   }
   async getOrCreateSandbox(invocationContext, agentEngineName, language) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e;
     if (this.sandboxResourceName) {
       return this.sandboxResourceName;
     }
     const stateKey = `sandbox_name_${language.toLowerCase()}`;
-    let sandboxName = (_b = (_a = invocationContext.session) == null ? void 0 : _a.state) == null ? void 0 : _b[stateKey];
+    const state = (_a = invocationContext.session) == null ? void 0 : _a.state;
+    const codeExecutionContext = state == null ? void 0 : state[import_code_executor_context.CONTEXT_KEY];
+    let sandboxName = (_b = state == null ? void 0 : state[stateKey]) != null ? _b : codeExecutionContext == null ? void 0 : codeExecutionContext[stateKey];
     let createNewSandbox = false;
     if (!sandboxName) {
       createNewSandbox = true;
@@ -293,6 +296,8 @@ let AgentEngineSandboxCodeExecutor = class extends import_base_code_executor.Bas
           invocationContext.session.state = {};
         }
         invocationContext.session.state[stateKey] = sandboxName;
+        const context = (_e = (_c = invocationContext.session.state)[_d = import_code_executor_context.CONTEXT_KEY]) != null ? _e : _c[_d] = {};
+        context[stateKey] = sandboxName;
       }
     }
     return sandboxName;

package/dist/cjs/code_executors/code_execution_utils.js

@@ -31,6 +31,8 @@ __export(code_execution_utils_exports, {
   buildExecutableCodePart: () => buildExecutableCodePart,
   convertCodeExecutionParts: () => convertCodeExecutionParts,
   extractCodeAndTruncateContent: () => extractCodeAndTruncateContent,
+  extractCodeBlockAndTruncateContent: () => extractCodeBlockAndTruncateContent,
+  getCodeBlockLanguage: () => getCodeBlockLanguage,
   getEncodedFileContent: () => getEncodedFileContent
 });
 module.exports = __toCommonJS(code_execution_utils_exports);
@@ -61,33 +63,62 @@ function getEncodedFileContent(data) {
   return (0, import_env_aware_utils.isBase64Encoded)(data) ? data : (0, import_env_aware_utils.base64Encode)(data);
 }
 __name(getEncodedFileContent, "getEncodedFileContent");
+const FENCE_TAG_LANGUAGE_MAP = {
+  tool_code: "python" /* PYTHON */,
+  python: "python" /* PYTHON */,
+  py: "python" /* PYTHON */,
+  javascript: "javascript" /* JAVASCRIPT */,
+  js: "javascript" /* JAVASCRIPT */,
+  typescript: "typescript" /* TYPESCRIPT */,
+  ts: "typescript" /* TYPESCRIPT */,
+  bash: "shell" /* SHELL */,
+  sh: "shell" /* SHELL */,
+  shell: "shell" /* SHELL */
+};
+const NO_CODE_BLOCK = Object.freeze({
+  code: "",
+  language: "unspecified" /* UNSPECIFIED */
+});
+function getCodeBlockLanguage(leadingDelimiter) {
+  var _a;
+  const tag = leadingDelimiter.trim().replace(/^`+/, "").toLowerCase();
+  return (_a = FENCE_TAG_LANGUAGE_MAP[tag]) != null ? _a : "unspecified" /* UNSPECIFIED */;
+}
+__name(getCodeBlockLanguage, "getCodeBlockLanguage");
 function extractCodeAndTruncateContent(content, codeBlockDelimiters) {
+  return extractCodeBlockAndTruncateContent(content, codeBlockDelimiters).code;
+}
+__name(extractCodeAndTruncateContent, "extractCodeAndTruncateContent");
+function extractCodeBlockAndTruncateContent(content, codeBlockDelimiters) {
   var _a;
   if (!((_a = content.parts) == null ? void 0 : _a.length)) {
-    return "";
+    return { ...NO_CODE_BLOCK };
   }
   for (let i = 0; i < content.parts.length; i++) {
     const part = content.parts[i];
     if (part.executableCode && (i === content.parts.length - 1 || !content.parts[i + 1].codeExecutionResult)) {
       content.parts = content.parts.slice(0, i + 1);
-      return part.executableCode.code || "";
+      return {
+        code: part.executableCode.code || "",
+        language: "python" /* PYTHON */
+      };
     }
   }
   const textParts = content.parts.filter((part) => part.text);
   if (!textParts.length) {
-    return "";
+    return { ...NO_CODE_BLOCK };
   }
   const firstTextPart = (0, import_lodash_es.cloneDeep)(textParts[0]);
   const responseText = textParts.map((part) => part.text).join("\n");
   const leadingDelimiterPattern = codeBlockDelimiters.map((d) => d[0]).join("|");
   const trailingDelimiterPattern = codeBlockDelimiters.map((d) => d[1]).join("|");
   const match = new RegExp(
-    `(?<prefix>.*?)(${leadingDelimiterPattern})(?<codeStr>.*?)(${trailingDelimiterPattern})(?<suffix>.*?)$`,
+    `(?<prefix>.*?)(?<leading>${leadingDelimiterPattern})(?<codeStr>.*?)(${trailingDelimiterPattern})(?<suffix>.*?)$`,
     "s"
   ).exec(responseText);
-  const { prefix, codeStr } = (match == null ? void 0 : match.groups) || {};
+  const { prefix, leading, codeStr } = (match == null ? void 0 : match.groups) || {};
   if (!codeStr) {
-    return "";
+    return { ...NO_CODE_BLOCK };
   }
   content.parts = [];
   if (prefix) {
@@ -95,12 +126,11 @@ function extractCodeAndTruncateContent(content, codeBlockDelimiters) {
     content.parts.push(firstTextPart);
   }
   content.parts.push(buildExecutableCodePart(codeStr));
-  return codeStr;
+  return { code: codeStr, language: getCodeBlockLanguage(leading != null ? leading : "") };
 }
-__name(extractCodeAndTruncateContent, "extractCodeAndTruncateContent");
+__name(extractCodeBlockAndTruncateContent, "extractCodeBlockAndTruncateContent");
 function buildExecutableCodePart(code) {
   return {
-    text: code,
     executableCode: {
       code,
       language: import_genai.Language.PYTHON
@@ -111,28 +141,28 @@ __name(buildExecutableCodePart, "buildExecutableCodePart");
 function buildCodeExecutionResultPart(codeExecutionResult) {
   if (codeExecutionResult.stderr) {
     return {
-      text: codeExecutionResult.stderr,
       codeExecutionResult: {
-        outcome: import_genai.Outcome.OUTCOME_FAILED
+        outcome: import_genai.Outcome.OUTCOME_FAILED,
+        output: codeExecutionResult.stderr
       }
     };
   }
   const finalResult = [];
-  if (codeExecutionResult.stdout || !codeExecutionResult.outputFiles) {
+  if (codeExecutionResult.stdout || !codeExecutionResult.outputFiles.length) {
     finalResult.push(`Code execution result:
 ${codeExecutionResult.stdout}
 `);
   }
-  if (codeExecutionResult.outputFiles) {
+  if (codeExecutionResult.outputFiles.length) {
     finalResult.push(
       `Saved artifacts:
-` + codeExecutionResult.outputFiles.map((f) => f.name).join(", ")
+` + codeExecutionResult.outputFiles.map((f) => `\`${f.name}\``).join(",")
     );
   }
   return {
-    text: finalResult.join("\n\n"),
     codeExecutionResult: {
-      outcome: import_genai.Outcome.OUTCOME_OK
+      outcome: import_genai.Outcome.OUTCOME_OK,
+      output: finalResult.join("\n\n")
     }
   };
 }
@@ -163,5 +193,7 @@ __name(convertCodeExecutionParts, "convertCodeExecutionParts");
   buildExecutableCodePart,
   convertCodeExecutionParts,
   extractCodeAndTruncateContent,
+  extractCodeBlockAndTruncateContent,
+  getCodeBlockLanguage,
   getEncodedFileContent
 });

package/dist/cjs/code_executors/code_executor_context.js

@@ -25,6 +25,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var code_executor_context_exports = {};
 __export(code_executor_context_exports, {
+  CONTEXT_KEY: () => CONTEXT_KEY,
   CodeExecutorContext: () => CodeExecutorContext
 });
 module.exports = __toCommonJS(code_executor_context_exports);
@@ -43,8 +44,10 @@ const CODE_EXECUTION_RESULTS_KEY = "_code_execution_results";
 const _CodeExecutorContext = class _CodeExecutorContext {
   constructor(sessionState) {
     this.sessionState = sessionState;
-    var _a;
-    this.context = (_a = sessionState.get(CONTEXT_KEY)) != null ? _a : {};
+    if (!sessionState.has(CONTEXT_KEY)) {
+      sessionState.set(CONTEXT_KEY, {});
+    }
+    this.context = sessionState.get(CONTEXT_KEY);
     this.sessionState = sessionState;
   }
   /**
@@ -197,5 +200,6 @@ __name(_CodeExecutorContext, "CodeExecutorContext");
 let CodeExecutorContext = _CodeExecutorContext;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CONTEXT_KEY,
   CodeExecutorContext
 });