databricks-sdk 0.29.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

databricks/sdk/service/serving.py

@@ -10,6 +10,9 @@ from datetime import timedelta
 from enum import Enum
 from typing import Any, BinaryIO, Callable, Dict, Iterator, List, Optional
 
+import requests
+
+from ..data_plane import DataPlaneService
 from ..errors import OperationFailed
 from ._internal import Wait, _enum, _from_dict, _repeated_dict
 
@@ -22,19 +25,29 @@ from databricks.sdk.service import oauth2
 
 @dataclass
 class Ai21LabsConfig:
-    ai21labs_api_key: str
-    """The Databricks secret key reference for an AI21Labs API key."""
+    ai21labs_api_key: Optional[str] = None
+    """The Databricks secret key reference for an AI21 Labs API key. If you prefer to paste your API
+    key directly, see `ai21labs_api_key_plaintext`. You must provide an API key using one of the
+    following fields: `ai21labs_api_key` or `ai21labs_api_key_plaintext`."""
+
+    ai21labs_api_key_plaintext: Optional[str] = None
+    """An AI21 Labs API key provided as a plaintext string. If you prefer to reference your key using
+    Databricks Secrets, see `ai21labs_api_key`. You must provide an API key using one of the
+    following fields: `ai21labs_api_key` or `ai21labs_api_key_plaintext`."""
 
     def as_dict(self) -> dict:
         """Serializes the Ai21LabsConfig into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.ai21labs_api_key is not None: body['ai21labs_api_key'] = self.ai21labs_api_key
+        if self.ai21labs_api_key_plaintext is not None:
+            body['ai21labs_api_key_plaintext'] = self.ai21labs_api_key_plaintext
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Ai21LabsConfig:
         """Deserializes the Ai21LabsConfig from a dictionary."""
-        return cls(ai21labs_api_key=d.get('ai21labs_api_key', None))
+        return cls(ai21labs_api_key=d.get('ai21labs_api_key', None),
+                   ai21labs_api_key_plaintext=d.get('ai21labs_api_key_plaintext', None))
 
 
 @dataclass
@@ -42,24 +55,44 @@ class AmazonBedrockConfig:
     aws_region: str
     """The AWS region to use. Bedrock has to be enabled there."""
 
-    aws_access_key_id: str
-    """The Databricks secret key reference for an AWS Access Key ID with permissions to interact with
-    Bedrock services."""
-
-    aws_secret_access_key: str
-    """The Databricks secret key reference for an AWS Secret Access Key paired with the access key ID,
-    with permissions to interact with Bedrock services."""
-
     bedrock_provider: AmazonBedrockConfigBedrockProvider
     """The underlying provider in Amazon Bedrock. Supported values (case insensitive) include:
     Anthropic, Cohere, AI21Labs, Amazon."""
 
+    aws_access_key_id: Optional[str] = None
+    """The Databricks secret key reference for an AWS access key ID with permissions to interact with
+    Bedrock services. If you prefer to paste your API key directly, see `aws_access_key_id`. You
+    must provide an API key using one of the following fields: `aws_access_key_id` or
+    `aws_access_key_id_plaintext`."""
+
+    aws_access_key_id_plaintext: Optional[str] = None
+    """An AWS access key ID with permissions to interact with Bedrock services provided as a plaintext
+    string. If you prefer to reference your key using Databricks Secrets, see `aws_access_key_id`.
+    You must provide an API key using one of the following fields: `aws_access_key_id` or
+    `aws_access_key_id_plaintext`."""
+
+    aws_secret_access_key: Optional[str] = None
+    """The Databricks secret key reference for an AWS secret access key paired with the access key ID,
+    with permissions to interact with Bedrock services. If you prefer to paste your API key
+    directly, see `aws_secret_access_key_plaintext`. You must provide an API key using one of the
+    following fields: `aws_secret_access_key` or `aws_secret_access_key_plaintext`."""
+
+    aws_secret_access_key_plaintext: Optional[str] = None
+    """An AWS secret access key paired with the access key ID, with permissions to interact with
+    Bedrock services provided as a plaintext string. If you prefer to reference your key using
+    Databricks Secrets, see `aws_secret_access_key`. You must provide an API key using one of the
+    following fields: `aws_secret_access_key` or `aws_secret_access_key_plaintext`."""
+
     def as_dict(self) -> dict:
         """Serializes the AmazonBedrockConfig into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.aws_access_key_id is not None: body['aws_access_key_id'] = self.aws_access_key_id
+        if self.aws_access_key_id_plaintext is not None:
+            body['aws_access_key_id_plaintext'] = self.aws_access_key_id_plaintext
         if self.aws_region is not None: body['aws_region'] = self.aws_region
         if self.aws_secret_access_key is not None: body['aws_secret_access_key'] = self.aws_secret_access_key
+        if self.aws_secret_access_key_plaintext is not None:
+            body['aws_secret_access_key_plaintext'] = self.aws_secret_access_key_plaintext
         if self.bedrock_provider is not None: body['bedrock_provider'] = self.bedrock_provider.value
         return body
 
@@ -67,8 +100,10 @@ class AmazonBedrockConfig:
     def from_dict(cls, d: Dict[str, any]) -> AmazonBedrockConfig:
         """Deserializes the AmazonBedrockConfig from a dictionary."""
         return cls(aws_access_key_id=d.get('aws_access_key_id', None),
+                   aws_access_key_id_plaintext=d.get('aws_access_key_id_plaintext', None),
                    aws_region=d.get('aws_region', None),
                    aws_secret_access_key=d.get('aws_secret_access_key', None),
+                   aws_secret_access_key_plaintext=d.get('aws_secret_access_key_plaintext', None),
                    bedrock_provider=_enum(d, 'bedrock_provider', AmazonBedrockConfigBedrockProvider))
 
 
@@ -84,249 +119,29 @@ class AmazonBedrockConfigBedrockProvider(Enum):
 
 @dataclass
 class AnthropicConfig:
