@google/adk 1.4.0 → 1.6.0

package/dist/web/memory/in_memory_memory_service.js

@@ -8,12 +8,23 @@ const require = topLevelCreateRequire(import.meta.url);
 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/web/memory/vertex_ai_memory_bank_service.js

@@ -24,7 +24,10 @@ var __spreadValues = (a, b) => {
 import { Client } from "@google-cloud/vertexai";
 import { createUserContent } from "@google/genai";
 import { logger } from "../utils/logger.js";
-import { getExpressModeApiKey } from "../utils/vertex_ai_utils.js";
+import {
+  EXPRESS_MODE_UNSUPPORTED_MESSAGE,
+  getExpressModeApiKey
+} from "../utils/vertex_ai_utils.js";
 const GENERATE_MEMORIES_KNOWN_FIELDS = [
   "disableConsolidation",
   "waitForCompletion",
@@ -105,6 +108,9 @@ class VertexAiMemoryBankService {
     if (options.client) {
       this.memories = options.client.agentEnginesInternal.memories;
     } else {
+      if (this.expressModeApiKey && (!this.projectId || !this.location)) {
+        throw new Error(EXPRESS_MODE_UNSUPPORTED_MESSAGE);
+      }
       const client = new Client({
         project: this.projectId,
         location: this.location

package/dist/web/plugins/base_plugin.js

@@ -73,8 +73,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/web/plugins/global_instruction_plugin.js

@@ -0,0 +1,67 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { injectSessionState } from "../agents/instructions.js";
+import { ReadonlyContext } from "../agents/readonly_context.js";
+import { BasePlugin } from "./base_plugin.js";
+class GlobalInstructionPlugin extends BasePlugin {
+  /**
+   * Initializes the GlobalInstructionPlugin.
+   *
+   * @param globalInstruction The instruction to apply globally. Can be a string
+   *     or an InstructionProvider function that takes ReadonlyContext and
+   *     returns a string (sync or async).
+   * @param name The name of the plugin (defaults to 'global_instruction').
+   */
+  constructor(globalInstruction, name = "global_instruction") {
+    super(name);
+    this.globalInstruction = globalInstruction;
+  }
+  async beforeModelCallback(params) {
+    if (!this.globalInstruction) {
+      return;
+    }
+    const readonlyContext = new ReadonlyContext(
+      params.callbackContext.invocationContext
+    );
+    const finalGlobalInstruction = await this.resolveGlobalInstruction(readonlyContext);
+    if (!finalGlobalInstruction) {
+      return;
+    }
+    if (!params.llmRequest.config) {
+      params.llmRequest.config = {};
+    }
+    const existingInstruction = params.llmRequest.config.systemInstruction;
+    if (!existingInstruction || Array.isArray(existingInstruction) && existingInstruction.length === 0) {
+      params.llmRequest.config.systemInstruction = finalGlobalInstruction;
+      return;
+    }
+    if (typeof existingInstruction === "string") {
+      params.llmRequest.config.systemInstruction = "".concat(finalGlobalInstruction, "\n\n").concat(existingInstruction);
+    } else if (Array.isArray(existingInstruction)) {
+      params.llmRequest.config.systemInstruction = [
+        finalGlobalInstruction,
+        ...existingInstruction
+      ];
+    } else {
+      params.llmRequest.config.systemInstruction = [
+        finalGlobalInstruction,
+        existingInstruction
+      ];
+    }
+    return;
+  }
+  async resolveGlobalInstruction(readonlyContext) {
+    if (typeof this.globalInstruction === "string") {
+      return await injectSessionState(this.globalInstruction, readonlyContext);
+    }
+    return await this.globalInstruction(readonlyContext);
+  }
+}
+export {
+  GlobalInstructionPlugin
+};

package/dist/web/runner/runner.js

@@ -191,7 +191,7 @@ class Runner {
           this,
           function() {
             return __asyncGenerator(this, null, 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 = yield new __await(this.sessionService.getSession({
                 appName: this.appName,
                 userId,
@@ -252,7 +252,7 @@ class Runner {
                   throw new Error("No parts in the newMessage.");
                 }
                 if (runConfig.saveInputBlobsAsArtifacts) {
-                  yield new __await(this.saveArtifacts(
+                  newMessage = yield new __await(this.saveArtifacts(
                     invocationContext.invocationId,
                     session.userId,
                     session.id,
@@ -310,21 +310,27 @@ class Runner {
                       if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
                         return;
                       }
-                      if (!event.partial) {
-                        yield new __await(this.sessionService.appendEvent({ session, event }));
-                      }
                       const modifiedEvent = yield new __await(this.pluginManager.runOnEventCallback({
                         invocationContext,
                         event
                       }));
-                      if ((_i = params.abortSignal) == null ? void 0 : _i.aborted) {
-                        return;
+                      const outputEvent = modifiedEvent ? __spreadProps(__spreadValues({}, 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) {
+                        yield new __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;
                     }
                   } catch (temp) {
                     error = [temp];
@@ -337,7 +343,7 @@ class Runner {
                     }
                   }
                   yield new __await(this.pluginManager.runAfterRunCallback({ invocationContext }));
-                  if ((_j = params.abortSignal) == null ? void 0 : _j.aborted) {
+                  if ((_k = params.abortSignal) == null ? void 0 : _k.aborted) {
                     return;
                   }
                 }
@@ -354,7 +360,7 @@ class Runner {
   }
   /**
    * Saves artifacts from the message parts and replaces the inline data with
-   * a file name placeholder.
+   * a file name placeholder and optional file reference.
    *
    * @param invocationId The current invocation ID.
    * @param userId The user ID of the session.
@@ -364,27 +370,64 @@ class Runner {
   async saveArtifacts(invocationId, userId, sessionId, message) {
     var _a2;
     if (!this.artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
-      return;
+      return message;
     }
     const sessionKey = {
       appName: this.appName,
       userId,
       sessionId
     };
+    const newParts = [];
+    let modified = false;
     for (let i = 0; i < message.parts.length; i++) {
       const part = message.parts[i];
       if (!part.inlineData) {
+        newParts.push(part);
         continue;
       }
-      const fileName = "artifact_".concat(invocationId, "_").concat(i);
-      await this.artifactService.saveArtifact(__spreadProps(__spreadValues({}, sessionKey), {
-        filename: fileName,
-        artifact: part
-      }));
-      message.parts[i] = createPartFromText(
-        "Uploaded file: ".concat(fileName, ". It is saved into artifacts")
-      );
+      try {
+        const inlineData = part.inlineData;
+        const fileName = inlineData.displayName || "artifact_".concat(invocationId, "_").concat(i);
+        const version = await this.artifactService.saveArtifact(__spreadProps(__spreadValues({}, sessionKey), {
+          filename: fileName,
+          artifact: part
+        }));
+        newParts.push(createPartFromText('[Uploaded Artifact: "'.concat(fileName, '"]')));
+        try {
+          const artifactVersion = await this.artifactService.getArtifactVersion(
+            __spreadProps(__spreadValues({}, sessionKey), {
+              filename: fileName,
+              version
+            })
+          );
+          if ((artifactVersion == null ? void 0 : artifactVersion.canonicalUri) && /^(gs|https?):/i.test(artifactVersion.canonicalUri)) {
+            newParts.push({
+              fileData: {
+                fileUri: artifactVersion.canonicalUri,
+                mimeType: artifactVersion.mimeType || inlineData.mimeType || "",
+                displayName: fileName
+              }
+            });
+          }
+        } catch (error) {
+          logger.warn(
+            "Failed to resolve artifact version for ".concat(fileName, ":"),
+            error
+          );
+        }
+        modified = true;
+        logger.info("Successfully saved artifact: ".concat(fileName));
+      } catch (error) {
+        logger.error("Failed to save artifact for part ".concat(i, ":"), error);
+        newParts.push(part);
+      }
     }
+    if (!modified) {
+      return message;
+    }
+    return __spreadProps(__spreadValues({}, message), {
+      parts: newParts
+    });
   }
   /**
    * Determines the next agent to run to continue the session. This is primarily

package/dist/web/sessions/base_session_service.js

@@ -61,7 +61,12 @@ class BaseSessionService {
       if (key.startsWith(State.TEMP_PREFIX)) {
         continue;
       }
-      session.state[key] = value;
+      Object.defineProperty(session.state, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
     }
   }
 }
@@ -70,7 +75,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(State.TEMP_PREFIX)) {
       filteredStateDelta[key] = value;
@@ -80,7 +85,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(State.TEMP_PREFIX)) {
       filteredState[key] = value;

package/dist/web/sessions/in_memory_session_service.js

@@ -25,15 +25,15 @@ class InMemorySessionService extends BaseSessionService {
      * 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,
@@ -52,10 +52,10 @@ class InMemorySessionService extends BaseSessionService {
       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 = cloneDeep(session);
@@ -220,12 +220,12 @@ class InMemorySessionService extends BaseSessionService {
     if (event.actions && event.actions.stateDelta) {
       for (const key of Object.keys(event.actions.stateDelta)) {
         if (key.startsWith(State.APP_PREFIX)) {
-          this.appState[appName] = this.appState[appName] || {};
+          this.appState[appName] = this.appState[appName] || /* @__PURE__ */ Object.create(null);
           this.appState[appName][key.replace(State.APP_PREFIX, "")] = event.actions.stateDelta[key];
         }
         if (key.startsWith(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(State.USER_PREFIX, "")] = event.actions.stateDelta[key];
         }
       }

package/dist/web/sessions/vertex_ai_session_service.js

@@ -37,7 +37,10 @@ import { Client } from "@google-cloud/vertexai/build/src/genai/client.js";
 import { isCompactedEvent } from "../events/compacted_event.js";
 import { experimental } from "../utils/experimental.js";
 import { logger } from "../utils/logger.js";
-import { getExpressModeApiKey } from "../utils/vertex_ai_utils.js";
+import {
+  EXPRESS_MODE_UNSUPPORTED_MESSAGE,
+  getExpressModeApiKey
+} from "../utils/vertex_ai_utils.js";
 import { partialCopy } from "../utils/partial_copy.js";
 import {
   BaseSessionService,
@@ -65,16 +68,14 @@ let VertexAiSessionService = class extends BaseSessionService {
       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 ? EXPRESS_MODE_UNSUPPORTED_MESSAGE : "Project ID and Location are required."
+        );
+      }
       const client = new Client({
         project: this.projectId,
         location: this.location
@@ -98,19 +99,31 @@ let VertexAiSessionService = class extends BaseSessionService {
     }
     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 ? trimTempState(state) : void 0;
     let apiResponse = await this.sessions.createInternal({
       name: "reasoningEngines/".concat(reasoningEngineId),
       userId,
-      config: __spreadValues(__spreadValues({}, filteredState ? { sessionState: filteredState } : {}), sessionId ? { sessionId } : {})
+      config: __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, filteredState ? { sessionState: filteredState } : {}), sessionId ? { sessionId } : {}), ttl != null ? { ttl } : {}), expireTime != null ? { expireTime } : {})
     });
     const operationName = apiResponse.name;
     let attempts = 0;
@@ -195,7 +208,7 @@ let VertexAiSessionService = class extends BaseSessionService {
       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;
       }
       logger.error("Error getting session from Vertex AI: ".concat(err.message));

package/dist/web/skills/loader.js

@@ -37,6 +37,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"
 ]);
@@ -99,7 +102,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 (---)");
   }
@@ -111,15 +114,34 @@ function parseSkillMdContent(content) {
   const body = parts.filter((_, i) => i >= 2).join("---").trim();
   try {
     const parsed = yaml.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 = FrontmatterSchema.parse(parsed);
-    return { frontmatter, body };
+    return { raw: parsed, body };
   } catch (e) {
     throw new Error("Invalid YAML in frontmatter: ".concat(e.message));
   }
 }
+function validateFrontmatter(raw) {
+  try {
+    return FrontmatterSchema.parse(raw);
+  } catch (e) {
+    throw new Error("Invalid YAML in frontmatter: ".concat(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);
@@ -258,6 +280,11 @@ async function loadAllSkillsInDir(skillsBasePath) {
 function loadSkillFromZipBuffer(zipBuffer) {
   const zip = new AdmZip(zipBuffer);
   const entries = zip.getEntries();
+  for (const entry of entries) {
+    if (isDangerousZipEntryName(entry.entryName)) {
+      throw new Error("Dangerous zip entry ignored: ".concat(entry.entryName));
+    }
+  }
   let skillMdContent = "";
   for (const entry of entries) {
     if (entry.isDirectory) continue;
@@ -269,8 +296,15 @@ function loadSkillFromZipBuffer(zipBuffer) {
   if (!skillMdContent) {
     throw new Error("SKILL.md not found in zipped filesystem.");
   }
-  const { frontmatter: parsed, body } = parseSkillMdContent(skillMdContent);
-  const frontmatter = 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: ".concat(String(skillName)));
+  }
+  const frontmatter = validateFrontmatter(raw);
   const references = {};
   const assets = {};
   const scripts = {};

package/dist/web/tools/enterprise_web_search_tool.js

@@ -0,0 +1,55 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  isGemini1Model,
+  isGeminiModel,
+  isGeminiModelIdCheckDisabled
+} from "../utils/model_name.js";
+import { BaseTool } from "./base_tool.js";
+function applyEnterpriseWebSearch(llmRequest) {
+  if (!llmRequest.model) {
+    return;
+  }
+  const modelCheckDisabled = isGeminiModelIdCheckDisabled();
+  llmRequest.config = llmRequest.config || {};
+  llmRequest.config.tools = llmRequest.config.tools || [];
+  if (isGeminiModel(llmRequest.model) || modelCheckDisabled) {
+    if (isGemini1Model(llmRequest.model) && llmRequest.config.tools.length > 0) {
+      throw new Error(
+        "Enterprise Web Search tool cannot be used with other tools in Gemini 1.x."
+      );
+    }
+    llmRequest.config.tools.push({ enterpriseWebSearch: {} });
+    return;
+  }
+  throw new Error(
+    "Enterprise Web Search tool is not supported for model ".concat(llmRequest.model)
+  );
+}
+class EnterpriseWebSearchTool extends BaseTool {
+  constructor() {
+    super({
+      name: "enterprise_web_search",
+      description: "Enterprise Web Search Tool"
+    });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    applyEnterpriseWebSearch(llmRequest);
+  }
+}
+const ENTERPRISE_WEB_SEARCH = new EnterpriseWebSearchTool();
+export {
+  ENTERPRISE_WEB_SEARCH,
+  EnterpriseWebSearchTool,
+  applyEnterpriseWebSearch
+};

package/dist/web/tools/example_tool.js

@@ -0,0 +1,42 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { buildExampleSi } from "../examples/example_util.js";
+import { appendInstructions } from "../models/llm_request.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+class ExampleTool extends BaseTool {
+  constructor(examples) {
+    super({
+      // Name and description are not used because this tool only changes
+      // llmRequest.
+      name: "example_tool",
+      description: "example tool"
+    });
+    this.examples = examples;
+  }
+  async runAsync(_request) {
+    throw new Error("ExampleTool should not be called by model");
+  }
+  async processLlmRequest({
+    toolContext,
+    llmRequest
+  }) {
+    var _a, _b;
+    const parts = (_a = toolContext.userContent) == null ? void 0 : _a.parts;
+    if (!parts || !((_b = parts[0]) == null ? void 0 : _b.text)) {
+      return;
+    }
+    appendInstructions(llmRequest, [
+      buildExampleSi(this.examples, parts[0].text, llmRequest.model)
+    ]);
+  }
+}
+export {
+  ExampleTool
+};

package/dist/web/tools/get_user_choice_tool.js

@@ -0,0 +1,25 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from "zod";
+import { LongRunningFunctionTool } from "./long_running_tool.js";
+const getUserChoiceTool = new LongRunningFunctionTool({
+  name: "get_user_choice",
+  description: "Presents a list of options to the user and awaits their selection.",
+  parameters: z.object({
+    options: z.array(z.string()).describe("List of options to present to the user.")
+  }),
+  execute: async (input, context) => {
+    if (context) {
+      context.actions.skipSummarization = true;
+    }
+    return null;
+  }
+});
+export {
+  getUserChoiceTool
+};