@softactivate/adk 1.1.0 → 1.2.0

package/dist/cjs/agents/functions.js

@@ -195,6 +195,8 @@ function buildResponseEvent(tool, functionResult, toolContext, invocationContext
   let responseResult;
   if (typeof functionResult !== "object" || functionResult == null) {
     responseResult = { result: functionResult };
+  } else if (Array.isArray(functionResult)) {
+    responseResult = { results: functionResult };
   } else {
     responseResult = functionResult;
   }
@@ -415,6 +417,8 @@ async function handleFunctionCallList({
       functionResponse = { error: functionResponseError };
     } else if (typeof functionResponse !== "object" || functionResponse == null) {
       functionResponse = { result: functionResponse };
+    } else if (Array.isArray(functionResponse)) {
+      functionResponse = { results: functionResponse };
     }
     const functionResponseEvent = (0, import_event.createEvent)({
       invocationId: invocationContext.invocationId,

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 === "127.0.0.1" || 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/common.js

@@ -109,6 +109,7 @@ __export(common_exports, {
   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,
@@ -185,6 +186,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");
@@ -320,6 +322,7 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   TruncatingContextCompactor,
   URL_CONTEXT,
   UrlContextTool,
+  VertexAiMemoryBankService,
   VertexAiSearchTool,
   VertexRagRetrievalTool,
   createEvent,

package/dist/cjs/events/event.js

@@ -114,6 +114,7 @@ const PRESERVE_KEYS_CAMEL_CASE = [
   "actions.requestedAuthConfigs",
   "actions.requestedToolConfirmations",
   "actions.customMetadata",
+  "customMetadata",
   "content.parts.functionCall.args",
   "content.parts.functionResponse.response"
 ];
@@ -123,6 +124,7 @@ const PRESERVE_KEYS_SNAKE_CASE = [
   "actions.requested_auth_configs",
   "actions.requested_tool_confirmations",
   "actions.custom_metadata",
+  "custom_metadata",
   "content.parts.function_call.args",
   "content.parts.function_response.response"
 ];

package/dist/cjs/index.js

@@ -27,13 +27,17 @@ var index_exports = {};
 __export(index_exports, {
   A2AAgentExecutor: () => import_agent_executor.A2AAgentExecutor,
   AGENT_CARD_PATH: () => import_a2a_remote_agent.AGENT_CARD_PATH,
+  AgentEngineSandboxCodeExecutor: () => import_agent_engine_sandbox_code_executor.AgentEngineSandboxCodeExecutor,
+  CodeExecutionLanguage: () => import_code_execution_utils.CodeExecutionLanguage,
   DatabaseSessionService: () => import_database_session_service.DatabaseSessionService,
   FileArtifactService: () => import_file_artifact_service.FileArtifactService,
   GcsArtifactService: () => import_gcs_artifact_service.GcsArtifactService,
+  InvocationContext: () => import_invocation_context.InvocationContext,
   RemoteA2AAgent: () => import_a2a_remote_agent.RemoteA2AAgent,
   RunSkillInlineScriptTool: () => import_run_skill_inline_script_tool.RunSkillInlineScriptTool,
   RunSkillScriptTool: () => import_run_skill_script_tool.RunSkillScriptTool,
   UnsafeLocalCodeExecutor: () => import_unsafe_local_code_executor.UnsafeLocalCodeExecutor,
+  VertexAiSessionService: () => import_vertex_ai_session_service.VertexAiSessionService,
   getA2AAgentCard: () => import_agent_card.getA2AAgentCard,
   getArtifactServiceFromUri: () => import_registry.getArtifactServiceFromUri,
   getSessionServiceFromUri: () => import_registry2.getSessionServiceFromUri,
@@ -47,16 +51,21 @@ 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_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");
 var import_registry = require("./artifacts/registry.js");
+var import_agent_engine_sandbox_code_executor = require("./code_executors/agent_engine_sandbox_code_executor.js");
+var import_code_execution_utils = require("./code_executors/code_execution_utils.js");
 var import_unsafe_local_code_executor = require("./code_executors/unsafe_local_code_executor.js");
 __reExport(index_exports, require("./common.js"), module.exports);
 var import_database_session_service = require("./sessions/database_session_service.js");
 var import_registry2 = require("./sessions/registry.js");
+var import_vertex_ai_session_service = require("./sessions/vertex_ai_session_service.js");
 var import_loader = require("./skills/loader.js");
 var import_run_skill_inline_script_tool = require("./tools/skill/run_skill_inline_script_tool.js");
 var import_run_skill_script_tool = require("./tools/skill/run_skill_script_tool.js");
+__reExport(index_exports, require("./integrations/agent_registry/agent_registry.js"), module.exports);
 __reExport(index_exports, require("./telemetry/google_cloud.js"), module.exports);
 __reExport(index_exports, require("./telemetry/setup.js"), module.exports);
 __reExport(index_exports, require("./tools/mcp/mcp_session_manager.js"), module.exports);
@@ -71,13 +80,17 @@ __reExport(index_exports, require("./tools/mcp/mcp_toolset.js"), module.exports)
 0 && (module.exports = {
   A2AAgentExecutor,
   AGENT_CARD_PATH,
+  AgentEngineSandboxCodeExecutor,
+  CodeExecutionLanguage,
   DatabaseSessionService,
   FileArtifactService,
   GcsArtifactService,
+  InvocationContext,
   RemoteA2AAgent,
   RunSkillInlineScriptTool,
   RunSkillScriptTool,
   UnsafeLocalCodeExecutor,
+  VertexAiSessionService,
   getA2AAgentCard,
   getArtifactServiceFromUri,
   getSessionServiceFromUri,
@@ -86,6 +99,7 @@ __reExport(index_exports, require("./tools/mcp/mcp_toolset.js"), module.exports)
   toA2a,
   validateSkillDir,
   ...require("./common.js"),
+  ...require("./integrations/agent_registry/agent_registry.js"),
   ...require("./telemetry/google_cloud.js"),
   ...require("./telemetry/setup.js"),
   ...require("./tools/mcp/mcp_session_manager.js"),