@google/adk 2.3.0 → 2.5.0

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

@@ -0,0 +1,84 @@
+/**
+  * @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 cleanup_exports = {};
+__export(cleanup_exports, {
+  RUNNER_CLEANUP_TIMEOUT_MS: () => RUNNER_CLEANUP_TIMEOUT_MS,
+  closeRunners: () => closeRunners
+});
+module.exports = __toCommonJS(cleanup_exports);
+var import_error_utils = require("../../utils/error_utils.js");
+var import_logger = require("../../utils/logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const RUNNER_CLEANUP_TIMEOUT_MS = 3e4;
+const RUNNER_CLEANUP_TIMEOUT_SYMBOL = /* @__PURE__ */ Symbol(
+  "google.adk.cli.runnerCleanupTimeout"
+);
+async function closeRunners(runners) {
+  if (runners.length === 0) {
+    return;
+  }
+  let pendingCount = runners.length;
+  const tasks = runners.map(async (runner) => {
+    try {
+      await runner.close();
+    } catch (e) {
+      import_logger.logger.error(
+        `Error closing runner ${runner.appName}: ${(0, import_error_utils.getErrorMessage)(e)}`
+      );
+    } finally {
+      pendingCount -= 1;
+    }
+  });
+  let timeoutId;
+  try {
+    const result = await Promise.race([
+      Promise.allSettled(tasks).then(() => void 0),
+      new Promise((resolve) => {
+        timeoutId = setTimeout(
+          () => resolve(RUNNER_CLEANUP_TIMEOUT_SYMBOL),
+          RUNNER_CLEANUP_TIMEOUT_MS
+        );
+      })
+    ]);
+    if (result === RUNNER_CLEANUP_TIMEOUT_SYMBOL && pendingCount > 0) {
+      import_logger.logger.warn(`${pendingCount} runner close tasks didn't complete in time`);
+    }
+  } finally {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+__name(closeRunners, "closeRunners");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RUNNER_CLEANUP_TIMEOUT_MS,
+  closeRunners
+});

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

