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

agentplatform/_genai/endpoints.py

@@ -0,0 +1,1149 @@
+# 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 import types as genai_types
+from google.genai._common import get_value_by_path as getv
+from google.genai._common import set_value_by_path as setv
+
+from . import _operations_utils
+from . import _transformers as t
+from . import types
+
+logger = logging.getLogger("agentplatform_genai.endpoints")
+
+
+def _DeleteEndpointRequestParameters_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"],
+            t.t_strict_endpoint(getv(from_object, ["name"])),
+        )
+
+    return to_object
+
+
+def _GetEndpointOperationParameters_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 _GetEndpointParameters_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"],
+            t.t_strict_endpoint(getv(from_object, ["name"])),
+        )
+
+    return to_object
+
+
+def _PredictConfig_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, ["parameters"]) is not None:
+        setv(parent_object, ["parameters"], getv(from_object, ["parameters"]))
+
+    return to_object
+
+
+def _PredictParameters_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", "endpoint"], t.t_endpoint(getv(from_object, ["name"])))
+
+    if getv(from_object, ["instances"]) is not None:
+        setv(to_object, ["instances"], getv(from_object, ["instances"]))
+
+    if getv(from_object, ["config"]) is not None:
+        _PredictConfig_to_vertex(getv(from_object, ["config"]), to_object)
+
+    return to_object
+
+
+def _UndeployModelRequestParameters_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", "endpoint"],
+            t.t_strict_endpoint(getv(from_object, ["name"])),
+        )
+
+    if getv(from_object, ["deployed_model_id"]) is not None:
+        setv(to_object, ["deployed_model_id"], getv(from_object, ["deployed_model_id"]))
+
+    return to_object
+
+
+class Endpoints(_api_module.BaseModule):
+    """Class for managing Endpoints for prediction, undeployment, and deletion."""
+
+    def _undeploy(
+        self,
+        *,
+        name: str,
+        deployed_model_id: str,
+        config: Optional[types.UndeployModelConfigOrDict] = None,
+    ) -> types.UndeployModelOperation:
+        """
+        Undeploys a Model from an Endpoint, removing a
+        DeployedModel from it, and freeing all resources it's using.
+        """
+
+        parameter_model = types._UndeployModelRequestParameters(
+            name=name,
+            deployed_model_id=deployed_model_id,
+            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 = _UndeployModelRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{endpoint}:undeployModel".format_map(request_url_dict)
+            else:
+                path = "{endpoint}:undeployModel"
+
+        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.UndeployModelOperation._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 _predict(
+        self,
+        *,
+        name: str,
+        instances: list[dict[str, Any]],
+        config: Optional[types.PredictConfigOrDict] = None,
+    ) -> types.PredictResponse:
+        """
+        Perform an online prediction.
+        """
+
+        parameter_model = types._PredictParameters(
+            name=name,
+            instances=instances,
+            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 = _PredictParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{endpoint}:predict".format_map(request_url_dict)
+            else:
+                path = "{endpoint}:predict"
+
+        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.PredictResponse._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.DeleteEndpointConfigOrDict] = None
+    ) -> types.DeleteEndpointOperation:
+        """
+        Deletes an endpoint resource.
+        """
+
+        parameter_model = types._DeleteEndpointRequestParameters(
+            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 = _DeleteEndpointRequestParameters_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.DeleteEndpointOperation._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.GetEndpointConfigOrDict] = None
+    ) -> types.Endpoint:
+        """
+        Retrieves a specific endpoint resource by its name.
+        """
+
+        parameter_model = types._GetEndpointParameters(
+            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 = _GetEndpointParameters_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.Endpoint._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_endpoint_operation(
+        self,
+        *,
+        operation_name: str,
+        config: Optional[types.GetEndpointOperationConfigOrDict] = None,
+    ) -> types.EndpointOperation:
+        parameter_model = types._GetEndpointOperationParameters(
+            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 = _GetEndpointOperationParameters_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.EndpointOperation._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 predict(
+        self,
+        *,
+        name: str,
+        instances: list[dict[str, Any]],
+        config: Optional[types.PredictConfigOrDict] = None,
+    ) -> types.PredictResponse:
+        """Performs an online prediction.
+
+        Args:
+            name (str):
+                Required. The Endpoint or publisher model that serves the
+                prediction. Format:
+                projects/{project}/locations/{location}/endpoints/{endpoint},
+                endpoints/{endpoint},
+                projects/{project}/locations/{location}/publishers/{publisher}/models/{model}
+                or publishers/{publisher}/models/{model}.
+            instances (list[dict[str, Any]]):
+                Required. The instances that are the input to the prediction call.
+            config (PredictConfigOrDict):
+                Optional. Additional configuration for the prediction.
+
+        Returns:
+            PredictResponse: The prediction response.
+
+        """
+        if config is None:
+            config = types.PredictConfig()
+        elif isinstance(config, dict):
+            config = types.PredictConfig.model_validate(config)
+        elif not isinstance(config, types.PredictConfig):
+            raise TypeError(
+                f"config must be a dict or PredictConfig, but got {type(config)}."
+            )
+
+        # A publisher model has no Endpoint resource to look up, and only an
+        # Endpoint can have a dedicated DNS.
+        if t.is_endpoint_resource_name(name):
+            deployed_endpoint = self.get(name=name)
+            if deployed_endpoint.dedicated_endpoint_enabled:
+                if not deployed_endpoint.dedicated_endpoint_dns:
+                    raise ValueError(
+                        "Dedicated endpoint is enabled but no dedicated endpoint DNS is provided."
+                    )
+                http_options = (
+                    config.http_options.model_copy(deep=True)
+                    if config.http_options is not None
+                    else genai_types.HttpOptions()
+                )
+                http_options.base_url = (
+                    "https://" + deployed_endpoint.dedicated_endpoint_dns
+                )
+                config = config.model_copy(update={"http_options": http_options})
+
+        response = self._predict(
+            name=name,
+            instances=instances,
+            config=config,
+        )
+
+        return response
+
+    def undeploy(
+        self,
+        *,
+        name: str,
+        deployed_model_id: str,
+        config: Optional[types.UndeployModelConfigOrDict] = None,
+    ) -> Optional[types.UndeployModelOperation]:
+        """Undeploys a model from an Endpoint.
+
+        Args:
+            name (str):
+                Required. The resource name of the Endpoint to undeploy model from.
+                Format: projects/{project}/locations/{location}/endpoints/{endpoint}
+            deployed_model_id (str):
+                Required. The ID of the DeployedModel to undeploy.
+            config (UndeployModelConfigOrDict):
+                Optional. Additional configuration for the undeploy operation.
+
+        Returns:
+            UndeployModelOperation: The pending LRO if wait_for_completion is False,
+                otherwise None (blocks until done).
+        """
+        if config is None:
+            config = types.UndeployModelConfig()
+        elif isinstance(config, dict):
+            config = types.UndeployModelConfig.model_validate(config)
+        elif not isinstance(config, types.UndeployModelConfig):
+            raise TypeError(
+                f"config must be a dict or UndeployModelConfig, but got {type(config)}."
+            )
+
+        operation = self._undeploy(
+            name=name, deployed_model_id=deployed_model_id, config=config
+        )
+
+        if config.wait_for_completion:
+            operation = _operations_utils.await_operation(
+                operation_name=operation.name,
+                get_operation_fn=self._get_endpoint_operation,
+            )
+            if operation.error:
+                raise RuntimeError(f"Failed to undeploy Endpoint: {operation.error}")
+            return None
+
+        return operation
+
+    def delete(
+        self,
+        *,
+        name: str,
+        config: Optional[types.DeleteEndpointConfigOrDict] = None,
+    ) -> Optional[types.DeleteEndpointOperation]:
+        """Deletes an Endpoint.
+
+        Args:
+            name (str):
+                Required. The resource name of the Endpoint to delete.
+                Format: projects/{project}/locations/{location}/endpoints/{endpoint}
+            config (DeleteEndpointConfigOrDict):
+                Optional. Additional configuration for the delete operation.
+
+        Returns:
+            DeleteEndpointOperation: The pending LRO if wait_for_completion is False,
+                otherwise None (blocks until done).
+        """
+        if config is None:
+            config = types.DeleteEndpointConfig()
+        elif isinstance(config, dict):
+            config = types.DeleteEndpointConfig.model_validate(config)
+        elif not isinstance(config, types.DeleteEndpointConfig):
+            raise TypeError(
+                f"config must be a dict or DeleteEndpointConfig, but got {type(config)}."
+            )
+
+        operation = self._delete(name=name, config=config)
+
+        if config.wait_for_completion:
+            operation = _operations_utils.await_operation(
+                operation_name=operation.name,
+                get_operation_fn=self._get_endpoint_operation,
+            )
+            if operation.error:
+                raise RuntimeError(f"Failed to delete Endpoint: {operation.error}")
+            return None
+
+        return operation
+
+
+class AsyncEndpoints(_api_module.BaseModule):
+    """Class for managing Endpoints for prediction, undeployment, and deletion."""
+
+    async def _undeploy(
+        self,
+        *,
+        name: str,
+        deployed_model_id: str,
+        config: Optional[types.UndeployModelConfigOrDict] = None,
+    ) -> types.UndeployModelOperation:
+        """
+        Undeploys a Model from an Endpoint, removing a
+        DeployedModel from it, and freeing all resources it's using.
+        """
+
+        parameter_model = types._UndeployModelRequestParameters(
+            name=name,
+            deployed_model_id=deployed_model_id,
+            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 = _UndeployModelRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{endpoint}:undeployModel".format_map(request_url_dict)
+            else:
+                path = "{endpoint}:undeployModel"
+
+        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.UndeployModelOperation._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 _predict(
+        self,
+        *,
+        name: str,
+        instances: list[dict[str, Any]],
+        config: Optional[types.PredictConfigOrDict] = None,
+    ) -> types.PredictResponse:
+        """
+        Perform an online prediction.
+        """
+
+        parameter_model = types._PredictParameters(
+            name=name,
+            instances=instances,
+            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 = _PredictParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{endpoint}:predict".format_map(request_url_dict)
+            else:
+                path = "{endpoint}:predict"
+
+        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.PredictResponse._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.DeleteEndpointConfigOrDict] = None
+    ) -> types.DeleteEndpointOperation:
+        """
+        Deletes an endpoint resource.
+        """
+
+        parameter_model = types._DeleteEndpointRequestParameters(
+            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 = _DeleteEndpointRequestParameters_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.DeleteEndpointOperation._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.GetEndpointConfigOrDict] = None
+    ) -> types.Endpoint:
+        """
+        Retrieves a specific endpoint resource by its name.
+        """
+
+        parameter_model = types._GetEndpointParameters(
+            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 = _GetEndpointParameters_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.Endpoint._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_endpoint_operation(
+        self,
+        *,
+        operation_name: str,
+        config: Optional[types.GetEndpointOperationConfigOrDict] = None,
+    ) -> types.EndpointOperation:
+        parameter_model = types._GetEndpointOperationParameters(
+            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 = _GetEndpointOperationParameters_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.EndpointOperation._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 predict(
+        self,
+        *,
+        name: str,
+        instances: list[dict[str, Any]],
+        config: Optional[types.PredictConfigOrDict] = None,
+    ) -> types.PredictResponse:
+        """Performs an online prediction.
+
+        Args:
+            name (str):
+                Required. The Endpoint or publisher model that serves the
+                prediction. Format:
+                projects/{project}/locations/{location}/endpoints/{endpoint},
+                endpoints/{endpoint},
+                projects/{project}/locations/{location}/publishers/{publisher}/models/{model}
+                or publishers/{publisher}/models/{model}.
+            instances (list[dict[str, Any]]):
+                Required. The instances that are the input to the prediction call.
+            config (PredictConfigOrDict):
+                Optional. Additional configuration for the prediction.
+
+        Returns:
+            PredictResponse: The prediction response.
+
+        """
+        if config is None:
+            config = types.PredictConfig()
+        elif isinstance(config, dict):
+            config = types.PredictConfig.model_validate(config)
+        elif not isinstance(config, types.PredictConfig):
+            raise TypeError(
+                f"config must be a dict or PredictConfig, but got {type(config)}."
+            )
+
+        # A publisher model has no Endpoint resource to look up, and only an
+        # Endpoint can have a dedicated DNS.
+        if t.is_endpoint_resource_name(name):
+            deployed_endpoint = await self.get(name=name)
+            if deployed_endpoint.dedicated_endpoint_enabled:
+                if not deployed_endpoint.dedicated_endpoint_dns:
+                    raise ValueError(
+                        "Dedicated endpoint is enabled but no dedicated endpoint DNS is provided."
+                    )
+                http_options = (
+                    config.http_options.model_copy(deep=True)
+                    if config.http_options is not None
+                    else genai_types.HttpOptions()
+                )
+                http_options.base_url = (
+                    "https://" + deployed_endpoint.dedicated_endpoint_dns
+                )
+                config = config.model_copy(update={"http_options": http_options})
+
+        response = await self._predict(
+            name=name,
+            instances=instances,
+            config=config,
+        )
+
+        return response
+
+    async def undeploy(
+        self,
+        *,
+        name: str,
+        deployed_model_id: str,
+        config: Optional[types.UndeployModelConfigOrDict] = None,
+    ) -> Optional[types.UndeployModelOperation]:
+        """Undeploys a model from an Endpoint.
+
+        Args:
+            name (str):
+                Required. The resource name of the Endpoint to undeploy model from.
+                Format: projects/{project}/locations/{location}/endpoints/{endpoint}
+            deployed_model_id (str):
+                Required. The ID of the DeployedModel to undeploy.
+            config (UndeployModelConfigOrDict):
+                Optional. Additional configuration for the undeploy operation.
+
+        Returns:
+            UndeployModelOperation: The pending LRO if wait_for_completion is False,
+                otherwise None (blocks until done).
+        """
+        if config is None:
+            config = types.UndeployModelConfig()
+        elif isinstance(config, dict):
+            config = types.UndeployModelConfig.model_validate(config)
+        elif not isinstance(config, types.UndeployModelConfig):
+            raise TypeError(
+                f"config must be a dict or UndeployModelConfig, but got {type(config)}."
+            )
+
+        operation = await self._undeploy(
+            name=name, deployed_model_id=deployed_model_id, config=config
+        )
+
+        if config.wait_for_completion:
+            operation = await _operations_utils.await_operation_async(
+                operation_name=operation.name,
+                get_operation_fn=self._get_endpoint_operation,
+            )
+            if operation.error:
+                raise RuntimeError(f"Failed to undeploy Endpoint: {operation.error}")
+            return None
+
+        return operation
+
+    async def delete(
+        self,
+        *,
+        name: str,
+        config: Optional[types.DeleteEndpointConfigOrDict] = None,
+    ) -> Optional[types.DeleteEndpointOperation]:
+        """Deletes an Endpoint.
+
+        Args:
+            name (str):
+                Required. The resource name of the Endpoint to delete.
+                Format: projects/{project}/locations/{location}/endpoints/{endpoint}
+            config (DeleteEndpointConfigOrDict):
+                Optional. Additional configuration for the delete operation.
+
+        Returns:
+            DeleteEndpointOperation: The pending LRO if wait_for_completion is False,
+                otherwise None (blocks until done).
+        """
+        if config is None:
+            config = types.DeleteEndpointConfig()
+        elif isinstance(config, dict):
+            config = types.DeleteEndpointConfig.model_validate(config)
+        elif not isinstance(config, types.DeleteEndpointConfig):
+            raise TypeError(
+                f"config must be a dict or DeleteEndpointConfig, but got {type(config)}."
+            )
+
+        operation = await self._delete(name=name, config=config)
+
+        if config.wait_for_completion:
+            operation = await _operations_utils.await_operation_async(
+                operation_name=operation.name,
+                get_operation_fn=self._get_endpoint_operation,
+            )
+            if operation.error:
+                raise RuntimeError(f"Failed to delete Endpoint: {operation.error}")
+            return None
+
+        return operation