@google/adk 1.1.0 → 1.3.0

package/dist/cjs/auth/oauth2/oauth2_discovery.js

@@ -152,6 +152,18 @@ class OAuth2DiscoveryManager {
     return void 0;
   }
 }
+function normaliseHostname(raw) {
+  const stripped = raw.replace(/^\[|\]$/g, "");
+  const m = stripped.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
+  if (m) {
+    const hi = parseInt(m[1], 16);
+    const lo = parseInt(m[2], 16);
+    return [hi >> 8 & 255, hi & 255, lo >> 8 & 255, lo & 255].join(".");
+  }
+  const mDot = stripped.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
+  if (mDot) return mDot[1];
+  return raw;
+}
 function validateDiscoveryUrl(urlStr) {
   try {
     const url = new URL(urlStr);
@@ -159,8 +171,8 @@ function validateDiscoveryUrl(urlStr) {
       import_logger.logger.warn(`Unsafe protocol for discovery URL: ${url.protocol}`);
       return false;
     }
-    const host = url.hostname.toLowerCase();
-    if (host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host.startsWith("10.") || host.startsWith("192.168.") || host.startsWith("169.254.")) {
+    const host = normaliseHostname(url.hostname.toLowerCase());
+    if (host === "localhost" || host === "metadata.google.internal" || host === "metadata.goog" || host.startsWith("127.") || host === "[::1]" || host === "0.0.0.0" || host.startsWith("10.") || host.startsWith("192.168.") || host.startsWith("169.254.")) {
       import_logger.logger.warn(`Unsafe host for discovery URL: ${host}`);
       return false;
     }
@@ -172,6 +184,18 @@ function validateDiscoveryUrl(urlStr) {
         return false;
       }
     }
+    const cgnatMatch = host.match(/^100\.(\d+)\./);
+    if (cgnatMatch) {
+      const secondOctet = parseInt(cgnatMatch[1], 10);
+      if (secondOctet >= 64 && secondOctet <= 127) {
+        import_logger.logger.warn(`Unsafe host for discovery URL: ${host}`);
+        return false;
+      }
+    }
+    if (/^\[(f[cd][0-9a-f]{2}|fe[89ab][0-9a-f]):/i.test(url.hostname)) {
+      import_logger.logger.warn(`Unsafe host for discovery URL: ${url.hostname}`);
+      return false;
+    }
     return true;
   } catch (e) {
     import_logger.logger.warn(`Failed to parse URL for validation ${urlStr}: ${e}`);

package/dist/cjs/code_executors/agent_engine_sandbox_code_executor.js

@@ -0,0 +1,305 @@
+/**
+  * @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 __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 agent_engine_sandbox_code_executor_exports = {};
+__export(agent_engine_sandbox_code_executor_exports, {
+  AgentEngineSandboxCodeExecutor: () => AgentEngineSandboxCodeExecutor
+});
+module.exports = __toCommonJS(agent_engine_sandbox_code_executor_exports);
+var import_vertexai = require("@google-cloud/vertexai");
+var import_types = require("@google-cloud/vertexai/build/src/genai/types.js");
+var import_experimental = require("../utils/experimental.js");
+var import_file_utils = require("../utils/file_utils.js");
+var import_logger = require("../utils/logger.js");
+var import_base_code_executor = require("./base_code_executor.js");
+var import_code_execution_utils = require("./code_execution_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const SANDBOX_PATTERN = /^projects\/([a-zA-Z0-9-_]+)\/locations\/([a-zA-Z0-9-_]+)\/reasoningEngines\/(\d+)\/sandboxEnvironments\/(\d+)$/;
+const ENGINE_PATTERN = /^projects\/([a-zA-Z0-9-_]+)\/locations\/([a-zA-Z0-9-_]+)\/reasoningEngines\/(\d+)$/;
+const DEFAULT_MAX_ATTEMPTS = 180;
+const DEFAULT_SANDBOX_TTL = "31536000s";
+const DEFAULT_SANDBOX_DISPLAY_NAME = "default_sandbox";
+const DEFAULT_ENGINE_DISPLAY_NAME = "default_engine";
+function mapLanguage(lang) {
+  switch (lang) {
+    case import_code_execution_utils.CodeExecutionLanguage.PYTHON:
+      return import_types.Language.LANGUAGE_PYTHON;
+    case import_code_execution_utils.CodeExecutionLanguage.JAVASCRIPT:
+      return import_types.Language.LANGUAGE_JAVASCRIPT;
+    default:
+      throw new Error(`Unsupported language for Agent Engine Sandbox: ${lang}`);
+  }
+}
+let AgentEngineSandboxCodeExecutor = class extends import_base_code_executor.BaseCodeExecutor {
+  constructor(options = {}) {
+    super();
+    this.sandboxResourceName = options.sandboxResourceName;
+    this.agentEngineResourceName = options.agentEngineResourceName;
+    this.projectId = options.projectId || process.env.GOOGLE_CLOUD_PROJECT;
+    this.location = options.location || process.env.GOOGLE_CLOUD_LOCATION || "us-central1";
+    if (this.sandboxResourceName) {
+      const match = this.sandboxResourceName.match(SANDBOX_PATTERN);
+      if (match) {
+        this.projectId = match[1];
+        this.location = match[2];
+      } else {
+        throw new Error(
+          `Invalid sandbox resource name: ${this.sandboxResourceName}`
+        );
+      }
+    } else if (this.agentEngineResourceName) {
+      const match = this.agentEngineResourceName.match(ENGINE_PATTERN);
+      if (match) {
+        this.projectId = match[1];
+        this.location = match[2];
+      } else {
+        throw new Error(
+          `Invalid agent engine resource name: ${this.agentEngineResourceName}`
+        );
+      }
+    }
+    if (options.client) {
+      this.client = options.client;
+    } else {
+      if (!this.projectId) {
+        throw new Error("Project ID is required.");
+      }
+      this.client = new import_vertexai.Client({
+        project: this.projectId,
+        location: this.location
+      });
+    }
+  }
+  async executeCode(params) {
+    var _a;
+    const { invocationContext, codeExecutionInput } = params;
+    const language = mapLanguage(codeExecutionInput.language);
+    const agentEngineName = await this.getOrCreateAgentEngine();
+    const sandboxName = await this.getOrCreateSandbox(
+      invocationContext,
+      agentEngineName,
+      language
+    );
+    const inputs = [
+      {
+        mimeType: "application/json",
+        data: Buffer.from(
+          JSON.stringify({ code: codeExecutionInput.code })
+        ).toString("base64")
+      }
+    ];
+    if (codeExecutionInput.inputFiles) {
+      for (const file of codeExecutionInput.inputFiles) {
+        inputs.push({
+          mimeType: file.mimeType,
+          data: file.content,
+          // Assumed to be already base64 encoded based on CodeExecutionInput definition
+          metadata: {
+            attributes: {
+              file_name: Buffer.from(file.name).toString("base64")
+            }
+          }
+        });
+      }
+    }
+    import_logger.logger.debug(`Executing code in sandbox ${sandboxName}...`);
+    const response = await this.client.agentEnginesInternal.sandboxes.executeCodeInternal({
+      name: sandboxName,
+      inputs
+    });
+    let stdout = "";
+    let stderr = "";
+    const outputFiles = [];
+    if (response.outputs) {
+      for (const output of response.outputs) {
+        const attributes = ((_a = output.metadata) == null ? void 0 : _a.attributes) || {};
+        const encodedFileName = attributes["file_name"];
+        const fileName = encodedFileName ? Buffer.from(encodedFileName, "base64").toString("utf-8") : void 0;
+        if (output.mimeType === "application/json" && !fileName) {
+          if (output.data) {
+            const jsonStr = Buffer.from(output.data, "base64").toString(
+              "utf-8"
+            );
+            try {
+              const jsonData = JSON.parse(jsonStr);
+              if (jsonData.msg_out !== void 0) {
+                stdout = jsonData.msg_out;
+              } else {
+                stdout = "";
+              }
+              if (jsonData.msg_err !== void 0) {
+                stderr = jsonData.msg_err;
+              } else {
+                stderr = "";
+              }
+            } catch (e) {
+              import_logger.logger.warn("Failed to parse JSON output from sandbox", e);
+              stdout = jsonStr;
+            }
+          }
+        } else {
+          let mimeType = output.mimeType;
+          const name = fileName || "output_file";
+          if (!mimeType) {
+            mimeType = (0, import_file_utils.guessMimeType)(name);
+          }
+          outputFiles.push({
+            name,
+            content: output.data || "",
+            mimeType
+          });
+        }
+      }
+    }
+    return {
+      stdout,
+      stderr,
+      outputFiles
+    };
+  }
+  async getOrCreateAgentEngine() {
+    if (this.agentEngineResourceName) {
+      return this.agentEngineResourceName;
+    }
+    if (!this.agentEngineCreationPromise) {
+      this.agentEngineCreationPromise = (async () => {
+        import_logger.logger.debug(
+          "No Agent Engine resource name provided. Creating a new one..."
+        );
+        const operation = await this.client.agentEnginesInternal.createInternal(
+          {
+            config: {
+              displayName: DEFAULT_ENGINE_DISPLAY_NAME
+            }
+          }
+        );
+        let apiResponse = operation;
+        let attempts = 0;
+        while (!apiResponse.done && attempts < DEFAULT_MAX_ATTEMPTS) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+          apiResponse = await this.client.agentEnginesInternal.getAgentOperationInternal({
+            operationName: operation.name
+          });
+          attempts++;
+        }
+        if (!apiResponse.done) {
+          throw new Error(
+            `Agent Engine creation operation ${operation.name} did not complete in time.`
+          );
+        }
+        const response = apiResponse.response;
+        this.agentEngineResourceName = response.name;
+        import_logger.logger.debug(`Created Agent Engine: ${this.agentEngineResourceName}`);
+        return this.agentEngineResourceName;
+      })();
+    }
+    return this.agentEngineCreationPromise;
+  }
+  async getOrCreateSandbox(invocationContext, agentEngineName, language) {
+    var _a, _b;
+    if (this.sandboxResourceName) {
+      return this.sandboxResourceName;
+    }
+    const stateKey = `sandbox_name_${language.toLowerCase()}`;
+    let sandboxName = (_b = (_a = invocationContext.session) == null ? void 0 : _a.state) == null ? void 0 : _b[stateKey];
+    let createNewSandbox = false;
+    if (!sandboxName) {
+      createNewSandbox = true;
+    } else {
+      try {
+        const sandbox = await this.client.agentEnginesInternal.sandboxes.getInternal({
+          name: sandboxName
+        });
+        if (!sandbox || sandbox.state !== "STATE_RUNNING") {
+          createNewSandbox = true;
+        }
+      } catch (error) {
+        import_logger.logger.debug(
+          `Failed to get sandbox ${sandboxName}, will create a new one`,
+          error
+        );
+        createNewSandbox = true;
+      }
+    }
+    if (createNewSandbox) {
+      import_logger.logger.debug(`Creating a new ${language} code execution sandbox...`);
+      const operation = await this.client.agentEnginesInternal.sandboxes.createInternal({
+        name: agentEngineName,
+        spec: {
+          codeExecutionEnvironment: {
+            codeLanguage: language
+          }
+        },
+        config: {
+          displayName: DEFAULT_SANDBOX_DISPLAY_NAME,
+          ttl: DEFAULT_SANDBOX_TTL
+        }
+      });
+      let apiResponse = operation;
+      let attempts = 0;
+      while (!apiResponse.done && attempts < DEFAULT_MAX_ATTEMPTS) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        apiResponse = await this.client.agentEnginesInternal.sandboxes.getSandboxOperationInternal(
+          {
+            operationName: operation.name
+          }
+        );
+        attempts++;
+      }
+      if (!apiResponse.done) {
+        throw new Error(
+          `Sandbox creation operation ${operation.name} did not complete in time.`
+        );
+      }
+      const response = apiResponse.response;
+      sandboxName = response.name;
+      if (invocationContext.session) {
+        if (!invocationContext.session.state) {
+          invocationContext.session.state = {};
+        }
+        invocationContext.session.state[stateKey] = sandboxName;
+      }
+    }
+    return sandboxName;
+  }
+};
+AgentEngineSandboxCodeExecutor = __decorateClass([
+  import_experimental.experimental
+], AgentEngineSandboxCodeExecutor);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentEngineSandboxCodeExecutor
+});

package/dist/cjs/code_executors/code_execution_utils.js

@@ -80,7 +80,7 @@ function extractCodeAndTruncateContent(content, codeBlockDelimiters) {
   const leadingDelimiterPattern = codeBlockDelimiters.map((d) => d[0]).join("|");
   const trailingDelimiterPattern = codeBlockDelimiters.map((d) => d[1]).join("|");
   const match = new RegExp(
-    `?<prefix>.*?)(${leadingDelimiterPattern})(?<codeStr>.*?)(${trailingDelimiterPattern})(?<suffix>.*?)$`,
+    `(?<prefix>.*?)(${leadingDelimiterPattern})(?<codeStr>.*?)(${trailingDelimiterPattern})(?<suffix>.*?)$`,
     "s"
   ).exec(responseText);
   const { prefix, codeStr } = (match == null ? void 0 : match.groups) || {};

package/dist/cjs/code_executors/code_executor_context.js

@@ -97,7 +97,7 @@ class CodeExecutorContext {
    * @return A list of input files in the code executor context.
    */
   getInputFiles() {
-    if (!(INPUT_FILE_KEY in this.sessionState)) {
+    if (!this.sessionState.has(INPUT_FILE_KEY)) {
       return [];
     }
     return this.sessionState.get(INPUT_FILE_KEY);
@@ -107,13 +107,13 @@ class CodeExecutorContext {
    * @param inputFiles The input files to add to the session state.
    */
   addInputFiles(inputFiles) {
-    if (!(INPUT_FILE_KEY in this.sessionState)) {
+    if (!this.sessionState.has(INPUT_FILE_KEY)) {
       this.sessionState.set(INPUT_FILE_KEY, []);
     }
     this.sessionState.get(INPUT_FILE_KEY).push(...inputFiles);
   }
   clearInputFiles() {
-    if (INPUT_FILE_KEY in this.sessionState) {
+    if (this.sessionState.has(INPUT_FILE_KEY)) {
       this.sessionState.set(INPUT_FILE_KEY, []);
     }
     if (PROCESSED_FILE_NAMES_KEY in this.context) {
@@ -126,7 +126,7 @@ class CodeExecutorContext {
    * @return The error count for the given invocation ID.
    */
   getErrorCount(invocationId) {
-    if (!(ERROR_COUNT_KEY in this.sessionState)) {
+    if (!this.sessionState.has(ERROR_COUNT_KEY)) {
       return 0;
     }
     return this.sessionState.get(ERROR_COUNT_KEY)[invocationId] || 0;
@@ -136,7 +136,7 @@ class CodeExecutorContext {
    * @param invocationId The invocation ID to increment the error count for.
    */
   incrementErrorCount(invocationId) {
-    if (!(ERROR_COUNT_KEY in this.sessionState)) {
+    if (!this.sessionState.has(ERROR_COUNT_KEY)) {
       this.sessionState.set(ERROR_COUNT_KEY, {});
     }
     this.sessionState.get(ERROR_COUNT_KEY)[invocationId] = this.getErrorCount(invocationId) + 1;
@@ -146,7 +146,7 @@ class CodeExecutorContext {
    * @param invocationId The invocation ID to reset the error count for.
    */
   resetErrorCount(invocationId) {
-    if (!(ERROR_COUNT_KEY in this.sessionState)) {
+    if (!this.sessionState.has(ERROR_COUNT_KEY)) {
       return;
     }
     const errorCounts = this.sessionState.get(ERROR_COUNT_KEY);
@@ -168,7 +168,7 @@ class CodeExecutorContext {
     resultStdout,
     resultStderr
   }) {
-    if (!(CODE_EXECUTION_RESULTS_KEY in this.sessionState)) {
+    if (!this.sessionState.has(CODE_EXECUTION_RESULTS_KEY)) {
       this.sessionState.set(CODE_EXECUTION_RESULTS_KEY, {});
     }
     const codeExecutionResults = this.sessionState.get(

package/dist/cjs/common.js

@@ -25,6 +25,7 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var common_exports = {};
 __export(common_exports, {
+  AUTH_PREPROCESSOR: () => import_auth_preprocessor.AUTH_PREPROCESSOR,
   ActiveStreamingTool: () => import_active_streaming_tool.ActiveStreamingTool,
   Agent: () => import_llm_agent.LlmAgent,
   AgentTool: () => import_agent_tool.AgentTool,
@@ -32,6 +33,7 @@ __export(common_exports, {
   ApigeeLlm: () => import_apigee_llm.ApigeeLlm,
   AuthCredentialTypes: () => import_auth_credential.AuthCredentialTypes,
   AuthHandler: () => import_auth_handler.AuthHandler,
+  AuthPreprocessor: () => import_auth_preprocessor.AuthPreprocessor,
   AuthProviderRegistry: () => import_auth_provider_registry.AuthProviderRegistry,
   BaseAgent: () => import_base_agent.BaseAgent,
   BaseCodeExecutor: () => import_base_code_executor.BaseCodeExecutor,
@@ -57,9 +59,12 @@ __export(common_exports, {
   ExitLoopTool: () => import_exit_loop_tool.ExitLoopTool,
   FileContentEncoding: () => import_code_execution_utils.FileContentEncoding,
   FunctionTool: () => import_function_tool.FunctionTool,
+  GCPSkillRegistry: () => import_gcp_skill_registry.GCPSkillRegistry,
+  GOOGLE_MAPS_GROUNDING: () => import_google_maps_grounding_tool.GOOGLE_MAPS_GROUNDING,
   GOOGLE_SEARCH: () => import_google_search_tool.GOOGLE_SEARCH,
   Gemini: () => import_google_llm.Gemini,
   GoogleLLMVariant: () => import_variant_utils.GoogleLLMVariant,
+  GoogleMapsGroundingTool: () => import_google_maps_grounding_tool.GoogleMapsGroundingTool,
   GoogleSearchTool: () => import_google_search_tool.GoogleSearchTool,
   InMemoryArtifactService: () => import_in_memory_artifact_service.InMemoryArtifactService,
   InMemoryCredentialService: () => import_in_memory_credential_service.InMemoryCredentialService,
@@ -86,6 +91,9 @@ __export(common_exports, {
   OAuth2CredentialExchanger: () => import_oauth2_credential_exchanger.OAuth2CredentialExchanger,
   OAuth2DiscoveryManager: () => import_oauth2_discovery.OAuth2DiscoveryManager,
   OAuthGrantType: () => import_auth_schemes.OAuthGrantType,
+  OpenAPIToolset: () => import_openapi_toolset.OpenAPIToolset,
+  OpenApiSpecParser: () => import_openapi_spec_parser.OpenApiSpecParser,
+  OperationParser: () => import_operation_parser.OperationParser,
   PRELOAD_MEMORY: () => import_preload_memory_tool.PRELOAD_MEMORY,
   ParallelAgent: () => import_parallel_agent.ParallelAgent,
   PluginManager: () => import_plugin_manager.PluginManager,
@@ -93,9 +101,11 @@ __export(common_exports, {
   PreloadMemoryTool: () => import_preload_memory_tool.PreloadMemoryTool,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME: () => import_security_plugin.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   ReadonlyContext: () => import_readonly_context.ReadonlyContext,
+  RestApiTool: () => import_rest_api_tool.RestApiTool,
   RoutedAgent: () => import_routed_agent.RoutedAgent,
   RoutedLlm: () => import_routed_llm.RoutedLlm,
   Runner: () => import_runner.Runner,
+  SearchSkillsTool: () => import_search_skills_tool.SearchSkillsTool,
   SecurityPlugin: () => import_security_plugin.SecurityPlugin,
   SequentialAgent: () => import_sequential_agent.SequentialAgent,
   SessionStateCredentialService: () => import_session_state_credential_service.SessionStateCredentialService,
@@ -103,13 +113,17 @@ __export(common_exports, {
   State: () => import_state.State,
   StreamingMode: () => import_run_config.StreamingMode,
   TokenBasedContextCompactor: () => import_token_based_context_compactor.TokenBasedContextCompactor,
+  ToolAuthHandler: () => import_tool_auth_handler.ToolAuthHandler,
   ToolConfirmation: () => import_tool_confirmation.ToolConfirmation,
   TruncatingContextCompactor: () => import_truncating_context_compactor.TruncatingContextCompactor,
   URL_CONTEXT: () => import_url_context_tool.URL_CONTEXT,
   UrlContextTool: () => import_url_context_tool.UrlContextTool,
+  VertexAiMemoryBankService: () => import_vertex_ai_memory_bank_service.VertexAiMemoryBankService,
   VertexAiSearchTool: () => import_vertex_ai_search_tool.VertexAiSearchTool,
+  VertexRagRetrievalTool: () => import_vertex_rag_retrieval_tool.VertexRagRetrievalTool,
   createEvent: () => import_event.createEvent,
   createEventActions: () => import_event_actions.createEventActions,
+  createRestApiTool: () => import_rest_api_tool.createRestApiTool,
   createSession: () => import_session.createSession,
   functionsExportedForTestingOnly: () => import_functions.functionsExportedForTestingOnly,
   geminiInitParams: () => import_google_llm.geminiInitParams,
@@ -128,16 +142,21 @@ __export(common_exports, {
   isFinalResponse: () => import_event.isFinalResponse,
   isFunctionTool: () => import_function_tool.isFunctionTool,
   isGemini2OrAbove: () => import_model_name.isGemini2OrAbove,
+  isGemini3xFlashLive: () => import_model_name.isGemini3xFlashLive,
   isLlmAgent: () => import_llm_agent.isLlmAgent,
   isLoopAgent: () => import_loop_agent.isLoopAgent,
   isParallelAgent: () => import_parallel_agent.isParallelAgent,
   isRoutedAgent: () => import_routed_agent.isRoutedAgent,
   isRunner: () => import_runner.isRunner,
   isSequentialAgent: () => import_sequential_agent.isSequentialAgent,
+  loadAllSkillsInDir: () => import_loader.loadAllSkillsInDir,
+  loadSkillFromDir: () => import_loader.loadSkillFromDir,
+  loadSkillFromZipBuffer: () => import_loader.loadSkillFromZipBuffer,
   setLogLevel: () => import_logger.setLogLevel,
   setLogger: () => import_logger.setLogger,
   stringifyContent: () => import_event.stringifyContent,
   toStructuredEvents: () => import_structured_events.toStructuredEvents,
+  validateSkillDir: () => import_loader.validateSkillDir,
   version: () => import_version.version,
   zodObjectToSchema: () => import_simple_zod_to_json.zodObjectToSchema
 });
@@ -162,6 +181,7 @@ var import_sequential_agent = require("./agents/sequential_agent.js");
 var import_in_memory_artifact_service = require("./artifacts/in_memory_artifact_service.js");
 var import_auth_credential = require("./auth/auth_credential.js");
 var import_auth_handler = require("./auth/auth_handler.js");
+var import_auth_preprocessor = require("./auth/auth_preprocessor.js");
 var import_auth_provider_registry = require("./auth/auth_provider_registry.js");
 var import_auth_schemes = require("./auth/auth_schemes.js");
 var import_in_memory_credential_service = require("./auth/credential_service/in_memory_credential_service.js");
@@ -182,6 +202,7 @@ var import_event_actions = require("./events/event_actions.js");
 var import_structured_events = require("./events/structured_events.js");
 var import_base_example_provider = require("./examples/base_example_provider.js");
 var import_in_memory_memory_service = require("./memory/in_memory_memory_service.js");
+var import_vertex_ai_memory_bank_service = require("./memory/vertex_ai_memory_bank_service.js");
 var import_apigee_llm = require("./models/apigee_llm.js");
 var import_base_llm = require("./models/base_llm.js");
 var import_google_llm = require("./models/google_llm.js");
@@ -202,6 +223,7 @@ var import_base_tool = require("./tools/base_tool.js");
 var import_base_toolset = require("./tools/base_toolset.js");
 var import_exit_loop_tool = require("./tools/exit_loop_tool.js");
 var import_function_tool = require("./tools/function_tool.js");
+var import_google_maps_grounding_tool = require("./tools/google_maps_grounding_tool.js");
 var import_google_search_tool = require("./tools/google_search_tool.js");
 var import_load_artifacts_tool = require("./tools/load_artifacts_tool.js");
 var import_load_memory_tool = require("./tools/load_memory_tool.js");
@@ -210,15 +232,24 @@ var import_preload_memory_tool = require("./tools/preload_memory_tool.js");
 var import_tool_confirmation = require("./tools/tool_confirmation.js");
 var import_url_context_tool = require("./tools/url_context_tool.js");
 var import_vertex_ai_search_tool = require("./tools/vertex_ai_search_tool.js");
+var import_vertex_rag_retrieval_tool = require("./tools/vertex_rag_retrieval_tool.js");
 var import_logger = require("./utils/logger.js");
 var import_model_name = require("./utils/model_name.js");
 var import_simple_zod_to_json = require("./utils/simple_zod_to_json.js");
 var import_variant_utils = require("./utils/variant_utils.js");
 var import_version = require("./version.js");
+var import_gcp_skill_registry = require("./skills/gcp_skill_registry.js");
+var import_loader = require("./skills/loader.js");
 var import_list_skills_tool = require("./tools/skill/list_skills_tool.js");
 var import_load_skill_resource_tool = require("./tools/skill/load_skill_resource_tool.js");
 var import_load_skill_tool = require("./tools/skill/load_skill_tool.js");
+var import_search_skills_tool = require("./tools/skill/search_skills_tool.js");
 var import_skill_toolset = require("./tools/skill/skill_toolset.js");
+var import_openapi_spec_parser = require("./tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js");
+var import_operation_parser = require("./tools/openapi_tool/openapi_spec_parser/operation_parser.js");
+var import_tool_auth_handler = require("./tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js");
+var import_openapi_toolset = require("./tools/openapi_tool/openapi_toolset.js");
+var import_rest_api_tool = require("./tools/openapi_tool/rest_api_tool.js");
 __reExport(common_exports, require("./artifacts/base_artifact_service.js"), module.exports);
 __reExport(common_exports, require("./features/feature_registry.js"), module.exports);
 __reExport(common_exports, require("./memory/base_memory_service.js"), module.exports);
@@ -231,6 +262,7 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
  */
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AUTH_PREPROCESSOR,
   ActiveStreamingTool,
   Agent,
   AgentTool,
@@ -238,6 +270,7 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   ApigeeLlm,
   AuthCredentialTypes,
   AuthHandler,
+  AuthPreprocessor,
   AuthProviderRegistry,
   BaseAgent,
   BaseCodeExecutor,
@@ -263,9 +296,12 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   ExitLoopTool,
   FileContentEncoding,
   FunctionTool,
+  GCPSkillRegistry,
+  GOOGLE_MAPS_GROUNDING,
   GOOGLE_SEARCH,
   Gemini,
   GoogleLLMVariant,
+  GoogleMapsGroundingTool,
   GoogleSearchTool,
   InMemoryArtifactService,
   InMemoryCredentialService,
@@ -292,6 +328,9 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   OAuth2CredentialExchanger,
   OAuth2DiscoveryManager,
   OAuthGrantType,
+  OpenAPIToolset,
+  OpenApiSpecParser,
+  OperationParser,
   PRELOAD_MEMORY,
   ParallelAgent,
   PluginManager,
@@ -299,9 +338,11 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   PreloadMemoryTool,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   ReadonlyContext,
+  RestApiTool,
   RoutedAgent,
   RoutedLlm,
   Runner,
+  SearchSkillsTool,
   SecurityPlugin,
   SequentialAgent,
   SessionStateCredentialService,
@@ -309,13 +350,17 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   State,
   StreamingMode,
   TokenBasedContextCompactor,
+  ToolAuthHandler,
   ToolConfirmation,
   TruncatingContextCompactor,
   URL_CONTEXT,
   UrlContextTool,
+  VertexAiMemoryBankService,
   VertexAiSearchTool,
+  VertexRagRetrievalTool,
   createEvent,
   createEventActions,
+  createRestApiTool,
   createSession,
   functionsExportedForTestingOnly,
   geminiInitParams,
@@ -334,16 +379,21 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   isFinalResponse,
   isFunctionTool,
   isGemini2OrAbove,
+  isGemini3xFlashLive,
   isLlmAgent,
   isLoopAgent,
   isParallelAgent,
   isRoutedAgent,
   isRunner,
   isSequentialAgent,
+  loadAllSkillsInDir,
+  loadSkillFromDir,
+  loadSkillFromZipBuffer,
   setLogLevel,
   setLogger,
   stringifyContent,
   toStructuredEvents,
+  validateSkillDir,
   version,
   zodObjectToSchema,
   ...require("./artifacts/base_artifact_service.js"),

package/dist/cjs/context/summarizers/llm_summarizer.js

@@ -36,10 +36,21 @@ var import_event = require("../../events/event.js");
  */
 const DEFAULT_PROMPT = "The following is a conversation history between a user and an AI agent. Please summarize the conversation, focusing on key information and decisions made, as well as any unresolved questions or tasks. The summary should be concise and capture the essence of the interaction.";
 class LlmSummarizer {
+  /**
+   * @param options - Configuration specifying the LLM and optional prompt.
+   */
   constructor(options) {
     this.llm = options.llm;
     this.prompt = options.prompt || DEFAULT_PROMPT;
   }
+  /**
+   * Summarizes a list of events into a single {@link CompactedEvent} using the
+   * configured LLM.
+   *
+   * @param events - The events to summarize. Must be non-empty.
+   * @returns A promise resolving to the compacted representation.
+   * @throws {Error} If `events` is empty or the LLM returns no content.
+   */
   async summarize(events) {
     var _a, _b, _c, _d, _e, _f;
     if (events.length === 0) {

package/dist/cjs/context/token_based_context_compactor.js

@@ -102,7 +102,7 @@ class TokenBasedContextCompactor {
       compactedEvent.actions = {
         stateDelta: {},
         artifactDelta: {},
-        requestedAuthConfigs: [],
+        requestedAuthConfigs: {},
         requestedToolConfirmations: {}
       };
     }