-    anthropic_api_key: str
-    """The Databricks secret key reference for an Anthropic API key."""
+    anthropic_api_key: Optional[str] = None
+    """The Databricks secret key reference for an Anthropic API key. If you prefer to paste your API
+    key directly, see `anthropic_api_key_plaintext`. You must provide an API key using one of the
+    following fields: `anthropic_api_key` or `anthropic_api_key_plaintext`."""
+
+    anthropic_api_key_plaintext: Optional[str] = None
+    """The Anthropic API key provided as a plaintext string. If you prefer to reference your key using
+    Databricks Secrets, see `anthropic_api_key`. You must provide an API key using one of the
+    following fields: `anthropic_api_key` or `anthropic_api_key_plaintext`."""
 
     def as_dict(self) -> dict:
         """Serializes the AnthropicConfig into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.anthropic_api_key is not None: body['anthropic_api_key'] = self.anthropic_api_key
+        if self.anthropic_api_key_plaintext is not None:
+            body['anthropic_api_key_plaintext'] = self.anthropic_api_key_plaintext
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AnthropicConfig:
         """Deserializes the AnthropicConfig from a dictionary."""
-        return cls(anthropic_api_key=d.get('anthropic_api_key', None))
-
-
-@dataclass
-class App:
-    name: str
-    """The name of the app. The name must contain only lowercase alphanumeric characters and hyphens.
-    It must be unique within the workspace."""
-
-    active_deployment: Optional[AppDeployment] = None
-    """The active deployment of the app."""
-
-    create_time: Optional[str] = None
-    """The creation time of the app. Formatted timestamp in ISO 6801."""
-
-    creator: Optional[str] = None
-    """The email of the user that created the app."""
-
-    description: Optional[str] = None
-    """The description of the app."""
-
-    pending_deployment: Optional[AppDeployment] = None
-    """The pending deployment of the app."""
-
-    service_principal_id: Optional[int] = None
-
-    service_principal_name: Optional[str] = None
-
-    status: Optional[AppStatus] = None
-
-    update_time: Optional[str] = None
-    """The update time of the app. Formatted timestamp in ISO 6801."""
-
-    updater: Optional[str] = None
-    """The email of the user that last updated the app."""
-
-    url: Optional[str] = None
-    """The URL of the app once it is deployed."""
-
-    def as_dict(self) -> dict:
-        """Serializes the App into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.active_deployment: body['active_deployment'] = self.active_deployment.as_dict()
-        if self.create_time is not None: body['create_time'] = self.create_time
-        if self.creator is not None: body['creator'] = self.creator
-        if self.description is not None: body['description'] = self.description
-        if self.name is not None: body['name'] = self.name
-        if self.pending_deployment: body['pending_deployment'] = self.pending_deployment.as_dict()
-        if self.service_principal_id is not None: body['service_principal_id'] = self.service_principal_id
-        if self.service_principal_name is not None:
-            body['service_principal_name'] = self.service_principal_name
-        if self.status: body['status'] = self.status.as_dict()
-        if self.update_time is not None: body['update_time'] = self.update_time
-        if self.updater is not None: body['updater'] = self.updater
-        if self.url is not None: body['url'] = self.url
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> App:
-        """Deserializes the App from a dictionary."""
-        return cls(active_deployment=_from_dict(d, 'active_deployment', AppDeployment),
-                   create_time=d.get('create_time', None),
-                   creator=d.get('creator', None),
-                   description=d.get('description', None),
-                   name=d.get('name', None),
-                   pending_deployment=_from_dict(d, 'pending_deployment', AppDeployment),
-                   service_principal_id=d.get('service_principal_id', None),
-                   service_principal_name=d.get('service_principal_name', None),
-                   status=_from_dict(d, 'status', AppStatus),
-                   update_time=d.get('update_time', None),
-                   updater=d.get('updater', None),
-                   url=d.get('url', None))
-
-
-@dataclass
-class AppDeployment:
-    source_code_path: str
-    """The workspace file system path of the source code used to create the app deployment. This is
-    different from `deployment_artifacts.source_code_path`, which is the path used by the deployed
-    app. The former refers to the original source code location of the app in the workspace during
-    deployment creation, whereas the latter provides a system generated stable snapshotted source
-    code path used by the deployment."""
-
-    mode: AppDeploymentMode
-    """The mode of which the deployment will manage the source code."""
-
-    create_time: Optional[str] = None
-    """The creation time of the deployment. Formatted timestamp in ISO 6801."""
-
-    creator: Optional[str] = None
-    """The email of the user creates the deployment."""
-
-    deployment_artifacts: Optional[AppDeploymentArtifacts] = None
-    """The deployment artifacts for an app."""
-
-    deployment_id: Optional[str] = None
-    """The unique id of the deployment."""
-
-    status: Optional[AppDeploymentStatus] = None
-    """Status and status message of the deployment"""
-
-    update_time: Optional[str] = None
-    """The update time of the deployment. Formatted timestamp in ISO 6801."""
-
-    def as_dict(self) -> dict:
-        """Serializes the AppDeployment into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.create_time is not None: body['create_time'] = self.create_time
-        if self.creator is not None: body['creator'] = self.creator
-        if self.deployment_artifacts: body['deployment_artifacts'] = self.deployment_artifacts.as_dict()
-        if self.deployment_id is not None: body['deployment_id'] = self.deployment_id
-        if self.mode is not None: body['mode'] = self.mode.value
-        if self.source_code_path is not None: body['source_code_path'] = self.source_code_path
-        if self.status: body['status'] = self.status.as_dict()
-        if self.update_time is not None: body['update_time'] = self.update_time
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppDeployment:
-        """Deserializes the AppDeployment from a dictionary."""
-        return cls(create_time=d.get('create_time', None),
-                   creator=d.get('creator', None),
-                   deployment_artifacts=_from_dict(d, 'deployment_artifacts', AppDeploymentArtifacts),
-                   deployment_id=d.get('deployment_id', None),
-                   mode=_enum(d, 'mode', AppDeploymentMode),
-                   source_code_path=d.get('source_code_path', None),
-                   status=_from_dict(d, 'status', AppDeploymentStatus),
-                   update_time=d.get('update_time', None))
-
-
-@dataclass
-class AppDeploymentArtifacts:
-    source_code_path: Optional[str] = None
-    """The snapshotted workspace file system path of the source code loaded by the deployed app."""
-
-    def as_dict(self) -> dict:
-        """Serializes the AppDeploymentArtifacts into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.source_code_path is not None: body['source_code_path'] = self.source_code_path
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppDeploymentArtifacts:
-        """Deserializes the AppDeploymentArtifacts from a dictionary."""
-        return cls(source_code_path=d.get('source_code_path', None))
-
-
-class AppDeploymentMode(Enum):
-
-    AUTO_SYNC = 'AUTO_SYNC'
-    MODE_UNSPECIFIED = 'MODE_UNSPECIFIED'
-    SNAPSHOT = 'SNAPSHOT'
-
-
-class AppDeploymentState(Enum):
-
-    FAILED = 'FAILED'
-    IN_PROGRESS = 'IN_PROGRESS'
-    STATE_UNSPECIFIED = 'STATE_UNSPECIFIED'
-    STOPPED = 'STOPPED'
-    SUCCEEDED = 'SUCCEEDED'
-
-
-@dataclass
-class AppDeploymentStatus:
-    message: Optional[str] = None
-    """Message corresponding with the deployment state."""
-
-    state: Optional[AppDeploymentState] = None
-    """State of the deployment."""
-
-    def as_dict(self) -> dict:
-        """Serializes the AppDeploymentStatus into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.message is not None: body['message'] = self.message
-        if self.state is not None: body['state'] = self.state.value
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppDeploymentStatus:
-        """Deserializes the AppDeploymentStatus from a dictionary."""
-        return cls(message=d.get('message', None), state=_enum(d, 'state', AppDeploymentState))
-
-
-@dataclass
-class AppEnvironment:
-    env: Optional[List[EnvVariable]] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the AppEnvironment into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.env: body['env'] = [v.as_dict() for v in self.env]
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppEnvironment:
-        """Deserializes the AppEnvironment from a dictionary."""
-        return cls(env=_repeated_dict(d, 'env', EnvVariable))
-
-
-class AppState(Enum):
-
-    CREATING = 'CREATING'
-    DELETED = 'DELETED'
-    DELETING = 'DELETING'
-    ERROR = 'ERROR'
-    IDLE = 'IDLE'
-    RUNNING = 'RUNNING'
-    STARTING = 'STARTING'
-    STATE_UNSPECIFIED = 'STATE_UNSPECIFIED'
-
-
-@dataclass
-class AppStatus:
-    message: Optional[str] = None
-    """Message corresponding with the app state."""
-
-    state: Optional[AppState] = None
-    """State of the app."""
-
-    def as_dict(self) -> dict:
-        """Serializes the AppStatus into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.message is not None: body['message'] = self.message
-        if self.state is not None: body['state'] = self.state.value
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppStatus:
-        """Deserializes the AppStatus from a dictionary."""
-        return cls(message=d.get('message', None), state=_enum(d, 'state', AppState))
+        return cls(anthropic_api_key=d.get('anthropic_api_key', None),
+                   anthropic_api_key_plaintext=d.get('anthropic_api_key_plaintext', None))
 
 
 @dataclass
