@google/adk 1.5.0 → 1.6.0

package/dist/cjs/context/compaction_utils.js

@@ -24,15 +24,26 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var compaction_utils_exports = {};
 __export(compaction_utils_exports, {
-  calculateRetainStartIndex: () => calculateRetainStartIndex
+  calculateRetainStartIndex: () => calculateRetainStartIndex,
+  getActiveEvents: () => getActiveEvents
 });
 module.exports = __toCommonJS(compaction_utils_exports);
+var import_compacted_event = require("../events/compacted_event.js");
 var import_event = require("../events/event.js");
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+function getActiveEvents(events) {
+  const latest = events.filter(import_compacted_event.isCompactedEvent).pop();
+  return latest ? [
+    latest,
+    ...events.filter(
+      (e) => !(0, import_compacted_event.isCompactedEvent)(e) && e.timestamp > latest.endTime
+    )
+  ] : events;
+}
 function calculateRetainStartIndex(rawEvents, eventRetentionSize) {
   let retainStartIndex = Math.max(0, rawEvents.length - eventRetentionSize);
   while (retainStartIndex > 0) {
@@ -48,5 +59,6 @@ function calculateRetainStartIndex(rawEvents, eventRetentionSize) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  calculateRetainStartIndex
+  calculateRetainStartIndex,
+  getActiveEvents
 });

package/dist/cjs/context/token_based_context_compactor.js

@@ -42,27 +42,9 @@ class TokenBasedContextCompactor {
     this.eventRetentionSize = options.eventRetentionSize;
     this.summarizer = options.summarizer;
   }
