databricks-sdk 0.157.0__tar.gz → 0.158.0__tar.gz

{databricks_sdk-0.157.0 → databricks_sdk-0.158.0}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Version changelog
 
+## Release v0.158.0 (2026-10-29)
+
+### API Changes
+* Add `get_budget_spend_status()` and `list_budget_spend_statuses()` methods for [a.budgets](https://databricks-sdk-py.readthedocs.io/en/latest/account/billing/budgets.html) account-level service.
+
+### Bug Fixes
+* Fix `WorkspaceClient.files.download_to` with `use_parallel=True` always falling back to the Files API for files above the parallel download threshold, instead of downloading byte ranges from presigned URLs (or from the storage proxy when `experimental_files_ext_enable_storage_proxy` is set). A byte range that fails after another range was received now raises, and expired GCP presigned URLs are refreshed like AWS and Azure ones.
+* Fix `WorkspaceClient.files.download_to` with `use_parallel=True` requesting the wrong path from the Files API when the file path contains characters such as `#`, `?` or `%`.
+* Fix Databricks CLI authentication rejecting small wrappers around the CLI (e.g. launcher scripts or version manager shims) as the legacy Python CLI. Small files found in `PATH` are now only rejected if they are the entry point pip installs for the legacy Python CLI.
+
 ## Release v0.157.0 (2026-10-24)
 
 ### API Changes

{databricks_sdk-0.157.0 → databricks_sdk-0.158.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-sdk
-Version: 0.157.0
+Version: 0.158.0
 Summary: Databricks SDK for Python (Beta)
 Project-URL: Documentation, https://databricks-sdk-py.readthedocs.io
 Keywords: databricks,sdk

{databricks_sdk-0.157.0 → databricks_sdk-0.158.0}/databricks/sdk/credentials_provider.py

@@ -1226,6 +1226,13 @@ class DatabricksCliTokenSource(CliTokenSource):
             cmd += ["--account-id", cfg.account_id]
         return cmd
 
+    # Files at least this large are assumed to be the Go CLI without reading them.
+    _CLI_MIN_SIZE = 1024 * 1024
+
+    # Identifies the legacy CLI's pip entry point script. The imported name is omitted
+    # because it changed from `cli` to `main` in 0.17.8.
+    _LEGACY_CLI_MARKER = b"from databricks_cli.cli import "
+
     @staticmethod
     def _find_executable(name) -> str:
         err = FileNotFoundError("Most likely the Databricks CLI is not installed")
@@ -1234,12 +1241,14 @@ class DatabricksCliTokenSource(CliTokenSource):
             if not path.is_file():
                 continue
 
-            # The new Databricks CLI is a single binary with size > 1MB.
-            # We use the size as a signal to determine which Databricks CLI is installed.
-            stat = path.stat()
-            if stat.st_size < (1024 * 1024):
-                err = FileNotFoundError("Databricks CLI version <0.100.0 detected")
-                continue
+            if path.stat().st_size < DatabricksCliTokenSource._CLI_MIN_SIZE:
+                try:
+                    content = path.read_bytes()
+                except OSError:
+                    continue
+                if DatabricksCliTokenSource._LEGACY_CLI_MARKER in content:
+                    err = FileNotFoundError("Databricks CLI version <0.100.0 detected")
+                    continue
 
             return str(path)
 

{databricks_sdk-0.157.0 → databricks_sdk-0.158.0}/databricks/sdk/mixins/files.py

@@ -850,25 +850,6 @@ class _PresignedUrlRequestBuilder:
         )
         return CreateDownloadUrlResponse.from_dict(response)
 
-    def build_abort_url(self, path: str, session_token: str, expire_time: str) -> _PresignedUrl:
-        """Fetches a presigned URL for aborting a multipart upload."""
-        body = {
-            "path": path,
-            "session_token": session_token,
-            "expire_time": expire_time,
-        }
-        response = self._api.do(
-            "POST",
-            url=f"{self._hostname}/api/2.0/fs/create-abort-upload-url",
-            headers={"Content-Type": "application/json"},
-            body=body,
-        )
-        abort_node = response["abort_upload_url"]
-        headers: dict[str, str] = {"Content-Type": "application/octet-stream"}
-        for h in abort_node.get("headers", []):
-            headers[h["name"]] = h["value"]
-        return _PresignedUrl(url=abort_node["url"], headers=headers)
-
 
 class _StorageProxyRequestBuilder:
     """Builds direct upload requests to the storage proxy.
@@ -930,21 +911,6 @@ class _StorageProxyRequestBuilder:
             headers={},
         )
 
-    def build_abort_url(self, path: str, session_token: str, expire_time: str) -> _PresignedUrl:
-        """Builds a URL for aborting an upload directly on the storage proxy."""
-        escaped = _escape_multi_segment_path_parameter(path)
-        base = f"{self._hostname}/api/2.0/fs/files{escaped}"
-        query = parse.urlencode(
-            {
-                "action": "abort-upload",
-                "session_token": session_token,
-            }
-        )
-        return _PresignedUrl(
-            url=f"{base}?{query}",
-            headers={"Content-Type": "application/json"},
-        )
-
 
 class FilesExt(files.FilesAPI):
     __doc__ = files.FilesAPI.__doc__
@@ -990,8 +956,8 @@ class FilesExt(files.FilesAPI):
         self._cached_cloud_provider_session: Optional[requests.Session] = None
         self._cloud_provider_session_lock = Lock()
         self._dp_hostname_available: Optional[bool] = None
-        self._cached_storage_proxy_session: Optional[requests.Session] = None
-        self._storage_proxy_session_lock = Lock()
+        self._cached_authenticated_session: Optional[requests.Session] = None
+        self._authenticated_session_lock = Lock()
         self._cached_endpoints: Optional[list[_Endpoint]] = None
         self._endpoints_lock = Lock()
 
@@ -1185,17 +1151,16 @@ class FilesExt(files.FilesAPI):
         except Exception:
             return False
 
-    def _create_storage_proxy_session(self) -> requests.Session:
-        """Returns an HTTP session with SDK auth for storage-proxy requests.
+    def _authenticated_session(self) -> requests.Session:
+        """Returns an HTTP session with SDK auth for direct Files API data requests.
 
-        Unlike _cloud_provider_session (which has no auth), this session
-        includes the SDK authentication callback so that every request to the
-        storage proxy carries valid credentials. The session is created on
-        first call and cached for reuse.
+        Unlike _cloud_provider_session (which has no auth), this session includes the SDK authentication
+        callback so that every request carries valid credentials. The session is created on first call and
+        cached for reuse.
         """
-        with self._storage_proxy_session_lock:
-            if self._cached_storage_proxy_session is not None:
-                return self._cached_storage_proxy_session
+        with self._authenticated_session_lock:
+            if self._cached_authenticated_session is not None:
+                return self._cached_authenticated_session
             session = requests.Session()
             config = self._config
 
@@ -1212,7 +1177,7 @@ class FilesExt(files.FilesAPI):
             )
             session.mount("https://", http_adapter)
             session.mount("http://", http_adapter)
