google-cloud-agentplatform 1.165.1.dev0__py3-none-any.whl

agentplatform/_genai/sandboxes.py

@@ -0,0 +1,1604 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Code generated by the Google Gen AI SDK generator DO NOT EDIT.
+
+import builtins
+import functools
+import json
+import logging
+import mimetypes
+import secrets
+import time
+from typing import Any, Iterator, Optional, Union
+from urllib.parse import urlencode
+
+from google import auth as google_auth
+from google import genai
+from google.auth.transport import requests as google_auth_requests
+from google.genai import _api_module
+from google.genai import _common
+from google.genai import types as genai_types
+from google.genai._common import get_value_by_path as getv
+from google.genai._common import set_value_by_path as setv
+from google.genai.pagers import Pager
+
+from . import _agent_engines_utils
+from . import types
+
+logger = logging.getLogger("agentplatform_genai.sandboxes")
+
+logger.setLevel(logging.INFO)
+
+
+def _CreateAgentEngineSandboxConfig_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+
+    if getv(from_object, ["display_name"]) is not None:
+        setv(parent_object, ["displayName"], getv(from_object, ["display_name"]))
+
+    if getv(from_object, ["description"]) is not None:
+        setv(parent_object, ["description"], getv(from_object, ["description"]))
+
+    if getv(from_object, ["ttl"]) is not None:
+        setv(parent_object, ["ttl"], getv(from_object, ["ttl"]))
+
+    if getv(from_object, ["sandbox_environment_template"]) is not None:
+        setv(
+            parent_object,
+            ["sandboxEnvironmentTemplate"],
+            getv(from_object, ["sandbox_environment_template"]),
+        )
+
+    if getv(from_object, ["sandbox_environment_snapshot"]) is not None:
+        setv(
+            parent_object,
+            ["sandboxEnvironmentSnapshot"],
+            getv(from_object, ["sandbox_environment_snapshot"]),
+        )
+
+    if getv(from_object, ["owner"]) is not None:
+        setv(parent_object, ["owner"], getv(from_object, ["owner"]))
+
+    return to_object
+
+
+def _CreateAgentEngineSandboxRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["name"]) is not None:
+        setv(to_object, ["_url", "name"], getv(from_object, ["name"]))
+
+    if getv(from_object, ["spec"]) is not None:
+        setv(to_object, ["spec"], getv(from_object, ["spec"]))
+
+    if getv(from_object, ["config"]) is not None:
+        _CreateAgentEngineSandboxConfig_to_vertex(
+            getv(from_object, ["config"]), to_object
+        )
+
+    return to_object
+
+
+def _DeleteAgentEngineSandboxRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["name"]) is not None:
+        setv(to_object, ["_url", "name"], getv(from_object, ["name"]))
+
+    return to_object
+
+
+def _ExecuteCodeAgentEngineSandboxRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["name"]) is not None:
+        setv(to_object, ["_url", "name"], getv(from_object, ["name"]))
+
+    if getv(from_object, ["inputs"]) is not None:
+        setv(to_object, ["inputs"], [item for item in getv(from_object, ["inputs"])])
+
+    return to_object
+
+
+def _GetAgentEngineSandboxOperationParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["operation_name"]) is not None:
+        setv(
+            to_object, ["_url", "operationName"], getv(from_object, ["operation_name"])
+        )
+
+    return to_object
+
+
+def _GetAgentEngineSandboxRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["name"]) is not None:
+        setv(to_object, ["_url", "name"], getv(from_object, ["name"]))
+
+    return to_object
+
+
+def _ListAgentEngineSandboxesConfig_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+
+    if getv(from_object, ["page_size"]) is not None:
+        setv(parent_object, ["_query", "pageSize"], getv(from_object, ["page_size"]))
+
+    if getv(from_object, ["page_token"]) is not None:
+        setv(parent_object, ["_query", "pageToken"], getv(from_object, ["page_token"]))
+
+    if getv(from_object, ["filter"]) is not None:
+        setv(parent_object, ["_query", "filter"], getv(from_object, ["filter"]))
+
+    return to_object
+
+
+def _ListAgentEngineSandboxesRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["name"]) is not None:
+        setv(to_object, ["_url", "name"], getv(from_object, ["name"]))
+
+    if getv(from_object, ["config"]) is not None:
+        _ListAgentEngineSandboxesConfig_to_vertex(
+            getv(from_object, ["config"]), to_object
+        )
+
+    return to_object
+
+
+class Sandboxes(_api_module.BaseModule):
+
+    def _create(
+        self,
+        *,
+        name: str,
+        spec: Optional[types.SandboxEnvironmentSpecOrDict] = None,
+        config: Optional[types.CreateAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.AgentEngineSandboxOperation:
+        """
+        Creates a new sandbox in the Agent Engine.
+        """
+
+        parameter_model = types._CreateAgentEngineSandboxRequestParameters(
+            name=name,
+            spec=spec,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _CreateAgentEngineSandboxRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}/sandboxEnvironments".format_map(request_url_dict)
+            else:
+                path = "{name}/sandboxEnvironments"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("post", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.AgentEngineSandboxOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def _delete(
+        self,
+        *,
+        name: str,
+        config: Optional[types.DeleteAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.DeleteAgentEngineSandboxOperation:
+        """
+        Delete an Agent Engine sandbox.
+
+        Args:
+            name (str):
+                Required. The name of the Agent Engine sandbox to be deleted. Format:
+                `projects/{project}/locations/{location}/reasoningEngines/{resource_id}/sandboxEnvironments/{sandbox}`.
+
+        """
+
+        parameter_model = types._DeleteAgentEngineSandboxRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _DeleteAgentEngineSandboxRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("delete", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.DeleteAgentEngineSandboxOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def _execute_code(
+        self,
+        *,
+        name: str,
+        inputs: Optional[builtins.list[types.ChunkOrDict]] = None,
+        config: Optional[types.ExecuteCodeAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.ExecuteSandboxEnvironmentResponse:
+        """
+        Execute code in an Agent Engine sandbox.
+        """
+
+        parameter_model = types._ExecuteCodeAgentEngineSandboxRequestParameters(
+            name=name,
+            inputs=inputs,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _ExecuteCodeAgentEngineSandboxRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}/:execute".format_map(request_url_dict)
+            else:
+                path = "{name}/:execute"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("post", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.ExecuteSandboxEnvironmentResponse._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def _get(
+        self,
+        *,
+        name: str,
+        config: Optional[types.GetAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.SandboxEnvironment:
+        """
+        Gets an agent engine sandbox.
+
+        Args:
+            name (str): Required. A fully-qualified resource name or ID such as
+              "projects/123/locations/us-central1/reasoningEngines/456/sandboxEnvironments/789"
+              or a shortened name such as "reasoningEngines/456/sandboxEnvironments/789".
+
+        """
+
+        parameter_model = types._GetAgentEngineSandboxRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _GetAgentEngineSandboxRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("get", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.SandboxEnvironment._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def _list(
+        self,
+        *,
+        name: str,
+        config: Optional[types.ListAgentEngineSandboxesConfigOrDict] = None,
+    ) -> types.ListAgentEngineSandboxesResponse:
+        """
+        Lists Agent Engine sandboxes.
+
+        Args:
+            name (str): Required. The name of the Agent Engine to list sessions for. Format:
+                `projects/{project}/locations/{location}/reasoningEngines/{resource_id}`.
+            config (ListAgentEngineSandboxesConfig):
+                Optional. Additional configurations for listing the Agent Engine sandboxes.
+
+        Returns:
+            ListReasoningEnginesSandboxesResponse: The requested Agent Engine sandboxes.
+
+        """
+
+        parameter_model = types._ListAgentEngineSandboxesRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _ListAgentEngineSandboxesRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}/sandboxEnvironments".format_map(request_url_dict)
+            else:
+                path = "{name}/sandboxEnvironments"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("get", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.ListAgentEngineSandboxesResponse._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def _get_sandbox_operation(
+        self,
+        *,
+        operation_name: str,
+        config: Optional[types.GetAgentEngineOperationConfigOrDict] = None,
+    ) -> types.AgentEngineSandboxOperation:
+        parameter_model = types._GetAgentEngineSandboxOperationParameters(
+            operation_name=operation_name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _GetAgentEngineSandboxOperationParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{operationName}".format_map(request_url_dict)
+            else:
+                path = "{operationName}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("get", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.AgentEngineSandboxOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    _templates = None
+    _snapshots = None
+
+    @property
+    def templates(self) -> Any:
+        if self._templates is None:
+            try:
+                self._templates = __import__("importlib").import_module(
+                    ".sandbox_templates", __package__
+                )
+            except ImportError as e:
+                raise ImportError(
+                    "The 'agent_engines.sandboxes.templates' module requires "
+                    "additional packages. Please install them using pip install "
+                    "google-cloud-aiplatform[agent_engines]"
+                ) from e
+        return self._templates.SandboxTemplates(self._api_client)
+
+    @property
+    def snapshots(self) -> Any:
+        if self._snapshots is None:
+            try:
+                self._snapshots = __import__("importlib").import_module(
+                    ".sandbox_snapshots", __package__
+                )
+            except ImportError as e:
+                raise ImportError(
+                    "The 'agent_engines.sandboxes.snapshots' module requires "
+                    "additional packages. Please install them using pip install "
+                    "google-cloud-aiplatform[sandbox_snapshots]"
+                ) from e
+        return self._snapshots.SandboxSnapshots(self._api_client)
+
+    def create(
+        self,
+        *,
+        name: str,
+        poll_interval_seconds: float = 0.1,
+        spec: Optional[types.SandboxEnvironmentSpecOrDict] = None,
+        config: Optional[types.CreateAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.AgentEngineSandboxOperation:
+        """Creates a new sandbox in the Agent Engine.
+
+        Args:
+            name (str):
+                Required. The name of the agent engine to create sandbox for.
+                projects/{project}/locations/{location}/reasoningEngines/{resource_id}
+            poll_interval_seconds (float):
+                Optional. The interval in seconds to poll for sandbox creation
+                completion.
+            spec (SandboxEnvironmentSpec):
+                Optional. The specification for the sandbox to create.
+            config (CreateAgentEngineSandboxConfigOrDict):
+                Optional. The configuration for the sandbox.
+
+        Returns:
+            AgentEngineSandboxOperation: The operation for creating the sandbox.
+        """
+        if config is None:
+            config = types.CreateAgentEngineSandboxConfig()
+        elif isinstance(config, dict):
+            config = types.CreateAgentEngineSandboxConfig.model_validate(config)
+
+        # A sandbox environment must be provided inline via `spec` (with an
+        # environment set), or by referencing an existing template or snapshot in
+        # `config`.
+        spec_has_environment = any(
+            _agent_engines_utils.has_field(spec, field_name)
+            for field_name in (
+                "code_execution_environment",
+                "computer_use_environment",
+                "shell_environment",
+            )
+        )
+        if (
+            not spec_has_environment
+            and not config.sandbox_environment_template
+            and not config.sandbox_environment_snapshot
+        ):
+            raise ValueError(
+                "A sandbox environment must be provided via `spec`, "
+                "`config.sandbox_environment_template`, or "
+                "`config.sandbox_environment_snapshot`."
+            )
+
+        if spec:
+            # Environments that can auto-provision a default sandbox
+            # environment template when the caller does not supply one. Ordered by
+            # precedence: the first matching environment is used.
+            environments = (
+                (
+                    "shell_environment",
+                    types.DefaultContainerCategory.DEFAULT_CONTAINER_CATEGORY_SHELL_SANDBOX,
+                    "shell-sandbox-template",
+                ),
+                (
+                    "computer_use_environment",
+                    types.DefaultContainerCategory.DEFAULT_CONTAINER_CATEGORY_COMPUTER_USE,
+                    "computer-use-template",
+                ),
+            )
+
+            for field_name, category, display_name in environments:
+                if not _agent_engines_utils.has_field(spec, field_name):
+                    continue
+
+                if (
+                    not config.sandbox_environment_template
+                    and not config.sandbox_environment_snapshot
+                ):
+                    default_container_environment = (
+                        types.SandboxEnvironmentTemplateDefaultContainerEnvironment(
+                            default_container_category=category,
+                        )
+                    )
+                    template_operation = self.templates.create(
+                        name=name,
+                        display_name=display_name,
+                        config=types.CreateSandboxEnvironmentTemplateConfig(
+                            default_container_environment=default_container_environment,
+                        ),
+                        poll_interval_seconds=poll_interval_seconds,
+                    )
+                    if not template_operation.response:
+                        raise ValueError(f"Error creating {display_name}.")
+                    config.sandbox_environment_template = (
+                        template_operation.response.name
+                    )
+                break
+
+        operation = self._create(
+            name=name,
+            spec=spec,
+            config=config,
+        )
+        if config.wait_for_completion:
+            if not operation.done:
+                operation = _agent_engines_utils._await_operation(
+                    operation_name=operation.name,
+                    get_operation_fn=self._get_sandbox_operation,
+                    poll_interval_seconds=poll_interval_seconds,
+                )
+            # We need to make a call to get the sandbox because the operation
+            # response might not contain the relevant fields.
+            if not operation.response:
+                raise ValueError("Error retrieving sandbox.")
+            operation.response = self.get(name=operation.response.name)
+        return operation
+
+    def list(
+        self,
+        *,
+        name: str,
+        config: Optional[types.ListAgentEngineSandboxesConfigOrDict] = None,
+    ) -> Iterator[types.SandboxEnvironment]:
+        """Lists Agent Engine sandboxes.
+
+        Args:
+            name (str):
+                Required. The name of the agent engine to list sandboxes for.
+                projects/{project}/locations/{location}/reasoningEngines/{resource_id}
+            config (ListAgentEngineSandboxConfig):
+                Optional. The configuration for the sandboxes to list.
+
+        Returns:
+            Iterable[SandboxEnvironment]: An iterable of agent engine sandboxes.
+        """
+        return Pager(
+            "sandbox_environments",
+            functools.partial(self._list, name=name),
+            self._list(name=name, config=config),
+            config,
+        )
+
+    def execute_code(
+        self,
+        *,
+        name: str,
+        input_data: dict[str, Any],
+        config: Optional[types.ExecuteCodeAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.ExecuteSandboxEnvironmentResponse:
+        """Executes code in the Agent Engine sandbox.
+
+        Args:
+            name (str):
+                Required. The name of the agent engine sandbox to run code in.
+                projects/{project}/locations/{location}/reasoningEngines/{resource_id}/SandboxEnvironments/{sandbox_id}
+            input_data (dict[str, Any]):
+                Required. The input to the code to execute.
+            config (ExecuteCodeAgentEngineSandboxConfigOrDict):
+                Optional. The configuration for the sandboxes to run code in.
+
+        Returns:
+            ExecuteSandboxEnvironmentResponse: The response from executing the code.
+        """
+        input_chunks = []
+
+        if input_data.get("code") is not None:
+            code = input_data.get("code", "")
+            json_code = json.dumps({"code": code}).encode("utf-8")
+            input_chunks.append(
+                types.Chunk(
+                    mime_type="application/json",
+                    data=json_code,
+                )
+            )
+
+        for file in input_data.get("files", []):
+            file_name = file.get("name", "")
+            input_chunks.append(
+                types.Chunk(
+                    mime_type=file.get("mimeType", ""),
+                    data=file.get("content", b""),
+                    metadata={"attributes": {"file_name": file_name.encode("utf-8")}},
+                )
+            )
+
+        response = self._execute_code(
+            name=name,
+            inputs=input_chunks,
+            config=config,
+        )
+
+        output_chunks = []
+        if response.outputs is not None:
+            for output in response.outputs:
+                if output.mime_type is None:
+                    # if mime_type is not available, try to guess the mime_type from the file_name.
+                    if (
+                        output.metadata is not None
+                        and output.metadata.attributes is not None
+                    ):
+                        file_name = output.metadata.attributes.get(
+                            "file_name", b""
+                        ).decode("utf-8")
+                        mime_type, _ = mimetypes.guess_type(file_name)
+                        output.mime_type = mime_type
+                output_chunks.append(output)
+
+        response = types.ExecuteSandboxEnvironmentResponse(outputs=output_chunks)
+
+        return response
+
+    def get(
+        self,
+        *,
+        name: str,
+        config: Optional[types.GetAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.SandboxEnvironment:
+        """Gets an agent engine sandbox.
+        Args:
+          name (str):
+              Required. A fully-qualified resource name or ID such as
+              projects/{project}/locations/{location}/reasoningEngines/{resource_id}/SandboxEnvironments/{sandbox_id}
+              or a shortened name such as "reasoningEngines/{resource_id}/sandboxEnvironments/{sandbox_id}".
+          config (GetAgentEngineSandboxConfigOrDict):
+              Optional. The configuration for the sandbox to get.
+
+        """
+        return self._get(name=name, config=config)
+
+    def delete(
+        self,
+        *,
+        name: str,
+        config: Optional[types.DeleteAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.DeleteAgentEngineSandboxOperation:
+        """Deletes an agent engine sandbox.
+        Args:
+          name (str):
+              Required. A fully-qualified resource name or ID such as
+              projects/{project}/locations/{location}/reasoningEngines/{resource_id}/SandboxEnvironments/{sandbox_id}
+              or a shortened name such as "reasoningEngines/{resource_id}/sandboxEnvironments/{sandbox_id}".
+          config (DeleteAgentEngineSandboxConfigOrDict):
+              Optional. The configuration for the sandbox to delete.
+        """
+        return self._delete(name=name, config=config)
+
+    def generate_access_token(
+        self,
+        service_account_email: str,
+        timeout: int = 3600,
+    ) -> str:
+        """Signs a JWT with a Google Cloud service account.
+
+        Args:
+            service_account_email (str):
+                Required. The email of the service account to use for signing.
+            timeout (int):
+                Optional. The timeout in seconds for the token. Defaults to 3600.
+
+        Returns:
+            str: The signed JWT.
+        """
+        issued_at = int(time.time())
+        payload = {
+            "iat": issued_at,
+            "exp": issued_at + timeout,
+            "iss": service_account_email,
+            "sub": service_account_email,
+            "nonce": secrets.randbelow(1000000000) + 1,
+            "aud": "https://aiplatform.googleapis.com/",  # default audience for sandbox proxy
+        }
+        credentials, _ = google_auth.default(
+            scopes=["https://www.googleapis.com/auth/cloud-platform"]
+        )
+        # Resolve the endpoint against the credentials' universe domain so this
+        # keeps working off googleapis.com, the same way google.auth.iam does.
+        universe_domain = (
+            getattr(credentials, "universe_domain", None) or "googleapis.com"
+        )
+        session = google_auth_requests.AuthorizedSession(credentials)  # type: ignore[no-untyped-call]
+        # The generated IAM client this replaced used the mTLS endpoint when
+        # client certificates are enabled, and so does the genai client that
+        # serves every other call in this module. configure_mtls_channel()
+        # self-gates on GOOGLE_API_USE_CLIENT_CERTIFICATE and on discovered
+        # workload certificates, so it is a no-op when mTLS is not in use.
+        session.configure_mtls_channel()  # type: ignore[no-untyped-call]
+        # mTLS is only defined on the default universe.
+        host = f"iamcredentials.{universe_domain}"
+        if session.is_mtls and universe_domain == "googleapis.com":
+            host = f"iamcredentials.mtls.{universe_domain}"
+        url = (
+            f"https://{host}/v1/"
+            f"projects/-/serviceAccounts/{service_account_email}:signJwt"
+        )
+        # The generated IAM client this replaced retried UNAVAILABLE and
+        # DEADLINE_EXCEEDED with initial=0.1s and multiplier=1.3 under a 60s
+        # total deadline. requests does not retry at all, so reproduce that
+        # policy here rather than silently dropping it.
+        deadline = time.monotonic() + 60.0
+        delay = 0.1
+        while True:
+            response = session.post(
+                url,
+                json={"payload": json.dumps(payload)},
+                timeout=max(1.0, deadline - time.monotonic()),
+            )
+            if response.status_code not in (503, 504):
+                break
+            if deadline - time.monotonic() <= delay:
+                break
+            time.sleep(delay)
+            delay *= 1.3
+        response.raise_for_status()
+        return response.json()["signedJwt"]  # type: ignore[no-any-return]
+
+    def send_command(
+        self,
+        *,
+        http_method: str,
+        access_token: str,
+        sandbox_environment: types.SandboxEnvironment,
+        port: str = "8080",
+        path: Optional[str] = None,
+        query_params: Optional[dict[str, object]] = None,
+        headers: Optional[dict[str, str]] = None,
+        request_dict: Optional[dict[str, object]] = None,
+    ) -> genai_types.HttpResponse:
+        """Sends a command to the sandbox.
+
+        Args:
+            http_method (str):
+                Required. The HTTP method to use for the command.
+            access_token (str):
+                Required. The access token to use for authorization.
+            sandbox_environment (types.SandboxEnvironment):
+                Required. The sandbox environment to send the command to.
+            port (str):
+                Optional. The port to use for the token. Defaults to "8080". This should be one of the ports specified during template creation.
+            path (str):
+                Optional. The path to send the command to.
+            query_params (dict[str, object]):
+                Optional. The query parameters to include in the command.
+            headers (dict[str, str]):
+                Optional. The headers to include in the command.
+            request_dict (dict[str, object]):
+                Optional. The request body to include in the command.
+
+        Returns:
+            genai_types.HttpResponse: The response from the sandbox.
+        """
+        headers = headers or {}
+        request_dict = request_dict or {}
+        connection_info = sandbox_environment.connection_info
+        if not connection_info:
+            raise ValueError("Connection info is not available.")
+        if connection_info.load_balancer_hostname:
+            endpoint = "https://" + connection_info.load_balancer_hostname
+        elif connection_info.load_balancer_ip:
+            endpoint = "http://" + connection_info.load_balancer_ip
+        else:
+            raise ValueError("Load balancer hostname or ip is not available.")
+
+        routing_token = connection_info.routing_token
+        if not routing_token:
+            raise ValueError("Routing token is not available.")
+
+        path = path or ""
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        headers["Authorization"] = f"Bearer {access_token}"
+        headers["X-Sandbox-Routing-Token"] = routing_token
+        headers["X-Sandbox-Port"] = port
+        endpoint = endpoint + path if path.startswith("/") else endpoint + "/" + path
+        http_options = genai_types.HttpOptions(headers=headers, base_url=endpoint)
+        http_client = genai.Client(vertexai=True, http_options=http_options)
+        # Full path is constructed in this function. The passed in path into request
+        # function will not be used.
+        response = http_client._api_client.request(http_method, path, request_dict)
+        return genai_types.HttpResponse(
+            headers=response.headers,
+            body=response.body,
+        )
+
+    def generate_browser_ws_headers(
+        self,
+        sandbox_environment: types.SandboxEnvironment,
+        service_account_email: str,
+        port: str = "8080",
+        timeout: int = 3600,
+    ) -> tuple[str, dict[str, str]]:
+        """Generates the websocket upgrade headers for the browser.
+
+        Args:
+            sandbox_environment (types.SandboxEnvironment):
+                Required. The sandbox environment to generate websocket headers for.
+            service_account_email (str):
+                Required. The email of the service account to use for signing.
+            port (str):
+                Optional. The port to use for the CDP websocket endpoint url fetching.
+                Defaults to "8080". This should be one of the ports specified during template creation.
+            timeout (int):
+                Optional. The timeout in seconds for the token. Defaults to 3600.
+        Returns:
+            tuple[str, dict[str, str]]: A tuple containing the websocket URL and
+            the headers for websocket upgrade.
+        """
+        if not sandbox_environment.connection_info:
+            raise ValueError("Connection info is not available.")
+
+        connection_info = sandbox_environment.connection_info
+        if connection_info.load_balancer_hostname:
+            ws_base_url = "wss://" + connection_info.load_balancer_hostname
+        elif connection_info.load_balancer_ip:
+            ws_base_url = "ws://" + connection_info.load_balancer_ip
+        else:
+            raise ValueError("Load balancer hostname or ip is not available.")
+
+        http_access_token = self.generate_access_token(service_account_email, timeout)
+        response = self.send_command(
+            http_method="GET",
+            access_token=http_access_token,
+            sandbox_environment=sandbox_environment,
+            port=port,
+            path="/cdp_ws_endpoint",
+        )
+        if not response:
+            raise ValueError("Failed to get the websocket endpoint.")
+        body_dict = json.loads(response.body)
+        ws_path = body_dict["endpoint"]
+        ws_url = ws_base_url + "/" + ws_path
+
+        # port 9222 is the default port for the browser websocket endpoint.
+        ws_access_token = self.generate_access_token(service_account_email, timeout)
+
+        routing_token = connection_info.routing_token
+
+        headers = {}
+        headers["Sec-WebSocket-Protocol"] = (
+            f"v1.stream, {ws_access_token}, {routing_token}, 9222"
+        )
+        return ws_url, headers
+
+
+class AsyncSandboxes(_api_module.BaseModule):
+
+    async def _create(
+        self,
+        *,
+        name: str,
+        spec: Optional[types.SandboxEnvironmentSpecOrDict] = None,
+        config: Optional[types.CreateAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.AgentEngineSandboxOperation:
+        """
+        Creates a new sandbox in the Agent Engine.
+        """
+
+        parameter_model = types._CreateAgentEngineSandboxRequestParameters(
+            name=name,
+            spec=spec,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _CreateAgentEngineSandboxRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}/sandboxEnvironments".format_map(request_url_dict)
+            else:
+                path = "{name}/sandboxEnvironments"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "post", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.AgentEngineSandboxOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def _delete(
+        self,
+        *,
+        name: str,
+        config: Optional[types.DeleteAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.DeleteAgentEngineSandboxOperation:
+        """
+        Delete an Agent Engine sandbox.
+
+        Args:
+            name (str):
+                Required. The name of the Agent Engine sandbox to be deleted. Format:
+                `projects/{project}/locations/{location}/reasoningEngines/{resource_id}/sandboxEnvironments/{sandbox}`.
+
+        """
+
+        parameter_model = types._DeleteAgentEngineSandboxRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _DeleteAgentEngineSandboxRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "delete", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.DeleteAgentEngineSandboxOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def _execute_code(
+        self,
+        *,
+        name: str,
+        inputs: Optional[builtins.list[types.ChunkOrDict]] = None,
+        config: Optional[types.ExecuteCodeAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.ExecuteSandboxEnvironmentResponse:
+        """
+        Execute code in an Agent Engine sandbox.
+        """
+
+        parameter_model = types._ExecuteCodeAgentEngineSandboxRequestParameters(
+            name=name,
+            inputs=inputs,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _ExecuteCodeAgentEngineSandboxRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}/:execute".format_map(request_url_dict)
+            else:
+                path = "{name}/:execute"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "post", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.ExecuteSandboxEnvironmentResponse._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def _get(
+        self,
+        *,
+        name: str,
+        config: Optional[types.GetAgentEngineSandboxConfigOrDict] = None,
+    ) -> types.SandboxEnvironment:
+        """
+        Gets an agent engine sandbox.
+
+        Args:
+            name (str): Required. A fully-qualified resource name or ID such as
+              "projects/123/locations/us-central1/reasoningEngines/456/sandboxEnvironments/789"
+              or a shortened name such as "reasoningEngines/456/sandboxEnvironments/789".
+
+        """
+
+        parameter_model = types._GetAgentEngineSandboxRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _GetAgentEngineSandboxRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "get", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.SandboxEnvironment._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def _list(
+        self,
+        *,
+        name: str,
+        config: Optional[types.ListAgentEngineSandboxesConfigOrDict] = None,
+    ) -> types.ListAgentEngineSandboxesResponse:
+        """
+        Lists Agent Engine sandboxes.
+
+        Args:
+            name (str): Required. The name of the Agent Engine to list sessions for. Format:
+                `projects/{project}/locations/{location}/reasoningEngines/{resource_id}`.
+            config (ListAgentEngineSandboxesConfig):
+                Optional. Additional configurations for listing the Agent Engine sandboxes.
+
+        Returns:
+            ListReasoningEnginesSandboxesResponse: The requested Agent Engine sandboxes.
+
+        """
+
+        parameter_model = types._ListAgentEngineSandboxesRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _ListAgentEngineSandboxesRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}/sandboxEnvironments".format_map(request_url_dict)
+            else:
+                path = "{name}/sandboxEnvironments"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "get", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.ListAgentEngineSandboxesResponse._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def _get_sandbox_operation(
+        self,
+        *,
+        operation_name: str,
+        config: Optional[types.GetAgentEngineOperationConfigOrDict] = None,
+    ) -> types.AgentEngineSandboxOperation:
+        parameter_model = types._GetAgentEngineSandboxOperationParameters(
+            operation_name=operation_name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _GetAgentEngineSandboxOperationParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{operationName}".format_map(request_url_dict)
+            else:
+                path = "{operationName}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "get", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.AgentEngineSandboxOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value