@@ -41,7 +41,9 @@ __export(envs_exports, {
 module.exports = __toCommonJS(envs_exports);
 var fs = __toESM(require("node:fs"), 1);
 var path = __toESM(require("node:path"), 1);
+var import_input_validation_error = require("../../errors/input_validation_error.js");
 var import_logger = require("../../utils/logger.js");
+var import_path_validation = require("./path_validation.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -92,8 +94,37 @@ function parseAndLoadDotenv(content) {
   }
 }
 __name(parseAndLoadDotenv, "parseAndLoadDotenv");
-function loadDotenvForAgent(agentName, agentParentFolder = ".", filename = ".env") {
-  let startingFolder = path.resolve(agentParentFolder, agentName);
+function loadDotenvForAgent(agentName, agentParentFolder, filename = ".env") {
+  (0, import_path_validation.validatePathSegment)(filename, "filename");
+  if (typeof agentName !== "string" || !agentName) {
+    throw new import_input_validation_error.InputValidationError("agentName must not be empty.");
+  }
+  if (agentName.includes("\0")) {
+    throw new import_input_validation_error.InputValidationError("agentName must not contain null bytes.");
+  }
+  let startingFolder;
+  if (agentParentFolder !== void 0) {
+    if (typeof agentParentFolder !== "string" || !agentParentFolder || agentParentFolder.includes("\0")) {
+      throw new import_input_validation_error.InputValidationError(
+        "agentParentFolder must be a valid non-empty path."
+      );
+    }
+    (0, import_path_validation.validatePathSegment)(agentName, "agentName");
+    const baseDir = path.resolve(agentParentFolder);
+    startingFolder = path.resolve(baseDir, agentName);
+    if (!(0, import_path_validation.isStrictlyInside)(baseDir, startingFolder)) {
+      throw new import_input_validation_error.InputValidationError(
+        `agentName '${agentName}' resolves outside agentParentFolder.`
+      );
+    }
+  } else {
+    if (agentName === "." || agentName.split(/[\\/]+/).includes("..")) {
+      throw new import_input_validation_error.InputValidationError(
+        `agentName '${agentName}' must not contain traversal segments.`
+      );
+    }
+    startingFolder = path.resolve(".", agentName);
+  }
   if (fs.existsSync(startingFolder) && fs.statSync(startingFolder).isFile()) {
     startingFolder = path.dirname(startingFolder);
   }

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

@@ -26,6 +26,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var evals_exports = {};
 __export(evals_exports, {
   convertSessionToEvalFormat: () => convertSessionToEvalFormat,
+  convertSessionToEvalInvocations: () => convertSessionToEvalInvocations,
   createEmptyState: () => createEmptyState
 });
 module.exports = __toCommonJS(evals_exports);
@@ -36,20 +37,22 @@ var import_llm_agent = require("../../agents/llm_agent.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 function convertSessionToEvalFormat(session) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const events = session && session.events ? session.events : [];
   const evalCases = [];
   let i = 0;
   while (i < events.length) {
     const event = events[i];
     if (event.author === "user") {
+      if (!event.content || !event.content.parts || event.content.parts.length === 0) {
+        i += 1;
+        continue;
+      }
       let userQuery = "";
-      if (event.content && event.content.parts) {
-        for (const part of event.content.parts) {
-          if (part.text) {
-            userQuery = part.text;
-            break;
-          }
+      for (const part of event.content.parts) {
+        if (part.text) {
+          userQuery = part.text;
+          break;
         }
       }
       const expectedToolUse = [];
@@ -63,6 +66,7 @@ function convertSessionToEvalFormat(session) {
         }
         if (subsequentEvent.content && subsequentEvent.content.parts) {
           let hasToolAction = false;
+          const textParts = [];
           for (const part of subsequentEvent.content.parts) {
             if (part.functionCall) {
               expectedToolUse.push({
@@ -72,13 +76,20 @@ function convertSessionToEvalFormat(session) {
               hasToolAction = true;
             } else if (part.functionResponse) {
               hasToolAction = true;
+            } else if (part.text) {
+              textParts.push(part);
             }
           }
-          if (!hasToolAction) {
+          if (!hasToolAction && textParts.length > 0) {
             expectedIntermediateAgentResponses.push([
               (_c = subsequentEvent.author) != null ? _c : "",
               subsequentEvent.content.parts
             ]);
+          } else if (hasToolAction && textParts.length > 0) {
+            expectedIntermediateAgentResponses.push([
+              (_d = subsequentEvent.author) != null ? _d : "",
+              textParts
+            ]);
           }
         }
         j += 1;
@@ -107,6 +118,61 @@ function convertSessionToEvalFormat(session) {
   return evalCases;
 }
 __name(convertSessionToEvalFormat, "convertSessionToEvalFormat");
+function convertSessionToEvalInvocations(session) {
+  const invocations = [];
+  const events = session && session.events ? session.events : [];
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i];
+    if (event.author !== "user") {
+      continue;
+    }
+    if (!event.content || !event.content.parts || event.content.parts.length === 0) {
+      continue;
+    }
+    const userContent = event.content;
+    const invocationId = event.invocationId || void 0;
+    const creationTimestamp = event.timestamp !== void 0 ? event.timestamp / 1e3 : void 0;
+    const toolUses = [];
+    const intermediateResponses = [];
+    for (let j = i + 1; j < events.length; j++) {
+      const subsequentEvent = events[j];
+      const eventAuthor = subsequentEvent.author || "agent";
+      if (eventAuthor === "user") {
+        break;
+      }
+      if (!subsequentEvent.content || !subsequentEvent.content.parts || subsequentEvent.content.parts.length === 0) {
+        continue;
+      }
+      const intermediateResponseParts = [];
+      for (const subsequentPart of subsequentEvent.content.parts) {
+        if (subsequentPart.functionCall) {
+          toolUses.push(subsequentPart.functionCall);
+        } else if (subsequentPart.text) {
+          intermediateResponseParts.push(subsequentPart);
+        }
+      }
+      if (intermediateResponseParts.length > 0) {
+        intermediateResponses.push([eventAuthor, intermediateResponseParts]);
+      }
+    }
+    const finalResponse = intermediateResponses.length > 0 ? {
+      parts: intermediateResponses[intermediateResponses.length - 1][1],
+      role: "model"
+    } : void 0;
+    invocations.push({
+      ...invocationId !== void 0 ? { invocationId } : {},
+      userContent,
+      ...finalResponse !== void 0 ? { finalResponse } : {},
+      intermediateData: {
+        toolUses,
+        intermediateResponses: intermediateResponses.length > 0 ? intermediateResponses.slice(0, -1) : []
+      },
+      ...creationTimestamp !== void 0 ? { creationTimestamp } : {}
+    });
+  }
+  return invocations;
+}
+__name(convertSessionToEvalInvocations, "convertSessionToEvalInvocations");
 function populateEmptyState(agent, allState) {
   for (const subAgent of agent.subAgents) {
     populateEmptyState(subAgent, allState);
@@ -133,5 +199,6 @@ __name(createEmptyState, "createEmptyState");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   convertSessionToEvalFormat,
+  convertSessionToEvalInvocations,
   createEmptyState
 });

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

@@ -36,8 +36,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var logs_exports = {};
 __export(logs_exports, {
   LOGGING_FORMAT: () => LOGGING_FORMAT,
-  logToStderr: () => logToStderr,
-  logToTmpFolder: () => logToTmpFolder
+  logToTmpFolder: () => logToTmpFolder,
+  setupAdkLogger: () => setupAdkLogger
 });
 module.exports = __toCommonJS(logs_exports);
 var fs = __toESM(require("node:fs"), 1);
@@ -51,6 +51,7 @@ var import_logger = require("../../utils/logger.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 const LOGGING_FORMAT = "%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s";
+const MAX_LOG_FILE_SUFFIX = 1e3;
 const LOG_LEVEL_NAMES = {
   [import_logger.LogLevel.DEBUG]: "DEBUG",
   [import_logger.LogLevel.INFO]: "INFO",
@@ -62,6 +63,109 @@ function formatDateTimestamp(date) {
   return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}_${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
 }
 __name(formatDateTimestamp, "formatDateTimestamp");
+function hasErrorCode(e, code) {
+  return typeof e === "object" && e !== null && "code" in e && e.code === code;
+}
+__name(hasErrorCode, "hasErrorCode");
+let activeLogFile;
+let exitListenerRegistered = false;
+function closeActiveLogFile() {
+  if (!activeLogFile) {
+    return;
+  }
+  const { fd } = activeLogFile;
+  activeLogFile = void 0;
+  try {
+    fs.closeSync(fd);
+  } catch {
+  }
+}
+__name(closeActiveLogFile, "closeActiveLogFile");
+function getUid() {
+  return typeof process.getuid === "function" ? process.getuid() : void 0;
+}
+__name(getUid, "getUid");
+function isSymlinkOrNonDirectory(dir) {
+  try {
+    const stat = fs.lstatSync(dir);
+    return stat.isSymbolicLink() || !stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+__name(isSymlinkOrNonDirectory, "isSymlinkOrNonDirectory");
+function preparePrivateDirectory(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  } catch (e) {
+    if (!isSymlinkOrNonDirectory(dir)) {
+      throw e;
+    }
+    return false;
+  }
+  const stat = fs.lstatSync(dir);
+  if (stat.isSymbolicLink() || !stat.isDirectory()) {
+    return false;
+  }
+  const uid = getUid();
+  if (uid === void 0) {
+    return true;
+  }
+  if (stat.uid !== uid) {
+    return false;
+  }
+  fs.chmodSync(dir, 448);
+  if ((fs.lstatSync(dir).mode & 63) !== 0) {
+    throw new Error(
+      `Log directory ${dir} is accessible by other users after chmod 0o700.`
+    );
+  }
+  return true;
+}
+__name(preparePrivateDirectory, "preparePrivateDirectory");
+function resolveLogDir(subFolder) {
+  const logDir = path.join(os.tmpdir(), subFolder);
+  if (preparePrivateDirectory(logDir)) {
+    return logDir;
+  }
+  const uid = getUid();
+  if (uid === void 0) {
+    throw new Error(`Log directory ${logDir} is not a directory.`);
+  }
+  const userLogDir = path.join(os.tmpdir(), `${subFolder}_${uid}`);
+  if (preparePrivateDirectory(userLogDir)) {
+    return userLogDir;
+  }
+  throw new Error(
+    `Log directories ${logDir} and ${userLogDir} are not directories owned by the current user.`
+  );
+}
+__name(resolveLogDir, "resolveLogDir");
+function createExclusiveLogFile({
+  logDir,
+  logFilePrefix,
+  logFileTimestamp
+}) {
+  for (let counter = 0; counter <= MAX_LOG_FILE_SUFFIX; counter++) {
+    const suffix = counter === 0 ? "" : `_${counter}`;
+    const candidate = path.join(
+      logDir,
+      `${logFilePrefix}.${logFileTimestamp}${suffix}.log`
+    );
+    try {
+      const fd = fs.openSync(candidate, "ax", 384);
+      return { logFilepath: candidate, fd };
+    } catch (e) {
+      if (!hasErrorCode(e, "EEXIST")) {
+        throw e;
+      }
+    }
+  }
+  throw new Error(
+    `Failed to create a unique log file in ${logDir} for ${logFilePrefix}.${logFileTimestamp}`
+  );
+}
+__name(createExclusiveLogFile, "createExclusiveLogFile");
 function formatLogLine(level, messages) {
   var _a;
   const iso = (/* @__PURE__ */ new Date()).toISOString();
@@ -99,7 +203,8 @@ function createWriterLogger(initialLevel, writeLine) {
   };
 }
 __name(createWriterLogger, "createWriterLogger");
-function logToStderr(level = import_logger.LogLevel.INFO) {
+function setupAdkLogger(level = import_logger.LogLevel.INFO) {
+  closeActiveLogFile();
   (0, import_logger.setLogLevel)(level);
   (0, import_logger.setLogger)(
     createWriterLogger(level, (line) => {
@@ -108,23 +213,35 @@ function logToStderr(level = import_logger.LogLevel.INFO) {
     })
   );
 }
-__name(logToStderr, "logToStderr");
+__name(setupAdkLogger, "setupAdkLogger");
 function logToTmpFolder(options = {}) {
+  var _a;
   const {
     level = import_logger.LogLevel.INFO,
     subFolder = "agents_log",
-    logFilePrefix = "agent",
-    logFileTimestamp = formatDateTimestamp(/* @__PURE__ */ new Date())
+    logFilePrefix = "agent"
   } = 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");
+  const logFileTimestamp = (_a = options.logFileTimestamp) != null ? _a : `${formatDateTimestamp(/* @__PURE__ */ new Date())}_${process.pid}`;
+  const logDir = resolveLogDir(subFolder);
+  const logFile = createExclusiveLogFile({
+    logDir,
+    logFilePrefix,
+    logFileTimestamp
+  });
+  const { logFilepath } = logFile;
+  closeActiveLogFile();
+  activeLogFile = logFile;
+  if (!exitListenerRegistered) {
+    process.on("exit", closeActiveLogFile);
+    exitListenerRegistered = true;
+  }
   (0, import_logger.setLogLevel)(level);
   const fileLogger = createWriterLogger(level, (line) => {
-    fs.appendFileSync(logFilepath, `${line}
-`, "utf-8");
+    if (activeLogFile !== logFile) {
+      return;
+    }
+    fs.writeSync(logFile.fd, `${line}
+`, null, "utf-8");
   });
   (0, import_logger.setLogger)(fileLogger);
   const latestLogLink = path.join(logDir, `${logFilePrefix}.latest.log`);
@@ -139,12 +256,14 @@ function logToTmpFolder(options = {}) {
     fileLogger.warn(`Failed to create symlink to latest log: ${String(e)}`);
   }
   fileLogger.info(`Log setup complete: ${logFilepath}`);
+  process.stderr.write(`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
+  logToTmpFolder,
+  setupAdkLogger
 });

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

@@ -0,0 +1,83 @@
+/**
+  * @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 path_validation_exports = {};
+__export(path_validation_exports, {
+  isStrictlyInside: () => isStrictlyInside,
+  validatePathSegment: () => validatePathSegment
+});
+module.exports = __toCommonJS(path_validation_exports);
+var path = __toESM(require("node:path"), 1);
+var import_input_validation_error = require("../../errors/input_validation_error.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const WINDOWS_DRIVE_RE = /^[A-Za-z]:/;
+function validatePathSegment(value, fieldName) {
+  if (typeof value !== "string" || !value) {
+    throw new import_input_validation_error.InputValidationError(`${fieldName} must not be empty.`);
+  }
+  if (value.includes("\0")) {
+    throw new import_input_validation_error.InputValidationError(`${fieldName} must not contain null bytes.`);
+  }
+  if (value.includes("/") || value.includes("\\")) {
+    throw new import_input_validation_error.InputValidationError(
+      `${fieldName} '${value}' must not contain path separators.`
+    );
+  }
+  if (WINDOWS_DRIVE_RE.test(value)) {
+    throw new import_input_validation_error.InputValidationError(
+      `${fieldName} '${value}' must not be drive-qualified.`
+    );
+  }
+  if (value === "." || value === "..") {
+    throw new import_input_validation_error.InputValidationError(
+      `${fieldName} '${value}' must not contain traversal segments.`
+    );
+  }
+}
+__name(validatePathSegment, "validatePathSegment");
+function isStrictlyInside(baseDir, target) {
+  const rel = path.relative(baseDir, target);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
+}
+__name(isStrictlyInside, "isStrictlyInside");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isStrictlyInside,
+  validatePathSegment
+});