-            self._cached_storage_proxy_session = session
+            self._cached_authenticated_session = session
             return session
 
     def download(
@@ -1339,8 +1304,12 @@ class FilesExt(files.FilesAPI):
         file_info = self.get_metadata(remote_path)
         file_size = file_info.content_length
         last_modified = file_info.last_modified
-        # If the file is smaller than the threshold, do not use parallel download.
-        if file_size <= self._config.files_ext_parallel_download_min_file_size:
+        # If the file is smaller than the threshold, or fits in one range, do not use parallel download. A range
+        # covering the whole file may also be answered with 200 instead of 206.
+        if file_size <= max(
+            self._config.files_ext_parallel_download_min_file_size,
+            self._config.files_ext_parallel_download_default_part_size,
+        ):
             self._sequential_download_to_file(destination, remote_path, last_modified)
             return
         part_size = self._config.files_ext_parallel_download_default_part_size
@@ -1422,13 +1391,16 @@ class FilesExt(files.FilesAPI):
                     url_distributor.invalidate_url(version)
                     retry_count += 1
                     continue
-                elif raw_resp.status_code == 403 and not any_success.is_set():
-                    raise FallbackToDownloadUsingFilesApi("Received 403 Forbidden from presigned URL")
-                elif not any_success.is_set():
-                    # For other errors, we raise a retryable exception to trigger retry logic.
-                    raise FallbackToDownloadUsingFilesApi(f"Received {raw_resp.status_code} from presigned URL")
+                # Only a 206 carries the requested range; a 200 carries the whole file, which must not be written
+                # at this range's offset.
+                if raw_resp.status_code != 206:
+                    message = f"Received {raw_resp.status_code} from presigned URL for {additional_headers['Range']}"
+                    if not any_success.is_set():
+                        raise FallbackToDownloadUsingFilesApi(message)
+                    if raw_resp.ok:
+                        raise ValueError(message)
+                    raise _error_mapper(raw_resp, {"message": message})
 
-                raw_resp.raise_for_status()
                 any_success.set()
                 return BytesIO(raw_resp.content)
             raise ValueError("Exceeded maximum retries for downloading with presigned URL: URL expired too many times")
@@ -1451,11 +1423,17 @@ class FilesExt(files.FilesAPI):
         def download_chunk(additional_headers: dict[str, str]) -> BinaryIO:
             raw_response: dict = self._api.do(
                 method="GET",
-                path=f"/api/2.0/fs/files{remote_path}",
+                path=f"/api/2.0/fs/files{_escape_multi_segment_path_parameter(remote_path)}",
                 headers=additional_headers,
                 raw=True,
             )
-            return raw_response["contents"]
+            contents = raw_response["contents"]
+            status = contents._response.status_code
+            if status != 206:
+                # Only a 206 carries the requested range; anything else must not be written at its offset.
+                contents.close()
+                raise ValueError(f"Received {status} from the Files API for {additional_headers['Range']}")
+            return contents
 
         self._do_parallel_download(remote_path, destination, parallelism, download_chunk)
 
@@ -2314,7 +2292,7 @@ class FilesExt(files.FilesAPI):
         """
         Checks if response matches one of the known "URL expired" responses from the cloud storage providers.
         """
-        if response.status_code != 403:
+        if response.status_code not in (400, 403):
             return False
 
         try:
@@ -2326,6 +2304,10 @@ class FilesExt(files.FilesAPI):
             if code is None:
                 return False
 
+            if code.text == "ExpiredToken":
+                # GCP, and AWS when the URL was signed with temporary credentials that have since expired.
+                return True
+
             if code.text == "AuthenticationFailed":
                 # Azure
                 details = xml_root.find("AuthenticationErrorDetail")
@@ -2587,37 +2569,30 @@ class FilesExt(files.FilesAPI):
         )
 
     def _abort_multipart_upload(self, ctx: _UploadContext, session_token: str) -> None:
-        """Aborts ongoing multipart upload session to clean up incomplete file."""
-        builder = self._create_request_builder()
-        abort_info = builder.build_abort_url(ctx.target_path, session_token, self._get_upload_url_expire_time())
-
-        def perform() -> requests.Response:
-            return self._cloud_provider_session().request(
-                "DELETE",
-                abort_info.url,
-                headers=abort_info.headers,
-                data=b"",
-                timeout=self._config.files_ext_network_transfer_inactivity_timeout_seconds,
-            )
+        """Aborts ongoing multipart upload session to clean up incomplete file.
 
-        abort_response = self._retry_cloud_idempotent_operation(perform)
+        Best-effort, so sent once, without the API client's retries.
+        """
+        escaped = _escape_multi_segment_path_parameter(ctx.target_path)
+        abort_response = self._authenticated_session().request(
+            "POST",
+            f"{self._get_hostname()}/api/2.0/fs/files{escaped}",
+            params={"action": "abort-upload", "upload_type": "multipart", "session_token": session_token},
+            timeout=self._config.files_ext_network_transfer_inactivity_timeout_seconds,
+        )
 
-        if abort_response.status_code not in (200, 201):
+        if not abort_response.ok:
             raise ValueError(abort_response)
 
     def _abort_resumable_upload(self, resumable_upload_url: str, headers: dict[str, str]) -> None:
-        """Aborts ongoing resumable upload session to clean up incomplete file."""
-
-        def perform() -> requests.Response:
-            return self._cloud_provider_session().request(
-                "DELETE",
-                resumable_upload_url,
-                headers=headers,
-                data=b"",
-                timeout=self._config.files_ext_network_transfer_inactivity_timeout_seconds,
-            )
-
-        abort_response = self._retry_cloud_idempotent_operation(perform)
+        """Aborts ongoing resumable upload session to clean up incomplete file. Best-effort, so sent once."""
+        abort_response = self._cloud_provider_session().request(
+            "DELETE",
+            resumable_upload_url,
+            headers=headers,
+            data=b"",
+            timeout=self._config.files_ext_network_transfer_inactivity_timeout_seconds,
+        )
 
         if abort_response.status_code not in (200, 201):
             raise ValueError(abort_response)
@@ -2631,7 +2606,7 @@ class FilesExt(files.FilesAPI):
         The session is created on first call and cached for reuse.
         """
         if self._config.experimental_files_ext_enable_storage_proxy and self._dp_hostname_available:
-            return self._create_storage_proxy_session()
+            return self._authenticated_session()
         with self._cloud_provider_session_lock:
             if self._cached_cloud_provider_session is None:
                 session = requests.Session()

{databricks_sdk-0.157.0 → databricks_sdk-0.158.0}/databricks/sdk/service/billing.py

@@ -187,6 +187,76 @@ class AlertConfigurationTriggerType(Enum):
     CUMULATIVE_SPENDING_EXCEEDED = "CUMULATIVE_SPENDING_EXCEEDED"
 
 
+@dataclass
+class AlertSpendStatus:
+    """The calling user's spend against a single blocking threshold. Values may be omitted if live
+    spend or threshold data is temporarily unavailable."""
+
+    percent_consumed: Optional[str] = None
+    """Percentage of the threshold consumed, as a decimal string rounded down to one decimal place (for
+    example, "68.4" means 68.4%). May exceed 100 when spend is over the threshold. Returns "0.0" if
+    there's no spend, and is omitted if the threshold is $0. For shared thresholds, this is the only
+    value returned; the absolute ``spend`` and ``threshold`` dollar amounts are withheld."""
+
+    scope_type: Optional[AlertConfigurationScopeType] = None
+    """Whether the threshold is evaluated per individual user
+    (``ALERT_CONFIGURATION_SCOPE_TYPE_PER_USER``) or on the shared spend across all users
+    (``ALERT_CONFIGURATION_SCOPE_TYPE_SHARED``)."""
+
+    spend: Optional[str] = None
+    """The calling user's live spend against this threshold, in USD at list price. Returns "0" if the
+    caller has no usage. Omitted for shared thresholds, where only ``percent_consumed`` is returned."""
+
+    threshold: Optional[str] = None
+    """The calling user's effective threshold, in USD at list price. The effective threshold is the
+    actual threshold amount that applies to the user, after adjusting for any user or group
+    overrides. Omitted for shared thresholds, where only ``percent_consumed`` is returned."""
+
+    time_period: Optional[AlertConfigurationTimePeriod] = None
+    """The time window the threshold applies to, for example ``MONTH``."""
+
+    def as_dict(self) -> dict:
+        """Serializes the AlertSpendStatus into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.percent_consumed is not None:
+            body["percent_consumed"] = self.percent_consumed
+        if self.scope_type is not None:
+            body["scope_type"] = self.scope_type.value
+        if self.spend is not None:
+            body["spend"] = self.spend
+        if self.threshold is not None:
+            body["threshold"] = self.threshold
+        if self.time_period is not None:
+            body["time_period"] = self.time_period.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AlertSpendStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.percent_consumed is not None:
+            body["percent_consumed"] = self.percent_consumed
+        if self.scope_type is not None:
+            body["scope_type"] = self.scope_type
+        if self.spend is not None:
+            body["spend"] = self.spend
+        if self.threshold is not None:
+            body["threshold"] = self.threshold
+        if self.time_period is not None:
+            body["time_period"] = self.time_period
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AlertSpendStatus:
+        """Deserializes the AlertSpendStatus from a dictionary."""
+        return cls(
+            percent_consumed=d.get("percent_consumed", None),
+            scope_type=_enum(d, "scope_type", AlertConfigurationScopeType),
+            spend=d.get("spend", None),
+            threshold=d.get("threshold", None),
+            time_period=_enum(d, "time_period", AlertConfigurationTimePeriod),
+        )
+
+
 @dataclass
 class BudgetConfiguration:
     account_id: Optional[str] = None
