@google/adk 1.1.0 → 1.3.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/code_executors/code_executor_context.js

@@ -70,7 +70,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);
@@ -80,13 +80,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) {
@@ -99,7 +99,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;
@@ -109,7 +109,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;
@@ -119,7 +119,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);
@@ -141,7 +141,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/esm/common.js

@@ -31,6 +31,7 @@ import { SequentialAgent, isSequentialAgent } from "./agents/sequential_agent.js
 import { InMemoryArtifactService } from "./artifacts/in_memory_artifact_service.js";
 import { AuthCredentialTypes } from "./auth/auth_credential.js";
 import { AuthHandler } from "./auth/auth_handler.js";
+import { AUTH_PREPROCESSOR, AuthPreprocessor } from "./auth/auth_preprocessor.js";
 import { AuthProviderRegistry } from "./auth/auth_provider_registry.js";
 import { OAuthGrantType } from "./auth/auth_schemes.js";
 import { InMemoryCredentialService } from "./auth/credential_service/in_memory_credential_service.js";
@@ -64,6 +65,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 +92,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,
@@ -104,21 +110,39 @@ import {
 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 { isGemini2OrAbove, isGemini3xFlashLive } from "./utils/model_name.js";
 import { zodObjectToSchema } from "./utils/simple_zod_to_json.js";
 import { GoogleLLMVariant } from "./utils/variant_utils.js";
 import { version } from "./version.js";
+import { GCPSkillRegistry } from "./skills/gcp_skill_registry.js";
+import {
+  loadAllSkillsInDir,
+  loadSkillFromDir,
+  loadSkillFromZipBuffer,
+  validateSkillDir
+} from "./skills/loader.js";
 import { ListSkillsTool } from "./tools/skill/list_skills_tool.js";
 import { LoadSkillResourceTool } from "./tools/skill/load_skill_resource_tool.js";
 import { LoadSkillTool } from "./tools/skill/load_skill_tool.js";
+import { SearchSkillsTool } from "./tools/skill/search_skills_tool.js";
 import { SkillToolset } from "./tools/skill/skill_toolset.js";
+import { OpenApiSpecParser } from "./tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js";
+import { OperationParser } from "./tools/openapi_tool/openapi_spec_parser/operation_parser.js";
+import { ToolAuthHandler } from "./tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js";
+import { OpenAPIToolset } from "./tools/openapi_tool/openapi_toolset.js";
+import {
+  RestApiTool,
+  createRestApiTool
+} from "./tools/openapi_tool/rest_api_tool.js";
 export * from "./artifacts/base_artifact_service.js";
 export * from "./features/feature_registry.js";
 export * from "./memory/base_memory_service.js";
 export * from "./sessions/base_session_service.js";
 export * from "./tools/base_tool.js";
 export {
+  AUTH_PREPROCESSOR,
   ActiveStreamingTool,
   LlmAgent as Agent,
   AgentTool,
@@ -126,6 +150,7 @@ export {
   ApigeeLlm,
   AuthCredentialTypes,
   AuthHandler,
+  AuthPreprocessor,
   AuthProviderRegistry,
   BaseAgent,
   BaseCodeExecutor,
@@ -151,9 +176,12 @@ export {
   ExitLoopTool,
   FileContentEncoding,
   FunctionTool,
+  GCPSkillRegistry,
+  GOOGLE_MAPS_GROUNDING,
   GOOGLE_SEARCH,
   Gemini,
   GoogleLLMVariant,
+  GoogleMapsGroundingTool,
   GoogleSearchTool,
   InMemoryArtifactService,
   InMemoryCredentialService,
@@ -180,6 +208,9 @@ export {
   OAuth2CredentialExchanger,
   OAuth2DiscoveryManager,
   OAuthGrantType,
+  OpenAPIToolset,
+  OpenApiSpecParser,
+  OperationParser,
   PRELOAD_MEMORY,
   ParallelAgent,
   PluginManager,
@@ -187,9 +218,11 @@ export {
   PreloadMemoryTool,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   ReadonlyContext,
+  RestApiTool,
   RoutedAgent,
   RoutedLlm,
   Runner,
+  SearchSkillsTool,
   SecurityPlugin,
   SequentialAgent,
   SessionStateCredentialService,
@@ -197,13 +230,17 @@ export {
   State,
   StreamingMode,
   TokenBasedContextCompactor,
+  ToolAuthHandler,
   ToolConfirmation,
   TruncatingContextCompactor,
   URL_CONTEXT,
   UrlContextTool,
+  VertexAiMemoryBankService,
   VertexAiSearchTool,
+  VertexRagRetrievalTool,
   createEvent,
   createEventActions,
+  createRestApiTool,
   createSession,
   functionsExportedForTestingOnly,
   geminiInitParams,
@@ -222,16 +259,21 @@ export {
   isFinalResponse,
   isFunctionTool,
   isGemini2OrAbove,
+  isGemini3xFlashLive,
   isLlmAgent,
   isLoopAgent,
   isParallelAgent,
   isRoutedAgent,
   isRunner,
   isSequentialAgent,
+  loadAllSkillsInDir,
+  loadSkillFromDir,
+  loadSkillFromZipBuffer,
   setLogLevel,
   setLogger,
   stringifyContent,
   toStructuredEvents,
+  validateSkillDir,
   version,
   zodObjectToSchema
 };

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

@@ -11,10 +11,21 @@ import {
 import { stringifyContent } from "../../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/esm/context/token_based_context_compactor.js

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

package/dist/esm/events/event.js

@@ -20,7 +20,7 @@ function createEvent(params = {}) {
   };
 }
 function isFinalResponse(event) {
-  if (event.actions.skipSummarization || event.longRunningToolIds && event.longRunningToolIds.length > 0) {
+  if (event.actions.skipSummarization || event.longRunningToolIds && event.longRunningToolIds.length > 0 || event.actions.requestedAuthConfigs && Object.keys(event.actions.requestedAuthConfigs).length > 0) {
     return true;
   }
   return getFunctionCalls(event).length === 0 && getFunctionResponses(event).length === 0 && !event.partial && !hasTrailingCodeExecutionResult(event);
@@ -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"
 ];

package/dist/esm/index.js

@@ -9,15 +9,21 @@ import { AGENT_CARD_PATH, RemoteA2AAgent } from "./a2a/a2a_remote_agent.js";
 import { getA2AAgentCard } from "./a2a/agent_card.js";
 import { A2AAgentExecutor } from "./a2a/agent_executor.js";
 import { toA2a } from "./a2a/agent_to_a2a.js";
+import { InvocationContext } from "./agents/invocation_context.js";
 import { FileArtifactService } from "./artifacts/file_artifact_service.js";
 import { GcsArtifactService } from "./artifacts/gcs_artifact_service.js";
 import { getArtifactServiceFromUri } from "./artifacts/registry.js";
+import {
+  AgentEngineSandboxCodeExecutor
+} from "./code_executors/agent_engine_sandbox_code_executor.js";
+import { CodeExecutionLanguage } from "./code_executors/code_execution_utils.js";
 import {
   UnsafeLocalCodeExecutor
 } from "./code_executors/unsafe_local_code_executor.js";
 export * from "./common.js";
 import { DatabaseSessionService } from "./sessions/database_session_service.js";
 import { getSessionServiceFromUri } from "./sessions/registry.js";
+import { VertexAiSessionService } from "./sessions/vertex_ai_session_service.js";
 import {
   loadAllSkillsInDir,
   loadSkillFromDir,
@@ -25,6 +31,7 @@ import {
 } from "./skills/loader.js";
 import { RunSkillInlineScriptTool } from "./tools/skill/run_skill_inline_script_tool.js";
 import { RunSkillScriptTool } from "./tools/skill/run_skill_script_tool.js";
+export * from "./integrations/agent_registry/agent_registry.js";
 export * from "./telemetry/google_cloud.js";
 export * from "./telemetry/setup.js";
 export * from "./tools/mcp/mcp_session_manager.js";
@@ -33,13 +40,17 @@ export * from "./tools/mcp/mcp_toolset.js";
 export {
   A2AAgentExecutor,
   AGENT_CARD_PATH,
+  AgentEngineSandboxCodeExecutor,
+  CodeExecutionLanguage,
   DatabaseSessionService,
   FileArtifactService,
   GcsArtifactService,
+  InvocationContext,
   RemoteA2AAgent,
   RunSkillInlineScriptTool,
   RunSkillScriptTool,
   UnsafeLocalCodeExecutor,
+  VertexAiSessionService,
   getA2AAgentCard,
   getArtifactServiceFromUri,
   getSessionServiceFromUri,