@google/adk 1.6.0 → 2.1.0

package/dist/esm/context/summarizers/llm_summarizer.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 2026 Google LLC
@@ -10,7 +12,7 @@ import {
 } from "../../events/compacted_event.js";
 import { stringifyContent } from "../../events/event.js";
 const DEFAULT_PROMPT = "The following is a conversation history between a user and an AI agent. Please summarize the conversation, focusing on key information and decisions made, as well as any unresolved questions or tasks. The summary should be concise and capture the essence of the interaction.";
-class LlmSummarizer {
+const _LlmSummarizer = class _LlmSummarizer {
   /**
    * @param options - Configuration specifying the LLM and optional prompt.
    */
@@ -72,7 +74,9 @@ ${formattedEvents}`;
       compactedContent
     });
   }
-}
+};
+__name(_LlmSummarizer, "LlmSummarizer");
+let LlmSummarizer = _LlmSummarizer;
 export {
   LlmSummarizer
 };

package/dist/esm/context/token_based_context_compactor.js

@@ -1,10 +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 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { requireAgent } from "../agents/invocation_context.js";
 import { getContents } from "../agents/processors/content_processor_utils.js";
 import { isCompactedEvent } from "../events/compacted_event.js";
 import {
@@ -12,7 +15,7 @@ import {
   getActiveEvents
 } from "./compaction_utils.js";
 const CHARS_PER_TOKEN = 4;
-class TokenBasedContextCompactor {
+const _TokenBasedContextCompactor = class _TokenBasedContextCompactor {
   constructor(options) {
     this.tokenThreshold = options.tokenThreshold;
     this.eventRetentionSize = options.eventRetentionSize;
@@ -20,7 +23,10 @@ class TokenBasedContextCompactor {
   }
   shouldCompact(invocationContext) {
     const events = invocationContext.session.events;
-    const activeEvents = getActiveEvents(events);
+    const activeEvents = getActiveEvents(
+      events,
+      invocationContext.isolationScope
+    );
     const rawEvents = activeEvents.filter((e) => !isCompactedEvent(e));
     if (rawEvents.length <= this.eventRetentionSize) {
       return false;
@@ -42,8 +48,12 @@ class TokenBasedContextCompactor {
     return promptTokenCount > this.tokenThreshold;
   }
   async compact(invocationContext) {
+    var _a;
     const events = invocationContext.session.events;
-    const activeEvents = getActiveEvents(events);
+    const activeEvents = getActiveEvents(
+      events,
+      invocationContext.isolationScope
+    );
     const rawEvents = activeEvents.filter((e) => !isCompactedEvent(e));
     if (rawEvents.length <= this.eventRetentionSize) {
       return;
@@ -67,9 +77,12 @@ class TokenBasedContextCompactor {
         requestedToolConfirmations: {}
       };
     }
+    (_a = compactedEvent.isolationScope) != null ? _a : compactedEvent.isolationScope = invocationContext.isolationScope;
     invocationContext.session.events.push(compactedEvent);
   }
-}
+};
+__name(_TokenBasedContextCompactor, "TokenBasedContextCompactor");
+let TokenBasedContextCompactor = _TokenBasedContextCompactor;
 function latestPromptTokenCount(activeEvents, invocationContext) {
   var _a;
   for (let i = activeEvents.length - 1; i >= 0; i--) {
@@ -80,11 +93,12 @@ function latestPromptTokenCount(activeEvents, invocationContext) {
   }
   return estimatePromptTokenCount(activeEvents, invocationContext);
 }
+__name(latestPromptTokenCount, "latestPromptTokenCount");
 function estimatePromptTokenCount(activeEvents, invocationContext) {
   var _a;
   const contents = getContents(
     activeEvents,
-    invocationContext.agent.name,
+    requireAgent(invocationContext).name,
     invocationContext.branch
   );
   let totalChars = 0;
@@ -106,6 +120,7 @@ function estimatePromptTokenCount(activeEvents, invocationContext) {
   }
   return Math.ceil(totalChars / CHARS_PER_TOKEN);
 }
+__name(estimatePromptTokenCount, "estimatePromptTokenCount");
 export {
   TokenBasedContextCompactor
 };

package/dist/esm/context/trajectory_thought_pruning_compactor.js

@@ -1,12 +1,15 @@
 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 { hasThoughts, pruneThoughts } from "../events/event.js";
-class TrajectoryThoughtPruningCompactor {
+import { isEventVisibleInIsolationScope } from "./compaction_utils.js";
+const _TrajectoryThoughtPruningCompactor = class _TrajectoryThoughtPruningCompactor {
   constructor(options) {
     if (options.eventRetentionSize < 0) {
       throw new Error("eventRetentionSize must be a non-negative integer.");
@@ -15,29 +18,37 @@ class TrajectoryThoughtPruningCompactor {
   }
   shouldCompact(invocationContext) {
     const events = invocationContext.session.events;
-    if (events.length <= this.eventRetentionSize) {
+    const visibleIndices = events.flatMap(
+      (event, index) => isEventVisibleInIsolationScope(event, invocationContext.isolationScope) ? [index] : []
+    );
+    if (visibleIndices.length <= this.eventRetentionSize) {
       return false;
     }
-    const olderEvents = events.slice(
-      0,
-      events.length - this.eventRetentionSize
-    );
+    const olderEvents = visibleIndices.slice(0, visibleIndices.length - this.eventRetentionSize).map((index) => events[index]);
     return olderEvents.some((event) => hasThoughts(event));
   }
   compact(invocationContext) {
     const events = invocationContext.session.events;
-    if (events.length <= this.eventRetentionSize) {
+    const visibleIndices = events.flatMap(
+      (event, index) => isEventVisibleInIsolationScope(event, invocationContext.isolationScope) ? [index] : []
+    );
+    if (visibleIndices.length <= this.eventRetentionSize) {
       return;
     }
-    const pruneLimit = events.length - this.eventRetentionSize;
-    for (let i = 0; i < pruneLimit; i++) {
-      const event = events[i];
+    const pruneIndices = visibleIndices.slice(
+      0,
+      visibleIndices.length - this.eventRetentionSize
+    );
+    for (const index of pruneIndices) {
+      const event = events[index];
       if (hasThoughts(event)) {
-        events[i] = pruneThoughts(event);
+        events[index] = pruneThoughts(event);
       }
     }
   }
-}
+};
+__name(_TrajectoryThoughtPruningCompactor, "TrajectoryThoughtPruningCompactor");
+let TrajectoryThoughtPruningCompactor = _TrajectoryThoughtPruningCompactor;
 export {
   TrajectoryThoughtPruningCompactor
 };

package/dist/esm/context/truncating_context_compactor.js

@@ -1,30 +1,46 @@
 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
  */
-class TruncatingContextCompactor {
+import { isEventVisibleInIsolationScope } from "./compaction_utils.js";
+const _TruncatingContextCompactor = class _TruncatingContextCompactor {
   constructor(options) {
     var _a;
     this.threshold = options.threshold;
     this.preserveLeadingEvents = (_a = options.preserveLeadingEvents) != null ? _a : 0;
   }
   shouldCompact(invocationContext) {
-    const eventsLength = invocationContext.session.events.length;
-    return eventsLength > this.threshold + Math.max(0, this.preserveLeadingEvents);
+    const visibleEventsLength = invocationContext.session.events.filter(
+      (event) => isEventVisibleInIsolationScope(event, invocationContext.isolationScope)
+    ).length;
+    return visibleEventsLength > this.threshold + Math.max(0, this.preserveLeadingEvents);
   }
   compact(invocationContext) {
     const events = invocationContext.session.events;
-    const excess = events.length - this.threshold - Math.max(0, this.preserveLeadingEvents);
+    const visibleIndices = events.flatMap(
+      (event, index) => isEventVisibleInIsolationScope(event, invocationContext.isolationScope) ? [index] : []
+    );
+    const excess = visibleIndices.length - this.threshold - Math.max(0, this.preserveLeadingEvents);
     if (excess <= 0) {
       return;
     }
-    const startIndexToRemove = Math.max(0, this.preserveLeadingEvents);
-    events.splice(startIndexToRemove, excess);
+    const preserveCount = Math.max(0, this.preserveLeadingEvents);
+    const indicesToRemove = visibleIndices.slice(
+      preserveCount,
+      preserveCount + excess
+    );
+    for (const index of indicesToRemove.reverse()) {
+      events.splice(index, 1);
+    }
   }
-}
+};
+__name(_TruncatingContextCompactor, "TruncatingContextCompactor");
+let TruncatingContextCompactor = _TruncatingContextCompactor;
 export {
   TruncatingContextCompactor
 };

package/dist/esm/environment/base_environment.js

@@ -0,0 +1,71 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { experimental } from "../utils/experimental.js";
+let BaseEnvironment = class {
+  constructor() {
+    /**
+     * Backing flag for {@link isInitialized}.
+     *
+     * Subclasses own this flag: set it in {@link initialize} and clear it in
+     * {@link close}.
+     */
+    this.initialized = false;
+  }
+  /** Whether the environment has been initialized. */
+  get isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Initializes the environment (e.g. creates the working directory).
+   *
+   * Called before first use. The default implementation is a no-op and leaves
+   * {@link isInitialized} `false`. Subclasses must be idempotent and must set
+   * {@link initialized}.
+   */
+  async initialize() {
+  }
+  /**
+   * Releases resources held by the environment.
+   *
+   * The default implementation is a no-op. Subclasses must be idempotent and
+   * must clear {@link initialized}.
+   */
+  async close() {
+  }
+  /**
+   * Throws if {@link initialize} has not been called.
+   *
+   * Implementations should call this at the start of every operation that needs
+   * a live working directory.
+   */
+  assertInitialized() {
+    if (!this.initialized) {
+      throw new Error(
+        "Environment is not initialized. Call initialize() first."
+      );
+    }
+  }
+};
+__name(BaseEnvironment, "BaseEnvironment");
+BaseEnvironment = __decorateClass([
+  experimental
+], BaseEnvironment);
+export {
+  BaseEnvironment
+};

package/dist/esm/environment/local_environment.js

@@ -0,0 +1,150 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { experimental } from "../utils/experimental.js";
+import { logger } from "../utils/logger.js";
+import { BaseEnvironment } from "./base_environment.js";
+const TEMP_WORKSPACE_PREFIX = "adk_workspace_";
+function resolvePathInWorkingDir(workingDir, filePath) {
+  const base = path.resolve(workingDir);
+  const resolved = path.resolve(base, filePath);
+  const relative = path.relative(base, resolved);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || // `path.relative` returns an absolute path across Windows drives.
+  path.isAbsolute(relative)) {
+    throw new Error(`Path escapes working directory: ${filePath}`);
+  }
+  return resolved;
+}
+__name(resolvePathInWorkingDir, "resolvePathInWorkingDir");
+let LocalEnvironment = class extends BaseEnvironment {
+  constructor(options = {}) {
+    super();
+    this.autoCreated = false;
+    this.currentWorkingDir = options.workingDir;
+    this.envVars = options.envVars;
+  }
+  get workingDir() {
+    if (this.currentWorkingDir === void 0) {
+      throw new Error("`workingDir` is not set. Call initialize() first.");
+    }
+    return this.currentWorkingDir;
+  }
+  async initialize() {
+    if (this.currentWorkingDir === void 0) {
+      this.currentWorkingDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), TEMP_WORKSPACE_PREFIX)
+      );
+      this.autoCreated = true;
+      logger.debug(`Created temporary workspace: ${this.currentWorkingDir}`);
+    } else {
+      await fs.mkdir(this.currentWorkingDir, { recursive: true });
+    }
+    this.initialized = true;
+  }
+  async close() {
+    if (this.autoCreated && this.currentWorkingDir !== void 0) {
+      await fs.rm(this.currentWorkingDir, { recursive: true, force: true });
+      logger.debug(`Removed temporary workspace: ${this.currentWorkingDir}`);
+      this.currentWorkingDir = void 0;
+    }
+    this.initialized = false;
+  }
+  async execute(command, timeoutSeconds) {
+    this.assertInitialized();
+    const child = spawn(command, {
+      shell: true,
+      cwd: this.workingDir,
+      env: { ...process.env, ...this.envVars }
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    let timedOut = false;
+    let timer;
+    if (timeoutSeconds !== void 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+        child.stdout.destroy();
+        child.stderr.destroy();
+      }, timeoutSeconds * 1e3);
+    }
+    try {
+      const exitCode = await new Promise((resolve, reject) => {
+        child.on("close", (code, signal) => {
+          resolve(
+            signal === null ? code != null ? code : 0 : -os.constants.signals[signal]
+          );
+        });
+        child.on("error", reject);
+      });
+      return {
+        exitCode,
+        // Decode once, so a multi-byte character split across two chunks is
+        // not corrupted. Invalid bytes become U+FFFD, matching Python's
+        // `errors='replace'`.
+        stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+        timedOut
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Reads a file from the working directory.
+   *
+   * `filePath` is confined to the working directory by a lexical check on the
+   * resolved path, which is not a sandbox.
+   *
+   * @throws If the environment is not initialized, if the path escapes the
+   *   working directory, or — as `ENOENT` — if the file does not exist.
+   */
+  async readFile(filePath) {
+    this.assertInitialized();
+    return fs.readFile(resolvePathInWorkingDir(this.workingDir, filePath));
+  }
+  /**
+   * Writes a file in the working directory, creating parent directories.
+   *
+   * `filePath` is confined to the working directory by a lexical check on the
+   * resolved path, which is not a sandbox. No newline translation is applied,
+   * so explicit CRLF sequences are preserved.
+   *
+   * @throws If the environment is not initialized or the path escapes the
+   *   working directory.
+   */
+  async writeFile(filePath, content) {
+    this.assertInitialized();
+    const resolved = resolvePathInWorkingDir(this.workingDir, filePath);
+    await fs.mkdir(path.dirname(resolved), { recursive: true });
+    await fs.writeFile(resolved, content);
+  }
+};
+__name(LocalEnvironment, "LocalEnvironment");
+LocalEnvironment = __decorateClass([
+  experimental
+], LocalEnvironment);
+export {
+  LocalEnvironment
+};

package/dist/esm/errors/already_exists_error.js

@@ -0,0 +1,23 @@
+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 _AlreadyExistsError = class _AlreadyExistsError extends Error {
+  /**
+   * @param message An optional custom message to describe the error.
+   */
+  constructor(message = "The resource already exists.") {
+    super(message);
+    this.name = "AlreadyExistsError";
+  }
+};
+__name(_AlreadyExistsError, "AlreadyExistsError");
+let AlreadyExistsError = _AlreadyExistsError;
+export {
+  AlreadyExistsError
+};

package/dist/esm/errors/input_validation_error.js

@@ -0,0 +1,23 @@
+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 _InputValidationError = class _InputValidationError extends Error {
+  /**
+   * @param message A message describing why the input is invalid.
+   */
+  constructor(message = "Invalid input.") {
+    super(message);
+    this.name = "InputValidationError";
+  }
+};
+__name(_InputValidationError, "InputValidationError");
+let InputValidationError = _InputValidationError;
+export {
+  InputValidationError
+};

package/dist/esm/errors/not_found_error.js

@@ -0,0 +1,23 @@
+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 _NotFoundError = class _NotFoundError extends Error {
+  /**
+   * @param message An optional custom message to describe the error.
+   */
+  constructor(message = "The requested item was not found.") {
+    super(message);
+    this.name = "NotFoundError";
+  }
+};
+__name(_NotFoundError, "NotFoundError");
+let NotFoundError = _NotFoundError;
+export {
+  NotFoundError
+};

package/dist/esm/errors/session_not_found_error.js

@@ -0,0 +1,23 @@
+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 _SessionNotFoundError = class _SessionNotFoundError extends Error {
+  /**
+   * @param message An optional custom message to describe the error.
+   */
+  constructor(message = "Session not found.") {
+    super(message);
+    this.name = "SessionNotFoundError";
+  }
+};
+__name(_SessionNotFoundError, "SessionNotFoundError");
+let SessionNotFoundError = _SessionNotFoundError;
+export {
+  SessionNotFoundError
+};

package/dist/esm/errors/tool_execution_error.js

@@ -0,0 +1,40 @@
+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
+ */
+var ToolErrorType = /* @__PURE__ */ ((ToolErrorType2) => {
+  ToolErrorType2["BAD_REQUEST"] = "BAD_REQUEST";
+  ToolErrorType2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  ToolErrorType2["FORBIDDEN"] = "FORBIDDEN";
+  ToolErrorType2["NOT_FOUND"] = "NOT_FOUND";
+  ToolErrorType2["REQUEST_TIMEOUT"] = "REQUEST_TIMEOUT";
+  ToolErrorType2["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+  ToolErrorType2["BAD_GATEWAY"] = "BAD_GATEWAY";
+  ToolErrorType2["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+  ToolErrorType2["GATEWAY_TIMEOUT"] = "GATEWAY_TIMEOUT";
+  return ToolErrorType2;
+})(ToolErrorType || {});
+const _ToolExecutionError = class _ToolExecutionError extends Error {
+  /**
+   * @param message A message describing the error.
+   * @param errorType The semantic error type (e.g.
+   *   {@link ToolErrorType.REQUEST_TIMEOUT} or `'500'`). Used to populate the
+   *   `error.type` span attribute in OpenTelemetry traces.
+   */
+  constructor(message, errorType) {
+    super(message);
+    this.errorType = errorType;
+    this.name = "ToolExecutionError";
+  }
+};
+__name(_ToolExecutionError, "ToolExecutionError");
+let ToolExecutionError = _ToolExecutionError;
+export {
+  ToolErrorType,
+  ToolExecutionError
+};

package/dist/esm/events/compacted_event.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 2026 Google LLC
@@ -9,9 +11,11 @@ import { createEvent } from "./event.js";
 function isCompactedEvent(event) {
   return "isCompacted" in event && event.isCompacted === true;
 }
+__name(isCompactedEvent, "isCompactedEvent");
 function isScratchpadEvent(event) {
   return isCompactedEvent(event) && event.isScratchpad === true;
 }
+__name(isScratchpadEvent, "isScratchpadEvent");
 function createCompactedEvent(params = {}) {
   return {
     ...createEvent(params),
@@ -22,6 +26,7 @@ function createCompactedEvent(params = {}) {
     isScratchpad: params.isScratchpad
   };
 }
+__name(createCompactedEvent, "createCompactedEvent");
 export {
   createCompactedEvent,
   isCompactedEvent,