@@ -464,72 +279,35 @@ class ChatMessageRole(Enum):
 
 @dataclass
 class CohereConfig:
-    cohere_api_key: str
-    """The Databricks secret key reference for a Cohere API key."""
+    cohere_api_base: Optional[str] = None
+    """This is an optional field to provide a customized base URL for the Cohere API. If left
+    unspecified, the standard Cohere base URL is used."""
+
+    cohere_api_key: Optional[str] = None
+    """The Databricks secret key reference for a Cohere API key. If you prefer to paste your API key
+    directly, see `cohere_api_key_plaintext`. You must provide an API key using one of the following
+    fields: `cohere_api_key` or `cohere_api_key_plaintext`."""
+
+    cohere_api_key_plaintext: Optional[str] = None
+    """The Cohere API key provided as a plaintext string. If you prefer to reference your key using
+    Databricks Secrets, see `cohere_api_key`. You must provide an API key using one of the following
+    fields: `cohere_api_key` or `cohere_api_key_plaintext`."""
 
     def as_dict(self) -> dict:
         """Serializes the CohereConfig into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.cohere_api_base is not None: body['cohere_api_base'] = self.cohere_api_base
         if self.cohere_api_key is not None: body['cohere_api_key'] = self.cohere_api_key
+        if self.cohere_api_key_plaintext is not None:
+            body['cohere_api_key_plaintext'] = self.cohere_api_key_plaintext
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CohereConfig:
         """Deserializes the CohereConfig from a dictionary."""
-        return cls(cohere_api_key=d.get('cohere_api_key', None))
-
-
-@dataclass
-class CreateAppDeploymentRequest:
-    source_code_path: str
-    """The workspace file system path of the source code used to create the app deployment. This is
-    different from `deployment_artifacts.source_code_path`, which is the path used by the deployed
-    app. The former refers to the original source code location of the app in the workspace during
-    deployment creation, whereas the latter provides a system generated stable snapshotted source
-    code path used by the deployment."""
-
-    mode: AppDeploymentMode
-    """The mode of which the deployment will manage the source code."""
-
-    app_name: Optional[str] = None
-    """The name of the app."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateAppDeploymentRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.app_name is not None: body['app_name'] = self.app_name
-        if self.mode is not None: body['mode'] = self.mode.value
-        if self.source_code_path is not None: body['source_code_path'] = self.source_code_path
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CreateAppDeploymentRequest:
-        """Deserializes the CreateAppDeploymentRequest from a dictionary."""
-        return cls(app_name=d.get('app_name', None),
-                   mode=_enum(d, 'mode', AppDeploymentMode),
-                   source_code_path=d.get('source_code_path', None))
-
-
-@dataclass
-class CreateAppRequest:
-    name: str
-    """The name of the app. The name must contain only lowercase alphanumeric characters and hyphens.
-    It must be unique within the workspace."""
-
-    description: Optional[str] = None
-    """The description of the app."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateAppRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.description is not None: body['description'] = self.description
-        if self.name is not None: body['name'] = self.name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CreateAppRequest:
-        """Deserializes the CreateAppRequest from a dictionary."""
-        return cls(description=d.get('description', None), name=d.get('name', None))
+        return cls(cohere_api_base=d.get('cohere_api_base', None),
+                   cohere_api_key=d.get('cohere_api_key', None),
+                   cohere_api_key_plaintext=d.get('cohere_api_key_plaintext', None))
 
 
 @dataclass
@@ -573,19 +351,30 @@ class CreateServingEndpoint:
 
 @dataclass
 class DatabricksModelServingConfig:
-    databricks_api_token: str
-    """The Databricks secret key reference for a Databricks API token that corresponds to a user or
-    service principal with Can Query access to the model serving endpoint pointed to by this
-    external model."""
-
     databricks_workspace_url: str
     """The URL of the Databricks workspace containing the model serving endpoint pointed to by this
     external model."""
 
+    databricks_api_token: Optional[str] = None
+    """The Databricks secret key reference for a Databricks API token that corresponds to a user or
+    service principal with Can Query access to the model serving endpoint pointed to by this
+    external model. If you prefer to paste your API key directly, see
+    `databricks_api_token_plaintext`. You must provide an API key using one of the following fields:
+    `databricks_api_token` or `databricks_api_token_plaintext`."""
+
+    databricks_api_token_plaintext: Optional[str] = None
+    """The Databricks API token that corresponds to a user or service principal with Can Query access
+    to the model serving endpoint pointed to by this external model provided as a plaintext string.
+    If you prefer to reference your key using Databricks Secrets, see `databricks_api_token`. You
+    must provide an API key using one of the following fields: `databricks_api_token` or
+    `databricks_api_token_plaintext`."""
+
     def as_dict(self) -> dict:
         """Serializes the DatabricksModelServingConfig into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.databricks_api_token is not None: body['databricks_api_token'] = self.databricks_api_token
+        if self.databricks_api_token_plaintext is not None:
+            body['databricks_api_token_plaintext'] = self.databricks_api_token_plaintext
         if self.databricks_workspace_url is not None:
             body['databricks_workspace_url'] = self.databricks_workspace_url
         return body
