@softactivate/adk 1.1.0

package/dist/cjs/code_executors/unsafe_local_code_executor.js

@@ -0,0 +1,241 @@
+/**
+  * @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 __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 unsafe_local_code_executor_exports = {};
+__export(unsafe_local_code_executor_exports, {
+  UnsafeLocalCodeExecutor: () => UnsafeLocalCodeExecutor
+});
+module.exports = __toCommonJS(unsafe_local_code_executor_exports);
+var import_child_process = require("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_file_extension_utils = require("../utils/file_extension_utils.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 IS_WINDOWS = os.platform() === "win32";
+async function createTempScriptFile(code, language, shellCommandPath) {
+  const tempDir = path.join(
+    os.tmpdir(),
+    "adk_js_unsafe_code_executor",
+    Date.now().toString() + "_" + Math.random().toString(36).slice(2)
+  );
+  await fs.mkdir(tempDir, { recursive: true });
+  const ext = getExtensionForLanguage(language, shellCommandPath) || ".js";
+  const filePath = path.join(tempDir, `script${ext}`);
+  await fs.writeFile(filePath, code);
+  return { filePath, tempDir };
+}
+function getExtensionForLanguage(language, shellCommandPath) {
+  if (language === import_code_execution_utils.CodeExecutionLanguage.JAVASCRIPT) {
+    return ".js";
+  }
+  if (language === import_code_execution_utils.CodeExecutionLanguage.PYTHON) {
+    return ".py";
+  }
+  if (language === import_code_execution_utils.CodeExecutionLanguage.POWERSHELL) {
+    return ".ps1";
+  }
+  if (language === import_code_execution_utils.CodeExecutionLanguage.WINDOWS_CMD) {
+    return ".bat";
+  }
+  if (language === import_code_execution_utils.CodeExecutionLanguage.SHELL) {
+    if (IS_WINDOWS) {
+      if (shellCommandPath && shellCommandPath.toLowerCase().includes("cmd")) {
+        return ".bat";
+      }
+      return ".ps1";
+    }
+    return ".sh";
+  }
+  return void 0;
+}
+class UnsafeLocalCodeExecutor extends import_base_code_executor.BaseCodeExecutor {
+  constructor(options = {}) {
+    var _a, _b, _c, _d;
+    super();
+    this.timeoutSeconds = (_a = options.timeoutSeconds) != null ? _a : 30;
+    this.nodeCommandPath = (_b = options.commandPath) != null ? _b : process.execPath;
+    this.pythonCommandPath = (_c = options.pythonCommandPath) != null ? _c : IS_WINDOWS ? "python" : "python3";
+    this.shellCommandPath = (_d = options.shellCommandPath) != null ? _d : IS_WINDOWS ? "powershell" : "bash";
+    this.stateful = false;
+    this.optimizeDataFile = false;
+  }
+  async executeCode(params) {
+    var _a;
+    const { code, language } = params.codeExecutionInput;
+    if (![
+      import_code_execution_utils.CodeExecutionLanguage.JAVASCRIPT,
+      import_code_execution_utils.CodeExecutionLanguage.PYTHON,
+      import_code_execution_utils.CodeExecutionLanguage.SHELL,
+      import_code_execution_utils.CodeExecutionLanguage.WINDOWS_CMD,
+      import_code_execution_utils.CodeExecutionLanguage.POWERSHELL
+    ].includes(language)) {
+      return {
+        stdout: "",
+        stderr: `Unsupported language: ${language}`,
+        outputFiles: []
+      };
+    }
+    import_logger.logger.warn(
+      "\n====================================================================================\n\u26A0\uFE0F DANGER: UnsafeLocalCodeExecutor is executing code locally on this host machine!\nThis component provides NO sandboxing or container isolation. Arbitrary shell/script\ncommands generated by AI or untrusted sources could lead to serious security risks.\n====================================================================================\n"
+    );
+    let tempDir;
+    try {
+      const res = await createTempScriptFile(
+        code,
+        language,
+        this.shellCommandPath
+      );
+      const filePath = res.filePath;
+      tempDir = res.tempDir;
+      if (params.codeExecutionInput.inputFiles) {
+        await (0, import_file_utils.materializeFiles)(params.codeExecutionInput.inputFiles, tempDir);
+      }
+      let command = this.nodeCommandPath;
+      let args = [filePath];
+      if (language === import_code_execution_utils.CodeExecutionLanguage.PYTHON) {
+        command = this.pythonCommandPath;
+      } else if (language === import_code_execution_utils.CodeExecutionLanguage.SHELL) {
+        command = this.shellCommandPath;
+        if (this.shellCommandPath.toLowerCase().includes("powershell")) {
+          args = ["-NoLogo", "-ExecutionPolicy", "Bypass", "-File", filePath];
+        } else if (this.shellCommandPath.toLowerCase().includes("cmd")) {
+          args = ["/c", filePath];
+        }
+      } else if (language === import_code_execution_utils.CodeExecutionLanguage.POWERSHELL) {
+        command = IS_WINDOWS ? "powershell" : "pwsh";
+        args = ["-NoLogo", "-ExecutionPolicy", "Bypass", "-File", filePath];
+      } else if (language === import_code_execution_utils.CodeExecutionLanguage.WINDOWS_CMD) {
+        command = "cmd.exe";
+        args = ["/c", filePath];
+      }
+      if (params.codeExecutionInput.args) {
+        if (Array.isArray(params.codeExecutionInput.args)) {
+          args.push(...params.codeExecutionInput.args);
+        } else {
+          for (const [k, v] of Object.entries(params.codeExecutionInput.args)) {
+            args.push(`--${k}`, String(v));
+          }
+        }
+      }
+      const executionResult = await new Promise((resolve) => {
+        const child = (0, import_child_process.spawn)(command, args, {
+          timeout: this.timeoutSeconds * 1e3,
+          killSignal: "SIGKILL",
+          cwd: tempDir
+        });
+        let stdout = "";
+        let stderr = "";
+        if (child.stdout) {
+          child.stdout.on("data", (data) => {
+            stdout += data.toString();
+          });
+        }
+        if (child.stderr) {
+          child.stderr.on("data", (data) => {
+            stderr += data.toString();
+          });
+        }
+        child.on("error", (err) => {
+          stderr += `Process error: ${err.message}
+`;
+        });
+        child.on("close", (exitCode, signal) => {
+          if (signal === "SIGKILL" || signal === "SIGTERM") {
+            stderr += `
+Code execution timed out after ${this.timeoutSeconds} seconds.`;
+          } else if (exitCode !== 0 && exitCode !== null) {
+            if (!stderr) {
+              stderr = `Exit code ${exitCode}`;
+            }
+          }
+          resolve({ stdout, stderr, exitCode });
+        });
+      });
+      const outputFiles = [];
+      try {
+        const allFiles = await fs.readdir(tempDir, { recursive: true });
+        for (const relativeFilePath of allFiles) {
+          const fullPath = path.join(tempDir, relativeFilePath);
+          const stat = await fs.lstat(fullPath);
+          if (!stat.isFile()) {
+            continue;
+          }
+          if (relativeFilePath === path.basename(filePath)) {
+            continue;
+          }
+          const isInputFile = (_a = params.codeExecutionInput.inputFiles) == null ? void 0 : _a.some(
+            (f) => f.name === relativeFilePath
+          );
+          if (isInputFile) {
+            continue;
+          }
+          const fileContent = await fs.readFile(fullPath);
+          const { mimeType, encoding } = (0, import_file_extension_utils.getMimeTypeAndEncoding)(
+            path.extname(relativeFilePath)
+          );
+          outputFiles.push({
+            name: relativeFilePath,
+            content: fileContent.toString(encoding),
+            contentEncoding: encoding,
+            mimeType
+          });
+        }
+      } catch (e) {
+        import_logger.logger.error(`Error scanning output files: ${e}`);
+      }
+      return {
+        stdout: executionResult.stdout,
+        stderr: executionResult.stderr,
+        outputFiles
+      };
+    } finally {
+      if (tempDir) {
+        await fs.rm(tempDir, { recursive: true, force: true });
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UnsafeLocalCodeExecutor
+});

package/dist/cjs/common.js

@@ -0,0 +1,362 @@
+/**
+  * @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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var common_exports = {};
+__export(common_exports, {
+  ActiveStreamingTool: () => import_active_streaming_tool.ActiveStreamingTool,
+  Agent: () => import_llm_agent.LlmAgent,
+  AgentTool: () => import_agent_tool.AgentTool,
+  AgentTransferLlmRequestProcessor: () => import_agent_transfer_llm_request_processor.AgentTransferLlmRequestProcessor,
+  ApigeeLlm: () => import_apigee_llm.ApigeeLlm,
+  AuthCredentialTypes: () => import_auth_credential.AuthCredentialTypes,
+  AuthHandler: () => import_auth_handler.AuthHandler,
+  AuthProviderRegistry: () => import_auth_provider_registry.AuthProviderRegistry,
+  BaseAgent: () => import_base_agent.BaseAgent,
+  BaseCodeExecutor: () => import_base_code_executor.BaseCodeExecutor,
+  BaseExampleProvider: () => import_base_example_provider.BaseExampleProvider,
+  BaseLlm: () => import_base_llm.BaseLlm,
+  BaseLlmRequestProcessor: () => import_base_llm_processor.BaseLlmRequestProcessor,
+  BaseLlmResponseProcessor: () => import_base_llm_processor.BaseLlmResponseProcessor,
+  BasePlugin: () => import_base_plugin.BasePlugin,
+  BaseSessionService: () => import_base_session_service.BaseSessionService,
+  BaseTool: () => import_base_tool.BaseTool,
+  BaseToolset: () => import_base_toolset.BaseToolset,
+  BuiltInCodeExecutor: () => import_built_in_code_executor.BuiltInCodeExecutor,
+  CONTENT_REQUEST_PROCESSOR: () => import_content_request_processor.CONTENT_REQUEST_PROCESSOR,
+  CodeExecutionLanguage: () => import_code_execution_utils.CodeExecutionLanguage,
+  ContentRequestProcessor: () => import_content_request_processor.ContentRequestProcessor,
+  Context: () => import_context.Context,
+  ContextCompactionTrigger: () => import_base_plugin.ContextCompactionTrigger,
+  ContextCompactorRequestProcessor: () => import_context_compactor_request_processor.ContextCompactorRequestProcessor,
+  CredentialExchangeError: () => import_base_credential_exchanger.CredentialExchangeError,
+  CredentialRefresherRegistry: () => import_credential_refresher_registry.CredentialRefresherRegistry,
+  EXIT_LOOP: () => import_exit_loop_tool.EXIT_LOOP,
+  EventType: () => import_structured_events.EventType,
+  ExitLoopTool: () => import_exit_loop_tool.ExitLoopTool,
+  FileContentEncoding: () => import_code_execution_utils.FileContentEncoding,
+  FunctionTool: () => import_function_tool.FunctionTool,
+  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,
+  InMemoryMemoryService: () => import_in_memory_memory_service.InMemoryMemoryService,
+  InMemoryPolicyEngine: () => import_security_plugin.InMemoryPolicyEngine,
+  InMemoryRunner: () => import_in_memory_runner.InMemoryRunner,
+  InMemorySessionService: () => import_in_memory_session_service.InMemorySessionService,
+  InvocationContext: () => import_invocation_context.InvocationContext,
+  LLMRegistry: () => import_registry.LLMRegistry,
+  LOAD_ARTIFACTS: () => import_load_artifacts_tool.LOAD_ARTIFACTS,
+  LOAD_MEMORY: () => import_load_memory_tool.LOAD_MEMORY,
+  ListSkillsTool: () => import_list_skills_tool.ListSkillsTool,
+  LiveRequestQueue: () => import_live_request_queue.LiveRequestQueue,
+  LlmAgent: () => import_llm_agent.LlmAgent,
+  LlmSummarizer: () => import_llm_summarizer.LlmSummarizer,
+  LoadArtifactsTool: () => import_load_artifacts_tool.LoadArtifactsTool,
+  LoadMemoryTool: () => import_load_memory_tool.LoadMemoryTool,
+  LoadSkillResourceTool: () => import_load_skill_resource_tool.LoadSkillResourceTool,
+  LoadSkillTool: () => import_load_skill_tool.LoadSkillTool,
+  LogLevel: () => import_logger.LogLevel,
+  LoggingPlugin: () => import_logging_plugin.LoggingPlugin,
+  LongRunningFunctionTool: () => import_long_running_tool.LongRunningFunctionTool,
+  LoopAgent: () => import_loop_agent.LoopAgent,
+  OAuth2CredentialExchanger: () => import_oauth2_credential_exchanger.OAuth2CredentialExchanger,
+  OAuth2DiscoveryManager: () => import_oauth2_discovery.OAuth2DiscoveryManager,
+  OAuthGrantType: () => import_auth_schemes.OAuthGrantType,
+  PRELOAD_MEMORY: () => import_preload_memory_tool.PRELOAD_MEMORY,
+  ParallelAgent: () => import_parallel_agent.ParallelAgent,
+  PluginManager: () => import_plugin_manager.PluginManager,
+  PolicyOutcome: () => import_security_plugin.PolicyOutcome,
+  PreloadMemoryTool: () => import_preload_memory_tool.PreloadMemoryTool,
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME: () => import_security_plugin.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  ReadonlyContext: () => import_readonly_context.ReadonlyContext,
+  RoutedAgent: () => import_routed_agent.RoutedAgent,
+  RoutedLlm: () => import_routed_llm.RoutedLlm,
+  Runner: () => import_runner.Runner,
+  SecurityPlugin: () => import_security_plugin.SecurityPlugin,
+  SequentialAgent: () => import_sequential_agent.SequentialAgent,
+  SessionStateCredentialService: () => import_session_state_credential_service.SessionStateCredentialService,
+  SkillToolset: () => import_skill_toolset.SkillToolset,
+  State: () => import_state.State,
+  StreamingMode: () => import_run_config.StreamingMode,
+  TokenBasedContextCompactor: () => import_token_based_context_compactor.TokenBasedContextCompactor,
+  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,
+  VertexAiSearchTool: () => import_vertex_ai_search_tool.VertexAiSearchTool,
+  VertexRagRetrievalTool: () => import_vertex_rag_retrieval_tool.VertexRagRetrievalTool,
+  createEvent: () => import_event.createEvent,
+  createEventActions: () => import_event_actions.createEventActions,
+  createSession: () => import_session.createSession,
+  functionsExportedForTestingOnly: () => import_functions.functionsExportedForTestingOnly,
+  geminiInitParams: () => import_google_llm.geminiInitParams,
+  getAskUserConfirmationFunctionCalls: () => import_security_plugin.getAskUserConfirmationFunctionCalls,
+  getFunctionCalls: () => import_event.getFunctionCalls,
+  getFunctionResponses: () => import_event.getFunctionResponses,
+  getLogger: () => import_logger.getLogger,
+  hasTrailingCodeExecutionResult: () => import_event.hasTrailingCodeExecutionResult,
+  isAgentTool: () => import_agent_tool.isAgentTool,
+  isBaseAgent: () => import_base_agent.isBaseAgent,
+  isBaseExampleProvider: () => import_base_example_provider.isBaseExampleProvider,
+  isBaseLlm: () => import_base_llm.isBaseLlm,
+  isBaseTool: () => import_base_tool.isBaseTool,
+  isBaseToolset: () => import_base_toolset.isBaseToolset,
+  isCompactedEvent: () => import_compacted_event.isCompactedEvent,
+  isFinalResponse: () => import_event.isFinalResponse,
+  isFunctionTool: () => import_function_tool.isFunctionTool,
+  isGemini2OrAbove: () => import_model_name.isGemini2OrAbove,
+  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,
+  setLogLevel: () => import_logger.setLogLevel,
+  setLogger: () => import_logger.setLogger,
+  stringifyContent: () => import_event.stringifyContent,
+  toStructuredEvents: () => import_structured_events.toStructuredEvents,
+  version: () => import_version.version,
+  zodObjectToSchema: () => import_simple_zod_to_json.zodObjectToSchema
+});
+module.exports = __toCommonJS(common_exports);
+var import_active_streaming_tool = require("./agents/active_streaming_tool.js");
+var import_base_agent = require("./agents/base_agent.js");
+var import_context = require("./agents/context.js");
+var import_functions = require("./agents/functions.js");
+var import_invocation_context = require("./agents/invocation_context.js");
+var import_live_request_queue = require("./agents/live_request_queue.js");
+var import_llm_agent = require("./agents/llm_agent.js");
+var import_loop_agent = require("./agents/loop_agent.js");
+var import_parallel_agent = require("./agents/parallel_agent.js");
+var import_agent_transfer_llm_request_processor = require("./agents/processors/agent_transfer_llm_request_processor.js");
+var import_base_llm_processor = require("./agents/processors/base_llm_processor.js");
+var import_content_request_processor = require("./agents/processors/content_request_processor.js");
+var import_context_compactor_request_processor = require("./agents/processors/context_compactor_request_processor.js");
+var import_readonly_context = require("./agents/readonly_context.js");
+var import_routed_agent = require("./agents/routed_agent.js");
+var import_run_config = require("./agents/run_config.js");
+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_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");
+var import_session_state_credential_service = require("./auth/credential_service/session_state_credential_service.js");
+var import_base_credential_exchanger = require("./auth/exchanger/base_credential_exchanger.js");
+var import_oauth2_credential_exchanger = require("./auth/oauth2/oauth2_credential_exchanger.js");
+var import_oauth2_discovery = require("./auth/oauth2/oauth2_discovery.js");
+var import_credential_refresher_registry = require("./auth/refresher/credential_refresher_registry.js");
+var import_base_code_executor = require("./code_executors/base_code_executor.js");
+var import_built_in_code_executor = require("./code_executors/built_in_code_executor.js");
+var import_code_execution_utils = require("./code_executors/code_execution_utils.js");
+var import_llm_summarizer = require("./context/summarizers/llm_summarizer.js");
+var import_token_based_context_compactor = require("./context/token_based_context_compactor.js");
+var import_truncating_context_compactor = require("./context/truncating_context_compactor.js");
+var import_compacted_event = require("./events/compacted_event.js");
+var import_event = require("./events/event.js");
+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_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");
+var import_registry = require("./models/registry.js");
+var import_routed_llm = require("./models/routed_llm.js");
+var import_base_plugin = require("./plugins/base_plugin.js");
+var import_logging_plugin = require("./plugins/logging_plugin.js");
+var import_plugin_manager = require("./plugins/plugin_manager.js");
+var import_security_plugin = require("./plugins/security_plugin.js");
+var import_in_memory_runner = require("./runner/in_memory_runner.js");
+var import_runner = require("./runner/runner.js");
+var import_base_session_service = require("./sessions/base_session_service.js");
+var import_in_memory_session_service = require("./sessions/in_memory_session_service.js");
+var import_session = require("./sessions/session.js");
+var import_state = require("./sessions/state.js");
+var import_agent_tool = require("./tools/agent_tool.js");
+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");
+var import_long_running_tool = require("./tools/long_running_tool.js");
+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_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_skill_toolset = require("./tools/skill/skill_toolset.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);
+__reExport(common_exports, require("./sessions/base_session_service.js"), module.exports);
+__reExport(common_exports, require("./tools/base_tool.js"), module.exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActiveStreamingTool,
+  Agent,
+  AgentTool,
+  AgentTransferLlmRequestProcessor,
+  ApigeeLlm,
+  AuthCredentialTypes,
+  AuthHandler,
+  AuthProviderRegistry,
+  BaseAgent,
+  BaseCodeExecutor,
+  BaseExampleProvider,
+  BaseLlm,
+  BaseLlmRequestProcessor,
+  BaseLlmResponseProcessor,
+  BasePlugin,
+  BaseSessionService,
+  BaseTool,
+  BaseToolset,
+  BuiltInCodeExecutor,
+  CONTENT_REQUEST_PROCESSOR,
+  CodeExecutionLanguage,
+  ContentRequestProcessor,
+  Context,
+  ContextCompactionTrigger,
+  ContextCompactorRequestProcessor,
+  CredentialExchangeError,
+  CredentialRefresherRegistry,
+  EXIT_LOOP,
+  EventType,
+  ExitLoopTool,
+  FileContentEncoding,
+  FunctionTool,
+  GOOGLE_MAPS_GROUNDING,
+  GOOGLE_SEARCH,
+  Gemini,
+  GoogleLLMVariant,
+  GoogleMapsGroundingTool,
+  GoogleSearchTool,
+  InMemoryArtifactService,
+  InMemoryCredentialService,
+  InMemoryMemoryService,
+  InMemoryPolicyEngine,
+  InMemoryRunner,
+  InMemorySessionService,
+  InvocationContext,
+  LLMRegistry,
+  LOAD_ARTIFACTS,
+  LOAD_MEMORY,
+  ListSkillsTool,
+  LiveRequestQueue,
+  LlmAgent,
+  LlmSummarizer,
+  LoadArtifactsTool,
+  LoadMemoryTool,
+  LoadSkillResourceTool,
+  LoadSkillTool,
+  LogLevel,
+  LoggingPlugin,
+  LongRunningFunctionTool,
+  LoopAgent,
+  OAuth2CredentialExchanger,
+  OAuth2DiscoveryManager,
+  OAuthGrantType,
+  PRELOAD_MEMORY,
+  ParallelAgent,
+  PluginManager,
+  PolicyOutcome,
+  PreloadMemoryTool,
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  ReadonlyContext,
+  RoutedAgent,
+  RoutedLlm,
+  Runner,
+  SecurityPlugin,
+  SequentialAgent,
+  SessionStateCredentialService,
+  SkillToolset,
+  State,
+  StreamingMode,
+  TokenBasedContextCompactor,
+  ToolConfirmation,
+  TruncatingContextCompactor,
+  URL_CONTEXT,
+  UrlContextTool,
+  VertexAiSearchTool,
+  VertexRagRetrievalTool,
+  createEvent,
+  createEventActions,
+  createSession,
+  functionsExportedForTestingOnly,
+  geminiInitParams,
+  getAskUserConfirmationFunctionCalls,
+  getFunctionCalls,
+  getFunctionResponses,
+  getLogger,
+  hasTrailingCodeExecutionResult,
+  isAgentTool,
+  isBaseAgent,
+  isBaseExampleProvider,
+  isBaseLlm,
+  isBaseTool,
+  isBaseToolset,
+  isCompactedEvent,
+  isFinalResponse,
+  isFunctionTool,
+  isGemini2OrAbove,
+  isLlmAgent,
+  isLoopAgent,
+  isParallelAgent,
+  isRoutedAgent,
+  isRunner,
+  isSequentialAgent,
+  setLogLevel,
+  setLogger,
+  stringifyContent,
+  toStructuredEvents,
+  version,
+  zodObjectToSchema,
+  ...require("./artifacts/base_artifact_service.js"),
+  ...require("./features/feature_registry.js"),
+  ...require("./memory/base_memory_service.js"),
+  ...require("./sessions/base_session_service.js"),
+  ...require("./tools/base_tool.js")
+});

package/dist/cjs/context/base_context_compactor.js

@@ -0,0 +1,27 @@
+/**
+  * @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 __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 base_context_compactor_exports = {};
+module.exports = __toCommonJS(base_context_compactor_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

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

@@ -0,0 +1,27 @@
+/**
+  * @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 __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 base_summarizer_exports = {};
+module.exports = __toCommonJS(base_summarizer_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */