@google/adk 2.0.0 → 2.2.0

package/dist/cjs/context/anchored_context_compactor.js

@@ -42,26 +42,32 @@ const _AnchoredContextCompactor = class _AnchoredContextCompactor {
     this.eventRetentionSize = options.eventRetentionSize;
     this.summarizer = options.summarizer;
   }
-  getActiveEvents(events) {
+  getActiveEvents(events, currentIsolationScope) {
+    const visibleEvents = events.filter(
+      (event) => (0, import_compaction_utils.isEventVisibleInIsolationScope)(event, currentIsolationScope)
+    );
     let latestScratchpad = void 0;
-    for (let i = events.length - 1; i >= 0; i--) {
-      const e = events[i];
+    for (let i = visibleEvents.length - 1; i >= 0; i--) {
+      const e = visibleEvents[i];
       if ((0, import_compacted_event.isScratchpadEvent)(e)) {
         latestScratchpad = e;
         break;
       }
     }
     if (!latestScratchpad) {
-      return events;
+      return visibleEvents;
     }
-    const activeRawEvents = events.filter(
+    const activeRawEvents = visibleEvents.filter(
       (e) => e.timestamp > latestScratchpad.endTime && !(0, import_compacted_event.isScratchpadEvent)(e)
     );
     return [latestScratchpad, ...activeRawEvents];
   }
   shouldCompact(invocationContext) {
     const events = invocationContext.session.events;
-    const activeEvents = this.getActiveEvents(events);
+    const activeEvents = this.getActiveEvents(
+      events,
+      invocationContext.isolationScope
+    );
     const hasScratchpad = activeEvents.length > 0 && (0, import_compacted_event.isScratchpadEvent)(activeEvents[0]);
     const rawEvents = hasScratchpad ? activeEvents.slice(1) : activeEvents;
     if (rawEvents.length <= this.eventRetentionSize) {
@@ -82,7 +88,10 @@ const _AnchoredContextCompactor = class _AnchoredContextCompactor {
   }
   async compact(invocationContext) {
     const events = invocationContext.session.events;
-    const activeEvents = this.getActiveEvents(events);
+    const activeEvents = this.getActiveEvents(
+      events,
+      invocationContext.isolationScope
+    );
     const hasScratchpad = activeEvents.length > 0 && (0, import_compacted_event.isScratchpadEvent)(activeEvents[0]);
     const rawEvents = hasScratchpad ? activeEvents.slice(1) : activeEvents;
     if (rawEvents.length <= this.eventRetentionSize) {
@@ -97,10 +106,11 @@ const _AnchoredContextCompactor = class _AnchoredContextCompactor {
     }
     const rawEventsToCompact = rawEvents.slice(0, retainStartIndex);
     let scratchpadEvent;
-    if (hasScratchpad) {
-      const existingScratchpad = activeEvents[0];
+    const existingScratchpad = hasScratchpad ? activeEvents[0] : void 0;
+    const reusableScratchpad = existingScratchpad && (existingScratchpad.isolationScope === void 0 || existingScratchpad.isolationScope === invocationContext.isolationScope) ? existingScratchpad : void 0;
+    if (reusableScratchpad) {
       scratchpadEvent = await this.summarizer.summarize([
-        existingScratchpad,
+        reusableScratchpad,
         ...rawEventsToCompact
       ]);
     } else {
@@ -109,15 +119,28 @@ const _AnchoredContextCompactor = class _AnchoredContextCompactor {
     const updatedScratchpad = {
       ...scratchpadEvent,
       isScratchpad: true,
-      author: "system"
+      author: "system",
+      ...invocationContext.isolationScope === void 0 ? {} : { isolationScope: invocationContext.isolationScope }
     };
-    const inactiveEvents = events.slice(0, events.indexOf(activeEvents[0]));
-    const retainedRawEvents = rawEvents.slice(retainStartIndex);
-    const newEventsList = [
-      ...inactiveEvents,
-      updatedScratchpad,
-      ...retainedRawEvents
-    ];
+    const shouldReplaceEvent = /* @__PURE__ */ __name((event) => invocationContext.isolationScope === void 0 || event.isolationScope === invocationContext.isolationScope, "shouldReplaceEvent");
+    const replacedEvents = /* @__PURE__ */ new Set([
+      ...reusableScratchpad && shouldReplaceEvent(reusableScratchpad) ? [reusableScratchpad] : [],
+      ...rawEventsToCompact.filter(shouldReplaceEvent)
+    ]);
+    const firstReplacedIndex = events.findIndex(
+      (event) => replacedEvents.has(event)
+    );
+    const newEventsList = [];
+    let insertedScratchpad = false;
+    for (let index = 0; index < events.length; index++) {
+      const event = events[index];
+      if (index === firstReplacedIndex) {
+        newEventsList.push(updatedScratchpad);
+        insertedScratchpad = true;
+      }
+      if (!replacedEvents.has(event)) newEventsList.push(event);
+    }
+    if (!insertedScratchpad) newEventsList.push(updatedScratchpad);
     events.length = 0;
     events.push(...newEventsList);
   }

package/dist/cjs/context/compaction_utils.js

@@ -26,7 +26,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var compaction_utils_exports = {};
 __export(compaction_utils_exports, {
   calculateRetainStartIndex: () => calculateRetainStartIndex,
-  getActiveEvents: () => getActiveEvents
+  getActiveEvents: () => getActiveEvents,
+  isEventVisibleInIsolationScope: () => isEventVisibleInIsolationScope
 });
 module.exports = __toCommonJS(compaction_utils_exports);
 var import_compacted_event = require("../events/compacted_event.js");
@@ -36,16 +37,23 @@ var import_event = require("../events/event.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-function getActiveEvents(events) {
-  const latest = events.filter(import_compacted_event.isCompactedEvent).pop();
+function getActiveEvents(events, currentIsolationScope) {
+  const visibleEvents = events.filter(
+    (event) => isEventVisibleInIsolationScope(event, currentIsolationScope)
+  );
+  const latest = visibleEvents.filter(import_compacted_event.isCompactedEvent).pop();
   return latest ? [
     latest,
-    ...events.filter(
+    ...visibleEvents.filter(
       (e) => !(0, import_compacted_event.isCompactedEvent)(e) && e.timestamp > latest.endTime
     )
-  ] : events;
+  ] : visibleEvents;
 }
 __name(getActiveEvents, "getActiveEvents");
+function isEventVisibleInIsolationScope(event, currentIsolationScope) {
+  return event.isolationScope === void 0 || event.isolationScope === currentIsolationScope;
+}
+__name(isEventVisibleInIsolationScope, "isEventVisibleInIsolationScope");
 function calculateRetainStartIndex(rawEvents, eventRetentionSize) {
   let retainStartIndex = Math.max(0, rawEvents.length - eventRetentionSize);
   while (retainStartIndex > 0) {
@@ -63,5 +71,6 @@ __name(calculateRetainStartIndex, "calculateRetainStartIndex");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   calculateRetainStartIndex,
-  getActiveEvents
+  getActiveEvents,
+  isEventVisibleInIsolationScope
 });

package/dist/cjs/context/token_based_context_compactor.js

@@ -46,7 +46,10 @@ const _TokenBasedContextCompactor = class _TokenBasedContextCompactor {
   }
   shouldCompact(invocationContext) {
     const events = invocationContext.session.events;
-    const activeEvents = (0, import_compaction_utils.getActiveEvents)(events);
+    const activeEvents = (0, import_compaction_utils.getActiveEvents)(
+      events,
+      invocationContext.isolationScope
+    );
     const rawEvents = activeEvents.filter((e) => !(0, import_compacted_event.isCompactedEvent)(e));
     if (rawEvents.length <= this.eventRetentionSize) {
       return false;
@@ -68,8 +71,12 @@ const _TokenBasedContextCompactor = class _TokenBasedContextCompactor {
     return promptTokenCount > this.tokenThreshold;
   }
   async compact(invocationContext) {
+    var _a;
     const events = invocationContext.session.events;
-    const activeEvents = (0, import_compaction_utils.getActiveEvents)(events);
+    const activeEvents = (0, import_compaction_utils.getActiveEvents)(
+      events,
+      invocationContext.isolationScope
+    );
     const rawEvents = activeEvents.filter((e) => !(0, import_compacted_event.isCompactedEvent)(e));
     if (rawEvents.length <= this.eventRetentionSize) {
       return;
@@ -93,6 +100,7 @@ const _TokenBasedContextCompactor = class _TokenBasedContextCompactor {
         requestedToolConfirmations: {}
       };
     }
+    (_a = compactedEvent.isolationScope) != null ? _a : compactedEvent.isolationScope = invocationContext.isolationScope;
     invocationContext.session.events.push(compactedEvent);
   }
 };

package/dist/cjs/context/trajectory_thought_pruning_compactor.js

@@ -29,6 +29,7 @@ __export(trajectory_thought_pruning_compactor_exports, {
 });
 module.exports = __toCommonJS(trajectory_thought_pruning_compactor_exports);
 var import_event = require("../events/event.js");
+var import_compaction_utils = require("./compaction_utils.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -43,25 +44,31 @@ const _TrajectoryThoughtPruningCompactor = class _TrajectoryThoughtPruningCompac
   }
   shouldCompact(invocationContext) {
     const events = invocationContext.session.events;
-    if (events.length <= this.eventRetentionSize) {
+    const visibleIndices = events.flatMap(
+      (event, index) => (0, import_compaction_utils.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) => (0, import_event.hasThoughts)(event));
   }
   compact(invocationContext) {
     const events = invocationContext.session.events;
-    if (events.length <= this.eventRetentionSize) {
+    const visibleIndices = events.flatMap(
+      (event, index) => (0, import_compaction_utils.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 ((0, import_event.hasThoughts)(event)) {
-        events[i] = (0, import_event.pruneThoughts)(event);
+        events[index] = (0, import_event.pruneThoughts)(event);
       }
     }
   }

package/dist/cjs/context/truncating_context_compactor.js

@@ -28,6 +28,7 @@ __export(truncating_context_compactor_exports, {
   TruncatingContextCompactor: () => TruncatingContextCompactor
 });
 module.exports = __toCommonJS(truncating_context_compactor_exports);
+var import_compaction_utils = require("./compaction_utils.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -40,17 +41,28 @@ const _TruncatingContextCompactor = class _TruncatingContextCompactor {
     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) => (0, import_compaction_utils.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) => (0, import_compaction_utils.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");

package/dist/cjs/errors/already_exists_error.js

@@ -0,0 +1,50 @@
+/**
+  * @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 already_exists_error_exports = {};
+__export(already_exists_error_exports, {
+  AlreadyExistsError: () => AlreadyExistsError
+});
+module.exports = __toCommonJS(already_exists_error_exports);
+/**
+ * @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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlreadyExistsError
+});

package/dist/cjs/errors/input_validation_error.js

@@ -0,0 +1,50 @@
+/**
+  * @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 input_validation_error_exports = {};
+__export(input_validation_error_exports, {
+  InputValidationError: () => InputValidationError
+});
+module.exports = __toCommonJS(input_validation_error_exports);
+/**
+ * @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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InputValidationError
+});

package/dist/cjs/errors/not_found_error.js

@@ -0,0 +1,50 @@
+/**
+  * @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 not_found_error_exports = {};
+__export(not_found_error_exports, {
+  NotFoundError: () => NotFoundError
+});
+module.exports = __toCommonJS(not_found_error_exports);
+/**
+ * @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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NotFoundError
+});

package/dist/cjs/errors/session_not_found_error.js

@@ -0,0 +1,50 @@
+/**
+  * @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 session_not_found_error_exports = {};
+__export(session_not_found_error_exports, {
+  SessionNotFoundError: () => SessionNotFoundError
+});
+module.exports = __toCommonJS(session_not_found_error_exports);
+/**
+ * @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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionNotFoundError
+});

package/dist/cjs/errors/tool_execution_error.js

@@ -0,0 +1,68 @@
+/**
+  * @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 tool_execution_error_exports = {};
+__export(tool_execution_error_exports, {
+  ToolErrorType: () => ToolErrorType,
+  ToolExecutionError: () => ToolExecutionError
+});
+module.exports = __toCommonJS(tool_execution_error_exports);
+/**
+ * @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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolErrorType,
+  ToolExecutionError
+});

package/dist/cjs/events/event.js

@@ -51,7 +51,7 @@ var import_event_actions = require("./event_actions.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const EVENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.event");
+const EVENT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.event");
 function createEvent(params = {}) {
   return {
     ...params,

package/dist/cjs/events/event_actions.js

@@ -26,9 +26,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var event_actions_exports = {};
 __export(event_actions_exports, {
   createEventActions: () => createEventActions,
+  isDefaultEventActions: () => isDefaultEventActions,
   mergeEventActions: () => mergeEventActions
 });
 module.exports = __toCommonJS(event_actions_exports);
+var import_lodash_es = require("lodash-es");
 var import_state_write_order = require("../sessions/state_write_order.js");
 /**
  * @license
@@ -45,6 +47,10 @@ function createEventActions(state = {}) {
   };
 }
 __name(createEventActions, "createEventActions");
+function isDefaultEventActions(actions) {
+  return (0, import_lodash_es.isEmpty)(actions.stateDelta) && (0, import_lodash_es.isEmpty)(actions.artifactDelta) && (0, import_lodash_es.isEmpty)(actions.requestedAuthConfigs) && (0, import_lodash_es.isEmpty)(actions.requestedToolConfirmations) && actions.skipSummarization === void 0 && actions.transferToAgent === void 0 && actions.escalate === void 0;
+}
+__name(isDefaultEventActions, "isDefaultEventActions");
 function mergeEventActions(sources, target) {
   const result = createEventActions();
   if (target) {
@@ -84,5 +90,6 @@ __name(mergeEventActions, "mergeEventActions");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createEventActions,
+  isDefaultEventActions,
   mergeEventActions
 });

package/dist/cjs/examples/base_example_provider.js

@@ -35,7 +35,7 @@ module.exports = __toCommonJS(base_example_provider_exports);
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-const BASE_EXAMPLE_PROVIDER_SIGNATURE_SYMBOL = Symbol.for(
+const BASE_EXAMPLE_PROVIDER_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
   "google.adk.baseExampleProvider"
 );
 function isBaseExampleProvider(obj) {