@@ -594,6 +383,7 @@ class DatabricksModelServingConfig:
     def from_dict(cls, d: Dict[str, any]) -> DatabricksModelServingConfig:
         """Deserializes the DatabricksModelServingConfig from a dictionary."""
         return cls(databricks_api_token=d.get('databricks_api_token', None),
+                   databricks_api_token_plaintext=d.get('databricks_api_token_plaintext', None),
                    databricks_workspace_url=d.get('databricks_workspace_url', None))
 
 
@@ -846,6 +636,7 @@ class EndpointStateConfigUpdate(Enum):
 
     IN_PROGRESS = 'IN_PROGRESS'
     NOT_UPDATING = 'NOT_UPDATING'
+    UPDATE_CANCELED = 'UPDATE_CANCELED'
     UPDATE_FAILED = 'UPDATE_FAILED'
 
 
@@ -879,28 +670,6 @@ class EndpointTag:
         return cls(key=d.get('key', None), value=d.get('value', None))
 
 
-@dataclass
-class EnvVariable:
-    name: Optional[str] = None
-
-    value: Optional[str] = None
-
-    value_from: Optional[str] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the EnvVariable into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.name is not None: body['name'] = self.name
-        if self.value is not None: body['value'] = self.value
-        if self.value_from is not None: body['value_from'] = self.value_from
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> EnvVariable:
-        """Deserializes the EnvVariable from a dictionary."""
-        return cls(name=d.get('name', None), value=d.get('value', None), value_from=d.get('value_from', None))
-
-
 @dataclass
 class ExportMetricsResponse:
     contents: Optional[BinaryIO] = None
@@ -921,8 +690,8 @@ class ExportMetricsResponse:
 class ExternalModel:
     provider: ExternalModelProvider
     """The name of the provider for the external model. Currently, the supported providers are
-    'ai21labs', 'anthropic', 'amazon-bedrock', 'cohere', 'databricks-model-serving', 'openai', and
-    'palm'.","""
+    'ai21labs', 'anthropic', 'amazon-bedrock', 'cohere', 'databricks-model-serving',
+    'google-cloud-vertex-ai', 'openai', and 'palm'.","""
 
     name: str
     """The name of the external model."""
@@ -945,6 +714,9 @@ class ExternalModel:
     databricks_model_serving_config: Optional[DatabricksModelServingConfig] = None
     """Databricks Model Serving Config. Only required if the provider is 'databricks-model-serving'."""
 
+    google_cloud_vertex_ai_config: Optional[GoogleCloudVertexAiConfig] = None
+    """Google Cloud Vertex AI Config. Only required if the provider is 'google-cloud-vertex-ai'."""
+
     openai_config: Optional[OpenAiConfig] = None
     """OpenAI Config. Only required if the provider is 'openai'."""
 
@@ -960,6 +732,8 @@ class ExternalModel:
         if self.cohere_config: body['cohere_config'] = self.cohere_config.as_dict()
         if self.databricks_model_serving_config:
             body['databricks_model_serving_config'] = self.databricks_model_serving_config.as_dict()
+        if self.google_cloud_vertex_ai_config:
+            body['google_cloud_vertex_ai_config'] = self.google_cloud_vertex_ai_config.as_dict()
         if self.name is not None: body['name'] = self.name
         if self.openai_config: body['openai_config'] = self.openai_config.as_dict()
         if self.palm_config: body['palm_config'] = self.palm_config.as_dict()
@@ -976,6 +750,8 @@ class ExternalModel:
                    cohere_config=_from_dict(d, 'cohere_config', CohereConfig),
                    databricks_model_serving_config=_from_dict(d, 'databricks_model_serving_config',
                                                               DatabricksModelServingConfig),
+                   google_cloud_vertex_ai_config=_from_dict(d, 'google_cloud_vertex_ai_config',
+                                                            GoogleCloudVertexAiConfig),
                    name=d.get('name', None),
                    openai_config=_from_dict(d, 'openai_config', OpenAiConfig),
                    palm_config=_from_dict(d, 'palm_config', PaLmConfig),
@@ -985,14 +761,15 @@ class ExternalModel:
 
 class ExternalModelProvider(Enum):
     """The name of the provider for the external model. Currently, the supported providers are
-    'ai21labs', 'anthropic', 'amazon-bedrock', 'cohere', 'databricks-model-serving', 'openai', and
-    'palm'.","""
+    'ai21labs', 'anthropic', 'amazon-bedrock', 'cohere', 'databricks-model-serving',
+    'google-cloud-vertex-ai', 'openai', and 'palm'.","""
 
     AI21LABS = 'ai21labs'
     AMAZON_BEDROCK = 'amazon-bedrock'
     ANTHROPIC = 'anthropic'
     COHERE = 'cohere'
     DATABRICKS_MODEL_SERVING = 'databricks-model-serving'
+    GOOGLE_CLOUD_VERTEX_AI = 'google-cloud-vertex-ai'
     OPENAI = 'openai'
     PALM = 'palm'
 
@@ -1091,45 +868,48 @@ class GetServingEndpointPermissionLevelsResponse:
 
 
 @dataclass
-class ListAppDeploymentsResponse:
-    app_deployments: Optional[List[AppDeployment]] = None
-    """Deployment history of the app."""
-
-    next_page_token: Optional[str] = None
-    """Pagination token to request the next page of apps."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ListAppDeploymentsResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.app_deployments: body['app_deployments'] = [v.as_dict() for v in self.app_deployments]
-        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> ListAppDeploymentsResponse:
-        """Deserializes the ListAppDeploymentsResponse from a dictionary."""
-        return cls(app_deployments=_repeated_dict(d, 'app_deployments', AppDeployment),
-                   next_page_token=d.get('next_page_token', None))
+class GoogleCloudVertexAiConfig:
+    private_key: Optional[str] = None
+    """The Databricks secret key reference for a private key for the service account which has access
+    to the Google Cloud Vertex AI Service. See [Best practices for managing service account keys].
+    If you prefer to paste your API key directly, see `private_key_plaintext`. You must provide an
+    API key using one of the following fields: `private_key` or `private_key_plaintext`
+    
+    [Best practices for managing service account keys]: https://cloud.google.com/iam/docs/best-practices-for-managing-service-account-keys"""
 
+    private_key_plaintext: Optional[str] = None
+    """The private key for the service account which has access to the Google Cloud Vertex AI Service
+    provided as a plaintext secret. See [Best practices for managing service account keys]. If you
+    prefer to reference your key using Databricks Secrets, see `private_key`. You must provide an
+    API key using one of the following fields: `private_key` or `private_key_plaintext`.
+    
+    [Best practices for managing service account keys]: https://cloud.google.com/iam/docs/best-practices-for-managing-service-account-keys"""
 
