scalekit-sdk-python 2.19.0__tar.gz → 2.20.0__tar.gz

{scalekit_sdk_python-2.19.0 → scalekit_sdk_python-2.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scalekit-sdk-python
-Version: 2.19.0
+Version: 2.20.0
 Summary: Scalekit official Python SDK
 Home-page: https://github.com/scalekit-inc/scalekit-sdk-python
 Author: Team Scalekit

{scalekit_sdk_python-2.19.0 → scalekit_sdk_python-2.20.0}/scalekit/_version.py

@@ -1,3 +1,3 @@
 # Single source of truth for the SDK version.
 # Import this in setup.py and scalekit/core.py — never hardcode the version elsewhere.
-__version__ = "2.19.0"
+__version__ = "2.20.0"

{scalekit_sdk_python-2.19.0 → scalekit_sdk_python-2.20.0}/scalekit/actions/actions.py

@@ -328,6 +328,8 @@ class ActionClient:
         identifier: Optional[str] = None,
         provider: Optional[str] = None,
         connection_names: Optional[List[str]] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
         **kwargs
     ) -> ListConnectedAccountsResponse:
         """List connected accounts with optional filtering.
@@ -341,14 +343,20 @@ class ActionClient:
                 of these connection slugs. Useful when you want to check multiple
                 connectors at once, e.g. ``["github", "google-calendar", "slack"]``.
                 Can be combined with ``identifier`` to narrow results to a specific user.
+            page_size: Maximum number of connected accounts per page (optional).
+            page_token: ``next_page_token`` from a previous response, to fetch the
+                next page (optional).
 
         Returns:
-            ListConnectedAccountsResponse containing the matching connected accounts.
+            ListConnectedAccountsResponse containing the matching connected accounts,
+            with ``next_page_token`` set when more pages remain.
         """
         result_tuple = self.connected_accounts.list_connected_accounts(
             connector=connection_name,
             identifier=identifier,
             provider=provider,
+            page_size=page_size,
+            page_token=page_token,
             connection_names=connection_names,
         )
         return ListConnectedAccountsResponse.from_proto(result_tuple[0])

scalekit_sdk_python-2.20.0/scalekit/actions/models/custom_provider.py

