databricks-sdk 0.58.0__py3-none-any.whl → 0.59.0__py3-none-any.whl

databricks/sdk/service/serving.py

@@ -299,12 +299,12 @@ class AiGatewayInferenceTableConfig:
 
 @dataclass
 class AiGatewayRateLimit:
-    calls: int
-    """Used to specify how many calls are allowed for a key within the renewal_period."""
-
     renewal_period: AiGatewayRateLimitRenewalPeriod
     """Renewal period field for a rate limit. Currently, only 'minute' is supported."""
 
+    calls: Optional[int] = None
+    """Used to specify how many calls are allowed for a key within the renewal_period."""
+
     key: Optional[AiGatewayRateLimitKey] = None
     """Key field for a rate limit. Currently, 'user', 'user_group, 'service_principal', and 'endpoint'
     are supported, with 'endpoint' being the default if not specified."""
@@ -853,152 +853,6 @@ class CohereConfig:
         )
 
 
-@dataclass
-class CreatePtEndpointRequest:
-    name: str
-    """The name of the serving endpoint. This field is required and must be unique across a Databricks
-    workspace. An endpoint name can consist of alphanumeric characters, dashes, and underscores."""
-
-    config: PtEndpointCoreConfig
-    """The core config of the serving endpoint."""
-
-    ai_gateway: Optional[AiGatewayConfig] = None
-    """The AI Gateway configuration for the serving endpoint."""
-
-    budget_policy_id: Optional[str] = None
-    """The budget policy associated with the endpoint."""
-
-    tags: Optional[List[EndpointTag]] = None
-    """Tags to be attached to the serving endpoint and automatically propagated to billing logs."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreatePtEndpointRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.ai_gateway:
-            body["ai_gateway"] = self.ai_gateway.as_dict()
-        if self.budget_policy_id is not None:
-            body["budget_policy_id"] = self.budget_policy_id
-        if self.config:
-            body["config"] = self.config.as_dict()
-        if self.name is not None:
-            body["name"] = self.name
-        if self.tags:
-            body["tags"] = [v.as_dict() for v in self.tags]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreatePtEndpointRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.ai_gateway:
-            body["ai_gateway"] = self.ai_gateway
-        if self.budget_policy_id is not None:
-            body["budget_policy_id"] = self.budget_policy_id
-        if self.config:
-            body["config"] = self.config
-        if self.name is not None:
-            body["name"] = self.name
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreatePtEndpointRequest:
-        """Deserializes the CreatePtEndpointRequest from a dictionary."""
-        return cls(
-            ai_gateway=_from_dict(d, "ai_gateway", AiGatewayConfig),
-            budget_policy_id=d.get("budget_policy_id", None),
-            config=_from_dict(d, "config", PtEndpointCoreConfig),
-            name=d.get("name", None),
-            tags=_repeated_dict(d, "tags", EndpointTag),
-        )
-
-
-@dataclass
-class CreateServingEndpoint:
-    name: str
-    """The name of the serving endpoint. This field is required and must be unique across a Databricks
-    workspace. An endpoint name can consist of alphanumeric characters, dashes, and underscores."""
-
-    ai_gateway: Optional[AiGatewayConfig] = None
-    """The AI Gateway configuration for the serving endpoint. NOTE: External model, provisioned
-    throughput, and pay-per-token endpoints are fully supported; agent endpoints currently only
-    support inference tables."""
-
-    budget_policy_id: Optional[str] = None
-    """The budget policy to be applied to the serving endpoint."""
-
-    config: Optional[EndpointCoreConfigInput] = None
-    """The core config of the serving endpoint."""
-
-    description: Optional[str] = None
-
-    rate_limits: Optional[List[RateLimit]] = None
-    """Rate limits to be applied to the serving endpoint. NOTE: this field is deprecated, please use AI
-    Gateway to manage rate limits."""
-
-    route_optimized: Optional[bool] = None
-    """Enable route optimization for the serving endpoint."""
-
-    tags: Optional[List[EndpointTag]] = None
-    """Tags to be attached to the serving endpoint and automatically propagated to billing logs."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateServingEndpoint into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.ai_gateway:
-            body["ai_gateway"] = self.ai_gateway.as_dict()
-        if self.budget_policy_id is not None:
-            body["budget_policy_id"] = self.budget_policy_id
-        if self.config:
-            body["config"] = self.config.as_dict()
-        if self.description is not None:
-            body["description"] = self.description
-        if self.name is not None:
-            body["name"] = self.name
-        if self.rate_limits:
-            body["rate_limits"] = [v.as_dict() for v in self.rate_limits]
-        if self.route_optimized is not None:
-            body["route_optimized"] = self.route_optimized
-        if self.tags:
-            body["tags"] = [v.as_dict() for v in self.tags]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateServingEndpoint into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.ai_gateway:
-            body["ai_gateway"] = self.ai_gateway
-        if self.budget_policy_id is not None:
-            body["budget_policy_id"] = self.budget_policy_id
-        if self.config:
-            body["config"] = self.config
-        if self.description is not None:
-            body["description"] = self.description
-        if self.name is not None:
-            body["name"] = self.name
-        if self.rate_limits:
-            body["rate_limits"] = self.rate_limits
-        if self.route_optimized is not None:
-            body["route_optimized"] = self.route_optimized
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateServingEndpoint:
-        """Deserializes the CreateServingEndpoint from a dictionary."""
-        return cls(
-            ai_gateway=_from_dict(d, "ai_gateway", AiGatewayConfig),
-            budget_policy_id=d.get("budget_policy_id", None),
-            config=_from_dict(d, "config", EndpointCoreConfigInput),
-            description=d.get("description", None),
-            name=d.get("name", None),
-            rate_limits=_repeated_dict(d, "rate_limits", RateLimit),
-            route_optimized=d.get("route_optimized", None),
-            tags=_repeated_dict(d, "tags", EndpointTag),
-        )
-
-
 @dataclass
 class CustomProviderConfig:
     """Configs needed to create a custom provider model route."""
@@ -1601,76 +1455,6 @@ class ExportMetricsResponse:
         return cls(contents=d.get("contents", None))
 
 
-@dataclass
-class ExternalFunctionRequest:
-    """Simple Proto message for testing"""
-
-    connection_name: str
-    """The connection name to use. This is required to identify the external connection."""
-
-    method: ExternalFunctionRequestHttpMethod
-    """The HTTP method to use (e.g., 'GET', 'POST')."""
-
-    path: str
-    """The relative path for the API endpoint. This is required."""
-
-    headers: Optional[str] = None
-    """Additional headers for the request. If not provided, only auth headers from connections would be
-    passed."""
-
-    json: Optional[str] = None
-    """The JSON payload to send in the request body."""
-
-    params: Optional[str] = None
-    """Query parameters for the request."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ExternalFunctionRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.connection_name is not None:
-            body["connection_name"] = self.connection_name
-        if self.headers is not None:
-            body["headers"] = self.headers
-        if self.json is not None:
-            body["json"] = self.json
-        if self.method is not None:
-            body["method"] = self.method.value
-        if self.params is not None:
-            body["params"] = self.params
-        if self.path is not None:
-            body["path"] = self.path
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ExternalFunctionRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.connection_name is not None:
-            body["connection_name"] = self.connection_name
-        if self.headers is not None:
-            body["headers"] = self.headers
-        if self.json is not None:
-            body["json"] = self.json
-        if self.method is not None:
-            body["method"] = self.method
-        if self.params is not None:
-            body["params"] = self.params
-        if self.path is not None:
-            body["path"] = self.path
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ExternalFunctionRequest:
-        """Deserializes the ExternalFunctionRequest from a dictionary."""
-        return cls(
-            connection_name=d.get("connection_name", None),
-            headers=d.get("headers", None),
-            json=d.get("json", None),
-            method=_enum(d, "method", ExternalFunctionRequestHttpMethod),
-            params=d.get("params", None),
-            path=d.get("path", None),
-        )
-
-
 class ExternalFunctionRequestHttpMethod(Enum):
 
     DELETE = "DELETE"
@@ -2291,49 +2075,6 @@ class PaLmConfig:
         )
 
 
-@dataclass
-class PatchServingEndpointTags:
-    add_tags: Optional[List[EndpointTag]] = None
-    """List of endpoint tags to add"""
-
-    delete_tags: Optional[List[str]] = None
-    """List of tag keys to delete"""
-
-    name: Optional[str] = None
-    """The name of the serving endpoint who's tags to patch. This field is required."""
-
-    def as_dict(self) -> dict:
-        """Serializes the PatchServingEndpointTags into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.add_tags:
-            body["add_tags"] = [v.as_dict() for v in self.add_tags]
-        if self.delete_tags:
-            body["delete_tags"] = [v for v in self.delete_tags]
-        if self.name is not None:
-            body["name"] = self.name
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the PatchServingEndpointTags into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.add_tags:
-            body["add_tags"] = self.add_tags
-        if self.delete_tags:
-            body["delete_tags"] = self.delete_tags
-        if self.name is not None:
-            body["name"] = self.name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> PatchServingEndpointTags:
-        """Deserializes the PatchServingEndpointTags from a dictionary."""
-        return cls(
-            add_tags=_repeated_dict(d, "add_tags", EndpointTag),
-            delete_tags=d.get("delete_tags", None),
-            name=d.get("name", None),
-        )
-
-
 @dataclass
 class PayloadTable:
     name: Optional[str] = None
@@ -2460,77 +2201,6 @@ class PtServedModel:
         )
 
 
-@dataclass
-class PutAiGatewayRequest:
-    fallback_config: Optional[FallbackConfig] = None
-    """Configuration for traffic fallback which auto fallbacks to other served entities if the request
-    to a served entity fails with certain error codes, to increase availability."""
-
-    guardrails: Optional[AiGatewayGuardrails] = None
-    """Configuration for AI Guardrails to prevent unwanted data and unsafe data in requests and
-    responses."""
-
-    inference_table_config: Optional[AiGatewayInferenceTableConfig] = None
-    """Configuration for payload logging using inference tables. Use these tables to monitor and audit
-    data being sent to and received from model APIs and to improve model quality."""
-
-    name: Optional[str] = None
-    """The name of the serving endpoint whose AI Gateway is being updated. This field is required."""
-
-    rate_limits: Optional[List[AiGatewayRateLimit]] = None
-    """Configuration for rate limits which can be set to limit endpoint traffic."""
-
-    usage_tracking_config: Optional[AiGatewayUsageTrackingConfig] = None
-    """Configuration to enable usage tracking using system tables. These tables allow you to monitor
-    operational usage on endpoints and their associated costs."""
-
-    def as_dict(self) -> dict:
-        """Serializes the PutAiGatewayRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.fallback_config:
-            body["fallback_config"] = self.fallback_config.as_dict()
-        if self.guardrails:
-            body["guardrails"] = self.guardrails.as_dict()
-        if self.inference_table_config:
-            body["inference_table_config"] = self.inference_table_config.as_dict()
-        if self.name is not None:
-            body["name"] = self.name
-        if self.rate_limits:
-            body["rate_limits"] = [v.as_dict() for v in self.rate_limits]
-        if self.usage_tracking_config:
-            body["usage_tracking_config"] = self.usage_tracking_config.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the PutAiGatewayRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.fallback_config:
-            body["fallback_config"] = self.fallback_config
-        if self.guardrails:
-            body["guardrails"] = self.guardrails
-        if self.inference_table_config:
-            body["inference_table_config"] = self.inference_table_config
-        if self.name is not None:
-            body["name"] = self.name
-        if self.rate_limits:
-            body["rate_limits"] = self.rate_limits
-        if self.usage_tracking_config:
-            body["usage_tracking_config"] = self.usage_tracking_config
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> PutAiGatewayRequest:
-        """Deserializes the PutAiGatewayRequest from a dictionary."""
-        return cls(
-            fallback_config=_from_dict(d, "fallback_config", FallbackConfig),
-            guardrails=_from_dict(d, "guardrails", AiGatewayGuardrails),
-            inference_table_config=_from_dict(d, "inference_table_config", AiGatewayInferenceTableConfig),
-            name=d.get("name", None),
-            rate_limits=_repeated_dict(d, "rate_limits", AiGatewayRateLimit),
-            usage_tracking_config=_from_dict(d, "usage_tracking_config", AiGatewayUsageTrackingConfig),
-        )
-
-
 @dataclass
 class PutAiGatewayResponse:
     fallback_config: Optional[FallbackConfig] = None
@@ -2594,38 +2264,6 @@ class PutAiGatewayResponse:
         )
 
 
-@dataclass
-class PutRequest:
-    name: Optional[str] = None
-    """The name of the serving endpoint whose rate limits are being updated. This field is required."""
-
-    rate_limits: Optional[List[RateLimit]] = None
-    """The list of endpoint rate limits."""
-
-    def as_dict(self) -> dict:
-        """Serializes the PutRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.name is not None:
-            body["name"] = self.name
-        if self.rate_limits:
-            body["rate_limits"] = [v.as_dict() for v in self.rate_limits]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the PutRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.name is not None:
-            body["name"] = self.name
-        if self.rate_limits:
-            body["rate_limits"] = self.rate_limits
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> PutRequest:
-        """Deserializes the PutRequest from a dictionary."""
-        return cls(name=d.get("name", None), rate_limits=_repeated_dict(d, "rate_limits", RateLimit))
-
-
 @dataclass
 class PutResponse:
     rate_limits: Optional[List[RateLimit]] = None
@@ -2651,153 +2289,6 @@ class PutResponse:
         return cls(rate_limits=_repeated_dict(d, "rate_limits", RateLimit))
 
 
-@dataclass
-class QueryEndpointInput:
-    dataframe_records: Optional[List[Any]] = None
-    """Pandas Dataframe input in the records orientation."""
-
-    dataframe_split: Optional[DataframeSplitInput] = None
-    """Pandas Dataframe input in the split orientation."""
-
-    extra_params: Optional[Dict[str, str]] = None
-    """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."""
-
-    input: Optional[Any] = None
-    """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."""
-
-    inputs: Optional[Any] = None
-    """Tensor-based input in columnar format."""
-
-    instances: Optional[List[Any]] = None
-    """Tensor-based input in row format."""
-
-    max_tokens: Optional[int] = None
-    """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."""
-
-    messages: Optional[List[ChatMessage]] = None
-    """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."""
-
-    n: Optional[int] = None
-    """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."""
-
-    name: Optional[str] = None
-    """The name of the serving endpoint. This field is required."""
-
-    prompt: Optional[Any] = None
-    """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."""
-
-    stop: Optional[List[str]] = None
-    """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."""
-
-    stream: Optional[bool] = None
-    """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."""
-
-    temperature: Optional[float] = None
-    """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."""
-
-    def as_dict(self) -> dict:
-        """Serializes the QueryEndpointInput into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.dataframe_records:
-            body["dataframe_records"] = [v for v in self.dataframe_records]
-        if self.dataframe_split:
-            body["dataframe_split"] = self.dataframe_split.as_dict()
-        if self.extra_params:
-            body["extra_params"] = self.extra_params
-        if self.input:
-            body["input"] = self.input
-        if self.inputs:
-            body["inputs"] = self.inputs
-        if self.instances:
-            body["instances"] = [v for v in self.instances]
-        if self.max_tokens is not None:
-            body["max_tokens"] = self.max_tokens
-        if self.messages:
-            body["messages"] = [v.as_dict() for v in self.messages]
-        if self.n is not None:
-            body["n"] = self.n
-        if self.name is not None:
-            body["name"] = self.name
-        if self.prompt:
-            body["prompt"] = self.prompt
-        if self.stop:
-            body["stop"] = [v for v in self.stop]
-        if self.stream is not None:
-            body["stream"] = self.stream
-        if self.temperature is not None:
-            body["temperature"] = self.temperature
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the QueryEndpointInput into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.dataframe_records:
-            body["dataframe_records"] = self.dataframe_records
-        if self.dataframe_split:
-            body["dataframe_split"] = self.dataframe_split
-        if self.extra_params:
-            body["extra_params"] = self.extra_params
-        if self.input:
-            body["input"] = self.input
-        if self.inputs:
-            body["inputs"] = self.inputs
-        if self.instances:
-            body["instances"] = self.instances
-        if self.max_tokens is not None:
-            body["max_tokens"] = self.max_tokens
-        if self.messages:
-            body["messages"] = self.messages
-        if self.n is not None:
-            body["n"] = self.n
-        if self.name is not None:
-            body["name"] = self.name
-        if self.prompt:
-            body["prompt"] = self.prompt
-        if self.stop:
-            body["stop"] = self.stop
-        if self.stream is not None:
-            body["stream"] = self.stream
-        if self.temperature is not None:
-            body["temperature"] = self.temperature
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> QueryEndpointInput:
-        """Deserializes the QueryEndpointInput from a dictionary."""
-        return cls(
-            dataframe_records=d.get("dataframe_records", None),
-            dataframe_split=_from_dict(d, "dataframe_split", DataframeSplitInput),
-            extra_params=d.get("extra_params", None),
-            input=d.get("input", None),
-            inputs=d.get("inputs", None),
-            instances=d.get("instances", None),
-            max_tokens=d.get("max_tokens", None),
-            messages=_repeated_dict(d, "messages", ChatMessage),
-            n=d.get("n", None),
-            name=d.get("name", None),
-            prompt=d.get("prompt", None),
-            stop=d.get("stop", None),
-            stream=d.get("stream", None),
-            temperature=d.get("temperature", None),
-        )
-
-
 @dataclass
 class QueryEndpointResponse:
     choices: Optional[List[V1ResponseChoiceElement]] = None
@@ -4314,40 +3805,6 @@ class ServingEndpointPermissionsDescription:
         )
 
 
-@dataclass
-class ServingEndpointPermissionsRequest:
-    access_control_list: Optional[List[ServingEndpointAccessControlRequest]] = None
-
-    serving_endpoint_id: Optional[str] = None
-    """The serving endpoint for which to get or manage permissions."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ServingEndpointPermissionsRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
-        if self.serving_endpoint_id is not None:
-            body["serving_endpoint_id"] = self.serving_endpoint_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ServingEndpointPermissionsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.serving_endpoint_id is not None:
-            body["serving_endpoint_id"] = self.serving_endpoint_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ServingEndpointPermissionsRequest:
-        """Deserializes the ServingEndpointPermissionsRequest from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", ServingEndpointAccessControlRequest),
-            serving_endpoint_id=d.get("serving_endpoint_id", None),
-        )
-
-
 class ServingModelWorkloadType(Enum):
     """Please keep this in sync with with workload types in InferenceEndpointEntities.scala"""
 
@@ -4383,37 +3840,6 @@ class TrafficConfig:
         return cls(routes=_repeated_dict(d, "routes", Route))
 
 
-@dataclass
-class UpdateProvisionedThroughputEndpointConfigRequest:
-    config: PtEndpointCoreConfig
-
-    name: Optional[str] = None
-    """The name of the pt endpoint to update. This field is required."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateProvisionedThroughputEndpointConfigRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.config:
-            body["config"] = self.config.as_dict()
-        if self.name is not None:
-            body["name"] = self.name
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateProvisionedThroughputEndpointConfigRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.config:
-            body["config"] = self.config
-        if self.name is not None:
-            body["name"] = self.name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateProvisionedThroughputEndpointConfigRequest:
-        """Deserializes the UpdateProvisionedThroughputEndpointConfigRequest from a dictionary."""
-        return cls(config=_from_dict(d, "config", PtEndpointCoreConfig), name=d.get("name", None))
-
-
 @dataclass
 class V1ResponseChoiceElement:
     finish_reason: Optional[str] = None
@@ -5074,6 +4500,7 @@ class ServingEndpointsAPI:
             "Accept": "application/json",
             "Content-Type": "application/json",
         }
+
         response_headers = [
             "served-model-name",
         ]
@@ -5386,6 +4813,7 @@ class ServingEndpointsDataPlaneAPI:
             "Accept": "application/json",
             "Content-Type": "application/json",
         }
+
         response_headers = [
             "served-model-name",
         ]