-@dataclass
-class ListAppsResponse:
-    apps: Optional[List[App]] = None
+    project_id: Optional[str] = None
+    """This is the Google Cloud project id that the service account is associated with."""
 
-    next_page_token: Optional[str] = None
-    """Pagination token to request the next page of apps."""
+    region: Optional[str] = None
+    """This is the region for the Google Cloud Vertex AI Service. See [supported regions] for more
+    details. Some models are only available in specific regions.
+    
+    [supported regions]: https://cloud.google.com/vertex-ai/docs/general/locations"""
 
     def as_dict(self) -> dict:
-        """Serializes the ListAppsResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the GoogleCloudVertexAiConfig into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.apps: body['apps'] = [v.as_dict() for v in self.apps]
-        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.private_key is not None: body['private_key'] = self.private_key
+        if self.private_key_plaintext is not None: body['private_key_plaintext'] = self.private_key_plaintext
+        if self.project_id is not None: body['project_id'] = self.project_id
+        if self.region is not None: body['region'] = self.region
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> ListAppsResponse:
-        """Deserializes the ListAppsResponse from a dictionary."""
-        return cls(apps=_repeated_dict(d, 'apps', App), next_page_token=d.get('next_page_token', None))
+    def from_dict(cls, d: Dict[str, any]) -> GoogleCloudVertexAiConfig:
+        """Deserializes the GoogleCloudVertexAiConfig from a dictionary."""
+        return cls(private_key=d.get('private_key', None),
+                   private_key_plaintext=d.get('private_key_plaintext', None),
+                   project_id=d.get('project_id', None),
+                   region=d.get('region', None))
 
 
 @dataclass
@@ -1172,19 +952,35 @@ class OpenAiConfig:
     """This field is only required for Azure AD OpenAI and is the Microsoft Entra Client ID."""
 
     microsoft_entra_client_secret: Optional[str] = None
-    """The Databricks secret key reference for the Microsoft Entra Client Secret that is only required
-    for Azure AD OpenAI."""
+    """The Databricks secret key reference for a client secret used for Microsoft Entra ID
+    authentication. If you prefer to paste your client secret directly, see
+    `microsoft_entra_client_secret_plaintext`. You must provide an API key using one of the
+    following fields: `microsoft_entra_client_secret` or `microsoft_entra_client_secret_plaintext`."""
+
+    microsoft_entra_client_secret_plaintext: Optional[str] = None
+    """The client secret used for Microsoft Entra ID authentication provided as a plaintext string. If
+    you prefer to reference your key using Databricks Secrets, see `microsoft_entra_client_secret`.
+    You must provide an API key using one of the following fields: `microsoft_entra_client_secret`
+    or `microsoft_entra_client_secret_plaintext`."""
 
     microsoft_entra_tenant_id: Optional[str] = None
     """This field is only required for Azure AD OpenAI and is the Microsoft Entra Tenant ID."""
 
     openai_api_base: Optional[str] = None
-    """This is the base URL for the OpenAI API (default: "https://api.openai.com/v1"). For Azure
-    OpenAI, this field is required, and is the base URL for the Azure OpenAI API service provided by
-    Azure."""
+    """This is a field to provide a customized base URl for the OpenAI API. For Azure OpenAI, this
+    field is required, and is the base URL for the Azure OpenAI API service provided by Azure. For
+    other OpenAI API types, this field is optional, and if left unspecified, the standard OpenAI
+    base URL is used."""
 
     openai_api_key: Optional[str] = None
-    """The Databricks secret key reference for an OpenAI or Azure OpenAI API key."""
+    """The Databricks secret key reference for an OpenAI API key using the OpenAI or Azure service. If
+    you prefer to paste your API key directly, see `openai_api_key_plaintext`. You must provide an
+    API key using one of the following fields: `openai_api_key` or `openai_api_key_plaintext`."""
+
+    openai_api_key_plaintext: Optional[str] = None
+    """The OpenAI API key using the OpenAI or Azure service provided as a plaintext string. If you
+    prefer to reference your key using Databricks Secrets, see `openai_api_key`. You must provide an
+    API key using one of the following fields: `openai_api_key` or `openai_api_key_plaintext`."""
 
     openai_api_type: Optional[str] = None
     """This is an optional field to specify the type of OpenAI API to use. For Azure OpenAI, this field
@@ -1210,10 +1006,14 @@ class OpenAiConfig:
             body['microsoft_entra_client_id'] = self.microsoft_entra_client_id
         if self.microsoft_entra_client_secret is not None:
             body['microsoft_entra_client_secret'] = self.microsoft_entra_client_secret
+        if self.microsoft_entra_client_secret_plaintext is not None:
+            body['microsoft_entra_client_secret_plaintext'] = self.microsoft_entra_client_secret_plaintext
         if self.microsoft_entra_tenant_id is not None:
             body['microsoft_entra_tenant_id'] = self.microsoft_entra_tenant_id
         if self.openai_api_base is not None: body['openai_api_base'] = self.openai_api_base
         if self.openai_api_key is not None: body['openai_api_key'] = self.openai_api_key
+        if self.openai_api_key_plaintext is not None:
+            body['openai_api_key_plaintext'] = self.openai_api_key_plaintext
         if self.openai_api_type is not None: body['openai_api_type'] = self.openai_api_type
         if self.openai_api_version is not None: body['openai_api_version'] = self.openai_api_version
         if self.openai_deployment_name is not None:
@@ -1226,9 +1026,12 @@ class OpenAiConfig:
         """Deserializes the OpenAiConfig from a dictionary."""
         return cls(microsoft_entra_client_id=d.get('microsoft_entra_client_id', None),
                    microsoft_entra_client_secret=d.get('microsoft_entra_client_secret', None),
+                   microsoft_entra_client_secret_plaintext=d.get('microsoft_entra_client_secret_plaintext',
+                                                                 None),
                    microsoft_entra_tenant_id=d.get('microsoft_entra_tenant_id', None),
                    openai_api_base=d.get('openai_api_base', None),
                    openai_api_key=d.get('openai_api_key', None),
+                   openai_api_key_plaintext=d.get('openai_api_key_plaintext', None),
                    openai_api_type=d.get('openai_api_type', None),
                    openai_api_version=d.get('openai_api_version', None),
                    openai_deployment_name=d.get('openai_deployment_name', None),
@@ -1237,19 +1040,29 @@ class OpenAiConfig:
 
 @dataclass
 class PaLmConfig:
-    palm_api_key: str
-    """The Databricks secret key reference for a PaLM API key."""
+    palm_api_key: Optional[str] = None
+    """The Databricks secret key reference for a PaLM API key. If you prefer to paste your API key
+    directly, see `palm_api_key_plaintext`. You must provide an API key using one of the following
+    fields: `palm_api_key` or `palm_api_key_plaintext`."""
+
+    palm_api_key_plaintext: Optional[str] = None
+    """The PaLM API key provided as a plaintext string. If you prefer to reference your key using
+    Databricks Secrets, see `palm_api_key`. You must provide an API key using one of the following
+    fields: `palm_api_key` or `palm_api_key_plaintext`."""
 
     def as_dict(self) -> dict:
         """Serializes the PaLmConfig into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.palm_api_key is not None: body['palm_api_key'] = self.palm_api_key
+        if self.palm_api_key_plaintext is not None:
+            body['palm_api_key_plaintext'] = self.palm_api_key_plaintext
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PaLmConfig:
         """Deserializes the PaLmConfig from a dictionary."""
-        return cls(palm_api_key=d.get('palm_api_key', None))
+        return cls(palm_api_key=d.get('palm_api_key', None),
+                   palm_api_key_plaintext=d.get('palm_api_key_plaintext', None))
 
 
 @dataclass
@@ -1581,11 +1394,10 @@ class ServedEntityInput:
     external_model: Optional[ExternalModel] = None
     """The external model to be served. NOTE: Only one of external_model and (entity_name,
     entity_version, workload_size, workload_type, and scale_to_zero_enabled) can be specified with
-    the latter set being used for custom model serving for a Databricks registered model. When an
-    external_model is present, the served entities list can only have one served_entity object. For
-    an existing endpoint with external_model, it can not be updated to an endpoint without
+    the latter set being used for custom model serving for a Databricks registered model. For an
+    existing endpoint with external_model, it cannot be updated to an endpoint without
     external_model. If the endpoint is created without external_model, users cannot update it to add
-    external_model later."""
+    external_model later. The task type of all external models within an endpoint must be the same."""
 
     instance_profile_arn: Optional[str] = None
     """ARN of the instance profile that the served entity uses to access AWS resources."""
@@ -2404,32 +2216,6 @@ class ServingEndpointPermissionsRequest:
                    serving_endpoint_id=d.get('serving_endpoint_id', None))
 
 
-@dataclass
-class StartAppRequest:
-    name: Optional[str] = None
-    """The name of the app."""
-
-
-@dataclass
-class StopAppRequest:
-    name: Optional[str] = None
-    """The name of the app."""
-
-
-@dataclass
-class StopAppResponse:
-
-    def as_dict(self) -> dict:
-        """Serializes the StopAppResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> StopAppResponse:
-        """Deserializes the StopAppResponse from a dictionary."""
-        return cls()
-
-
 @dataclass
 class TrafficConfig:
     routes: Optional[List[Route]] = None
@@ -2447,28 +2233,6 @@ class TrafficConfig:
         return cls(routes=_repeated_dict(d, 'routes', Route))
 
 
-@dataclass
-class UpdateAppRequest:
-    name: str
-    """The name of the app. The name must contain only lowercase alphanumeric characters and hyphens.
-    It must be unique within the workspace."""
-
-    description: Optional[str] = None
-    """The description of the app."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateAppRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.description is not None: body['description'] = self.description
-        if self.name is not None: body['name'] = self.name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> UpdateAppRequest:
-        """Deserializes the UpdateAppRequest from a dictionary."""
-        return cls(description=d.get('description', None), name=d.get('name', None))
-
-
 @dataclass
 class V1ResponseChoiceElement:
     finish_reason: Optional[str] = None
@@ -2506,333 +2270,6 @@ class V1ResponseChoiceElement:
                    text=d.get('text', None))
 
 