@@ -491,6 +561,45 @@ class BudgetResourceType(Enum):
     BUDGET_RESOURCE_TYPE_UNITY_AI_GATEWAY = "BUDGET_RESOURCE_TYPE_UNITY_AI_GATEWAY"
 
 
+@dataclass
+class BudgetSpendStatus:
+    """The calling user's live spend against the blocking thresholds of a single budget."""
+
+    alert_spend_statuses: Optional[List[AlertSpendStatus]] = None
+    """The calling user's spend against each blocking threshold on this budget, one entry per scope
+    type and time period. A blocking threshold is a threshold that, once reached, blocks further
+    requests through Unity Gateway."""
+
+    name: Optional[str] = None
+    """The resource name of this budget spend status, of the form
+    ``accounts/{account_id}/budget-spend-statuses/{budget_id}``."""
+
+    def as_dict(self) -> dict:
+        """Serializes the BudgetSpendStatus into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.alert_spend_statuses:
+            body["alert_spend_statuses"] = [v.as_dict() for v in self.alert_spend_statuses]
+        if self.name is not None:
+            body["name"] = self.name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the BudgetSpendStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.alert_spend_statuses:
+            body["alert_spend_statuses"] = self.alert_spend_statuses
+        if self.name is not None:
+            body["name"] = self.name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> BudgetSpendStatus:
+        """Deserializes the BudgetSpendStatus from a dictionary."""
+        return cls(
+            alert_spend_statuses=_repeated_dict(d, "alert_spend_statuses", AlertSpendStatus), name=d.get("name", None)
+        )
+
+
 @dataclass
 class CreateBillingUsageDashboardResponse:
     dashboard_id: Optional[str] = None
@@ -1156,6 +1265,45 @@ class ListBudgetPoliciesResponse:
         )
 
 
+@dataclass
+class ListBudgetSpendStatusesResponse:
+    """Response for ListBudgetSpendStatuses."""
+
+    budget_spend_statuses: Optional[List[BudgetSpendStatus]] = None
+    """The calling user's spend status, one entry per returned budget."""
+
+    next_page_token: Optional[str] = None
+    """Token to pass as ``page_token`` to retrieve the next page. Absent when there are no more
+    results. A page can contain fewer results than ``page_size``, or none, while this token is still
+    set, so keep paging until it's absent."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListBudgetSpendStatusesResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.budget_spend_statuses:
+            body["budget_spend_statuses"] = [v.as_dict() for v in self.budget_spend_statuses]
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListBudgetSpendStatusesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.budget_spend_statuses:
+            body["budget_spend_statuses"] = self.budget_spend_statuses
+        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]) -> ListBudgetSpendStatusesResponse:
+        """Deserializes the ListBudgetSpendStatusesResponse from a dictionary."""
+        return cls(
+            budget_spend_statuses=_repeated_dict(d, "budget_spend_statuses", BudgetSpendStatus),
+            next_page_token=d.get("next_page_token", None),
+        )
+
+
 class LogDeliveryConfigStatus(Enum):
     """Log Delivery Status
 
