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

agentplatform/_genai/sandbox_templates.py

@@ -0,0 +1,1088 @@
+# 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 functools
+import json
+import logging
+from typing import Any, Iterator, Optional, Union
+from urllib.parse import urlencode
+
+from google.genai import _api_module
+from google.genai import _common
+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.sandboxtemplates")
+
+logger.setLevel(logging.INFO)
+
+
+def _CreateSandboxEnvironmentTemplateConfig_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, ["custom_container_environment"]) is not None:
+        setv(
+            parent_object,
+            ["customContainerEnvironment"],
+            getv(from_object, ["custom_container_environment"]),
+        )
+
+    if getv(from_object, ["default_container_environment"]) is not None:
+        setv(
+            parent_object,
+            ["defaultContainerEnvironment"],
+            getv(from_object, ["default_container_environment"]),
+        )
+
+    if getv(from_object, ["egress_control_config"]) is not None:
+        setv(
+            parent_object,
+            ["egressControlConfig"],
+            getv(from_object, ["egress_control_config"]),
+        )
+
+    return to_object
+
+
+def _CreateSandboxEnvironmentTemplateRequestParameters_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:
+        _CreateSandboxEnvironmentTemplateConfig_to_vertex(
+            getv(from_object, ["config"]), to_object
+        )
+
+    if getv(from_object, ["display_name"]) is not None:
+        setv(to_object, ["displayName"], getv(from_object, ["display_name"]))
+
+    return to_object
+
+
+def _DeleteSandboxEnvironmentTemplateRequestParameters_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 _GetSandboxEnvironmentTemplateOperationParameters_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 _GetSandboxEnvironmentTemplateRequestParameters_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 _ListSandboxEnvironmentTemplatesConfig_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 _ListSandboxEnvironmentTemplatesRequestParameters_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:
+        _ListSandboxEnvironmentTemplatesConfig_to_vertex(
+            getv(from_object, ["config"]), to_object
+        )
+
+    return to_object
+
+
+class SandboxTemplates(_api_module.BaseModule):
+    """Sandbox environment templates commands."""
+
+    def _create(
+        self,
+        *,
+        name: str,
+        config: Optional[types.CreateSandboxEnvironmentTemplateConfigOrDict] = None,
+        display_name: str,
+    ) -> types.SandboxEnvironmentTemplateOperation:
+        """
+        Creates a new sandbox template in the Agent Engine.
+
+            Args:
+                name (str):
+                    Required. The name of the agent engine to create the template under.
+                    Format: projects/{project}/locations/{location}/reasoningEngines/{resource_id}
+                display_name (str):
+                    Required. The display name of the sandbox template.
+                config (CreateSandboxEnvironmentTemplateConfig):
+                    Optional. The configuration for the sandbox template.
+
+        """
+
+        parameter_model = types._CreateSandboxEnvironmentTemplateRequestParameters(
+            name=name,
+            config=config,
+            display_name=display_name,
+        )
+
+        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 = _CreateSandboxEnvironmentTemplateRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}/sandboxEnvironmentTemplates".format_map(request_url_dict)
+            else:
+                path = "{name}/sandboxEnvironmentTemplates"
+
+        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.SandboxEnvironmentTemplateOperation._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.DeleteSandboxEnvironmentTemplateConfigOrDict] = None,
+    ) -> types.DeleteSandboxEnvironmentTemplateOperation:
+        """
+        Delete an Agent Engine sandbox template.
+
+            Args:
+                name (str):
+                    Required. The name of the sandbox template to delete.
+                    Format: projects/{project}/locations/{location}/reasoningEngines/{resource_id}/sandboxTemplates/{sandbox_template}
+                config (DeleteSandboxEnvironmentTemplateConfig):
+                    Optional. Configuration for the delete operation.
+
+        """
+
+        parameter_model = types._DeleteSandboxEnvironmentTemplateRequestParameters(
+            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 = _DeleteSandboxEnvironmentTemplateRequestParameters_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.DeleteSandboxEnvironmentTemplateOperation._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.GetSandboxEnvironmentTemplateConfigOrDict] = None,
+    ) -> types.SandboxEnvironmentTemplate:
+        """
+        Gets an agent engine sandbox template.
+
+        Args:
+            name (str): The resource name of the SandboxEnvironmentTemplate.
+                Format:
+                `projects/{project}/locations/{location}/reasoningEngines/{resource_id}/sandboxEnvironmentTemplates/{sandbox_environment_template}`
+            config (GetSandboxEnvironmentTemplateConfig): Configuration for the
+                request.
+
+        Returns:
+            shared.SandboxEnvironmentTemplate: The retrieved sandbox environment
+                template.
+
+        """
+
+        parameter_model = types._GetSandboxEnvironmentTemplateRequestParameters(
+            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 = _GetSandboxEnvironmentTemplateRequestParameters_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.SandboxEnvironmentTemplate._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.ListSandboxEnvironmentTemplatesConfigOrDict] = None,
+    ) -> types.ListSandboxEnvironmentTemplatesResponse:
+        """
+        Lists Agent Engine sandbox templates.
+
+            Args:
+                name (str): Name of the agent engine. Format: projects/{project}/locations/{location}/reasoningEngines/{resource_id}
+                config (ListSandboxEnvironmentTemplatesConfig): Configuration for listing sandbox templates.
+
+            Returns:
+                ListSandboxEnvironmentTemplatesResponse: A list of sandbox templates.
+
+        """
+
+        parameter_model = types._ListSandboxEnvironmentTemplatesRequestParameters(
+            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 = _ListSandboxEnvironmentTemplatesRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}/sandboxEnvironmentTemplates".format_map(request_url_dict)
+            else:
+                path = "{name}/sandboxEnvironmentTemplates"
+
+        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.ListSandboxEnvironmentTemplatesResponse._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_environment_template_operation(
+        self,
+        *,
+        operation_name: str,
+        config: Optional[types.GetAgentEngineOperationConfigOrDict] = None,
+    ) -> types.SandboxEnvironmentTemplateOperation:
+        parameter_model = types._GetSandboxEnvironmentTemplateOperationParameters(
+            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 = _GetSandboxEnvironmentTemplateOperationParameters_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.SandboxEnvironmentTemplateOperation._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 create(
+        self,
+        *,
+        name: str,
+        display_name: str,
+        config: Optional[types.CreateSandboxEnvironmentTemplateConfigOrDict] = None,
+        poll_interval_seconds: float = 0.1,
+    ) -> types.SandboxEnvironmentTemplateOperation:
+        """Creates a new sandbox template in the Agent Engine.
+
+        Args:
+            name (str):
+                Required. The name of the agent engine to create sandbox template for.
+                projects/{project}/locations/{location}/reasoningEngines/{resource_id}
+            display_name (str):
+                Required. The display name of the sandbox template.
+            config (CreateSandboxEnvironmentTemplateConfig):
+                Optional. The configuration for the sandbox template.
+            polling_interval (int):
+                Optional. Seconds to wait between polling for operation status. Defaults to 5.
+
+        Returns:
+            SandboxEnvironmentTemplateOperation: The operation for creating the sandbox template.
+        """
+        operation = self._create(
+            name=name,
+            display_name=display_name,
+            config=config,
+        )
+        if config is None:
+            config = types.CreateSandboxEnvironmentTemplateConfig()
+        elif isinstance(config, dict):
+            config = types.CreateSandboxEnvironmentTemplateConfig.model_validate(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_environment_template_operation,
+                    poll_interval_seconds=poll_interval_seconds,
+                )
+            # We need to make a call to get the sandbox template because the operation
+            # response might not contain the relevant fields.
+            if not operation.response:
+                raise ValueError("Error retrieving sandbox template.")
+            operation.response = self.get(name=operation.response.name)
+        return operation
+
+    def list(
+        self,
+        *,
+        name: str,
+        config: Optional[types.ListSandboxEnvironmentTemplatesConfigOrDict] = None,
+    ) -> Iterator[types.SandboxEnvironmentTemplate]:
+        """Lists Agent Engine sandbox templates.
+
+        Args:
+            name (str):
+                Required. The name of the agent engine to list sandbox templates for.
+                projects/{project}/locations/{location}/reasoningEngines/{resource_id}
+            config (ListSandboxEnvironmentTemplatesConfig):
+                Optional. The configuration for the sandbox templates to list.
+
+        Returns:
+            Iterable[SandboxEnvironmentTemplate]: An iterable of agent engine sandbox templates.
+        """
+        return Pager(
+            "sandbox_environment_templates",
+            functools.partial(self._list, name=name),
+            self._list(name=name, config=config),
+            config,
+        )
+
+    def get(
+        self,
+        *,
+        name: str,
+        config: Optional[types.GetSandboxEnvironmentTemplateConfigOrDict] = None,
+    ) -> types.SandboxEnvironmentTemplate:
+        """Gets a sandbox template in the Agent Engine.
+        Args:
+          name (str):
+              Required. A fully-qualified resource name or ID such as
+              projects/{project}/locations/{location}/reasoningEngines/{resource_id}/sandboxEnvironmentTemplates/{sandbox_template_id}
+              or a shortened name such as "reasoningEngines/{resource_id}/sandboxEnvironmentTemplates/{sandbox_template_id}".
+          config (GetSandboxEnvironmentTemplateConfigOrDict):
+              Optional. The configuration for the sandbox template to get.
+        """
+        return self._get(name=name, config=config)
+
+    def delete(
+        self,
+        *,
+        name: str,
+        config: Optional[types.DeleteSandboxEnvironmentTemplateConfigOrDict] = None,
+    ) -> types.DeleteSandboxEnvironmentTemplateOperation:
+        """Deletes a sandbox template in the Agent Engine.
+        Args:
+            name (str):
+                Required. The name of the sandbox template to delete.
+                Format: projects/{project}/locations/{location}/reasoningEngines/{resource_id}/sandboxEnvironmentTemplates/{sandbox_template_id}
+            config (DeleteSandboxEnvironmentTemplateConfig):
+                Optional. Configuration for the delete operation.
+        """
+        return self._delete(name=name, config=config)
+
+
+class AsyncSandboxTemplates(_api_module.BaseModule):
+    """Sandbox environment templates commands."""
+
+    async def _create(
+        self,
+        *,
+        name: str,
+        config: Optional[types.CreateSandboxEnvironmentTemplateConfigOrDict] = None,
+        display_name: str,
+    ) -> types.SandboxEnvironmentTemplateOperation:
+        """
+        Creates a new sandbox template in the Agent Engine.
+
+            Args:
+                name (str):
+                    Required. The name of the agent engine to create the template under.
+                    Format: projects/{project}/locations/{location}/reasoningEngines/{resource_id}
+                display_name (str):
+                    Required. The display name of the sandbox template.
+                config (CreateSandboxEnvironmentTemplateConfig):
+                    Optional. The configuration for the sandbox template.
+
+        """
+
+        parameter_model = types._CreateSandboxEnvironmentTemplateRequestParameters(
+            name=name,
+            config=config,
+            display_name=display_name,
+        )
+
+        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 = _CreateSandboxEnvironmentTemplateRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}/sandboxEnvironmentTemplates".format_map(request_url_dict)
+            else:
+                path = "{name}/sandboxEnvironmentTemplates"
+
+        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.SandboxEnvironmentTemplateOperation._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.DeleteSandboxEnvironmentTemplateConfigOrDict] = None,
+    ) -> types.DeleteSandboxEnvironmentTemplateOperation:
+        """
+        Delete an Agent Engine sandbox template.
+
+            Args:
+                name (str):
+                    Required. The name of the sandbox template to delete.
+                    Format: projects/{project}/locations/{location}/reasoningEngines/{resource_id}/sandboxTemplates/{sandbox_template}
+                config (DeleteSandboxEnvironmentTemplateConfig):
+                    Optional. Configuration for the delete operation.
+
+        """
+
+        parameter_model = types._DeleteSandboxEnvironmentTemplateRequestParameters(
+            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 = _DeleteSandboxEnvironmentTemplateRequestParameters_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.DeleteSandboxEnvironmentTemplateOperation._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.GetSandboxEnvironmentTemplateConfigOrDict] = None,
+    ) -> types.SandboxEnvironmentTemplate:
+        """
+        Gets an agent engine sandbox template.
+
+        Args:
+            name (str): The resource name of the SandboxEnvironmentTemplate.
+                Format:
+                `projects/{project}/locations/{location}/reasoningEngines/{resource_id}/sandboxEnvironmentTemplates/{sandbox_environment_template}`
+            config (GetSandboxEnvironmentTemplateConfig): Configuration for the
+                request.
+
+        Returns:
+            shared.SandboxEnvironmentTemplate: The retrieved sandbox environment
+                template.
+
+        """
+
+        parameter_model = types._GetSandboxEnvironmentTemplateRequestParameters(
+            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 = _GetSandboxEnvironmentTemplateRequestParameters_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.SandboxEnvironmentTemplate._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.ListSandboxEnvironmentTemplatesConfigOrDict] = None,
+    ) -> types.ListSandboxEnvironmentTemplatesResponse:
+        """
+        Lists Agent Engine sandbox templates.
+
+            Args:
+                name (str): Name of the agent engine. Format: projects/{project}/locations/{location}/reasoningEngines/{resource_id}
+                config (ListSandboxEnvironmentTemplatesConfig): Configuration for listing sandbox templates.
+
+            Returns:
+                ListSandboxEnvironmentTemplatesResponse: A list of sandbox templates.
+
+        """
+
+        parameter_model = types._ListSandboxEnvironmentTemplatesRequestParameters(
+            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 = _ListSandboxEnvironmentTemplatesRequestParameters_to_vertex(
+                parameter_model
+            )
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}/sandboxEnvironmentTemplates".format_map(request_url_dict)
+            else:
+                path = "{name}/sandboxEnvironmentTemplates"
+
+        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.ListSandboxEnvironmentTemplatesResponse._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_environment_template_operation(
+        self,
+        *,
+        operation_name: str,
+        config: Optional[types.GetAgentEngineOperationConfigOrDict] = None,
+    ) -> types.SandboxEnvironmentTemplateOperation:
+        parameter_model = types._GetSandboxEnvironmentTemplateOperationParameters(
+            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 = _GetSandboxEnvironmentTemplateOperationParameters_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.SandboxEnvironmentTemplateOperation._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