-class AppsAPI:
-    """Apps run directly on a customer’s Databricks instance, integrate with their data, use and extend
-    Databricks services, and enable users to interact through single sign-on."""
-
-    def __init__(self, api_client):
-        self._api = api_client
-
-    def wait_get_app_idle(self,
-                          name: str,
-                          timeout=timedelta(minutes=20),
-                          callback: Optional[Callable[[App], None]] = None) -> App:
-        deadline = time.time() + timeout.total_seconds()
-        target_states = (AppState.IDLE, )
-        failure_states = (AppState.ERROR, )
-        status_message = 'polling...'
-        attempt = 1
-        while time.time() < deadline:
-            poll = self.get(name=name)
-            status = poll.status.state
-            status_message = f'current status: {status}'
-            if poll.status:
-                status_message = poll.status.message
-            if status in target_states:
-                return poll
-            if callback:
-                callback(poll)
-            if status in failure_states:
-                msg = f'failed to reach IDLE, got {status}: {status_message}'
-                raise OperationFailed(msg)
-            prefix = f"name={name}"
-            sleep = attempt
-            if sleep > 10:
-                # sleep 10s max per attempt
-                sleep = 10
-            _LOG.debug(f'{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)')
-            time.sleep(sleep + random.random())
-            attempt += 1
-        raise TimeoutError(f'timed out after {timeout}: {status_message}')
-
-    def wait_get_deployment_app_succeeded(
-            self,
-            app_name: str,
-            deployment_id: str,
-            timeout=timedelta(minutes=20),
-            callback: Optional[Callable[[AppDeployment], None]] = None) -> AppDeployment:
-        deadline = time.time() + timeout.total_seconds()
-        target_states = (AppDeploymentState.SUCCEEDED, )
-        failure_states = (AppDeploymentState.FAILED, )
-        status_message = 'polling...'
-        attempt = 1
-        while time.time() < deadline:
-            poll = self.get_deployment(app_name=app_name, deployment_id=deployment_id)
-            status = poll.status.state
-            status_message = f'current status: {status}'
-            if poll.status:
-                status_message = poll.status.message
-            if status in target_states:
-                return poll
-            if callback:
-                callback(poll)
-            if status in failure_states:
-                msg = f'failed to reach SUCCEEDED, got {status}: {status_message}'
-                raise OperationFailed(msg)
-            prefix = f"app_name={app_name}, deployment_id={deployment_id}"
-            sleep = attempt
-            if sleep > 10:
-                # sleep 10s max per attempt
-                sleep = 10
-            _LOG.debug(f'{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)')
-            time.sleep(sleep + random.random())
-            attempt += 1
-        raise TimeoutError(f'timed out after {timeout}: {status_message}')
-
-    def create(self, name: str, *, description: Optional[str] = None) -> Wait[App]:
-        """Create an app.
-        
-        Creates a new app.
-        
-        :param name: str
-          The name of the app. The name must contain only lowercase alphanumeric characters and hyphens. It
-          must be unique within the workspace.
-        :param description: str (optional)
-          The description of the app.
-        
-        :returns:
-          Long-running operation waiter for :class:`App`.
-          See :method:wait_get_app_idle for more details.
-        """
-        body = {}
-        if description is not None: body['description'] = description
-        if name is not None: body['name'] = name
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        op_response = self._api.do('POST', '/api/2.0/preview/apps', body=body, headers=headers)
-        return Wait(self.wait_get_app_idle, response=App.from_dict(op_response), name=op_response['name'])
-
-    def create_and_wait(self,
-                        name: str,
-                        *,
-                        description: Optional[str] = None,
-                        timeout=timedelta(minutes=20)) -> App:
-        return self.create(description=description, name=name).result(timeout=timeout)
-
-    def delete(self, name: str):
-        """Delete an app.
-        
-        Deletes an app.
-        
-        :param name: str
-          The name of the app.
-        
-        
-        """
-
-        headers = {'Accept': 'application/json', }
-
-        self._api.do('DELETE', f'/api/2.0/preview/apps/{name}', headers=headers)
-
-    def deploy(self, app_name: str, source_code_path: str, mode: AppDeploymentMode) -> Wait[AppDeployment]:
-        """Create an app deployment.
-        
-        Creates an app deployment for the app with the supplied name.
-        
-        :param app_name: str
-          The name of the app.
-        :param source_code_path: str
-          The workspace file system path of the source code used to create the app deployment. This is
-          different from `deployment_artifacts.source_code_path`, which is the path used by the deployed app.
-          The former refers to the original source code location of the app in the workspace during deployment
-          creation, whereas the latter provides a system generated stable snapshotted source code path used by
-          the deployment.
-        :param mode: :class:`AppDeploymentMode`
-          The mode of which the deployment will manage the source code.
-        
-        :returns:
-          Long-running operation waiter for :class:`AppDeployment`.
-          See :method:wait_get_deployment_app_succeeded for more details.
-        """
-        body = {}
-        if mode is not None: body['mode'] = mode.value
-        if source_code_path is not None: body['source_code_path'] = source_code_path
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        op_response = self._api.do('POST',
-                                   f'/api/2.0/preview/apps/{app_name}/deployments',
-                                   body=body,
-                                   headers=headers)
-        return Wait(self.wait_get_deployment_app_succeeded,
-                    response=AppDeployment.from_dict(op_response),
-                    app_name=app_name,
-                    deployment_id=op_response['deployment_id'])
-
-    def deploy_and_wait(self,
-                        app_name: str,
-                        source_code_path: str,
-                        mode: AppDeploymentMode,
-                        timeout=timedelta(minutes=20)) -> AppDeployment:
-        return self.deploy(app_name=app_name, mode=mode,
-                           source_code_path=source_code_path).result(timeout=timeout)
-
-    def get(self, name: str) -> App:
-        """Get an app.
-        
-        Retrieves information for the app with the supplied name.
-        
-        :param name: str
-          The name of the app.
-        
-        :returns: :class:`App`
-        """
-
-        headers = {'Accept': 'application/json', }
-
-        res = self._api.do('GET', f'/api/2.0/preview/apps/{name}', headers=headers)
-        return App.from_dict(res)
-
-    def get_deployment(self, app_name: str, deployment_id: str) -> AppDeployment:
-        """Get an app deployment.
-        
-        Retrieves information for the app deployment with the supplied name and deployment id.
-        
-        :param app_name: str
-          The name of the app.
-        :param deployment_id: str
-          The unique id of the deployment.
-        
-        :returns: :class:`AppDeployment`
-        """
-
-        headers = {'Accept': 'application/json', }
-
-        res = self._api.do('GET',
-                           f'/api/2.0/preview/apps/{app_name}/deployments/{deployment_id}',
-                           headers=headers)
-        return AppDeployment.from_dict(res)
-
-    def get_environment(self, name: str) -> AppEnvironment:
-        """Get app environment.
-        
-        Retrieves app environment.
-        
-        :param name: str
-          The name of the app.
-        
-        :returns: :class:`AppEnvironment`
-        """
-
-        headers = {'Accept': 'application/json', }
-
-        res = self._api.do('GET', f'/api/2.0/preview/apps/{name}/environment', headers=headers)
-        return AppEnvironment.from_dict(res)
-
-    def list(self, *, page_size: Optional[int] = None, page_token: Optional[str] = None) -> Iterator[App]:
-        """List apps.
-        
-        Lists all apps in the workspace.
-        
-        :param page_size: int (optional)
-          Upper bound for items returned.
-        :param page_token: str (optional)
-          Pagination token to go to the next page of apps. Requests first page if absent.
-        
-        :returns: Iterator over :class:`App`
-        """
-
-        query = {}
-        if page_size is not None: query['page_size'] = page_size
-        if page_token is not None: query['page_token'] = page_token
-        headers = {'Accept': 'application/json', }
-
-        while True:
-            json = self._api.do('GET', '/api/2.0/preview/apps', query=query, headers=headers)
-            if 'apps' in json:
-                for v in json['apps']:
-                    yield App.from_dict(v)
-            if 'next_page_token' not in json or not json['next_page_token']:
-                return
-            query['page_token'] = json['next_page_token']
-
-    def list_deployments(self,
-                         app_name: str,
-                         *,
-                         page_size: Optional[int] = None,
-                         page_token: Optional[str] = None) -> Iterator[AppDeployment]:
-        """List app deployments.
-        
-        Lists all app deployments for the app with the supplied name.
-        
-        :param app_name: str
-          The name of the app.
-        :param page_size: int (optional)
-          Upper bound for items returned.
-        :param page_token: str (optional)
-          Pagination token to go to the next page of apps. Requests first page if absent.
-        
-        :returns: Iterator over :class:`AppDeployment`
-        """
-
-        query = {}
-        if page_size is not None: query['page_size'] = page_size
-        if page_token is not None: query['page_token'] = page_token
-        headers = {'Accept': 'application/json', }
-
-        while True:
-            json = self._api.do('GET',
-                                f'/api/2.0/preview/apps/{app_name}/deployments',
-                                query=query,
-                                headers=headers)
-            if 'app_deployments' in json:
-                for v in json['app_deployments']:
-                    yield AppDeployment.from_dict(v)
-            if 'next_page_token' not in json or not json['next_page_token']:
-                return
-            query['page_token'] = json['next_page_token']
-
-    def start(self, name: str) -> AppDeployment:
-        """Start an app.
-        
-        Start the last active deployment of the app in the workspace.
-        
-        :param name: str
-          The name of the app.
-        
-        :returns: :class:`AppDeployment`
-        """
-
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        res = self._api.do('POST', f'/api/2.0/preview/apps/{name}/start', headers=headers)
-        return AppDeployment.from_dict(res)
-
-    def stop(self, name: str):
-        """Stop an app.
-        
-        Stops the active deployment of the app in the workspace.
-        
-        :param name: str
-          The name of the app.
-        
-        
-        """
-
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        self._api.do('POST', f'/api/2.0/preview/apps/{name}/stop', headers=headers)
-
-    def update(self, name: str, *, description: Optional[str] = None) -> App:
-        """Update an app.
-        
-        Updates the app with the supplied name.
-        
-        :param name: str
-          The name of the app. The name must contain only lowercase alphanumeric characters and hyphens. It
-          must be unique within the workspace.
-        :param description: str (optional)
-          The description of the app.
-        
-        :returns: :class:`App`
-        """
-        body = {}
-        if description is not None: body['description'] = description
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        res = self._api.do('PATCH', f'/api/2.0/preview/apps/{name}', body=body, headers=headers)
-        return App.from_dict(res)
-
-
 class ServingEndpointsAPI:
     """The Serving Endpoints API allows you to create, update, and delete model serving endpoints.
     
@@ -2855,7 +2292,8 @@ class ServingEndpointsAPI:
             callback: Optional[Callable[[ServingEndpointDetailed], None]] = None) -> ServingEndpointDetailed:
         deadline = time.time() + timeout.total_seconds()
         target_states = (EndpointStateConfigUpdate.NOT_UPDATING, )
-        failure_states = (EndpointStateConfigUpdate.UPDATE_FAILED, )
+        failure_states = (EndpointStateConfigUpdate.UPDATE_FAILED, EndpointStateConfigUpdate.UPDATE_CANCELED,
+                          )
         status_message = 'polling...'
         attempt = 1
         while time.time() < deadline:
@@ -3335,3 +2773,118 @@ class ServingEndpointsAPI:
                            body=body,
                            headers=headers)
         return ServingEndpointPermissions.from_dict(res)
+
+
+class ServingEndpointsDataPlaneAPI:
+    """Serving endpoints DataPlane provides a set of operations to interact with data plane endpoints for Serving
+    endpoints service."""
+
+    def __init__(self, api_client, control_plane):
+        self._api = api_client
+        self._control_plane = control_plane
+        self._data_plane_service = DataPlaneService()
+
+    def query(self,
+              name: str,
+              *,
+              dataframe_records: Optional[List[Any]] = None,
+              dataframe_split: Optional[DataframeSplitInput] = None,
+              extra_params: Optional[Dict[str, str]] = None,
+              input: Optional[Any] = None,
+              inputs: Optional[Any] = None,
+              instances: Optional[List[Any]] = None,
+              max_tokens: Optional[int] = None,
+              messages: Optional[List[ChatMessage]] = None,
+              n: Optional[int] = None,
+              prompt: Optional[Any] = None,
+              stop: Optional[List[str]] = None,
+              stream: Optional[bool] = None,
+              temperature: Optional[float] = None) -> QueryEndpointResponse:
+        """Query a serving endpoint.
+        
+        :param name: str
+          The name of the serving endpoint. This field is required.
+        :param dataframe_records: List[Any] (optional)
+          Pandas Dataframe input in the records orientation.
+        :param dataframe_split: :class:`DataframeSplitInput` (optional)
+          Pandas Dataframe input in the split orientation.
+        :param extra_params: Dict[str,str] (optional)
+          The extra parameters field used ONLY for __completions, chat,__ and __embeddings external &
+          foundation model__ serving endpoints. This is a map of strings and should only be used with other
+          external/foundation model query fields.
+        :param input: Any (optional)
+          The input string (or array of strings) field used ONLY for __embeddings external & foundation
+          model__ serving endpoints and is the only field (along with extra_params if needed) used by
+          embeddings queries.
+        :param inputs: Any (optional)
+          Tensor-based input in columnar format.
+        :param instances: List[Any] (optional)
+          Tensor-based input in row format.
+        :param max_tokens: int (optional)
+          The max tokens field used ONLY for __completions__ and __chat external & foundation model__ serving
+          endpoints. This is an integer and should only be used with other chat/completions query fields.
+        :param messages: List[:class:`ChatMessage`] (optional)
+          The messages field used ONLY for __chat external & foundation model__ serving endpoints. This is a
+          map of strings and should only be used with other chat query fields.
+        :param n: int (optional)
+          The n (number of candidates) field used ONLY for __completions__ and __chat external & foundation
+          model__ serving endpoints. This is an integer between 1 and 5 with a default of 1 and should only be
+          used with other chat/completions query fields.
+        :param prompt: Any (optional)
+          The prompt string (or array of strings) field used ONLY for __completions external & foundation
+          model__ serving endpoints and should only be used with other completions query fields.
+        :param stop: List[str] (optional)
+          The stop sequences field used ONLY for __completions__ and __chat external & foundation model__
+          serving endpoints. This is a list of strings and should only be used with other chat/completions
+          query fields.
+        :param stream: bool (optional)
+          The stream field used ONLY for __completions__ and __chat external & foundation model__ serving
+          endpoints. This is a boolean defaulting to false and should only be used with other chat/completions
+          query fields.
+        :param temperature: float (optional)
+          The temperature field used ONLY for __completions__ and __chat external & foundation model__ serving
+          endpoints. This is a float between 0.0 and 2.0 with a default of 1.0 and should only be used with
+          other chat/completions query fields.
+        
+        :returns: :class:`QueryEndpointResponse`
+        """
+        body = {}
+        if dataframe_records is not None: body['dataframe_records'] = [v for v in dataframe_records]
+        if dataframe_split is not None: body['dataframe_split'] = dataframe_split.as_dict()
+        if extra_params is not None: body['extra_params'] = extra_params
+        if input is not None: body['input'] = input
+        if inputs is not None: body['inputs'] = inputs
+        if instances is not None: body['instances'] = [v for v in instances]
+        if max_tokens is not None: body['max_tokens'] = max_tokens
+        if messages is not None: body['messages'] = [v.as_dict() for v in messages]
+        if n is not None: body['n'] = n
+        if prompt is not None: body['prompt'] = prompt
+        if stop is not None: body['stop'] = [v for v in stop]
+        if stream is not None: body['stream'] = stream
+        if temperature is not None: body['temperature'] = temperature
+
+        def info_getter():
+            response = self._control_plane.get(name=name, )
+            if response.data_plane_info is None:
+                raise Exception("Resource does not support direct Data Plane access")
+            return response.data_plane_info.query_info
+
+        get_params = [name, ]
+        data_plane_details = self._data_plane_service.get_data_plane_details('query', get_params, info_getter,
+                                                                             self._api.get_oauth_token)
+        token = data_plane_details.token
+
+        def auth(r: requests.PreparedRequest) -> requests.PreparedRequest:
+            authorization = f"{token.token_type} {token.access_token}"
+            r.headers["Authorization"] = authorization
+            return r
+
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+        response_headers = ['served-model-name', ]
+        res = self._api.do('POST',
+                           url=data_plane_details.endpoint_url,
+                           body=body,
+                           headers=headers,
+                           response_headers=response_headers,
+                           auth=auth)
+        return QueryEndpointResponse.from_dict(res)