-  getActiveEvents(events) {
-    let latestCompactedEvent = void 0;
-    for (let i = events.length - 1; i >= 0; i--) {
-      const e = events[i];
-      if ((0, import_compacted_event.isCompactedEvent)(e)) {
-        if (!latestCompactedEvent || e.endTime > latestCompactedEvent.endTime) {
-          latestCompactedEvent = e;
-        }
-      }
-    }
-    if (!latestCompactedEvent) {
-      return events;
-    }
-    const activeRawEvents = events.filter(
-      (e) => !(0, import_compacted_event.isCompactedEvent)(e) && e.timestamp > latestCompactedEvent.endTime
-    );
-    return [latestCompactedEvent, ...activeRawEvents];
-  }
   shouldCompact(invocationContext) {
     const events = invocationContext.session.events;
-    const activeEvents = this.getActiveEvents(events);
+    const activeEvents = (0, import_compaction_utils.getActiveEvents)(events);
     const rawEvents = activeEvents.filter((e) => !(0, import_compacted_event.isCompactedEvent)(e));
     if (rawEvents.length <= this.eventRetentionSize) {
       return false;
@@ -85,7 +67,7 @@ class TokenBasedContextCompactor {
   }
   async compact(invocationContext) {
     const events = invocationContext.session.events;
-    const activeEvents = this.getActiveEvents(events);
+    const activeEvents = (0, import_compaction_utils.getActiveEvents)(events);
     const rawEvents = activeEvents.filter((e) => !(0, import_compacted_event.isCompactedEvent)(e));
     if (rawEvents.length <= this.eventRetentionSize) {
       return;

package/dist/cjs/index.js

@@ -39,6 +39,7 @@ __export(index_exports, {
   RunSkillScriptTool: () => import_run_skill_script_tool.RunSkillScriptTool,
   UnsafeLocalCodeExecutor: () => import_unsafe_local_code_executor.UnsafeLocalCodeExecutor,
   VertexAiSessionService: () => import_vertex_ai_session_service.VertexAiSessionService,
+  bearerTokenUserBuilder: () => import_auth.bearerTokenUserBuilder,
   getA2AAgentCard: () => import_agent_card.getA2AAgentCard,
   getArtifactServiceFromUri: () => import_registry.getArtifactServiceFromUri,
   getSessionServiceFromUri: () => import_registry2.getSessionServiceFromUri,
@@ -52,6 +53,7 @@ var import_a2a_remote_agent = require("./a2a/a2a_remote_agent.js");
 var import_agent_card = require("./a2a/agent_card.js");
 var import_agent_executor = require("./a2a/agent_executor.js");
 var import_agent_to_a2a = require("./a2a/agent_to_a2a.js");
+var import_auth = require("./a2a/auth.js");
 var import_invocation_context = require("./agents/invocation_context.js");
 var import_file_artifact_service = require("./artifacts/file_artifact_service.js");
 var import_gcs_artifact_service = require("./artifacts/gcs_artifact_service.js");
@@ -94,6 +96,7 @@ __reExport(index_exports, require("./tools/mcp/mcp_toolset.js"), module.exports)
   RunSkillScriptTool,
   UnsafeLocalCodeExecutor,
   VertexAiSessionService,
+  bearerTokenUserBuilder,
   getA2AAgentCard,
   getArtifactServiceFromUri,
   getSessionServiceFromUri,

package/dist/cjs/memory/in_memory_memory_service.js

@@ -35,12 +35,23 @@ module.exports = __toCommonJS(in_memory_memory_service_exports);
 class InMemoryMemoryService {
   constructor() {
     this.memories = [];
-    this.sessionEvents = {};
+    /**
+     * A map from user key to a map from session ID to events.
+     *
+     * The inner map is keyed by `session.id`, which arrives off the request path
+     * and contains no `/`, so it can be exactly `__proto__`. On a plain object
+     * literal that key would reach the inherited `__proto__` setter and
+     * re-parent the map instead of creating an own property, silently dropping
+     * the session from the `Object.values` scan in `searchMemory`. The outer key
+     * always contains a `/` (see `getUserKey`) and cannot collide, but is
+     * created the same way for consistency.
+     */
+    this.sessionEvents = /* @__PURE__ */ Object.create(null);
   }
   async addSessionToMemory(session) {
     const userKey = getUserKey(session.appName, session.userId);
     if (!this.sessionEvents[userKey]) {
-      this.sessionEvents[userKey] = {};
+      this.sessionEvents[userKey] = /* @__PURE__ */ Object.create(null);
     }
     this.sessionEvents[userKey][session.id] = session.events.filter(
       (event) => {

package/dist/cjs/memory/vertex_ai_memory_bank_service.js

@@ -116,6 +116,9 @@ class VertexAiMemoryBankService {
     if (options.client) {
       this.memories = options.client.agentEnginesInternal.memories;
     } else {
+      if (this.expressModeApiKey && (!this.projectId || !this.location)) {
+        throw new Error(import_vertex_ai_utils.EXPRESS_MODE_UNSUPPORTED_MESSAGE);
+      }
       const client = new import_vertexai.Client({
         project: this.projectId,
         location: this.location

package/dist/cjs/plugins/base_plugin.js

@@ -99,8 +99,10 @@ class BasePlugin {
    * @param params.invocationContext The context for the entire invocation.
    * @param params.event The event raised by the runner.
    * @returns An optional value. A non-`undefined` return may be used by the
-   *     framework to modify or replace the response. Returning `undefined`
-   *     allows the original response to be used.
+   *     framework to modify or replace the response. Copy `params.event` when
+   *     constructing a replacement to preserve fields that are not being
+   *     modified, such as event actions. Returning `undefined` allows the
+   *     original response to be used.
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async onEventCallback(params) {

package/dist/cjs/runner/runner.js

@@ -142,7 +142,7 @@ class Runner {
         ctx,
         this,
         async function* () {
-          var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+          var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
           const session = await this.sessionService.getSession({
             appName: this.appName,
             userId,
@@ -259,24 +259,31 @@ class Runner {
                 if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
                   return;
                 }
-                if (!event.partial) {
-                  await this.sessionService.appendEvent({ session, event });
-                }
                 const modifiedEvent = await this.pluginManager.runOnEventCallback({
                   invocationContext,
                   event
                 });
-                if ((_i = params.abortSignal) == null ? void 0 : _i.aborted) {
-                  return;
+                const outputEvent = modifiedEvent ? {
+                  ...modifiedEvent,
+                  id: event.id,
+                  invocationId: event.invocationId,
+                  timestamp: event.timestamp,
+                  author: modifiedEvent.author || event.author,
+                  branch: (_i = modifiedEvent.branch) != null ? _i : event.branch
+                } : event;
+                if (!event.partial) {
+                  await this.sessionService.appendEvent({
+                    session,
+                    event: outputEvent
+                  });
                 }
-                if (modifiedEvent) {
-                  yield modifiedEvent;
-                } else {
-                  yield event;
+                if ((_j = params.abortSignal) == null ? void 0 : _j.aborted) {
+                  return;
                 }
+                yield outputEvent;
               }
               await this.pluginManager.runAfterRunCallback({ invocationContext });
-              if ((_j = params.abortSignal) == null ? void 0 : _j.aborted) {
+              if ((_k = params.abortSignal) == null ? void 0 : _k.aborted) {
                 return;
               }
             }

package/dist/cjs/sessions/base_session_service.js

@@ -91,7 +91,12 @@ class BaseSessionService {
       if (key.startsWith(import_state.State.TEMP_PREFIX)) {
         continue;
       }
-      session.state[key] = value;
+      Object.defineProperty(session.state, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
     }
   }
 }
@@ -100,7 +105,7 @@ function trimTempDeltaState(event) {
     return event;
   }
   const stateDelta = event.actions.stateDelta;
-  const filteredStateDelta = {};
+  const filteredStateDelta = /* @__PURE__ */ Object.create(null);
   for (const [key, value] of Object.entries(stateDelta)) {
     if (!key.startsWith(import_state.State.TEMP_PREFIX)) {
       filteredStateDelta[key] = value;
@@ -110,7 +115,7 @@ function trimTempDeltaState(event) {
   return event;
 }
 function trimTempState(state) {
-  const filteredState = {};
+  const filteredState = /* @__PURE__ */ Object.create(null);
   for (const [key, value] of Object.entries(state)) {
     if (!key.startsWith(import_state.State.TEMP_PREFIX)) {
       filteredState[key] = value;

package/dist/cjs/sessions/in_memory_session_service.js

@@ -49,15 +49,15 @@ class InMemorySessionService extends import_base_session_service.BaseSessionServ
      * A map from app name to a map from user ID to a map from session ID to
      * session.
      */
-    this.sessions = {};
+    this.sessions = /* @__PURE__ */ Object.create(null);
     /**
      * A map from app name to a map from user ID to a map from key to the value.
      */
-    this.userState = {};
+    this.userState = /* @__PURE__ */ Object.create(null);
     /**
      * A map from app name to a map from key to the value.
      */
-    this.appState = {};
+    this.appState = /* @__PURE__ */ Object.create(null);
   }
   async createSession({
     appName,
@@ -76,10 +76,10 @@ class InMemorySessionService extends import_base_session_service.BaseSessionServ
       lastUpdateTime: Date.now()
     });
     if (!this.sessions[appName]) {
-      this.sessions[appName] = {};
+      this.sessions[appName] = /* @__PURE__ */ Object.create(null);
     }
     if (!this.sessions[appName][userId]) {
-      this.sessions[appName][userId] = {};
+      this.sessions[appName][userId] = /* @__PURE__ */ Object.create(null);
     }
     this.sessions[appName][userId][session.id] = session;
     const copiedSession = (0, import_lodash_es.cloneDeep)(session);
@@ -244,12 +244,12 @@ class InMemorySessionService extends import_base_session_service.BaseSessionServ
     if (event.actions && event.actions.stateDelta) {
       for (const key of Object.keys(event.actions.stateDelta)) {
         if (key.startsWith(import_state.State.APP_PREFIX)) {
-          this.appState[appName] = this.appState[appName] || {};
+          this.appState[appName] = this.appState[appName] || /* @__PURE__ */ Object.create(null);
           this.appState[appName][key.replace(import_state.State.APP_PREFIX, "")] = event.actions.stateDelta[key];
         }
         if (key.startsWith(import_state.State.USER_PREFIX)) {
-          this.userState[appName] = this.userState[appName] || {};
-          this.userState[appName][userId] = this.userState[appName][userId] || {};
+          this.userState[appName] = this.userState[appName] || /* @__PURE__ */ Object.create(null);
+          this.userState[appName][userId] = this.userState[appName][userId] || /* @__PURE__ */ Object.create(null);
           this.userState[appName][userId][key.replace(import_state.State.USER_PREFIX, "")] = event.actions.stateDelta[key];
         }
       }

package/dist/cjs/sessions/vertex_ai_session_service.js

@@ -71,16 +71,14 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
       this.location,
       options.expressModeApiKey
     );
-    if (!options.sessions) {
-      if (!this.expressModeApiKey && (!this.projectId || !this.location)) {
-        throw new Error(
-          "Either (Project ID and Location) or an expressModeApiKey is required."
-        );
-      }
-    }
     if (options.sessions) {
       this.sessions = options.sessions;
     } else {
+      if (!this.projectId || !this.location) {
+        throw new Error(
+          this.expressModeApiKey ? import_vertex_ai_utils.EXPRESS_MODE_UNSUPPORTED_MESSAGE : "Project ID and Location are required."
+        );
+      }
       const client = new import_client.Client({
         project: this.projectId,
         location: this.location
@@ -104,13 +102,25 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
     }
     return match[3];
   }
+  /**
+   * Creates a session on Vertex AI Agent Engine.
+   *
+   * @throws if both `ttl` and `expireTime` are specified.
+   */
   async createSession({
     appName,
     userId,
     state,
-    sessionId
+    sessionId,
+    ttl,
+    expireTime
   }) {
     var _a;
+    if (ttl != null && expireTime != null) {
+      throw new Error(
+        "Cannot specify both 'ttl' and 'expireTime' simultaneously."
+      );
+    }
     const reasoningEngineId = this.getReasoningEngineId(appName);
     const filteredState = state ? (0, import_base_session_service.trimTempState)(state) : void 0;
     let apiResponse = await this.sessions.createInternal({
@@ -118,7 +128,9 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
       userId,
       config: {
         ...filteredState ? { sessionState: filteredState } : {},
-        ...sessionId ? { sessionId } : {}
+        ...sessionId ? { sessionId } : {},
+        ...ttl != null ? { ttl } : {},
+        ...expireTime != null ? { expireTime } : {}
       }
     });
     const operationName = apiResponse.name;
@@ -204,7 +216,7 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
       return session;
     } catch (error) {
       const err = error;
-      if (err.code === GRPC_NOT_FOUND || err.code === HTTP_NOT_FOUND) {
+      if (err.code === GRPC_NOT_FOUND || err.code === HTTP_NOT_FOUND || err.status === HTTP_NOT_FOUND) {
         return void 0;
       }
       import_logger.logger.error(`Error getting session from Vertex AI: ${err.message}`);

package/dist/cjs/skills/loader.js

@@ -57,6 +57,9 @@ const ALLOWED_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
   "description",
   "license",
   "allowed-tools",
+  // Camel-case alias: FrontmatterSchema's preprocessor derives `allowedTools`
+  // from `allowed-tools`, and `.loose()` passes either spelling through.
+  "allowedTools",
   "metadata",
   "compatibility"
 ]);
@@ -119,7 +122,7 @@ async function loadDir(directoryPath) {
   }
   return files;
 }
-function parseSkillMdContent(content) {
+function parseFrontmatterYaml(content) {
   if (!content.startsWith("---")) {
     throw new Error("SKILL.md must start with YAML frontmatter (---)");
   }
@@ -131,15 +134,34 @@ function parseSkillMdContent(content) {
   const body = parts.filter((_, i) => i >= 2).join("---").trim();
   try {
     const parsed = import_js_yaml.default.load(frontmatterStr);
-    if (typeof parsed !== "object" || parsed === null) {
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       throw new Error("SKILL.md frontmatter must be a YAML mapping");
     }
-    const frontmatter = import_skill.FrontmatterSchema.parse(parsed);
-    return { frontmatter, body };
+    return { raw: parsed, body };
   } catch (e) {
     throw new Error(`Invalid YAML in frontmatter: ${e.message}`);
   }
 }
+function validateFrontmatter(raw) {
+  try {
+    return import_skill.FrontmatterSchema.parse(raw);
+  } catch (e) {
+    throw new Error(`Invalid YAML in frontmatter: ${e.message}`);
+  }
+}
+function parseSkillMdContent(content) {
+  const { raw, body } = parseFrontmatterYaml(content);
+  return { frontmatter: validateFrontmatter(raw), body };
+}
+function isDangerousZipEntryName(entryName) {
+  if (path.posix.isAbsolute(entryName) || path.win32.isAbsolute(entryName)) {
+    return true;
+  }
+  return entryName.split(/[/\\]/).some((segment) => segment === "..");
+}
+function isBareSkillName(name) {
+  return name !== "." && name !== ".." && path.basename(name) === name;
+}
 async function loadSkillFromDir(skillDir) {
   const resolvedDir = path.resolve(skillDir);
   const skill = await loadSkillFile(skillDir);
@@ -279,6 +301,11 @@ async function loadAllSkillsInDir(skillsBasePath) {
 function loadSkillFromZipBuffer(zipBuffer) {
   const zip = new import_adm_zip.default(zipBuffer);
   const entries = zip.getEntries();
+  for (const entry of entries) {
+    if (isDangerousZipEntryName(entry.entryName)) {
+      throw new Error(`Dangerous zip entry ignored: ${entry.entryName}`);
+    }
+  }
   let skillMdContent = "";
   for (const entry of entries) {
     if (entry.isDirectory) continue;
@@ -290,8 +317,15 @@ function loadSkillFromZipBuffer(zipBuffer) {
   if (!skillMdContent) {
     throw new Error("SKILL.md not found in zipped filesystem.");
   }
-  const { frontmatter: parsed, body } = parseSkillMdContent(skillMdContent);
-  const frontmatter = import_skill.FrontmatterSchema.parse(parsed);
+  const { raw, body } = parseFrontmatterYaml(skillMdContent);
+  const skillName = raw["name"];
+  if (!skillName) {
+    throw new Error("SKILL.md frontmatter must contain 'name'");
+  }
+  if (typeof skillName !== "string" || !isBareSkillName(skillName)) {
+    throw new Error(`Invalid skill name in SKILL.md: ${String(skillName)}`);
+  }
+  const frontmatter = validateFrontmatter(raw);
   const references = {};
   const assets = {};
   const scripts = {};

package/dist/cjs/tools/get_user_choice_tool.js

@@ -0,0 +1,53 @@
+/**
+  * @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 __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 get_user_choice_tool_exports = {};
+__export(get_user_choice_tool_exports, {
+  getUserChoiceTool: () => getUserChoiceTool
+});
+module.exports = __toCommonJS(get_user_choice_tool_exports);
+var import_zod = require("zod");
+var import_long_running_tool = require("./long_running_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const getUserChoiceTool = new import_long_running_tool.LongRunningFunctionTool({
+  name: "get_user_choice",
+  description: "Presents a list of options to the user and awaits their selection.",
+  parameters: import_zod.z.object({
+    options: import_zod.z.array(import_zod.z.string()).describe("List of options to present to the user.")
+  }),
+  execute: async (input, context) => {
+    if (context) {
+      context.actions.skipSummarization = true;
+    }
+    return null;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getUserChoiceTool
+});

package/dist/cjs/tools/mcp/mcp_session_manager.js

@@ -30,11 +30,16 @@ module.exports = __toCommonJS(mcp_session_manager_exports);
 var import_client = require("@modelcontextprotocol/sdk/client/index.js");
 var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
 var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var import_error_utils = require("../../utils/error_utils.js");
+var import_logger = require("../../utils/logger.js");
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+function logTransportError(err) {
+  import_logger.logger.error("MCP transport error: " + (0, import_error_utils.formatError)(err));
+}
 class MCPSessionManager {
   constructor(connectionParams) {
     this.activeSessions = /* @__PURE__ */ new Set();
@@ -43,31 +48,40 @@ class MCPSessionManager {
   async createSession() {
     var _a;
     const client = new import_client.Client({ name: "MCPClient", version: "1.0.0" });
-    switch (this.connectionParams.type) {
-      case "StdioConnectionParams":
-        await client.connect(
-          new import_stdio.StdioClientTransport(this.connectionParams.serverParams)
-        );
-        break;
-      case "StreamableHTTPConnectionParams": {
-        const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
-        if (!options.requestInit && this.connectionParams.header !== void 0) {
-          options.requestInit = {
-            headers: this.connectionParams.header
-          };
+    try {
+      switch (this.connectionParams.type) {
+        case "StdioConnectionParams": {
+          const transport = new import_stdio.StdioClientTransport(
+            this.connectionParams.serverParams
+          );
+          transport.onerror = logTransportError;
+          await client.connect(transport);
+          break;
         }
-        await client.connect(
-          new import_streamableHttp.StreamableHTTPClientTransport(
+        case "StreamableHTTPConnectionParams": {
+          const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
+          if (!options.requestInit && this.connectionParams.header !== void 0) {
+            options.requestInit = {
+              headers: this.connectionParams.header
+            };
+          }
+          const transport = new import_streamableHttp.StreamableHTTPClientTransport(
             new URL(this.connectionParams.url),
             options
-          )
-        );
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = this.connectionParams;
-        break;
+          );
+          transport.onerror = logTransportError;
+          await client.connect(transport);
+          break;
+        }
+        default: {
+          const _exhaustiveCheck = this.connectionParams;
+          break;
+        }
       }
+    } catch (err) {
+      throw new Error("Failed to create MCP session: " + (0, import_error_utils.formatError)(err), {
+        cause: err
+      });
     }
     this.activeSessions.add(client);
     return client;

package/dist/cjs/tools/request_input_tool.js

@@ -0,0 +1,54 @@
+/**
+  * @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 __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 request_input_tool_exports = {};
+__export(request_input_tool_exports, {
+  requestInputTool: () => requestInputTool
+});
+module.exports = __toCommonJS(request_input_tool_exports);
+var import_zod = require("zod");
+var import_long_running_tool = require("./long_running_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const requestInputTool = new import_long_running_tool.LongRunningFunctionTool({
+  name: "adk_request_input",
+  description: "Presents a custom message to the user and awaits unstructured or structured input.",
+  parameters: import_zod.z.object({
+    message: import_zod.z.string().describe("The prompt for the user."),
+    responseSchema: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Expected schema of the response.")
+  }),
+  execute: async (input, context) => {
+    if (context) {
+      context.actions.skipSummarization = true;
+    }
+    return null;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  requestInputTool
+});

package/dist/cjs/utils/crypto_shim.js

@@ -0,0 +1,43 @@
+/**
+  * @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 __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 crypto_shim_exports = {};
+__export(crypto_shim_exports, {
+  randomUUID: () => randomUUID
+});
+module.exports = __toCommonJS(crypto_shim_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function randomUUID() {
+  throw new Error(
+    "randomUUID: no cryptographically secure source of randomness is available. Neither crypto.randomUUID() nor crypto.getRandomValues() is present in this environment."
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomUUID
+});