@@ -1949,6 +2097,27 @@ class BudgetsAPI:
         res = self._api.do("GET", f"/api/2.1/accounts/{self._api.account_id}/budgets/{budget_id}", headers=headers)
         return GetBudgetConfigurationResponse.from_dict(res)
 
+    def get_budget_spend_status(self, name: str) -> BudgetSpendStatus:
+        """Get the calling user's live spend against the blocking thresholds of a single Unity Gateway budget.
+        Any account user can call this for their own spend. Spend is reported in USD at list price and is
+        near-real-time, so it may differ slightly from billing data. Returns NOT_FOUND if the budget doesn't
+        exist or has no blocking thresholds.
+
+        :param name: str
+          The resource name of the budget spend status to read, of the form
+          ``accounts/{account_id}/budget-spend-statuses/{budget_id}``. A ``budget_id`` that isn't a valid UUID
+          fails with INVALID_PARAMETER_VALUE.
+
+        :returns: :class:`BudgetSpendStatus`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do("GET", f"/api/2.1/{name}", headers=headers)
+        return BudgetSpendStatus.from_dict(res)
+
     def list(self, *, page_token: Optional[str] = None) -> Iterator[BudgetConfiguration]:
         """Gets all budgets associated with this account.
 
@@ -1977,6 +2146,55 @@ class BudgetsAPI:
                 return
             query["page_token"] = json["next_page_token"]
 
+    def list_budget_spend_statuses(
+        self,
+        parent: str,
+        *,
+        filter: Optional[str] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> ListBudgetSpendStatusesResponse:
+        """List the calling user's live spend against the blocking thresholds across the account's Unity Gateway
+        budgets. Any account user can call this for their own spend. Spend is reported in USD at list price
+        and is near-real-time, so it may differ slightly from billing data. By default, returns every budget
+        in the account that has a blocking threshold. Use ``filter`` to narrow results by workspace.
+
+        :param parent: str
+          The parent account whose budget spend statuses to list, of the form ``accounts/{account_id}``.
+        :param filter: str (optional)
+          A filter expression that narrows the returned budgets by workspace. Only ``workspace_id`` is
+          supported, in lower case with numeric workspace IDs, for example ``workspace_id = 123`` or
+          ``workspace_id IN (123, 456)``. Matches budgets that apply to any of the listed workspaces,
+          including budgets that apply to all workspaces. Any other expression, such as an empty ``IN ()``
+          list, fails with INVALID_PARAMETER_VALUE. If empty, returns every budget in the account that has a
+          blocking threshold.
+        :param page_size: int (optional)
+          The maximum number of spend statuses to return per page. If unspecified or 0, at most 100 are
+          returned. The maximum value is 100; values above 100 are coerced to 100. Negative values fail with
+          INVALID_PARAMETER_VALUE. The server may return fewer results than requested, including zero, even
+          when more pages remain; page until ``next_page_token`` is absent.
+        :param page_token: str (optional)
+          A page token from a previous ``ListBudgetSpendStatuses`` response, used to fetch the next page.
+          Requests the first page if absent. All other request parameters except ``page_size`` must match the
+          request that returned the token; otherwise the request fails with INVALID_PARAMETER_VALUE.
+
+        :returns: :class:`ListBudgetSpendStatusesResponse`
+        """
+
+        query = {}
+        if filter is not None:
+            query["filter"] = filter
+        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",
+        }
+
+        res = self._api.do("GET", f"/api/2.1/{parent}/budget-spend-statuses", query=query, headers=headers)
+        return ListBudgetSpendStatusesResponse.from_dict(res)
+
     def update(self, budget_id: str, budget: UpdateBudgetConfigurationBudget) -> UpdateBudgetConfigurationResponse:
         """Updates a budget configuration for an account. Both account and budget configuration are specified by
         ID.

{databricks_sdk-0.157.0 → databricks_sdk-0.158.0}/databricks/sdk/service/catalog.py

@@ -7531,9 +7531,10 @@ class ModelProviderServiceConfig:
     cross the trust boundary to the upstream provider."""
 
     allow_all_targets: Optional[bool] = None
