databricks-sdk 0.148.0__tar.gz → 0.149.0__tar.gz

{databricks_sdk-0.148.0 → databricks_sdk-0.149.0}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Version changelog
 
+## Release v0.149.0 (2026-10-08)
+
+### API Changes
+* Add `databricks.sdk.service.agentkit` package.
+* Add [w.agent_kit](https://databricks-sdk-py.readthedocs.io/en/latest/workspace/agentkit/agent_kit.html) workspace-level service.
+* Add `create_identity_visibility_filter()`, `delete_identity_visibility_filter()`, `get_identity_visibility_filter()` and `list_identity_visibility_filters()` methods for [a.account_iam_v2](https://databricks-sdk-py.readthedocs.io/en/latest/account/iamv2/account_iam_v2.html) account-level service.
+* Add `endpoint_route` field for `databricks.sdk.service.catalog.ModelProviderServiceConfigModelTargetConfig`.
+* Add `notifications` field for `databricks.sdk.service.ml.MaterializedFeature`.
+* Add `shuffle_partitions` field for `databricks.sdk.service.ml.StreamingMode`.
+* Add `parent_path` field for `databricks.sdk.service.pipelines.ClonePipelineRequest`.
+* Add `parent_path` field for `databricks.sdk.service.pipelines.CreatePipeline`.
+* Add `parent_path` field for `databricks.sdk.service.pipelines.EditPipeline`.
+* Add `parent_path` field for `databricks.sdk.service.pipelines.PipelineSpec`.
+* Add `custom_template_format` field for `databricks.sdk.service.sql.AlertV2`.
+* Add `statement_timeout` field for `databricks.sdk.service.sql.CreateWarehouseRequest`.
+* Add `statement_timeout` field for `databricks.sdk.service.sql.EditWarehouseRequest`.
+* Add `statement_timeout` field for `databricks.sdk.service.sql.EndpointInfo`.
+* Add `statement_timeout` field for `databricks.sdk.service.sql.GetWarehouseResponse`.
+* [Breaking] Remove `databricks.sdk.service.mason` package.
+* [Breaking] Remove [w.mason](https://databricks-sdk-py.readthedocs.io/en/latest/workspace/mason/mason.html) workspace-level service.
+
 ## Release v0.148.0 (2026-10-07)
 
 ### API Changes

{databricks_sdk-0.148.0 → databricks_sdk-0.149.0}/PKG-INFO

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

{databricks_sdk-0.148.0 → databricks_sdk-0.149.0}/databricks/sdk/__init__.py

@@ -10,6 +10,7 @@ import databricks.sdk.dbutils as dbutils
 from databricks.sdk.credentials_provider import CredentialsStrategy
 from databricks.sdk.data_plane import DataPlaneTokenSource
 from databricks.sdk.service import agentbricks as pkg_agentbricks
+from databricks.sdk.service import agentkit as pkg_agentkit
 from databricks.sdk.service import aifunctions as pkg_aifunctions
 from databricks.sdk.service import aisearch as pkg_aisearch
 from databricks.sdk.service import apps as pkg_apps
@@ -31,7 +32,6 @@ from databricks.sdk.service import iamv2 as pkg_iamv2
 from databricks.sdk.service import jobs as pkg_jobs
 from databricks.sdk.service import knowledgeassistants as pkg_knowledgeassistants
 from databricks.sdk.service import marketplace as pkg_marketplace
-from databricks.sdk.service import mason as pkg_mason
 from databricks.sdk.service import ml as pkg_ml
 from databricks.sdk.service import networking as pkg_networking
 from databricks.sdk.service import oauth2 as pkg_oauth2
@@ -61,6 +61,7 @@ from databricks.sdk.service.iam import AccessControlAPI
 from databricks.sdk.service.iam import AccountAccessControlAPI
 from databricks.sdk.service.iam import AccountAccessControlProxyAPI
 from databricks.sdk.service.agentbricks import AgentBricksAPI
+from databricks.sdk.service.agentkit import AgentKitAPI
 from databricks.sdk.service.aifunctions import AiFunctionsAPI
 from databricks.sdk.service.catalog import AiGatewayAPI
 from databricks.sdk.service.aisearch import AiSearchAPI
@@ -155,7 +156,6 @@ from databricks.sdk.service.settings import LlmProxyPartnerPoweredAccountAPI
 from databricks.sdk.service.settings import LlmProxyPartnerPoweredEnforceAPI
 from databricks.sdk.service.settings import LlmProxyPartnerPoweredWorkspaceAPI
 from databricks.sdk.service.billing import LogDeliveryAPI
-from databricks.sdk.service.mason import MasonAPI
 from databricks.sdk.service.ml import MaterializedFeaturesAPI
 from databricks.sdk.service.catalog import AccountMetastoreAssignmentsAPI
 from databricks.sdk.service.catalog import MetastoresAPI
@@ -369,6 +369,7 @@ class WorkspaceClient:
         self._access_control = pkg_iam.AccessControlAPI(self._api_client)
         self._account_access_control_proxy = pkg_iam.AccountAccessControlProxyAPI(self._api_client)
         self._agent_bricks = pkg_agentbricks.AgentBricksAPI(self._api_client)
+        self._agent_kit = pkg_agentkit.AgentKitAPI(self._api_client)
         self._ai_functions = pkg_aifunctions.AiFunctionsAPI(self._api_client)
         self._ai_gateway = pkg_catalog.AiGatewayAPI(self._api_client)
         self._ai_search = pkg_aisearch.AiSearchAPI(self._api_client)
@@ -430,7 +431,6 @@ class WorkspaceClient:
         self._lakeview = pkg_dashboards.LakeviewAPI(self._api_client)
         self._lakeview_embedded = pkg_dashboards.LakeviewEmbeddedAPI(self._api_client)
         self._libraries = pkg_compute.LibrariesAPI(self._api_client)
-        self._mason = pkg_mason.MasonAPI(self._api_client)
         self._materialized_features = pkg_ml.MaterializedFeaturesAPI(self._api_client)
         self._metastores = pkg_catalog.MetastoresAPI(self._api_client)
         self._model_registry = pkg_ml.ModelRegistryAPI(self._api_client)
@@ -542,6 +542,11 @@ class WorkspaceClient:
         """The Custom LLMs service manages state and powers the UI for the Custom LLM product."""
         return self._agent_bricks
 
+    @property
+    def agent_kit(self) -> pkg_agentkit.AgentKitAPI:
+        """APIs for managing agent memory and durable session state."""
+        return self._agent_kit
+
     @property
     def ai_functions(self) -> pkg_aifunctions.AiFunctionsAPI:
         """Transform and enrich data with AI on Databricks."""
@@ -842,11 +847,6 @@ class WorkspaceClient:
         """The Libraries API allows you to install and uninstall libraries and get the status of libraries on a cluster."""
         return self._libraries
 
-    @property
-    def mason(self) -> pkg_mason.MasonAPI:
-        """APIs for managing agent memory and durable session state."""
-        return self._mason
-
     @property
     def materialized_features(self) -> pkg_ml.MaterializedFeaturesAPI:
         """Materialized Features are columns in tables and views that can be directly used as features to train and serve ML models."""

databricks_sdk-0.148.0/databricks/sdk/service/mason.py → databricks_sdk-0.149.0/databricks/sdk/service/agentkit.py

@@ -883,7 +883,7 @@ class StorageBackendType(Enum):
     STORAGE_BACKEND_TYPE_LAKEBASE = "STORAGE_BACKEND_TYPE_LAKEBASE"
 
 
-class MasonAPI:
+class AgentKitAPI:
     """APIs for managing agent memory and durable session state. This interface is under active development and
     may change."""
 

{databricks_sdk-0.148.0 → databricks_sdk-0.149.0}/databricks/sdk/service/aifunctions.py

@@ -827,8 +827,8 @@ class AiFunctionsAPI:
           answer the provided questions. For example, provide a support message, a conversation, or records
           describing the current state of an application. All questions receive this same state.
         :param questions: any
-          A JSON object mapping question IDs to their definitions. Choose a nonempty string for each ID; its
-          answer is returned with the same ID in ``response.answers``.
+          A JSON object mapping question IDs to their definitions. Each ID must contain non-whitespace text;
+          its answer is returned with the same ID in ``response.answers``.
 
           Each definition is an object with the required fields ``type`` and ``instructions``. The
           ``criteria`` field is optional for the type ``noul`` but is required for the types ``choice`` and
@@ -858,8 +858,9 @@ class AiFunctionsAPI:
 
           - ``noul``: Estimates the probability that the answer to a true-or-false question is true.
             ``criteria`` can take the fields ``true`` or ``false``, or both, with descriptions that are
-            strings, objects, or arrays. Omit ``criteria`` to use the question alone. For example, both of the
-            following are valid:
+            strings, objects, or arrays. Omit ``criteria`` to use the question alone. The instructions or at
+            least one criteria description must contain non-whitespace text, a nonempty object, or a nonempty
+            array. For example, both of the following are valid:
 
           .. code-block:: json
 
@@ -886,8 +887,8 @@ class AiFunctionsAPI:
              }
 
           - ``score``: Rates the state on an ordered scale. Requires ``criteria`` to be an array of 2 to 10
-            level descriptions, ordered from low to high. Descriptions can be strings, objects, or arrays.
-            Array positions define levels starting at 0. For example:
+            level descriptions, ordered from low to high. Descriptions must contain non-whitespace text, a
+            nonempty object, or a nonempty array. Array positions define levels starting at 0. For example:
 
           .. code-block:: json
 

{databricks_sdk-0.148.0 → databricks_sdk-0.149.0}/databricks/sdk/service/catalog.py

@@ -8313,20 +8313,30 @@ class ModelProviderServiceConfigMicrosoftFoundryProviderDirectConfig:
 
 @dataclass
 class ModelProviderServiceConfigModelTargetConfig:
-    """Model target configuration for an external model destination."""
+    """Model target configuration shared by model provider service targets and external model
+    destinations on model services."""
 
     model: str
     """Provider-side model identifier, such as ``gpt-5`` or ``claude-opus-4-7``. This identifies a
     model at the upstream provider; it is not a Unity Catalog model resource."""
 
+    endpoint_route: Optional[str] = None
+    """Relative path appended to a custom provider's ``base_url`` for this model, such as
+    ``serve/openai/chat``. Only custom model provider service targets use this field; other provider
+    types ignore it, and model service destinations reject it. Do not include URI templates,
+    queries, or fragments. When empty, ``base_url`` is used unchanged."""
+
     native_api_types: Optional[List[str]] = None
-    """Provider-native API types supported by this model, such as ``openai/v1/chat/completions``. At
-    least one value is required. AI Gateway uses these values to translate requests and responses.
-    At most 64 entries of 256 characters each are allowed."""
+    """Provider-native API types supported by this model, such as ``openai/v1/chat/completions``. A
+    model provider service target requires at least one value. A model service destination may omit
+    the list to use the matching provider service target's types when available. AI Gateway uses the
+    selected types for translation. At most 64 entries of 256 characters each are allowed."""
 
     def as_dict(self) -> dict:
         """Serializes the ModelProviderServiceConfigModelTargetConfig into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.endpoint_route is not None:
+            body["endpoint_route"] = self.endpoint_route
         if self.model is not None:
             body["model"] = self.model
         if self.native_api_types:
@@ -8336,6 +8346,8 @@ class ModelProviderServiceConfigModelTargetConfig:
     def as_shallow_dict(self) -> dict:
         """Serializes the ModelProviderServiceConfigModelTargetConfig into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.endpoint_route is not None:
+            body["endpoint_route"] = self.endpoint_route
         if self.model is not None:
             body["model"] = self.model
         if self.native_api_types:
@@ -8345,7 +8357,11 @@ class ModelProviderServiceConfigModelTargetConfig:
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> ModelProviderServiceConfigModelTargetConfig:
         """Deserializes the ModelProviderServiceConfigModelTargetConfig from a dictionary."""
-        return cls(model=d.get("model", None), native_api_types=d.get("native_api_types", None))
+        return cls(
+            endpoint_route=d.get("endpoint_route", None),
+            model=d.get("model", None),
+            native_api_types=d.get("native_api_types", None),
+        )
 
 
 @dataclass

{databricks_sdk-0.148.0 → databricks_sdk-0.149.0}/databricks/sdk/service/domains.py

@@ -356,7 +356,7 @@ class DomainsAPI:
     def get_domain(self, name: str) -> Domain:
         """Get a domain by resource name.
 
-        Authorization: external callers must have the ``MANAGE DISCOVERY`` permission.
+        Authorization: external callers must have the ``MANAGE DISCOVER`` permission.
 
         :param name: str
           Full resource name of the domain to retrieve. Format: ``domains/{domain_id}``
@@ -385,7 +385,7 @@ class DomainsAPI:
         """List domains in the account. Set ``parent_domain_id`` to return only the direct subdomains of a given
         domain.
 
-        Authorization: external callers must have the ``MANAGE DISCOVERY`` permission; only domains the caller
+        Authorization: external callers must have the ``MANAGE DISCOVER`` permission; only domains the caller
         is authorized to read are returned.
 
         :param page_size: int (optional)

{databricks_sdk-0.148.0 → databricks_sdk-0.149.0}/databricks/sdk/service/iamv2.py

@@ -105,6 +105,33 @@ class Entitlement(Enum):
     WORKSPACE_CONSUME = "WORKSPACE_CONSUME"
 
 
+@dataclass
+class ExactMatchRule:
+    """A rule that matches an identity whose external ID (from the identity provider) equals the value."""
+
+    external_id: str
+    """The external ID to match exactly."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ExactMatchRule into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.external_id is not None:
+            body["external_id"] = self.external_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExactMatchRule into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.external_id is not None:
+            body["external_id"] = self.external_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExactMatchRule:
+        """Deserializes the ExactMatchRule from a dictionary."""
+        return cls(external_id=d.get("external_id", None))
+
+
 @dataclass
 class ExternalGroup:
     """An external group from the customer's Identity Provider, resolved into Databricks. This is a
@@ -442,6 +469,65 @@ class GroupMembershipSource(Enum):
     INTERNAL = "INTERNAL"
 
 
+@dataclass
+class IdentityVisibilityFilter:
+    """A rule controlling which externally provisioned identities are visible in the account. Filters
+    are scoped by principal_type: an identity is only ever evaluated against filters whose
+    principal_type matches its own. When the account has no filter for an identity's principal_type,
+    all identities of that type are visible; once it has at least one filter for that type, an
+    identity of that type is visible only if it matches at least one of those filters. So a set of
+    group-only filters gates groups but leaves users and service principals fully visible."""
+
+    principal_type: PrincipalType
+    """Which type of principal (user, service principal, or group) this rule applies to."""
+
+    exact: Optional[ExactMatchRule] = None
+    """Exact match on the identity's external ID."""
+
+    name: Optional[str] = None
+    """The resource name of the identity-visibility filter. Format:
+    accounts/{account_id}/identity-visibility-filters/{identity_visibility_filter_id}"""
+
+    prefix: Optional[PrefixMatchRule] = None
+    """Prefix match on the identity's display name."""
+
+    def as_dict(self) -> dict:
+        """Serializes the IdentityVisibilityFilter into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.exact:
+            body["exact"] = self.exact.as_dict()
+        if self.name is not None:
+            body["name"] = self.name
+        if self.prefix:
+            body["prefix"] = self.prefix.as_dict()
+        if self.principal_type is not None:
+            body["principal_type"] = self.principal_type.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the IdentityVisibilityFilter into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.exact:
+            body["exact"] = self.exact
+        if self.name is not None:
+            body["name"] = self.name
+        if self.prefix:
+            body["prefix"] = self.prefix
+        if self.principal_type is not None:
+            body["principal_type"] = self.principal_type
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> IdentityVisibilityFilter:
+        """Deserializes the IdentityVisibilityFilter from a dictionary."""
+        return cls(
+            exact=_from_dict(d, "exact", ExactMatchRule),
+            name=d.get("name", None),
+            prefix=_from_dict(d, "prefix", PrefixMatchRule),
+            principal_type=_enum(d, "principal_type", PrincipalType),
+        )
+
+
 @dataclass
 class ListDirectGroupMembersResponse:
     """Response message for listing direct group members."""
@@ -514,6 +600,43 @@ class ListGroupsResponse:
         return cls(groups=_repeated_dict(d, "groups", Group), next_page_token=d.get("next_page_token", None))
 
 
+@dataclass
+class ListIdentityVisibilityFiltersResponse:
+    """Response message containing a page of identity-visibility filters in the account."""
+
+    identity_visibility_filters: Optional[List[IdentityVisibilityFilter]] = None
+
+    next_page_token: Optional[str] = None
+    """A token, which can be sent as page_token to retrieve the next page. If omitted, there are no
+    subsequent pages."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListIdentityVisibilityFiltersResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.identity_visibility_filters:
+            body["identity_visibility_filters"] = [v.as_dict() for v in self.identity_visibility_filters]
+        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 ListIdentityVisibilityFiltersResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.identity_visibility_filters:
+            body["identity_visibility_filters"] = self.identity_visibility_filters
+        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]) -> ListIdentityVisibilityFiltersResponse:
+        """Deserializes the ListIdentityVisibilityFiltersResponse from a dictionary."""
+        return cls(
+            identity_visibility_filters=_repeated_dict(d, "identity_visibility_filters", IdentityVisibilityFilter),
+            next_page_token=d.get("next_page_token", None),
+        )
+
+
 @dataclass
 class ListServicePrincipalsResponse:
     """Response message containing a page of service principals in the account."""
@@ -695,6 +818,33 @@ class ListWorkspaceAssignmentsResponse:
         )
 
 
+@dataclass
+class PrefixMatchRule:
+    """A rule that matches an identity whose display name starts with the value."""
+
+    display_name_prefix: str
+    """The display-name prefix to match."""
+
+    def as_dict(self) -> dict:
+        """Serializes the PrefixMatchRule into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.display_name_prefix is not None:
+            body["display_name_prefix"] = self.display_name_prefix
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PrefixMatchRule into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.display_name_prefix is not None:
+            body["display_name_prefix"] = self.display_name_prefix
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> PrefixMatchRule:
+        """Deserializes the PrefixMatchRule from a dictionary."""
+        return cls(display_name_prefix=d.get("display_name_prefix", None))
+
+
 class PrincipalType(Enum):
     """The type of the principal (user/sp/group)."""
 
@@ -1397,6 +1547,40 @@ class AccountIamV2API:
         )
         return Group.from_dict(res)
 
+    def create_identity_visibility_filter(
+        self,
+        parent: str,
+        identity_visibility_filter: IdentityVisibilityFilter,
+        *,
+        identity_visibility_filter_id: Optional[str] = None,
+    ) -> IdentityVisibilityFilter:
+        """Creates an identity-visibility filter in the account.
+
+        :param parent: str
+          Required. The parent account. Format: accounts/{account_id}
+        :param identity_visibility_filter: :class:`IdentityVisibilityFilter`
+          Required. The filter to create.
+        :param identity_visibility_filter_id: str (optional)
+          Optional. The ID to use for the filter, which becomes the final component of its resource name. If
+          not specified, the server generates one.
+
+        :returns: :class:`IdentityVisibilityFilter`
+        """
+
+        body = identity_visibility_filter.as_dict()
+        query = {}
+        if identity_visibility_filter_id is not None:
+            query["identity_visibility_filter_id"] = identity_visibility_filter_id
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "POST", f"/api/2.0/identity/{parent}/identity-visibility-filters", query=query, body=body, headers=headers
+        )
+        return IdentityVisibilityFilter.from_dict(res)
+
     def create_service_principal(self, service_principal: ServicePrincipal) -> ServicePrincipal:
         """Creates a local service principal in the Databricks account and returns the created service principal.
         A local service principal is one that is not synced from the customer's identity provider, and can be
@@ -1552,6 +1736,22 @@ class AccountIamV2API:
 
         self._api.do("DELETE", f"/api/2.0/identity/accounts/{self._api.account_id}/groups/{group_id}", headers=headers)
 
+    def delete_identity_visibility_filter(self, name: str):
+        """Deletes an identity-visibility filter by resource name.
+
+        :param name: str
+          Required. The resource name of the filter. Format:
+          accounts/{account_id}/identity-visibility-filters/{identity_visibility_filter_id}
+
+
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do("DELETE", f"/api/2.0/identity/{name}", headers=headers)
+
     def delete_service_principal(self, service_principal_id: str):
         """Deletes a service principal from the Databricks account by its internal ID.
 
@@ -1729,6 +1929,23 @@ class AccountIamV2API:
         )
         return Group.from_dict(res)
 
+    def get_identity_visibility_filter(self, name: str) -> IdentityVisibilityFilter:
+        """Fetches an identity-visibility filter by resource name.
+
+        :param name: str
+          Required. The resource name of the filter. Format:
+          accounts/{account_id}/identity-visibility-filters/{identity_visibility_filter_id}
+
+        :returns: :class:`IdentityVisibilityFilter`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do("GET", f"/api/2.0/identity/{name}", headers=headers)
+        return IdentityVisibilityFilter.from_dict(res)
+
     def get_service_principal(self, service_principal_id: str) -> ServicePrincipal:
         """Fetches a service principal from the Databricks account by its internal ID.
 
@@ -1930,6 +2147,42 @@ class AccountIamV2API:
                 return
             query["page_token"] = json["next_page_token"]
 
+    def list_identity_visibility_filters(
+        self, parent: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[IdentityVisibilityFilter]:
+        """Lists the identity-visibility filters in the account, returning one page per call.
+
+        :param parent: str
+          Required. The parent account. Format: accounts/{account_id}
+        :param page_size: int (optional)
+          The maximum number of filters to return. The service may return fewer than this value.
+        :param page_token: str (optional)
+          A page token, received from a previous ListIdentityVisibilityFilters call. Provide this to retrieve
+          the subsequent page.
+
+        :returns: Iterator over :class:`IdentityVisibilityFilter`
+        """
+
+        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/identity/{parent}/identity-visibility-filters", query=query, headers=headers
+            )
+            if "identity_visibility_filters" in json:
+                for v in json["identity_visibility_filters"]:
+                    yield IdentityVisibilityFilter.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_service_principals(
         self, *, filter: Optional[str] = None, page_size: Optional[int] = None, page_token: Optional[str] = None
     ) -> Iterator[ServicePrincipal]: