@google/adk 1.0.0 → 1.2.0

package/dist/esm/code_executors/agent_engine_sandbox_code_executor.js

@@ -0,0 +1,281 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client } from "@google-cloud/vertexai";
+import { Language } from "@google-cloud/vertexai/build/src/genai/types.js";
+import { experimental } from "../utils/experimental.js";
+import { guessMimeType } from "../utils/file_utils.js";
+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+)$/;
+import { logger } from "../utils/logger.js";
+import { BaseCodeExecutor } from "./base_code_executor.js";
+import {
+  CodeExecutionLanguage
+} from "./code_execution_utils.js";
+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 CodeExecutionLanguage.PYTHON:
+      return Language.LANGUAGE_PYTHON;
+    case CodeExecutionLanguage.JAVASCRIPT:
+      return Language.LANGUAGE_JAVASCRIPT;
+    default:
+      throw new Error(`Unsupported language for Agent Engine Sandbox: ${lang}`);
+  }
+}
+let AgentEngineSandboxCodeExecutor = class extends 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 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")
+            }
+          }
+        });
+      }
+    }
+    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) {
+              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 = 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 () => {
+        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;
+        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) {
+        logger.debug(
+          `Failed to get sandbox ${sandboxName}, will create a new one`,
+          error
+        );
+        createNewSandbox = true;
+      }
+    }
+    if (createNewSandbox) {
+      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([
+  experimental
+], AgentEngineSandboxCodeExecutor);
+export {
+  AgentEngineSandboxCodeExecutor
+};

package/dist/esm/code_executors/code_execution_utils.js

@@ -47,7 +47,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/esm/common.js

@@ -64,6 +64,7 @@ import {
   isBaseExampleProvider
 } from "./examples/base_example_provider.js";
 import { InMemoryMemoryService } from "./memory/in_memory_memory_service.js";
+import { VertexAiMemoryBankService } from "./memory/vertex_ai_memory_bank_service.js";
 import { ApigeeLlm } from "./models/apigee_llm.js";
 import { BaseLlm, isBaseLlm } from "./models/base_llm.js";
 import { Gemini, geminiInitParams } from "./models/google_llm.js";
@@ -90,6 +91,10 @@ import { BaseTool, isBaseTool } from "./tools/base_tool.js";
 import { BaseToolset, isBaseToolset } from "./tools/base_toolset.js";
 import { EXIT_LOOP, ExitLoopTool } from "./tools/exit_loop_tool.js";
 import { FunctionTool, isFunctionTool } from "./tools/function_tool.js";
+import {
+  GOOGLE_MAPS_GROUNDING,
+  GoogleMapsGroundingTool
+} from "./tools/google_maps_grounding_tool.js";
 import { GOOGLE_SEARCH, GoogleSearchTool } from "./tools/google_search_tool.js";
 import {
   LOAD_ARTIFACTS,
@@ -102,6 +107,9 @@ import {
   PreloadMemoryTool
 } from "./tools/preload_memory_tool.js";
 import { ToolConfirmation } from "./tools/tool_confirmation.js";
+import { URL_CONTEXT, UrlContextTool } from "./tools/url_context_tool.js";
+import { VertexAiSearchTool } from "./tools/vertex_ai_search_tool.js";
+import { VertexRagRetrievalTool } from "./tools/vertex_rag_retrieval_tool.js";
 import { LogLevel, getLogger, setLogLevel, setLogger } from "./utils/logger.js";
 import { isGemini2OrAbove } from "./utils/model_name.js";
 import { zodObjectToSchema } from "./utils/simple_zod_to_json.js";
@@ -149,9 +157,11 @@ export {
   ExitLoopTool,
   FileContentEncoding,
   FunctionTool,
+  GOOGLE_MAPS_GROUNDING,
   GOOGLE_SEARCH,
   Gemini,
   GoogleLLMVariant,
+  GoogleMapsGroundingTool,
   GoogleSearchTool,
   InMemoryArtifactService,
   InMemoryCredentialService,
@@ -197,6 +207,11 @@ export {
   TokenBasedContextCompactor,
   ToolConfirmation,
   TruncatingContextCompactor,
+  URL_CONTEXT,
+  UrlContextTool,
+  VertexAiMemoryBankService,
+  VertexAiSearchTool,
+  VertexRagRetrievalTool,
   createEvent,
   createEventActions,
   createSession,

package/dist/esm/events/event.js

@@ -60,7 +60,7 @@ function stringifyContent(event) {
   if (!((_a = event.content) == null ? void 0 : _a.parts)) {
     return "";
   }
-  return event.content.parts.map((part) => {
+  return event.content.parts.filter((part) => !part.thought).map((part) => {
     var _a2;
     return (_a2 = part.text) != null ? _a2 : "";
   }).join("");
@@ -79,6 +79,7 @@ const PRESERVE_KEYS_CAMEL_CASE = [
   "actions.requestedAuthConfigs",
   "actions.requestedToolConfirmations",
   "actions.customMetadata",
+  "customMetadata",
   "content.parts.functionCall.args",
   "content.parts.functionResponse.response"
 ];
@@ -88,6 +89,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"
 ];