-    """When true, accepts any model exposed by the upstream provider; ``targets`` is not required and
-    does not restrict routability. When false, only models listed in ``targets`` are routable.
-    Defaults to false."""
+    """When true, allows models from the provider's built-in model catalog in addition to explicit
+    ``targets``. When false, only models listed in ``targets`` are routable. Defaults to false.
+    CUSTOM providers have no built-in model catalog and must leave this false and list their models
+    in ``targets``."""
 
     amazon_bedrock: Optional[ModelProviderServiceConfigAmazonBedrockProviderConfig] = None
 
@@ -7588,8 +7589,9 @@ class ModelProviderServiceConfig:
     """Models and provider-native API types exposed by this provider service. Each entry must include
     at least one ``native_api_types`` value. When ``allow_all_targets`` is false, at least one entry
     is required and model service destinations can reference only listed models. When
-    ``allow_all_targets`` is true, any upstream model is routable; entries in this list provide
-    API-type metadata without restricting other models."""
+    ``allow_all_targets`` is true, models from the provider's built-in model catalog are also
+    routable. CUSTOM providers must explicitly list their models here and cannot enable
+    ``allow_all_targets``."""
 
     def as_dict(self) -> dict:
         """Serializes the ModelProviderServiceConfig into a dictionary suitable for use as a JSON request body."""
@@ -14828,8 +14830,8 @@ class AiGatewayAPI:
         returned.
 
         :param page_size: int (optional)
-          Maximum number of MCP services to return. Defaults to 200 when unset or 0; the maximum is 200. Use
-          ``page_token`` to retrieve additional pages.
+          Maximum number of MCP services to return. Defaults to 200 when unset or 0; the maximum is 1000 for
+          ``view = BASIC`` and 200 for ``view = FULL``. Use ``page_token`` to retrieve additional pages.
         :param page_token: str (optional)
           Opaque pagination token from the previous response.
         :param parent: str (optional)
@@ -14886,8 +14888,8 @@ class AiGatewayAPI:
         ``MANAGE``) are returned.
 
         :param page_size: int (optional)
-          Maximum number of provider services to return. Defaults to 200 when unset or 0; the maximum is 200.
-          Use ``page_token`` to retrieve additional pages.
+          Maximum number of provider services to return. Defaults to 200 when unset or 0; the maximum is 1000
+          for ``view = BASIC`` and 200 for ``view = FULL``. Use ``page_token`` to retrieve additional pages.
         :param page_token: str (optional)
           Opaque pagination token from the previous response.
         :param parent: str (optional)
@@ -14944,8 +14946,8 @@ class AiGatewayAPI:
         returned by default.
 
         :param page_size: int (optional)
-          Maximum number of model services to return. Defaults to 200 when unset or 0; the maximum is 200. Use
-          ``page_token`` to retrieve additional pages.
+          Maximum number of model services to return. Defaults to 200 when unset or 0; the maximum is 1000 for
+          ``view = BASIC`` and 200 for ``view = FULL``. Use ``page_token`` to retrieve additional pages.
         :param page_token: str (optional)
           Opaque pagination token from the previous response.
         :param parent: str (optional)