@google/adk 1.6.0 → 2.1.0

package/dist/cjs/environment/local_environment.js

@@ -0,0 +1,186 @@
+/**
+  * @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 __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;
+};
+var local_environment_exports = {};
+__export(local_environment_exports, {
+  LocalEnvironment: () => LocalEnvironment
+});
+module.exports = __toCommonJS(local_environment_exports);
+var import_node_child_process = require("node:child_process");
+var fs = __toESM(require("node:fs/promises"), 1);
+var os = __toESM(require("node:os"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_experimental = require("../utils/experimental.js");
+var import_logger = require("../utils/logger.js");
+var import_base_environment = require("./base_environment.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 import_base_environment.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;
+      import_logger.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 });
+      import_logger.logger.debug(`Removed temporary workspace: ${this.currentWorkingDir}`);
+      this.currentWorkingDir = void 0;
+    }
+    this.initialized = false;
+  }
+  async execute(command, timeoutSeconds) {
+    this.assertInitialized();
+    const child = (0, import_node_child_process.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([
+  import_experimental.experimental
+], LocalEnvironment);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalEnvironment
+});

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/compacted_event.js

@@ -9,6 +9,7 @@ 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 });
@@ -38,9 +39,11 @@ var import_event = require("./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 {
     ...(0, import_event.createEvent)(params),
@@ -51,6 +54,7 @@ function createCompactedEvent(params = {}) {
     isScratchpad: params.isScratchpad
   };
 }
+__name(createCompactedEvent, "createCompactedEvent");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createCompactedEvent,

package/dist/cjs/events/event.js

@@ -9,6 +9,7 @@ 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 });
@@ -33,6 +34,7 @@ __export(event_exports, {
   getFunctionResponses: () => getFunctionResponses,
   hasThoughts: () => hasThoughts,
   hasTrailingCodeExecutionResult: () => hasTrailingCodeExecutionResult,
+  isEvent: () => isEvent,
   isFinalResponse: () => isFinalResponse,
   populateClientFunctionCallId: () => populateClientFunctionCallId,
   pruneThoughts: () => pruneThoughts,
@@ -49,24 +51,28 @@ var import_event_actions = require("./event_actions.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const EVENT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.event");
 function createEvent(params = {}) {
   return {
     ...params,
+    [EVENT_SIGNATURE_SYMBOL]: true,
     id: params.id || createNewEventId(),
     invocationId: params.invocationId || "",
     author: params.author,
-    actions: params.actions || (0, import_event_actions.createEventActions)(),
+    actions: (0, import_event_actions.createEventActions)(params.actions),
     longRunningToolIds: params.longRunningToolIds || [],
     branch: params.branch,
     timestamp: params.timestamp || Date.now()
   };
 }
+__name(createEvent, "createEvent");
 function isFinalResponse(event) {
   if (event.actions.skipSummarization || event.longRunningToolIds && event.longRunningToolIds.length > 0 || event.actions.requestedAuthConfigs && Object.keys(event.actions.requestedAuthConfigs).length > 0) {
     return true;
   }
   return getFunctionCalls(event).length === 0 && getFunctionResponses(event).length === 0 && !event.partial && !hasTrailingCodeExecutionResult(event);
 }
+__name(isFinalResponse, "isFinalResponse");
 function getFunctionCalls(event) {
   const funcCalls = [];
   if (event.content && event.content.parts) {
@@ -78,10 +84,12 @@ function getFunctionCalls(event) {
   }
   return funcCalls;
 }
+__name(getFunctionCalls, "getFunctionCalls");
 const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
 function generateClientFunctionCallId() {
   return `${AF_FUNCTION_CALL_ID_PREFIX}${(0, import_env_aware_utils.randomUUID)()}`;
 }
+__name(generateClientFunctionCallId, "generateClientFunctionCallId");
 function populateClientFunctionCallId(modelResponseEvent) {
   for (const functionCall of getFunctionCalls(modelResponseEvent)) {
     if (!functionCall.id) {
@@ -89,6 +97,7 @@ function populateClientFunctionCallId(modelResponseEvent) {
     }
   }
 }
+__name(populateClientFunctionCallId, "populateClientFunctionCallId");
 function getFunctionResponses(event) {
   const funcResponses = [];
   if (event.content && event.content.parts) {
@@ -100,6 +109,7 @@ function getFunctionResponses(event) {
   }
   return funcResponses;
 }
+__name(getFunctionResponses, "getFunctionResponses");
 function hasTrailingCodeExecutionResult(event) {
   var _a;
   if (event.content && ((_a = event.content.parts) == null ? void 0 : _a.length)) {
@@ -108,6 +118,7 @@ function hasTrailingCodeExecutionResult(event) {
   }
   return false;
 }
+__name(hasTrailingCodeExecutionResult, "hasTrailingCodeExecutionResult");
 function stringifyContent(event) {
   var _a;
   if (!((_a = event.content) == null ? void 0 : _a.parts)) {
@@ -118,6 +129,7 @@ function stringifyContent(event) {
     return (_a2 = part.text) != null ? _a2 : "";
   }).join("");
 }
+__name(stringifyContent, "stringifyContent");
 function getEventTokens(event) {
   var _a;
   if (((_a = event.usageMetadata) == null ? void 0 : _a.promptTokenCount) !== void 0) {
@@ -126,10 +138,12 @@ function getEventTokens(event) {
   const contentStr = stringifyContent(event);
   return Math.ceil(contentStr.length / 4);
 }
+__name(getEventTokens, "getEventTokens");
 function hasThoughts(event) {
   var _a, _b;
   return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some((part) => part.thought === true));
 }
+__name(hasThoughts, "hasThoughts");
 function pruneThoughts(event) {
   var _a;
   if (!((_a = event.content) == null ? void 0 : _a.parts)) {
@@ -146,7 +160,12 @@ function pruneThoughts(event) {
     }
   };
 }
+__name(pruneThoughts, "pruneThoughts");
 const ASCII_LETTERS_AND_NUMBERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+function isEvent(obj) {
+  return typeof obj === "object" && obj !== null && EVENT_SIGNATURE_SYMBOL in obj && obj[EVENT_SIGNATURE_SYMBOL] === true;
+}
+__name(isEvent, "isEvent");
 function createNewEventId() {
   let id = "";
   for (let i = 0; i < 8; i++) {
@@ -154,6 +173,7 @@ function createNewEventId() {
   }
   return id;
 }
+__name(createNewEventId, "createNewEventId");
 const PRESERVE_KEYS_CAMEL_CASE = [
   "actions.stateDelta",
   "actions.artifactDelta",
@@ -162,7 +182,14 @@ const PRESERVE_KEYS_CAMEL_CASE = [
   "actions.customMetadata",
   "customMetadata",
   "content.parts.functionCall.args",
-  "content.parts.functionResponse.response"
+  "content.parts.functionResponse.response",
+  // Workflow: arbitrary node output, emitted route(s), and checkpointed node
+  // state carry user-defined keys that must survive round-trips verbatim (a
+  // node's original input is stashed under `actions.agentState` for HITL
+  // resume, and rehydration reads `output`/`route`/`actions.agentState` back).
+  "output",
+  "route",
+  "actions.agentState"
 ];
 const PRESERVE_KEYS_SNAKE_CASE = [
   "actions.state_delta",
@@ -172,14 +199,21 @@ const PRESERVE_KEYS_SNAKE_CASE = [
   "actions.custom_metadata",
   "custom_metadata",
   "content.parts.function_call.args",
-  "content.parts.function_response.response"
+  "content.parts.function_response.response",
+  // Workflow: arbitrary node output, emitted route(s), and checkpointed node
+  // state (see the camelCase list above).
+  "output",
+  "route",
+  "actions.agent_state"
 ];
 function transformToCamelCaseEvent(event) {
   return (0, import_object_notation_utils.toCamelCase)(event, PRESERVE_KEYS_SNAKE_CASE);
 }
+__name(transformToCamelCaseEvent, "transformToCamelCaseEvent");
 function transformToSnakeCaseEvent(event) {
   return (0, import_object_notation_utils.toSnakeCase)(event, PRESERVE_KEYS_CAMEL_CASE);
 }
+__name(transformToSnakeCaseEvent, "transformToSnakeCaseEvent");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AF_FUNCTION_CALL_ID_PREFIX,
@@ -191,6 +225,7 @@ function transformToSnakeCaseEvent(event) {
   getFunctionResponses,
   hasThoughts,
   hasTrailingCodeExecutionResult,
+  isEvent,
   isFinalResponse,
   populateClientFunctionCallId,
   pruneThoughts,