@google/adk 2.4.0 → 2.5.0

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

@@ -0,0 +1,56 @@
+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
+ */
+import { getErrorMessage } from "../../utils/error_utils.js";
+import { logger } from "../../utils/logger.js";
+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) {
+      logger.error(
+        `Error closing runner ${runner.appName}: ${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) {
+      logger.warn(`${pendingCount} runner close tasks didn't complete in time`);
+    }
+  } finally {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+__name(closeRunners, "closeRunners");
+export {
+  RUNNER_CLEANUP_TIMEOUT_MS,
+  closeRunners
+};

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

@@ -9,7 +9,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { InputValidationError } from "../../errors/input_validation_error.js";
 import { logger } from "../../utils/logger.js";
+import { isStrictlyInside, validatePathSegment } from "./path_validation.js";
 function walkToRootUntilFound(folder, filename = ".env") {
   const checkpath = path.join(folder, filename);
   if (fs.existsSync(checkpath) && fs.statSync(checkpath).isFile()) {
@@ -55,8 +57,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") {
+  validatePathSegment(filename, "filename");
+  if (typeof agentName !== "string" || !agentName) {
+    throw new InputValidationError("agentName must not be empty.");
+  }
+  if (agentName.includes("\0")) {
+    throw new InputValidationError("agentName must not contain null bytes.");
+  }
+  let startingFolder;
+  if (agentParentFolder !== void 0) {
+    if (typeof agentParentFolder !== "string" || !agentParentFolder || agentParentFolder.includes("\0")) {
+      throw new InputValidationError(
+        "agentParentFolder must be a valid non-empty path."
+      );
+    }
+    validatePathSegment(agentName, "agentName");
+    const baseDir = path.resolve(agentParentFolder);
+    startingFolder = path.resolve(baseDir, agentName);
+    if (!isStrictlyInside(baseDir, startingFolder)) {
+      throw new InputValidationError(
+        `agentName '${agentName}' resolves outside agentParentFolder.`
+      );
+    }
+  } else {
+    if (agentName === "." || agentName.split(/[\\/]+/).includes("..")) {
+      throw new 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/esm/cli/utils/evals.js

@@ -9,20 +9,22 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { isLlmAgent } from "../../agents/llm_agent.js";
 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 = [];
@@ -36,6 +38,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({
@@ -45,13 +48,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;
@@ -80,6 +90,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);
@@ -105,5 +170,6 @@ function createEmptyState(agent, initializedStates) {
 __name(createEmptyState, "createEmptyState");
 export {
   convertSessionToEvalFormat,
+  convertSessionToEvalInvocations,
   createEmptyState
 };

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

@@ -13,6 +13,7 @@ import * as path from "node:path";
 import * as util from "node:util";
 import { LogLevel, setLogger, setLogLevel } from "../../utils/logger.js";
 const LOGGING_FORMAT = "%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s";
+const MAX_LOG_FILE_SUFFIX = 1e3;
 const LOG_LEVEL_NAMES = {
   [LogLevel.DEBUG]: "DEBUG",
   [LogLevel.INFO]: "INFO",
@@ -24,6 +25,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();
@@ -62,6 +166,7 @@ function createWriterLogger(initialLevel, writeLine) {
 }
 __name(createWriterLogger, "createWriterLogger");
 function setupAdkLogger(level = LogLevel.INFO) {
+  closeActiveLogFile();
   setLogLevel(level);
   setLogger(
     createWriterLogger(level, (line) => {
@@ -72,21 +177,33 @@ function setupAdkLogger(level = LogLevel.INFO) {
 }
 __name(setupAdkLogger, "setupAdkLogger");
 function logToTmpFolder(options = {}) {
+  var _a;
   const {
     level = 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;
+  }
   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");
   });
   setLogger(fileLogger);
   const latestLogLink = path.join(logDir, `${logFilePrefix}.latest.log`);
@@ -101,6 +218,8 @@ 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");

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

@@ -0,0 +1,45 @@
+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
+ */
+import * as path from "node:path";
+import { InputValidationError } from "../../errors/input_validation_error.js";
+const WINDOWS_DRIVE_RE = /^[A-Za-z]:/;
+function validatePathSegment(value, fieldName) {
+  if (typeof value !== "string" || !value) {
+    throw new InputValidationError(`${fieldName} must not be empty.`);
+  }
+  if (value.includes("\0")) {
+    throw new InputValidationError(`${fieldName} must not contain null bytes.`);
+  }
+  if (value.includes("/") || value.includes("\\")) {
+    throw new InputValidationError(
+      `${fieldName} '${value}' must not contain path separators.`
+    );
+  }
+  if (WINDOWS_DRIVE_RE.test(value)) {
+    throw new InputValidationError(
+      `${fieldName} '${value}' must not be drive-qualified.`
+    );
+  }
+  if (value === "." || value === "..") {
+    throw new 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");
+export {
+  isStrictlyInside,
+  validatePathSegment
+};