@@ -0,0 +1,596 @@
+from typing import Dict, List, Optional
+
+from google.protobuf.json_format import MessageToDict
+from pydantic import BaseModel, Field, PrivateAttr, ValidationInfo, model_validator
+
+
+class AuthFieldOption(BaseModel):
+    """One selectable choice on an AuthField whose input_type is 'select'.
+
+    Served alongside every select field. Without these the caller has a
+    dropdown with no values to render.
+    """
+
+    value: str = Field(
+        "",
+        description=(
+            "The value submitted when this choice is selected. This is what gets "
+            "stored as the field's credential value. Example: 'offline'."
+        ),
+    )
+    display_name: str = Field(
+        "",
+        description=(
+            "Human-readable label for this choice as shown in the dropdown. "
+            "Example: 'Offline'."
+        ),
+    )
+    description: str = Field(
+        "",
+        description=(
+            "Optional. Longer explanation of what this choice means, shown as "
+            "helper text. Example: 'Offline with refresh token support'."
+        ),
+    )
+    default: bool = Field(
+        False,
+        description=(
+            "Whether this choice is pre-selected when the field is first "
+            "rendered. At most one option in a field is the default."
+        ),
+    )
+
+    def to_dict(self) -> dict:
+        """Serialize this option to a wire-format dict.
+
+        :returns: Dict with 'value', 'display_name', 'description', and 'default'.
+                  Keys the SDK does not declare are re-emitted unchanged.
+        :rtype: dict
+        """
+        d: dict = {
+            "value": self.value,
+            "display_name": self.display_name,
+            "description": self.description,
+            "default": self.default,
+        }
+        d.update(self.model_extra or {})
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "AuthFieldOption":
+        """Deserialize an AuthFieldOption from a response dict.
+
+        Keys this SDK does not declare are kept on the instance rather than
+        dropped, so they survive a decode/encode round-trip.
+
+        :param d: Dict containing option data as returned by the server.
+        :type d: dict
+        :returns: AuthFieldOption instance populated from the dict values.
+        :rtype: AuthFieldOption
+        """
+        known = {
+            "value": d.get("value") or "",
+            "display_name": d.get("display_name") or "",
+            "description": d.get("description") or "",
+            "default": d.get("default") or False,
+        }
+        extras = {k: v for k, v in d.items() if k not in known}
+        return cls(**known, **extras)
+
+    class Config:
+        extra = "allow"
+
+
+class AuthField(BaseModel):
+    """A single input field displayed to the user during connection setup.
+
+    Use one AuthField per value the user must supply. For a BEARER connector, add
+    one AuthField(field_name='token', ...). For an API_KEY connector, add one
+    AuthField(field_name='api_key', ...). Always set input_type='password' for
+    tokens and keys so the UI masks the value.
+
+    Fields are not limited to BEARER and API_KEY patterns. OAUTH patterns carry
+    them too, for options collected before the browser flow starts rather than
+    credentials — a select field choosing how the flow behaves, for example.
+
+    The server models this as a free-form JSON object, so it may carry keys this
+    SDK does not declare. Those are preserved on the instance and re-emitted by
+    to_dict() rather than dropped.
+    """
+
+    field_name: str = Field(
+        ...,
+        description=(
+            "Required. Machine-readable identifier for this field. Used as the key "
+            "when the credential value is stored and retrieved. "
+            "For BEARER patterns use 'token' or 'bearer_token'. "
+            "For API_KEY patterns use 'api_key'."
+        ),
+    )
+    label: str = Field(
+        "",
+        description=(
+            "Optional. Human-readable label displayed above the input in the UI. "
+            "Example: 'API Key', 'Bearer Token'. Defaults to empty string."
+        ),
+    )
+    input_type: str = Field(
+        "text",
+        description=(
+            "Optional. Controls how the input is rendered in the UI. "
+            "Known values: 'text' (visible input, default), 'password' (masked "
+            "input — use for secrets, tokens, and keys), 'select' (dropdown), and "
+            "'textarea' (multi-line input). Not restricted to a fixed set: the "
+            "value vocabulary is owned by the Scalekit provider catalogue and may "
+            "grow, so the SDK accepts any string and passes an unknown type through "
+            "unchanged rather than failing to parse the response."
+        ),
+    )
+    hint: str = Field(
+        "",
+        description=(
+            "Optional. Placeholder or helper text shown below the input field. "
+            "Example: 'Find your token at Settings → API'. Defaults to empty string."
+        ),
+    )
+    required: bool = Field(
+        False,
+        description=(
+            "Optional. Whether the user must fill this field before the connection "
+            "can be saved. True = field is mandatory; False = field is optional. "
+            "Defaults to False."
+        ),
+    )
+    options: List["AuthFieldOption"] = Field(
+        default_factory=list,
+        description=(
+            "Optional. The selectable choices for this field, populated when "
+            "input_type='select'. Empty for every other input type. A select "
+            "field without options cannot be rendered, so the catalogue always "
+            "ships them together."
+        ),
+    )
+    is_path_param: bool = Field(
+        False,
+        description=(
+            "Optional. True when the collected value is substituted into the "
+            "provider's request path rather than sent as a credential — used by "
+            "connectors whose base URL embeds a tenant or region. Defaults to False."
+        ),
+    )
+    header_name: str = Field(
+        "",
+        description=(
+            "Optional. On an API_KEY pattern, marks this field's value for "
+            "injection as this exact HTTP header (case preserved). Setting it on "
+            "any field puts the pattern in multiple-headers mode. Empty means "
+            "single-key mode, which uses the pattern's auth_header_key_override. "
+            "Defaults to empty string."
+        ),
+    )
+
+    def to_dict(self) -> dict:
+        """Serialize this field to a wire-format dict for inclusion in auth_patterns.
+
+        :returns: Dict representation of the field. 'hint', 'required', 'options',
+                  'is_path_param', and 'header_name' are omitted when they hold
+                  their default values to keep the wire payload minimal. Keys the
+                  SDK does not declare are re-emitted unchanged.
+        :rtype: dict
+        """
+        d: dict = {
+            "field_name": self.field_name,
+            "label": self.label,
+            "input_type": self.input_type,
+        }
+        if self.hint:
+            d["hint"] = self.hint
+        if self.required:
+            d["required"] = True
+        if self.options:
+            d["options"] = [o.to_dict() for o in self.options]
+        if self.is_path_param:
+            d["is_path_param"] = True
+        if self.header_name:
+            d["header_name"] = self.header_name
+        d.update(self.model_extra or {})
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "AuthField":
+        """Deserialize an AuthField from a response dict.
+
+        Keys this SDK does not declare are kept on the instance rather than
+        dropped, so a field the catalogue grows later survives a decode/encode
+        round-trip.
+
+        :param d: Dict containing field data as returned by the server.
+        :type d: dict
+        :returns: AuthField instance populated from the dict values.
+        :rtype: AuthField
+        """
+        known = {
+            "field_name": d.get("field_name") or "",
+            "label": d.get("label") or "",
+            "input_type": d.get("input_type") or "text",
+            "hint": d.get("hint") or "",
+            "required": d.get("required") or False,
+            "options": [AuthFieldOption.from_dict(o) for o in d.get("options") or []],
+            "is_path_param": d.get("is_path_param") or False,
+            "header_name": d.get("header_name") or "",
+        }
+        extras = {k: v for k, v in d.items() if k not in known}
+        return cls(**known, **extras)
+
+    class Config:
+        extra = "allow"
+
+
+class OAuthConfig(BaseModel):
+    """OAuth configuration attached to an OAUTH auth pattern.
+
+    Pass OAuthConfig() (all defaults) for MCP connectors that use Dynamic Client
+    Registration — the MCP server manages the OAuth flow itself and no static
+    endpoints are needed. Set pkce_enabled=False only if your OAuth server does
+    not support PKCE.
+
+    Attach it to AuthPattern(type="OAUTH"). The managed catalogue also attaches
+    one to its other OAuth-family types ('OAUTH_M2M', 'GOOGLE_DWD',
+    'TRELLO_OAUTH1'). Do not attach it to BEARER or API_KEY patterns.
+
+    pkce_enabled is the only key you set when authoring a connector, but a
+    catalogue provider's oauth_config carries much more — 'authorize_uri',
+    'token_uri', 'user_info_uri', 'available_scopes',
+    'allow_use_scalekit_credentials' and others. Those are preserved on the
+    instance (readable as ordinary attributes) and re-emitted by to_dict()
+    rather than dropped, so reading a provider and writing it back does not
+    erase its OAuth endpoints and scopes.
+    """
+
+    pkce_enabled: bool = Field(
+        True,
+        description=(
+            "Optional. Whether to enable PKCE (Proof Key for Code Exchange, RFC 7636) "
+            "for the OAuth authorization flow. True = PKCE on (default, recommended); "
+            "False = PKCE disabled. Only set to False if the OAuth server does not "
+            "support PKCE."
+        ),
+    )
+
+    def to_dict(self) -> dict:
+        """Serialize to a wire-format dict.
+
+        :returns: Dict with 'pkce_enabled', always emitted explicitly so the
+                  server receives an unambiguous value, plus any other keys the
+                  config was decoded with, re-emitted unchanged.
+        :rtype: dict
+        """
+        d: dict = {"pkce_enabled": self.pkce_enabled}
+        d.update(self.model_extra or {})
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "OAuthConfig":
+        """Deserialize an OAuthConfig from a response dict.
+
+        Keys this SDK does not declare are kept on the instance rather than
+        dropped, so a catalogue provider's endpoints and scopes survive a
+        decode/encode round-trip.
+
+        :param d: Dict containing oauth_config data as returned by the server.
+        :type d: dict
+        :returns: OAuthConfig instance. pkce_enabled defaults to True if the key
+                  is absent from the dict.
+        :rtype: OAuthConfig
+        """
+        extras = {k: v for k, v in d.items() if k != "pkce_enabled"}
+        return cls(pkce_enabled=d.get("pkce_enabled", True), **extras)
+
+    class Config:
+        extra = "allow"
+
+
+class AuthPattern(BaseModel):
+    """One authentication option available on a custom connector.
+
+    A custom provider can have multiple auth patterns (e.g. both OAUTH and API_KEY),
+    giving users a choice of how to authenticate. For MCP connectors set is_mcp=True
+    on every pattern.
+
+    Type guide for the four types you create custom connectors with:
+      - "OAUTH"   — Browser-based OAuth 2.0 / 2.1 flow. Attach an OAuthConfig.
+      - "BEARER"  — Static bearer token supplied by the user. Add AuthFields for
+                    the token input.
+      - "API_KEY" — Static API key supplied by the user. Add AuthFields for the
+                    key input.
+      - "NO_AUTH" — Connector requires no credentials (e.g. public docs MCP
+                    servers). Attach no fields and no OAuthConfig.
+
+    Reading providers back can surface further types the managed catalogue uses
+    (e.g. 'BASIC', 'OAUTH_M2M', 'GOOGLE_DWD', 'TRELLO_OAUTH1', 'TRUSTED_IDP'), so
+    type is not restricted to the four above — see the field description.
+
+    The server models this as a free-form JSON object, so it may carry keys this
+    SDK does not declare. Those are preserved on the instance and re-emitted by
+    to_dict() rather than dropped.
+    """
+
+    type: str = Field(
+        ...,
+        description=(
+            "Required. Authentication mechanism for this pattern. "
+            "Use one of 'OAUTH' (browser OAuth flow), 'BEARER' (static bearer "
+            "token), 'API_KEY' (static API key), or 'NO_AUTH' (connector requires "
+            "no credentials) when creating a custom connector. Not restricted to "
+            "those four: the managed catalogue also serves 'BASIC', 'OAUTH_M2M', "
+            "'GOOGLE_DWD', 'TRELLO_OAUTH1', 'TRUSTED_IDP' and others, and the set "
+            "is owned by the server, so the SDK accepts any string and passes an "
+            "unknown type through unchanged rather than failing to parse."
+        ),
+    )
+    display_name: str = Field(
+        ...,
+        description=(
+            "Required. Human-readable label for this auth option shown in the UI. "
+            "Accepted characters: a-z, A-Z, 0-9, and spaces. "
+            "Example: 'GitHub OAuth', 'API Token', 'Service Account Key'."
+        ),
+    )
+    description: str = Field(
+        "",
+        description=(
+            "Optional. Short explanation of this auth method shown to the user. "
+            "Example: 'Authenticate with your GitHub account using OAuth 2.1'. "
+            "Defaults to empty string."
+        ),
+    )
+    fields: List[AuthField] = Field(
+        default_factory=list,
+        description=(
+            "Optional. List of AuthField objects defining the inputs the user must "
+            "supply. For BEARER and API_KEY these are the credential itself. OAUTH "
+            "patterns also use them, for options gathered before the browser flow "
+            "starts rather than for credentials, which the flow collects itself. "
+            "Leave empty for NO_AUTH, which collects nothing. Defaults to empty list."
+        ),
+    )
+    account_fields: List[AuthField] = Field(
+        default_factory=list,
+        description=(
+            "Optional. Inputs collected per connected account rather than once per "
+            "connection, for connectors that need an account-scoped value (a "
+            "workspace or subdomain, say) alongside the shared credential. Same "
+            "shape as 'fields'. Defaults to empty list."
+        ),
+    )
+    is_mcp: bool = Field(
+        False,
+        description=(
+            "Optional. Set to True for MCP (Model Context Protocol) server connectors. "
+            "When True the server sets is_custom_mcp=True on the provider. "
+            "Defaults to False."
+        ),
+    )
+    oauth_config: Optional["OAuthConfig"] = Field(
+        None,
+        description=(
+            "Optional. OAuth configuration. Required when type='OAUTH'; omit for "
+            "'BEARER' and 'API_KEY'. "
+            "Pass OAuthConfig() for MCP connectors using Dynamic Client Registration. "
+            "Pass OAuthConfig(pkce_enabled=False) to disable PKCE. "
+            "The managed catalogue also attaches one to its other OAuth-family "
+            "types ('OAUTH_M2M', 'GOOGLE_DWD', 'TRELLO_OAUTH1'). "
+            "Defaults to None."
+        ),
+    )
+    auth_header_key_override: str = Field(
+        "",
+        description=(
+            "Optional. Overrides the HTTP header name Scalekit uses when injecting "
+            "the static credential into proxied requests. Applies to BEARER and "
+            "API_KEY patterns. Example: 'x-api-key' to send the credential in the "
+            "'x-api-key' header instead of the default 'Authorization' header. "
+            "Defaults to empty string (use the default header)."
+        ),
+    )
+    allowed_proxy_domains: List[str] = Field(
+        default_factory=list,
+        description=(
+            "Optional. Domains this connector's proxied requests may be routed to. "
+            "Empty means no domain restriction beyond the provider's proxy_url. "
+            "Defaults to empty list."
+        ),
+    )
+
+    # Set on instances produced by from_dict. validate_assignment=True re-runs
+    # the validator below on every attribute write, and that re-run carries no
+    # validation context, so without this flag editing a decoded provider would
+    # raise for a shape the server legitimately served.
+    _decoded: bool = PrivateAttr(default=False)
+
+    @model_validator(mode="after")
+    def validate_auth_invariants(self, info: ValidationInfo):
+        """Guard the shapes create_custom_provider accepts.
+
+        These are SDK-side authoring guardrails, not server rules — the API
+        validates almost nothing about an auth pattern. So they are skipped for
+        anything decoded from a response (from_dict passes decoding=True): the
+        managed catalogue legitimately serves shapes a caller should not
+        hand-author, and refusing one would break list_providers() for the whole
+        page.
+        """
+        if (info.context or {}).get("decoding"):
+            self._decoded = True
+            return self
+        if self._decoded:
+            return self
+        if self.type == "OAUTH" and self.oauth_config is None:
+            raise ValueError("oauth_config is required when type='OAUTH'")
+        if self.type == "NO_AUTH" and self.fields:
+            raise ValueError("fields must be empty when type='NO_AUTH'")
+        return self
+
+    def to_dict(self) -> dict:
+        """Serialize to a wire-format dict for inclusion in the auth_patterns ListValue.
+
+        :returns: Dict representation of this auth pattern. 'description' is omitted
+                  when empty, 'is_mcp' when False, 'oauth_config' when None, and
+                  'auth_header_key_override', 'account_fields' and
+                  'allowed_proxy_domains' when empty, to keep the wire payload
+                  minimal. Keys the SDK does not declare are re-emitted unchanged.
+        :rtype: dict
+        """
+        d: dict = {
+            "type": self.type,
+            "display_name": self.display_name,
+            "fields": [f.to_dict() for f in self.fields],
+        }
+        if self.description:
+            d["description"] = self.description
+        if self.is_mcp:
+            d["is_mcp"] = True
+        if self.oauth_config is not None:
+            d["oauth_config"] = self.oauth_config.to_dict()
+        if self.auth_header_key_override:
+            d["auth_header_key_override"] = self.auth_header_key_override
+        if self.account_fields:
+            d["account_fields"] = [f.to_dict() for f in self.account_fields]
+        if self.allowed_proxy_domains:
+            d["allowed_proxy_domains"] = list(self.allowed_proxy_domains)
+        d.update(self.model_extra or {})
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "AuthPattern":
+        """Deserialize an AuthPattern from a response dict.
+
+        Decoding is deliberately permissive: the authoring guardrails in
+        validate_auth_invariants are skipped, unknown 'type' values are accepted,
+        and keys this SDK does not declare are kept on the instance. A managed
+        provider whose shape the SDK has not seen still decodes, instead of
+        failing the whole list_providers() page.
+
+        :param d: Dict containing auth pattern data as returned by the server.
+                  The 'oauth_config' key must be present for OAuth patterns;
+                  its absence is interpreted as oauth_config=None.
+        :type d: dict
+        :returns: AuthPattern instance populated from the dict values.
+        :rtype: AuthPattern
+        """
+        # A JSON null is treated as absent, not as an empty config: the server
+        # models oauth_config as a nullable pointer, so the key can arrive with
+        # no value.
+        oauth_cfg: Optional[OAuthConfig] = None
+        if d.get("oauth_config") is not None:
+            oauth_cfg = OAuthConfig.from_dict(d["oauth_config"])
+        known = {
+            "type": d.get("type", ""),
+            "display_name": d.get("display_name", ""),
+            "description": d.get("description", ""),
+            "fields": [AuthField.from_dict(f) for f in d.get("fields") or []],
+            "account_fields": [
+                AuthField.from_dict(f) for f in d.get("account_fields") or []
+            ],
+            "is_mcp": d.get("is_mcp", False),
+            "oauth_config": oauth_cfg,
+            "auth_header_key_override": d.get("auth_header_key_override", ""),
+            "allowed_proxy_domains": list(d.get("allowed_proxy_domains") or []),
+        }
+        extras = {k: v for k, v in d.items() if k not in known}
+        return cls.model_validate({**known, **extras}, context={"decoding": True})
+
+    class Config:
+        validate_assignment = True
+        extra = "allow"
+
+
+class Provider(BaseModel):
+    """A custom provider as returned by the Scalekit API.
+
+    Produced exclusively by ProvidersClient response decoding via from_proto().
+    All fields are populated from the server response — do not construct this
+    directly. The auth_patterns list is fully decoded so callers never need to
+    handle protobuf types.
+    """
+
+    identifier: str = Field(
+        "",
+        description="Unique identifier assigned by the server. Read-only.",
+    )
+    display_name: str = Field(
+        "",
+        description=(
+            "Human-readable name of the provider. "
+            "Accepted characters: a-z, A-Z, 0-9, and spaces."
+        ),
+    )
+    description: str = Field(
+        "",
+        description="Short description of the provider.",
+    )
+    proxy_url: str = Field(
+        "",
+        description="The proxy URL through which requests to this provider are routed.",
+    )
+    proxy_enabled: bool = Field(
+        False,
+        description="Whether request proxying is enabled for this provider.",
+    )
+    icon_src: str = Field(
+        "",
+        description="URL of the provider's icon image. Empty string when not set.",
+    )
+    metadata: Dict[str, str] = Field(
+        default_factory=dict,
+        description=(
+            "Arbitrary string key-value pairs attached to the provider. "
+            "Empty dict when none are set."
+        ),
+    )
+    is_custom: bool = Field(
+        False,
+        description="True for all providers created via create_custom_provider.",
+    )
+    is_custom_mcp: bool = Field(
+        False,
+        description=(
+            "True when at least one auth_pattern was created with is_mcp=True. "
+            "Set by the server — not a field you write."
+        ),
+    )
+    auth_patterns: List[AuthPattern] = Field(
+        default_factory=list,
+        description=(
+            "Decoded list of authentication options for this provider. "
+            "Currently contains at most one element — only a single auth pattern "
+            "is supported today. The list type is intentional for future multi-pattern support."
+        ),
+    )
+
+    @classmethod
+    def from_proto(cls, proto) -> "Provider":
+        """Decode a proto Provider message into a typed Provider.
+
+        Calls MessageToDict on the auth_patterns ListValue field to produce a
+        plain Python list, then deserializes each element into an AuthPattern.
+
+        :param proto: A proto Provider message instance from providers_pb2.
+        :returns: Provider instance with all fields populated and auth_patterns decoded.
+        :rtype: Provider
+        """
+        auth_patterns_raw = MessageToDict(proto.auth_patterns)
+        return cls(
+            identifier=proto.identifier,
+            display_name=proto.display_name,
+            description=proto.description,
+            proxy_url=proto.proxy_url,
+            proxy_enabled=proto.proxy_enabled,
+            icon_src=proto.icon_src,
+            metadata=dict(proto.metadata),
+            is_custom=proto.is_custom,
+            is_custom_mcp=proto.is_custom_mcp,
+            auth_patterns=[AuthPattern.from_dict(p) for p in auth_patterns_raw],
+        )
+
+    class Config:
+        validate_assignment = True

{scalekit_sdk_python-2.19.0 → scalekit_sdk_python-2.20.0}/scalekit/actions/types.py

@@ -27,7 +27,13 @@ from .models.tool_input_output import ToolInput, ToolOutput
 from .models.tool_mapping import ToolMapping
 from .models.mcp_config import McpConfig, McpConfigConnectionToolMapping
 from .models.mcp_instance import McpInstance, McpInstanceConnectionAuthState
-from .models.custom_provider import AuthPattern, AuthField, OAuthConfig, Provider
+from .models.custom_provider import (
+    AuthPattern,
+    AuthField,
+    AuthFieldOption,
+    OAuthConfig,
+    Provider,
+)
 from .models.requests.create_custom_provider_request import CreateCustomProviderRequest
 from .models.requests.update_custom_provider_request import UpdateCustomProviderRequest
 from .models.requests.list_providers_request import ListProvidersRequest
@@ -77,6 +83,7 @@ __all__ = [
     'McpInstanceConnectionAuthState',
     'AuthPattern',
     'AuthField',
+    'AuthFieldOption',
     'OAuthConfig',
     'Provider',
     'CreateCustomProviderRequest',