diff --git a/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_byoc_create.py b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_byoc_create.py new file mode 100644 index 0000000000..c97fba594f --- /dev/null +++ b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_byoc_create.py @@ -0,0 +1,70 @@ +# Copyright 2026 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. +# +# pylint: disable=protected-access,bad-continuation,missing-function-docstring + +from tests.unit.vertexai.genai.replays import pytest_helper +from vertexai._genai import types + + +def test_sandbox_templates_byoc_create(client): + container_image_uri = "us-central1-docker.pkg.dev/agent-sandbox-fishfood-1564/agent-sandbox/custom-jupiter-sandbox:latest" + cpu_request = "1" + memory_request = "500Mi" + cpu_limit = "1" + memory_limit = "500Mi" + config = { + "custom_container_environment": { + "custom_container_spec": { + "image_uri": container_image_uri + }, + "resources": { + "requests": { + "cpu": cpu_request, + "memory": memory_request, + }, + "limits": { + "cpu": cpu_limit, + "memory": memory_limit, + } + }, + "ports": [ + { + "port": 8080, + "protocol": "TCP", + } + ] + }, + "egress_control_config": { + "internet_access": True, + }, + } + sandbox_template_operation = client.agent_engines.sandboxes.templates.create( + name=( + "projects/254005681254/locations/us-central1/reasoningEngines/208148546254274560" + ), + display_name="Test Sandbox Template 1", + config=config, + ) + assert isinstance( + sandbox_template_operation, + types.SandboxEnvironmentTemplateOperation + ) + + +pytestmark = pytest_helper.setup( + file=__file__, + globals_for_file=globals(), + test_method="agent_engines.sandboxes.templates.create", +) diff --git a/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_default_create.py b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_default_create.py new file mode 100644 index 0000000000..87cd02931a --- /dev/null +++ b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_default_create.py @@ -0,0 +1,47 @@ +# Copyright 2026 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. +# +# pylint: disable=protected-access,bad-continuation,missing-function-docstring + +from tests.unit.vertexai.genai.replays import pytest_helper +from vertexai._genai import types + + +def test_sandbox_templates_default_create(client): + config = { + "default_container_environment": { + "default_container_category": "DEFAULT_CONTAINER_CATEGORY_COMPUTER_USE", + }, + "egress_control_config": { + "internet_access": True, + }, + } + sandbox_template_operation = client.agent_engines.sandboxes.templates.create( + name=( + "projects/254005681254/locations/us-central1/reasoningEngines/208148546254274560" + ), + display_name="Test Sandbox Template 1", + config=config, + ) + assert isinstance( + sandbox_template_operation, + types.SandboxEnvironmentTemplateOperation + ) + + +pytestmark = pytest_helper.setup( + file=__file__, + globals_for_file=globals(), + test_method="agent_engines.sandboxes.templates.create", +) diff --git a/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_delete.py b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_delete.py new file mode 100644 index 0000000000..7f053fd3da --- /dev/null +++ b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_delete.py @@ -0,0 +1,37 @@ +# Copyright 2026 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. +# +# pylint: disable=protected-access,bad-continuation,missing-function-docstring + +from tests.unit.vertexai.genai.replays import pytest_helper +from vertexai._genai import types + + +def test_sandbox_templates_delete(client): + sandbox_template_delete_operation = client.agent_engines.sandboxes.templates.delete( + name=( + "projects/254005681254/locations/us-central1/reasoningEngines/208148546254274560/sandboxEnvironmentTemplates/4632233691727265792" + ), + ) + assert isinstance( + sandbox_template_delete_operation, + types.DeleteSandboxEnvironmentTemplateOperation + ) + + +pytestmark = pytest_helper.setup( + file=__file__, + globals_for_file=globals(), + test_method="agent_engines.sandboxes.templates.delete", +) diff --git a/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_get.py b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_get.py new file mode 100644 index 0000000000..9ad684a323 --- /dev/null +++ b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_get.py @@ -0,0 +1,37 @@ +# Copyright 2026 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. +# +# pylint: disable=protected-access,bad-continuation,missing-function-docstring + +from tests.unit.vertexai.genai.replays import pytest_helper +from vertexai._genai import types + + +def test_sandbox_templates_get(client): + sandbox_template_name = ( + "projects/254005681254/locations/us-central1/reasoningEngines/208148546254274560/sandboxEnvironmentTemplates/4632233691727265792" + ) + + sandbox_template = client.agent_engines.sandboxes.templates.get( + name=sandbox_template_name + ) + assert isinstance(sandbox_template, types.SandboxEnvironmentTemplate) + assert sandbox_template.name == sandbox_template_name + + +pytestmark = pytest_helper.setup( + file=__file__, + globals_for_file=globals(), + test_method="agent_engines.sandboxes.templates.get", +) diff --git a/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_get_sandbox_template_operation.py b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_get_sandbox_template_operation.py new file mode 100644 index 0000000000..34c1c6e229 --- /dev/null +++ b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_get_sandbox_template_operation.py @@ -0,0 +1,41 @@ +# Copyright 2026 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. +# +# pylint: disable=protected-access,bad-continuation,missing-function-docstring + +from tests.unit.vertexai.genai.replays import pytest_helper +from vertexai._genai import types + + +def test_get_sandbox_template_operation(client): + operation_name = ( + "projects/254005681254/locations/us-central1/operations/7252775414349692928" + ) + + sandbox_template_operation = ( + client.agent_engines.sandboxes.templates.get_sandbox_environment_template_operation( + operation_name=operation_name + ) + ) + assert isinstance( + sandbox_template_operation, types.SandboxEnvironmentTemplateOperation) + assert sandbox_template_operation.name == operation_name + + +pytestmark = pytest_helper.setup( + file=__file__, + globals_for_file=globals(), + test_method= + "agent_engines.sandboxes.templates.get_sandbox_environment_template_operation", +) diff --git a/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_list.py b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_list.py new file mode 100644 index 0000000000..50990c2f05 --- /dev/null +++ b/tests/unit/vertexai/genai/replays/test_ae_sandbox_templates_list.py @@ -0,0 +1,40 @@ +# Copyright 2026 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. +# +# pylint: disable=protected-access,bad-continuation,missing-function-docstring + +from tests.unit.vertexai.genai.replays import pytest_helper +from vertexai._genai import types + + +def test_sandbox_templates_list(client): + sandbox_templates_list_operation = client.agent_engines.sandboxes.templates.list( + name=( + "projects/254005681254/locations/us-central1/reasoningEngines/208148546254274560" + ), + ) + assert isinstance( + sandbox_templates_list_operation.sandbox_environment_templates[0], + types.SandboxEnvironmentTemplate, + ) + assert isinstance( + sandbox_templates_list_operation, types.ListSandboxEnvironmentTemplatesResponse + ) + + +pytestmark = pytest_helper.setup( + file=__file__, + globals_for_file=globals(), + test_method="agent_engines.sandboxes.templates.list", +) diff --git a/vertexai/_genai/sandbox_templates.py b/vertexai/_genai/sandbox_templates.py new file mode 100644 index 0000000000..fe4af62fa9 --- /dev/null +++ b/vertexai/_genai/sandbox_templates.py @@ -0,0 +1,902 @@ +# 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 json +import logging +from typing import Any, 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 . import types + +logger = logging.getLogger("vertexai_genai.sandboxtemplates") + + +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(parent_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. + """ + + 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 the Gemini Enterprise Agent Platform (previously known as Vertex AI) client." + ) + 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. + """ + + 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 the Gemini Enterprise Agent Platform (previously known as Vertex AI) client." + ) + 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. + """ + + 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 the Gemini Enterprise Agent Platform (previously known as Vertex AI) client." + ) + 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. + """ + + 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 the Gemini Enterprise Agent Platform (previously known as Vertex AI) client." + ) + 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 the Gemini Enterprise Agent Platform (previously known as Vertex AI) client." + ) + 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 + + +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. + """ + + 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 the Gemini Enterprise Agent Platform (previously known as Vertex AI) client." + ) + 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. + """ + + 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 the Gemini Enterprise Agent Platform (previously known as Vertex AI) client." + ) + 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. + """ + + 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 the Gemini Enterprise Agent Platform (previously known as Vertex AI) client." + ) + 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. + """ + + 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 the Gemini Enterprise Agent Platform (previously known as Vertex AI) client." + ) + 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 the Gemini Enterprise Agent Platform (previously known as Vertex AI) client." + ) + 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 diff --git a/vertexai/_genai/sandboxes.py b/vertexai/_genai/sandboxes.py index 565e1d80d8..ea5e1427ac 100644 --- a/vertexai/_genai/sandboxes.py +++ b/vertexai/_genai/sandboxes.py @@ -629,6 +629,23 @@ def _get_sandbox_operation( self._api_client._verify_response(return_value) return return_value + _templates = 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.sandbox_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) # type: ignore[attr-defined, no-any-return] + def create( self, *, diff --git a/vertexai/_genai/types/__init__.py b/vertexai/_genai/types/__init__.py index d278f1cce3..1ce1cfeb62 100644 --- a/vertexai/_genai/types/__init__.py +++ b/vertexai/_genai/types/__init__.py @@ -40,6 +40,7 @@ from .common import _CreateEvaluationRunParameters from .common import _CreateEvaluationSetParameters from .common import _CreateMultimodalDatasetParameters +from .common import _CreateSandboxEnvironmentTemplateRequestParameters from .common import _CustomJobParameters from .common import _CustomJobParameters from .common import _DeleteAgentEngineMemoryRequestParameters @@ -51,6 +52,7 @@ from .common import _DeleteEvaluationMetricParameters from .common import _DeleteMultimodalDatasetRequestParameters from .common import _DeletePromptVersionRequestParameters +from .common import _DeleteSandboxEnvironmentTemplateRequestParameters from .common import _EvaluateInstancesRequestParameters from .common import _ExecuteCodeAgentEngineSandboxRequestParameters from .common import _GenerateAgentEngineMemoriesRequestParameters @@ -79,6 +81,8 @@ from .common import _GetEvaluationSetParameters from .common import _GetMultimodalDatasetOperationParameters from .common import _GetMultimodalDatasetParameters +from .common import _GetSandboxEnvironmentTemplateOperationParameters +from .common import _GetSandboxEnvironmentTemplateRequestParameters from .common import _IngestEventsRequestParameters from .common import _ListAgentEngineMemoryRequestParameters from .common import _ListAgentEngineMemoryRevisionsRequestParameters @@ -92,6 +96,7 @@ from .common import _ListDatasetVersionsRequestParameters from .common import _ListEvaluationMetricsParameters from .common import _ListMultimodalDatasetsRequestParameters +from .common import _ListSandboxEnvironmentTemplatesRequestParameters from .common import _OptimizeRequestParameters from .common import _OptimizeRequestParameters from .common import _PurgeAgentEngineMemoriesRequestParameters @@ -271,6 +276,9 @@ from .common import CreatePromptVersionConfig from .common import CreatePromptVersionConfigDict from .common import CreatePromptVersionConfigOrDict +from .common import CreateSandboxEnvironmentTemplateConfig +from .common import CreateSandboxEnvironmentTemplateConfigDict +from .common import CreateSandboxEnvironmentTemplateConfigOrDict from .common import CustomCodeExecutionSpec from .common import CustomCodeExecutionSpecDict from .common import CustomCodeExecutionSpecOrDict @@ -289,6 +297,7 @@ from .common import DatasetVersion from .common import DatasetVersionDict from .common import DatasetVersionOrDict +from .common import DefaultContainerCategory from .common import DeleteAgentEngineConfig from .common import DeleteAgentEngineConfigDict from .common import DeleteAgentEngineConfigOrDict @@ -331,6 +340,12 @@ from .common import DeletePromptVersionOperation from .common import DeletePromptVersionOperationDict from .common import DeletePromptVersionOperationOrDict +from .common import DeleteSandboxEnvironmentTemplateConfig +from .common import DeleteSandboxEnvironmentTemplateConfigDict +from .common import DeleteSandboxEnvironmentTemplateConfigOrDict +from .common import DeleteSandboxEnvironmentTemplateOperation +from .common import DeleteSandboxEnvironmentTemplateOperationDict +from .common import DeleteSandboxEnvironmentTemplateOperationOrDict from .common import DiskSpec from .common import DiskSpecDict from .common import DiskSpecOrDict @@ -550,6 +565,9 @@ from .common import GetPromptConfig from .common import GetPromptConfigDict from .common import GetPromptConfigOrDict +from .common import GetSandboxEnvironmentTemplateConfig +from .common import GetSandboxEnvironmentTemplateConfigDict +from .common import GetSandboxEnvironmentTemplateConfigOrDict from .common import IdentityType from .common import Importance from .common import IngestEventsConfig @@ -641,6 +659,12 @@ from .common import ListReasoningEnginesSessionsResponse from .common import ListReasoningEnginesSessionsResponseDict from .common import ListReasoningEnginesSessionsResponseOrDict +from .common import ListSandboxEnvironmentTemplatesConfig +from .common import ListSandboxEnvironmentTemplatesConfigDict +from .common import ListSandboxEnvironmentTemplatesConfigOrDict +from .common import ListSandboxEnvironmentTemplatesResponse +from .common import ListSandboxEnvironmentTemplatesResponseDict +from .common import ListSandboxEnvironmentTemplatesResponseOrDict from .common import LLMMetric from .common import LossAnalysisConfig from .common import LossAnalysisConfigDict @@ -826,6 +850,7 @@ from .common import PromptVersionRef from .common import PromptVersionRefDict from .common import PromptVersionRefOrDict +from .common import Protocol from .common import PscInterfaceConfig from .common import PscInterfaceConfigDict from .common import PscInterfaceConfigOrDict @@ -1042,6 +1067,33 @@ from .common import SandboxEnvironmentSpecComputerUseEnvironmentOrDict from .common import SandboxEnvironmentSpecDict from .common import SandboxEnvironmentSpecOrDict +from .common import SandboxEnvironmentTemplate +from .common import SandboxEnvironmentTemplateCustomContainerEnvironment +from .common import SandboxEnvironmentTemplateCustomContainerEnvironmentDict +from .common import SandboxEnvironmentTemplateCustomContainerEnvironmentOrDict +from .common import SandboxEnvironmentTemplateCustomContainerSpec +from .common import SandboxEnvironmentTemplateCustomContainerSpecDict +from .common import SandboxEnvironmentTemplateCustomContainerSpecOrDict +from .common import SandboxEnvironmentTemplateDefaultContainerEnvironment +from .common import SandboxEnvironmentTemplateDefaultContainerEnvironmentDict +from .common import SandboxEnvironmentTemplateDefaultContainerEnvironmentOrDict +from .common import SandboxEnvironmentTemplateDict +from .common import SandboxEnvironmentTemplateEgressControlConfig +from .common import SandboxEnvironmentTemplateEgressControlConfigDict +from .common import SandboxEnvironmentTemplateEgressControlConfigOrDict +from .common import SandboxEnvironmentTemplateNetworkPort +from .common import SandboxEnvironmentTemplateNetworkPortDict +from .common import SandboxEnvironmentTemplateNetworkPortOrDict +from .common import SandboxEnvironmentTemplateOperation +from .common import SandboxEnvironmentTemplateOperationDict +from .common import SandboxEnvironmentTemplateOperationOrDict +from .common import SandboxEnvironmentTemplateOrDict +from .common import SandboxEnvironmentTemplateResourceRequirements +from .common import SandboxEnvironmentTemplateResourceRequirementsDict +from .common import SandboxEnvironmentTemplateResourceRequirementsOrDict +from .common import SandboxEnvironmentTemplateWarmPoolConfig +from .common import SandboxEnvironmentTemplateWarmPoolConfigDict +from .common import SandboxEnvironmentTemplateWarmPoolConfigOrDict from .common import SavedQuery from .common import SavedQueryDict from .common import SavedQueryOrDict @@ -2064,6 +2116,51 @@ "ListAgentEngineSandboxesResponse", "ListAgentEngineSandboxesResponseDict", "ListAgentEngineSandboxesResponseOrDict", + "SandboxEnvironmentTemplateCustomContainerSpec", + "SandboxEnvironmentTemplateCustomContainerSpecDict", + "SandboxEnvironmentTemplateCustomContainerSpecOrDict", + "SandboxEnvironmentTemplateNetworkPort", + "SandboxEnvironmentTemplateNetworkPortDict", + "SandboxEnvironmentTemplateNetworkPortOrDict", + "SandboxEnvironmentTemplateResourceRequirements", + "SandboxEnvironmentTemplateResourceRequirementsDict", + "SandboxEnvironmentTemplateResourceRequirementsOrDict", + "SandboxEnvironmentTemplateCustomContainerEnvironment", + "SandboxEnvironmentTemplateCustomContainerEnvironmentDict", + "SandboxEnvironmentTemplateCustomContainerEnvironmentOrDict", + "SandboxEnvironmentTemplateDefaultContainerEnvironment", + "SandboxEnvironmentTemplateDefaultContainerEnvironmentDict", + "SandboxEnvironmentTemplateDefaultContainerEnvironmentOrDict", + "SandboxEnvironmentTemplateEgressControlConfig", + "SandboxEnvironmentTemplateEgressControlConfigDict", + "SandboxEnvironmentTemplateEgressControlConfigOrDict", + "CreateSandboxEnvironmentTemplateConfig", + "CreateSandboxEnvironmentTemplateConfigDict", + "CreateSandboxEnvironmentTemplateConfigOrDict", + "SandboxEnvironmentTemplateWarmPoolConfig", + "SandboxEnvironmentTemplateWarmPoolConfigDict", + "SandboxEnvironmentTemplateWarmPoolConfigOrDict", + "SandboxEnvironmentTemplate", + "SandboxEnvironmentTemplateDict", + "SandboxEnvironmentTemplateOrDict", + "SandboxEnvironmentTemplateOperation", + "SandboxEnvironmentTemplateOperationDict", + "SandboxEnvironmentTemplateOperationOrDict", + "DeleteSandboxEnvironmentTemplateConfig", + "DeleteSandboxEnvironmentTemplateConfigDict", + "DeleteSandboxEnvironmentTemplateConfigOrDict", + "DeleteSandboxEnvironmentTemplateOperation", + "DeleteSandboxEnvironmentTemplateOperationDict", + "DeleteSandboxEnvironmentTemplateOperationOrDict", + "GetSandboxEnvironmentTemplateConfig", + "GetSandboxEnvironmentTemplateConfigDict", + "GetSandboxEnvironmentTemplateConfigOrDict", + "ListSandboxEnvironmentTemplatesConfig", + "ListSandboxEnvironmentTemplatesConfigDict", + "ListSandboxEnvironmentTemplatesConfigOrDict", + "ListSandboxEnvironmentTemplatesResponse", + "ListSandboxEnvironmentTemplatesResponseDict", + "ListSandboxEnvironmentTemplatesResponseOrDict", "CreateAgentEngineSessionConfig", "CreateAgentEngineSessionConfigDict", "CreateAgentEngineSessionConfigOrDict", @@ -2371,6 +2468,8 @@ "Operator", "Language", "MachineConfig", + "Protocol", + "DefaultContainerCategory", "Framework", "EvaluationItemType", "SamplingMethod", @@ -2456,6 +2555,11 @@ "_GetAgentEngineSandboxRequestParameters", "_ListAgentEngineSandboxesRequestParameters", "_GetAgentEngineSandboxOperationParameters", + "_CreateSandboxEnvironmentTemplateRequestParameters", + "_DeleteSandboxEnvironmentTemplateRequestParameters", + "_GetSandboxEnvironmentTemplateRequestParameters", + "_ListSandboxEnvironmentTemplatesRequestParameters", + "_GetSandboxEnvironmentTemplateOperationParameters", "_CreateAgentEngineSessionRequestParameters", "_DeleteAgentEngineSessionRequestParameters", "_GetAgentEngineSessionRequestParameters", diff --git a/vertexai/_genai/types/common.py b/vertexai/_genai/types/common.py index 13118e782c..b2b26b8573 100644 --- a/vertexai/_genai/types/common.py +++ b/vertexai/_genai/types/common.py @@ -324,6 +324,26 @@ class MachineConfig(_common.CaseInSensitiveEnum): """The default value: milligcu 4000, memory 4 Gib""" +class Protocol(_common.CaseInSensitiveEnum): + """Protocol for port. Defaults to TCP if not specified.""" + + PROTOCOL_UNSPECIFIED = "PROTOCOL_UNSPECIFIED" + """Unspecified protocol. Defaults to TCP.""" + TCP = "TCP" + """TCP protocol.""" + UDP = "UDP" + """UDP protocol.""" + + +class DefaultContainerCategory(_common.CaseInSensitiveEnum): + """The category of the default container image.""" + + DEFAULT_CONTAINER_CATEGORY_UNSPECIFIED = "DEFAULT_CONTAINER_CATEGORY_UNSPECIFIED" + """The default value. This value is unused.""" + DEFAULT_CONTAINER_CATEGORY_COMPUTER_USE = "DEFAULT_CONTAINER_CATEGORY_COMPUTER_USE" + """The default container image for Computer Use.""" + + class Framework(_common.CaseInSensitiveEnum): """Framework used to build the application.""" @@ -12354,6 +12374,687 @@ class _GetAgentEngineSandboxOperationParametersDict(TypedDict, total=False): ] +class SandboxEnvironmentTemplateCustomContainerSpec(_common.BaseModel): + """Specification for deploying from a custom container image.""" + + image_uri: Optional[str] = Field( + default=None, + description="""Required. The Artifact Registry Docker image URI (e.g., us-central1-docker.pkg.dev/my-project/my-repo/my-image:tag) of the container image that is to be run on each worker replica.""", + ) + + +class SandboxEnvironmentTemplateCustomContainerSpecDict(TypedDict, total=False): + """Specification for deploying from a custom container image.""" + + image_uri: Optional[str] + """Required. The Artifact Registry Docker image URI (e.g., us-central1-docker.pkg.dev/my-project/my-repo/my-image:tag) of the container image that is to be run on each worker replica.""" + + +SandboxEnvironmentTemplateCustomContainerSpecOrDict = Union[ + SandboxEnvironmentTemplateCustomContainerSpec, + SandboxEnvironmentTemplateCustomContainerSpecDict, +] + + +class SandboxEnvironmentTemplateNetworkPort(_common.BaseModel): + """Represents a network port in a container.""" + + port: Optional[int] = Field( + default=None, + description="""Optional. Port number to expose. This must be a valid port number, between 1 and 65535.""", + ) + protocol: Optional[Protocol] = Field( + default=None, + description="""Optional. Protocol for port. Defaults to TCP if not specified.""", + ) + + +class SandboxEnvironmentTemplateNetworkPortDict(TypedDict, total=False): + """Represents a network port in a container.""" + + port: Optional[int] + """Optional. Port number to expose. This must be a valid port number, between 1 and 65535.""" + + protocol: Optional[Protocol] + """Optional. Protocol for port. Defaults to TCP if not specified.""" + + +SandboxEnvironmentTemplateNetworkPortOrDict = Union[ + SandboxEnvironmentTemplateNetworkPort, SandboxEnvironmentTemplateNetworkPortDict +] + + +class SandboxEnvironmentTemplateResourceRequirements(_common.BaseModel): + """Message to define resource requests and limits (mirroring Kubernetes) for each sandbox instance created from this template.""" + + limits: Optional[dict[str, str]] = Field( + default=None, + description="""Optional. The maximum amounts of compute resources allowed. Keys are resource names (e.g., "cpu", "memory"). Values are quantities (e.g., "500m", "1Gi").""", + ) + requests: Optional[dict[str, str]] = Field( + default=None, + description="""Optional. The requested amounts of compute resources. Keys are resource names (e.g., "cpu", "memory"). Values are quantities (e.g., "250m", "512Mi").""", + ) + + +class SandboxEnvironmentTemplateResourceRequirementsDict(TypedDict, total=False): + """Message to define resource requests and limits (mirroring Kubernetes) for each sandbox instance created from this template.""" + + limits: Optional[dict[str, str]] + """Optional. The maximum amounts of compute resources allowed. Keys are resource names (e.g., "cpu", "memory"). Values are quantities (e.g., "500m", "1Gi").""" + + requests: Optional[dict[str, str]] + """Optional. The requested amounts of compute resources. Keys are resource names (e.g., "cpu", "memory"). Values are quantities (e.g., "250m", "512Mi").""" + + +SandboxEnvironmentTemplateResourceRequirementsOrDict = Union[ + SandboxEnvironmentTemplateResourceRequirements, + SandboxEnvironmentTemplateResourceRequirementsDict, +] + + +class SandboxEnvironmentTemplateCustomContainerEnvironment(_common.BaseModel): + """The customized sandbox runtime environment for BYOC.""" + + custom_container_spec: Optional[SandboxEnvironmentTemplateCustomContainerSpec] = ( + Field( + default=None, + description="""The specification of the custom container environment.""", + ) + ) + ports: Optional[list[SandboxEnvironmentTemplateNetworkPort]] = Field( + default=None, description="""Ports to expose from the container.""" + ) + resources: Optional[SandboxEnvironmentTemplateResourceRequirements] = Field( + default=None, description="""Resource requests and limits for the container.""" + ) + + +class SandboxEnvironmentTemplateCustomContainerEnvironmentDict(TypedDict, total=False): + """The customized sandbox runtime environment for BYOC.""" + + custom_container_spec: Optional[SandboxEnvironmentTemplateCustomContainerSpecDict] + """The specification of the custom container environment.""" + + ports: Optional[list[SandboxEnvironmentTemplateNetworkPortDict]] + """Ports to expose from the container.""" + + resources: Optional[SandboxEnvironmentTemplateResourceRequirementsDict] + """Resource requests and limits for the container.""" + + +SandboxEnvironmentTemplateCustomContainerEnvironmentOrDict = Union[ + SandboxEnvironmentTemplateCustomContainerEnvironment, + SandboxEnvironmentTemplateCustomContainerEnvironmentDict, +] + + +class SandboxEnvironmentTemplateDefaultContainerEnvironment(_common.BaseModel): + """The default sandbox runtime environment for default container workloads.""" + + default_container_category: Optional[DefaultContainerCategory] = Field( + default=None, + description="""Required. The category of the default container image.""", + ) + + +class SandboxEnvironmentTemplateDefaultContainerEnvironmentDict(TypedDict, total=False): + """The default sandbox runtime environment for default container workloads.""" + + default_container_category: Optional[DefaultContainerCategory] + """Required. The category of the default container image.""" + + +SandboxEnvironmentTemplateDefaultContainerEnvironmentOrDict = Union[ + SandboxEnvironmentTemplateDefaultContainerEnvironment, + SandboxEnvironmentTemplateDefaultContainerEnvironmentDict, +] + + +class SandboxEnvironmentTemplateEgressControlConfig(_common.BaseModel): + """Configuration for egress control of sandbox instances.""" + + internet_access: Optional[bool] = Field( + default=None, description="""Optional. Whether to allow internet access.""" + ) + + +class SandboxEnvironmentTemplateEgressControlConfigDict(TypedDict, total=False): + """Configuration for egress control of sandbox instances.""" + + internet_access: Optional[bool] + """Optional. Whether to allow internet access.""" + + +SandboxEnvironmentTemplateEgressControlConfigOrDict = Union[ + SandboxEnvironmentTemplateEgressControlConfig, + SandboxEnvironmentTemplateEgressControlConfigDict, +] + + +class CreateSandboxEnvironmentTemplateConfig(_common.BaseModel): + """Config for creating a Sandbox Template.""" + + http_options: Optional[genai_types.HttpOptions] = Field( + default=None, description="""Used to override HTTP request options.""" + ) + wait_for_completion: Optional[bool] = Field( + default=True, + description="""Waits for the operation to complete before returning.""", + ) + custom_container_environment: Optional[ + SandboxEnvironmentTemplateCustomContainerEnvironment + ] = Field( + default=None, + description="""The custom container environment for the sandbox template.""", + ) + default_container_environment: Optional[ + SandboxEnvironmentTemplateDefaultContainerEnvironment + ] = Field( + default=None, + description="""The default container environment for the sandbox template.""", + ) + egress_control_config: Optional[SandboxEnvironmentTemplateEgressControlConfig] = ( + Field( + default=None, + description="""The egress control config for the sandbox template.""", + ) + ) + + +class CreateSandboxEnvironmentTemplateConfigDict(TypedDict, total=False): + """Config for creating a Sandbox Template.""" + + http_options: Optional[genai_types.HttpOptionsDict] + """Used to override HTTP request options.""" + + wait_for_completion: Optional[bool] + """Waits for the operation to complete before returning.""" + + custom_container_environment: Optional[ + SandboxEnvironmentTemplateCustomContainerEnvironmentDict + ] + """The custom container environment for the sandbox template.""" + + default_container_environment: Optional[ + SandboxEnvironmentTemplateDefaultContainerEnvironmentDict + ] + """The default container environment for the sandbox template.""" + + egress_control_config: Optional[SandboxEnvironmentTemplateEgressControlConfigDict] + """The egress control config for the sandbox template.""" + + +CreateSandboxEnvironmentTemplateConfigOrDict = Union[ + CreateSandboxEnvironmentTemplateConfig, CreateSandboxEnvironmentTemplateConfigDict +] + + +class _CreateSandboxEnvironmentTemplateRequestParameters(_common.BaseModel): + """Parameters for creating Sandbox Environment Templates.""" + + name: Optional[str] = Field( + default=None, + description="""Name of the agent engine to create the template under.""", + ) + config: Optional[CreateSandboxEnvironmentTemplateConfig] = Field( + default=None, description="""""" + ) + display_name: Optional[str] = Field( + default=None, description="""The display name of the sandbox template.""" + ) + + +class _CreateSandboxEnvironmentTemplateRequestParametersDict(TypedDict, total=False): + """Parameters for creating Sandbox Environment Templates.""" + + name: Optional[str] + """Name of the agent engine to create the template under.""" + + config: Optional[CreateSandboxEnvironmentTemplateConfigDict] + """""" + + display_name: Optional[str] + """The display name of the sandbox template.""" + + +_CreateSandboxEnvironmentTemplateRequestParametersOrDict = Union[ + _CreateSandboxEnvironmentTemplateRequestParameters, + _CreateSandboxEnvironmentTemplateRequestParametersDict, +] + + +class SandboxEnvironmentTemplateWarmPoolConfig(_common.BaseModel): + """Configuration for a warm pool of sandbox instances.""" + + target_instance_count: Optional[int] = Field( + default=None, + description="""Optional. The target number of pre-warmed instances to maintain.""", + ) + + +class SandboxEnvironmentTemplateWarmPoolConfigDict(TypedDict, total=False): + """Configuration for a warm pool of sandbox instances.""" + + target_instance_count: Optional[int] + """Optional. The target number of pre-warmed instances to maintain.""" + + +SandboxEnvironmentTemplateWarmPoolConfigOrDict = Union[ + SandboxEnvironmentTemplateWarmPoolConfig, + SandboxEnvironmentTemplateWarmPoolConfigDict, +] + + +class SandboxEnvironmentTemplate(_common.BaseModel): + """A sandbox environment template.""" + + create_time: Optional[datetime.datetime] = Field( + default=None, + description="""Output only. The timestamp when this SandboxEnvironmentTemplate was created.""", + ) + custom_container_environment: Optional[ + SandboxEnvironmentTemplateCustomContainerEnvironment + ] = Field( + default=None, + description="""The sandbox environment for custom container workloads.""", + ) + default_container_environment: Optional[ + SandboxEnvironmentTemplateDefaultContainerEnvironment + ] = Field( + default=None, + description="""The sandbox environment for default container workloads.""", + ) + display_name: Optional[str] = Field( + default=None, + description="""Required. The display name of the SandboxEnvironmentTemplate.""", + ) + egress_control_config: Optional[SandboxEnvironmentTemplateEgressControlConfig] = ( + Field( + default=None, + description="""Optional. The configuration for egress control of this template.""", + ) + ) + name: Optional[str] = Field( + default=None, + description="""Identifier. The resource name of the SandboxEnvironmentTemplate. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/sandboxEnvironmentTemplates/{sandbox_environment_template}`""", + ) + state: Optional[ + Literal[ + "UNSPECIFIED", + "PROVISIONING", + "ACTIVE", + "DEPROVISIONING", + "DELETED", + "FAILED", + ] + ] = Field( + default=None, + description="""Output only. The state of the sandbox environment template.""", + ) + update_time: Optional[datetime.datetime] = Field( + default=None, + description="""Output only. The timestamp when this SandboxEnvironmentTemplate was most recently updated.""", + ) + warm_pool_config: Optional[SandboxEnvironmentTemplateWarmPoolConfig] = Field( + default=None, + description="""Optional. The configuration for the warm pool of this template.""", + ) + + +class SandboxEnvironmentTemplateDict(TypedDict, total=False): + """A sandbox environment template.""" + + create_time: Optional[datetime.datetime] + """Output only. The timestamp when this SandboxEnvironmentTemplate was created.""" + + custom_container_environment: Optional[ + SandboxEnvironmentTemplateCustomContainerEnvironmentDict + ] + """The sandbox environment for custom container workloads.""" + + default_container_environment: Optional[ + SandboxEnvironmentTemplateDefaultContainerEnvironmentDict + ] + """The sandbox environment for default container workloads.""" + + display_name: Optional[str] + """Required. The display name of the SandboxEnvironmentTemplate.""" + + egress_control_config: Optional[SandboxEnvironmentTemplateEgressControlConfigDict] + """Optional. The configuration for egress control of this template.""" + + name: Optional[str] + """Identifier. The resource name of the SandboxEnvironmentTemplate. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/sandboxEnvironmentTemplates/{sandbox_environment_template}`""" + + state: Optional[ + Literal[ + "UNSPECIFIED", + "PROVISIONING", + "ACTIVE", + "DEPROVISIONING", + "DELETED", + "FAILED", + ] + ] + """Output only. The state of the sandbox environment template.""" + + update_time: Optional[datetime.datetime] + """Output only. The timestamp when this SandboxEnvironmentTemplate was most recently updated.""" + + warm_pool_config: Optional[SandboxEnvironmentTemplateWarmPoolConfigDict] + """Optional. The configuration for the warm pool of this template.""" + + +SandboxEnvironmentTemplateOrDict = Union[ + SandboxEnvironmentTemplate, SandboxEnvironmentTemplateDict +] + + +class SandboxEnvironmentTemplateOperation(_common.BaseModel): + """Operation that has an agent engine sandbox as a response.""" + + name: Optional[str] = Field( + default=None, + description="""The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.""", + ) + metadata: Optional[dict[str, Any]] = Field( + default=None, + description="""Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.""", + ) + done: Optional[bool] = Field( + default=None, + description="""If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.""", + ) + error: Optional[dict[str, Any]] = Field( + default=None, + description="""The error result of the operation in case of failure or cancellation.""", + ) + response: Optional[SandboxEnvironmentTemplate] = Field( + default=None, description="""The Agent Engine Sandbox Template.""" + ) + + +class SandboxEnvironmentTemplateOperationDict(TypedDict, total=False): + """Operation that has an agent engine sandbox as a response.""" + + name: Optional[str] + """The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.""" + + metadata: Optional[dict[str, Any]] + """Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.""" + + done: Optional[bool] + """If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.""" + + error: Optional[dict[str, Any]] + """The error result of the operation in case of failure or cancellation.""" + + response: Optional[SandboxEnvironmentTemplateDict] + """The Agent Engine Sandbox Template.""" + + +SandboxEnvironmentTemplateOperationOrDict = Union[ + SandboxEnvironmentTemplateOperation, SandboxEnvironmentTemplateOperationDict +] + + +class DeleteSandboxEnvironmentTemplateConfig(_common.BaseModel): + """Config for deleting a Sandbox Template.""" + + http_options: Optional[genai_types.HttpOptions] = Field( + default=None, description="""Used to override HTTP request options.""" + ) + + +class DeleteSandboxEnvironmentTemplateConfigDict(TypedDict, total=False): + """Config for deleting a Sandbox Template.""" + + http_options: Optional[genai_types.HttpOptionsDict] + """Used to override HTTP request options.""" + + +DeleteSandboxEnvironmentTemplateConfigOrDict = Union[ + DeleteSandboxEnvironmentTemplateConfig, DeleteSandboxEnvironmentTemplateConfigDict +] + + +class _DeleteSandboxEnvironmentTemplateRequestParameters(_common.BaseModel): + """Parameters for deleting sandbox templates.""" + + name: Optional[str] = Field( + default=None, description="""Name of the sandbox template to delete.""" + ) + config: Optional[DeleteSandboxEnvironmentTemplateConfig] = Field( + default=None, description="""""" + ) + + +class _DeleteSandboxEnvironmentTemplateRequestParametersDict(TypedDict, total=False): + """Parameters for deleting sandbox templates.""" + + name: Optional[str] + """Name of the sandbox template to delete.""" + + config: Optional[DeleteSandboxEnvironmentTemplateConfigDict] + """""" + + +_DeleteSandboxEnvironmentTemplateRequestParametersOrDict = Union[ + _DeleteSandboxEnvironmentTemplateRequestParameters, + _DeleteSandboxEnvironmentTemplateRequestParametersDict, +] + + +class DeleteSandboxEnvironmentTemplateOperation(_common.BaseModel): + """Operation for deleting sandbox templates.""" + + name: Optional[str] = Field( + default=None, + description="""The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.""", + ) + metadata: Optional[dict[str, Any]] = Field( + default=None, + description="""Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.""", + ) + done: Optional[bool] = Field( + default=None, + description="""If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.""", + ) + error: Optional[dict[str, Any]] = Field( + default=None, + description="""The error result of the operation in case of failure or cancellation.""", + ) + + +class DeleteSandboxEnvironmentTemplateOperationDict(TypedDict, total=False): + """Operation for deleting sandbox templates.""" + + name: Optional[str] + """The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.""" + + metadata: Optional[dict[str, Any]] + """Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.""" + + done: Optional[bool] + """If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.""" + + error: Optional[dict[str, Any]] + """The error result of the operation in case of failure or cancellation.""" + + +DeleteSandboxEnvironmentTemplateOperationOrDict = Union[ + DeleteSandboxEnvironmentTemplateOperation, + DeleteSandboxEnvironmentTemplateOperationDict, +] + + +class GetSandboxEnvironmentTemplateConfig(_common.BaseModel): + """Config for getting a Sandbox Template.""" + + http_options: Optional[genai_types.HttpOptions] = Field( + default=None, description="""Used to override HTTP request options.""" + ) + + +class GetSandboxEnvironmentTemplateConfigDict(TypedDict, total=False): + """Config for getting a Sandbox Template.""" + + http_options: Optional[genai_types.HttpOptionsDict] + """Used to override HTTP request options.""" + + +GetSandboxEnvironmentTemplateConfigOrDict = Union[ + GetSandboxEnvironmentTemplateConfig, GetSandboxEnvironmentTemplateConfigDict +] + + +class _GetSandboxEnvironmentTemplateRequestParameters(_common.BaseModel): + """Parameters for getting a sandbox template.""" + + name: Optional[str] = Field( + default=None, description="""Name of the sandbox template.""" + ) + config: Optional[GetSandboxEnvironmentTemplateConfig] = Field( + default=None, description="""""" + ) + + +class _GetSandboxEnvironmentTemplateRequestParametersDict(TypedDict, total=False): + """Parameters for getting a sandbox template.""" + + name: Optional[str] + """Name of the sandbox template.""" + + config: Optional[GetSandboxEnvironmentTemplateConfigDict] + """""" + + +_GetSandboxEnvironmentTemplateRequestParametersOrDict = Union[ + _GetSandboxEnvironmentTemplateRequestParameters, + _GetSandboxEnvironmentTemplateRequestParametersDict, +] + + +class ListSandboxEnvironmentTemplatesConfig(_common.BaseModel): + """Config for listing sandbox templates.""" + + http_options: Optional[genai_types.HttpOptions] = Field( + default=None, description="""Used to override HTTP request options.""" + ) + page_size: Optional[int] = Field(default=None, description="""""") + page_token: Optional[str] = Field(default=None, description="""""") + filter: Optional[str] = Field( + default=None, + description="""An expression for filtering the results of the request.""", + ) + + +class ListSandboxEnvironmentTemplatesConfigDict(TypedDict, total=False): + """Config for listing sandbox templates.""" + + http_options: Optional[genai_types.HttpOptionsDict] + """Used to override HTTP request options.""" + + page_size: Optional[int] + """""" + + page_token: Optional[str] + """""" + + filter: Optional[str] + """An expression for filtering the results of the request.""" + + +ListSandboxEnvironmentTemplatesConfigOrDict = Union[ + ListSandboxEnvironmentTemplatesConfig, ListSandboxEnvironmentTemplatesConfigDict +] + + +class _ListSandboxEnvironmentTemplatesRequestParameters(_common.BaseModel): + """Parameters for listing sandbox templates.""" + + name: Optional[str] = Field( + default=None, description="""Name of the agent engine.""" + ) + config: Optional[ListSandboxEnvironmentTemplatesConfig] = Field( + default=None, description="""""" + ) + + +class _ListSandboxEnvironmentTemplatesRequestParametersDict(TypedDict, total=False): + """Parameters for listing sandbox templates.""" + + name: Optional[str] + """Name of the agent engine.""" + + config: Optional[ListSandboxEnvironmentTemplatesConfigDict] + """""" + + +_ListSandboxEnvironmentTemplatesRequestParametersOrDict = Union[ + _ListSandboxEnvironmentTemplatesRequestParameters, + _ListSandboxEnvironmentTemplatesRequestParametersDict, +] + + +class ListSandboxEnvironmentTemplatesResponse(_common.BaseModel): + """Response for listing sandbox templates.""" + + sdk_http_response: Optional[genai_types.HttpResponse] = Field( + default=None, description="""Used to retain the full HTTP response.""" + ) + next_page_token: Optional[str] = Field(default=None, description="""""") + sandbox_environment_templates: Optional[list[SandboxEnvironmentTemplate]] = Field( + default=None, description="""List of sandbox templates.""" + ) + + +class ListSandboxEnvironmentTemplatesResponseDict(TypedDict, total=False): + """Response for listing sandbox templates.""" + + sdk_http_response: Optional[genai_types.HttpResponseDict] + """Used to retain the full HTTP response.""" + + next_page_token: Optional[str] + """""" + + sandbox_environment_templates: Optional[list[SandboxEnvironmentTemplateDict]] + """List of sandbox templates.""" + + +ListSandboxEnvironmentTemplatesResponseOrDict = Union[ + ListSandboxEnvironmentTemplatesResponse, ListSandboxEnvironmentTemplatesResponseDict +] + + +class _GetSandboxEnvironmentTemplateOperationParameters(_common.BaseModel): + """Parameters for getting an operation with a sandbox template as a response.""" + + operation_name: Optional[str] = Field( + default=None, description="""The server-assigned name for the operation.""" + ) + config: Optional[GetAgentEngineOperationConfig] = Field( + default=None, description="""Used to override the default configuration.""" + ) + + +class _GetSandboxEnvironmentTemplateOperationParametersDict(TypedDict, total=False): + """Parameters for getting an operation with a sandbox template as a response.""" + + operation_name: Optional[str] + """The server-assigned name for the operation.""" + + config: Optional[GetAgentEngineOperationConfigDict] + """Used to override the default configuration.""" + + +_GetSandboxEnvironmentTemplateOperationParametersOrDict = Union[ + _GetSandboxEnvironmentTemplateOperationParameters, + _GetSandboxEnvironmentTemplateOperationParametersDict, +] + + class CreateAgentEngineSessionConfig(_common.BaseModel): """Config for creating a Session."""