scalekit-sdk-python 2.8.0__tar.gz → 2.10.0__tar.gz

{scalekit_sdk_python-2.8.0 → scalekit_sdk_python-2.10.0}/PKG-INFO

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

{scalekit_sdk_python-2.8.0 → scalekit_sdk_python-2.10.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.8.0"
+__version__ = "2.10.0"

{scalekit_sdk_python-2.8.0 → scalekit_sdk_python-2.10.0}/scalekit/actions/actions.py

@@ -1,9 +1,11 @@
 from typing import Optional, Any, List, Dict, Union
 import requests
-from scalekit.actions.types import ToolRequest,ExecuteToolResponse,MagicLinkResponse,ListConnectedAccountsResponse,DeleteConnectedAccountResponse,GetConnectedAccountAuthResponse,ToolInput, \
+from scalekit.actions.types import ToolRequest,ExecuteToolResponse,MagicLinkResponse,ListConnectedAccountsResponse,DeleteConnectedAccountResponse,GetConnectedAccountAuthResponse,GetConnectedAccountDetailsResponse,ToolInput, \
     UpdateConnectedAccountResponse,CreateMcpConfigResponse,ListMcpConfigsResponse,UpdateMcpConfigResponse,DeleteMcpConfigResponse, \
     EnsureMcpInstanceResponse,UpdateMcpInstanceResponse,GetMcpInstanceResponse,ListMcpInstancesResponse,DeleteMcpInstanceResponse,GetMcpInstanceAuthStateResponse, \
-    McpConfig,McpConfigConnectionToolMapping,VerifyConnectedAccountUserResponse
+    McpConfig,McpConfigConnectionToolMapping,VerifyConnectedAccountUserResponse, \
+    CreateCustomProviderRequest,UpdateCustomProviderRequest,ListProvidersRequest,DeleteCustomProviderRequest, \
+    CreateCustomProviderResponse,UpdateCustomProviderResponse,ListProvidersResponse,DeleteCustomProviderResponse
 from scalekit.actions.models.responses.create_connected_account_response import CreateConnectedAccountResponse
 from scalekit.actions.models.requests.create_connected_account_request import CreateConnectedAccountRequest
 from scalekit.actions.models.requests.update_connected_account_request import UpdateConnectedAccountRequest
@@ -19,17 +21,19 @@ from scalekit.common.exceptions import ScalekitNotFoundException
 class ActionClient:
     """Class definition for Connect Client"""
 
-    def __init__(self,tools_client, connected_accounts_client, mcp_client=None):
+    def __init__(self,tools_client, connected_accounts_client, mcp_client=None, providers_client=None):
         """
         Initialize ActionClient with tools, connected accounts, and MCP dependencies
-        
+
         :param tools_client: ToolsClient instance
         :type: ToolsClient
         :param connected_accounts_client: ConnectedAccountsClient instance
         :type: ConnectedAccountsClient
         :param mcp_client: McpClient instance (optional)
         :type: McpClient
-        
+        :param providers_client: ProvidersClient instance (optional)
+        :type: ProvidersClient
+
         :returns:
             None
         """
@@ -38,6 +42,8 @@ class ActionClient:
         self.connected_accounts = connected_accounts_client
         self._mcp_client = mcp_client
         self._mcp_actions = None
+        self._providers_client = providers_client
+        self._providers_actions = None
         self._modifiers: List[Modifier] = []
         self._google = None
         self._langchain = None
@@ -87,6 +93,20 @@ class ActionClient:
             self._mcp_actions = ActionMcp(self)
         return self._mcp_actions
 
+    @property
+    def providers(self) -> "ActionProviders":
+        """Expose custom provider CRUD with typed request and response objects.
+
+        :returns: ActionProviders instance bound to the configured ProvidersClient.
+        :rtype: ActionProviders
+        :raises ValueError: If no ProvidersClient was passed at construction time.
+        """
+        if self._providers_client is None:
+            raise ValueError("Providers client not initialized.")
+        if self._providers_actions is None:
+            self._providers_actions = ActionProviders(self._providers_client)
+        return self._providers_actions
+
     def execute_tool(
         self,
         tool_input:ToolInput,
@@ -323,7 +343,51 @@ class ActionClient:
         
         # Convert proto to our GetConnectedAccountAuthResponse class
         return GetConnectedAccountAuthResponse.from_proto(proto_response)
-    
+
+    def get_connected_account_details(
+        self,
+        connection_name: Optional[str] = None,
+        identifier: Optional[str] = None,
+        connected_account_id: Optional[str] = None,
+        **kwargs
+    ) -> GetConnectedAccountDetailsResponse:
+        """
+        Get connected account details by identifier, without auth credentials.
+
+        Use this instead of :meth:`get_connected_account` when you only need
+        account metadata (status, connector, api_config, etc.) and do not
+        require the access/refresh tokens.
+
+        You must provide **one** of the following to identify the connected account:
+
+        - ``connection_name`` **and** ``identifier`` — use when you know the
+          connector name and the end-user's identifier (e.g. email address).
+        - ``connected_account_id`` — use when you already hold the Scalekit
+          connected account ID.
+
+        :param connection_name: Connector identifier, e.g. ``"salesforce-1hpnGzcD"``.
+            Required when ``connected_account_id`` is not provided.
+        :type connection_name: str
+        :param identifier: End-user identifier tied to the connected account,
+            e.g. ``"john.doe"``. Required when ``connected_account_id`` is not provided.
+        :type identifier: str
+        :param connected_account_id: Scalekit connected account ID. When supplied,
+            ``connection_name`` and ``identifier`` are ignored.
+        :type connected_account_id: str
+
+        :returns:
+            GetConnectedAccountDetailsResponse containing account metadata
+            without auth credentials
+        :rtype: GetConnectedAccountDetailsResponse
+        """
+        result_tuple = self.connected_accounts.get_connected_account_details_by_identifier(
+            connector=connection_name,
+            identifier=identifier,
+            connected_account_id=connected_account_id
+        )
+        proto_response = result_tuple[0]
+        return GetConnectedAccountDetailsResponse.from_proto(proto_response)
+
     def add_modifier(self, modifier: Modifier) -> None:
         """Add a modifier to the private list"""
         self._modifiers.append(modifier)
@@ -383,6 +447,7 @@ class ActionClient:
         query_params: Optional[Dict[str, Any]] = None,
         body: Optional[Any] = None,
         form_data: Optional[Dict[str, Any]] = None,
+        raw_body: Optional[Union[bytes, str]] = None,
         headers: Optional[Dict[str, str]] = None,
         **kwargs,
     ) -> requests.Response:
@@ -403,6 +468,14 @@ class ActionClient:
         :type body: Optional[Any]
         :param form_data: Request body sent as URL-encoded form data
         :type form_data: Optional[Dict[str, Any]]
+        :param raw_body: Raw request body sent as-is, without any serialization.
+            Use this **only** when the request payload is not JSON — for example,
+            when the downstream API expects an XML body, a plain-text payload, or
+            any other non-JSON content type. For JSON payloads use ``body`` instead.
+            When ``raw_body`` is provided it takes priority over both ``body`` and
+            ``form_data``. You must also pass a matching ``Content-Type`` header via
+            ``headers`` (e.g. ``"Content-Type": "application/xml"``).
+        :type raw_body: Optional[Union[bytes, str]]
         :param headers: Additional HTTP headers to merge into the request
         :type headers: Optional[Dict[str, str]]
 
@@ -439,8 +512,8 @@ class ActionClient:
             method=method.upper(),
             url=url,
             params=params,
-            json=body,
-            data=form_data,
+            json=body if raw_body is None else None,
+            data=raw_body or form_data,
             headers=req_headers,
             timeout=timeout,
             **kwargs,
@@ -454,8 +527,8 @@ class ActionClient:
                 method=method.upper(),
                 url=url,
                 params=params,
-                json=body,
-                data=form_data,
+                json=body if raw_body is None else None,
+                data=raw_body if raw_body is not None else form_data,
                 headers=req_headers,
                 timeout=timeout,
                 **kwargs,
@@ -1086,3 +1159,116 @@ class ActionMcp:
             include_auth_links=include_auth_links,
         )
         return GetMcpInstanceAuthStateResponse.from_proto(result_tuple[0])
+
+
+class ActionProviders:
+    """Typed action layer over ProvidersClient for custom provider CRUD.
+
+    Accepts typed request objects and returns typed response objects.
+    Access via ActionClient.providers — do not instantiate directly.
+    """
+
+    def __init__(self, providers_client) -> None:
+        self._providers_client = providers_client
+
+    def create_custom_provider(
+        self,
+        request: CreateCustomProviderRequest,
+    ) -> CreateCustomProviderResponse:
+        """Create a new custom provider.
+
+        :param request: Request object containing display_name (required),
+                        proxy_url (required), and optional description,
+                        proxy_enabled, and auth_patterns.
+        :type request: CreateCustomProviderRequest
+
+        :returns: Response containing the created provider with its server-assigned
+                  identifier and all decoded auth_patterns.
+        :rtype: CreateCustomProviderResponse
+
+        :raises ScalekitBadRequestException: If required fields are missing or invalid.
+        :raises ScalekitConflictException: If a provider with the same name already exists.
+        """
+        result_tuple = self._providers_client.create_custom_provider(
+            display_name=request.display_name,
+            proxy_url=request.proxy_url,
+            proxy_enabled=request.proxy_enabled,
+            description=request.description,
+            auth_patterns=request.auth_patterns,
+        )
+        return CreateCustomProviderResponse.from_proto(result_tuple[0])
+
+    def update_custom_provider(
+        self,
+        request: UpdateCustomProviderRequest,
+    ) -> UpdateCustomProviderResponse:
+        """Update an existing custom provider.
+
+        Only fields set to a non-None value in the request are applied.
+        Fields left as None are ignored and their existing server values are kept.
+
+        :param request: Request object containing identifier (required) and any
+                        combination of display_name, description, proxy_url, and
+                        auth_patterns to update.
+        :type request: UpdateCustomProviderRequest
+
+        :returns: Response containing the provider's full state after the update.
+        :rtype: UpdateCustomProviderResponse
+
+        :raises ScalekitNotFoundException: If no provider with the given identifier exists.
+        :raises ScalekitBadRequestException: If any updated field value is invalid.
+        """
+        result_tuple = self._providers_client.update_custom_provider(
+            identifier=request.identifier,
+            display_name=request.display_name,
+            proxy_url=request.proxy_url,
+            description=request.description,
+            auth_patterns=request.auth_patterns,
+        )
+        return UpdateCustomProviderResponse.from_proto(result_tuple[0])
+
+    def list_providers(
+        self,
+        request: ListProvidersRequest,
+    ) -> ListProvidersResponse:
+        """List providers with optional filtering and pagination.
+
+        :param request: Request object with optional provider_type, page_size,
+                        page_token, and identifier filters. All fields are optional —
+                        an empty ListProvidersRequest() returns all providers.
+        :type request: ListProvidersRequest
+
+        :returns: Response containing a page of providers and a next_page_token
+                  for fetching subsequent pages.
+        :rtype: ListProvidersResponse
+        """
+        result_tuple = self._providers_client.list_providers(
+            page_size=request.page_size,
+            page_token=request.page_token,
+            provider_type=request.provider_type,
+            identifier=request.identifier,
+        )
+        return ListProvidersResponse.from_proto(result_tuple[0])
+
+    def delete_custom_provider(
+        self,
+        request: DeleteCustomProviderRequest,
+    ) -> DeleteCustomProviderResponse:
+        """Delete a custom provider by identifier.
+
+        Deletion is permanent. Returns an empty response on success. Any error
+        (provider not found, insufficient permissions) raises a
+        ScalekitServerException subclass before this method returns.
+
+        :param request: Request object containing the identifier of the provider
+                        to delete.
+        :type request: DeleteCustomProviderRequest
+
+        :returns: Empty response confirming deletion.
+        :rtype: DeleteCustomProviderResponse
+
+        :raises ScalekitNotFoundException: If no provider with the given identifier exists.
+        :raises ScalekitForbiddenException: If the caller lacks permission to delete.
+        """
+        result_tuple = self._providers_client.delete_custom_provider(request.identifier)
+        return DeleteCustomProviderResponse.from_proto(result_tuple[0])

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

@@ -0,0 +1,348 @@
+from typing import List, Literal, Optional
+
+from google.protobuf.json_format import MessageToDict
+from pydantic import BaseModel, Field, root_validator
+
+
+class AuthField(BaseModel):
+    """A single credential input field displayed to the user during connection setup.
+
+    AuthField is only used with BEARER and API_KEY auth patterns — do not attach
+    fields to OAUTH patterns (the OAuth flow collects credentials itself).
+
+    Use one AuthField per credential 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.
+    """
+
+    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: Literal["text", "password"] = Field(
+        "text",
+        description=(
+            "Optional. Controls how the input is rendered in the UI. "
+            "Accepted values: 'text' (visible input, default) or "
+            "'password' (masked input — use for secrets, tokens, and keys)."
+        ),
+    )
+    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."
+        ),
+    )
+
+    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' and 'required' are omitted
+                  when they hold their default values to keep the wire payload minimal.
+        :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
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "AuthField":
+        """Deserialize an AuthField from a response dict.
+
+        :param d: Dict containing field data as returned by the server.
+        :type d: dict
+        :returns: AuthField instance populated from the dict values.
+        :rtype: AuthField
+        """
+        return cls(
+            field_name=d.get("field_name", ""),
+            label=d.get("label", ""),
+            input_type=d.get("input_type", "text"),
+            hint=d.get("hint", ""),
+            required=d.get("required", False),
+        )
+
+
+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.
+
+    This class is only used with AuthPattern(type="OAUTH"). Do not attach it to
+    BEARER or API_KEY patterns.
+    """
+
+    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 a single key 'pkce_enabled'. Always emitted explicitly
+                  so the server receives an unambiguous value.
+        :rtype: dict
+        """
+        return {"pkce_enabled": self.pkce_enabled}
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "OAuthConfig":
+        """Deserialize an OAuthConfig from a response dict.
+
+        :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
+        """
+        return cls(pkce_enabled=d.get("pkce_enabled", True))
+
+
+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:
+      - "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.
+    """
+
+    type: Literal["OAUTH", "BEARER", "API_KEY"] = Field(
+        ...,
+        description=(
+            "Required. Authentication mechanism for this pattern. "
+            "Accepted values: 'OAUTH' (browser OAuth flow), "
+            "'BEARER' (static bearer token), 'API_KEY' (static API key)."
+        ),
+    )
+    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 credential inputs "
+            "the user must supply. Only applicable to BEARER and API_KEY types — "
+            "must be empty (or omitted) for OAUTH, which collects credentials "
+            "through the browser OAuth flow and does not use static input 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' (must be None). "
+            "Pass OAuthConfig() for MCP connectors using Dynamic Client Registration. "
+            "Pass OAuthConfig(pkce_enabled=False) to disable PKCE. "
+            "Defaults to None."
+        ),
+    )
+
+    @root_validator(skip_on_failure=True)
+    def validate_auth_invariants(cls, values):
+        auth_type = values.get("type")
+        if auth_type is None:
+            return values  # type field already failed validation
+        oauth_config = values.get("oauth_config")
+        fields = values.get("fields", [])
+        if auth_type == "OAUTH":
+            if oauth_config is None:
+                raise ValueError("oauth_config is required when type='OAUTH'")
+            if fields:
+                raise ValueError("fields must be empty when type='OAUTH'")
+        else:
+            if oauth_config is not None:
+                raise ValueError(f"oauth_config must be None when type='{auth_type}'")
+        return values
+
+    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, and 'oauth_config' when None, to
+                  keep the wire payload minimal.
+        :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()
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "AuthPattern":
+        """Deserialize an AuthPattern from a response dict.
+
+        :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 (non-OAuth).
+        :type d: dict
+        :returns: AuthPattern instance populated from the dict values.
+        :rtype: AuthPattern
+        """
+        oauth_cfg: Optional[OAuthConfig] = None
+        if "oauth_config" in d:
+            oauth_cfg = OAuthConfig.from_dict(d["oauth_config"])
+        return cls(
+            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", [])],
+            is_mcp=d.get("is_mcp", False),
+            oauth_config=oauth_cfg,
+        )
+
+    class Config:
+        validate_assignment = True
+
+
+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.",
+    )
+    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,
+            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.8.0 → scalekit_sdk_python-2.10.0}/scalekit/actions/models/requests/create_connected_account_request.py

@@ -4,7 +4,8 @@ from scalekit.v1.connected_accounts.connected_accounts_pb2 import (
     CreateConnectedAccount,
     AuthorizationDetails,
     OauthToken,
-    StaticAuth
+    StaticAuth,
+    GoogleDWDAuth
 )
 from google.protobuf import struct_pb2
 
@@ -44,6 +45,16 @@ class CreateConnectedAccountRequest(BaseModel):
             struct_details.update(static_data)
             static_auth = StaticAuth(details=struct_details)
             auth_details = AuthorizationDetails(static_auth=static_auth)
+
+        elif self.authorization_details and "google_dwd" in self.authorization_details:
+            dwd_data = self.authorization_details["google_dwd"]
+            if not isinstance(dwd_data, dict):
+                raise ValueError("authorization_details.google_dwd must be an object")
+            subject = dwd_data.get("subject")
+            if not subject:
+                raise ValueError("authorization_details.google_dwd.subject is required")
+            google_dwd = GoogleDWDAuth(subject=subject)
+            auth_details = AuthorizationDetails(google_dwd=google_dwd)
         
         # Handle api_config if provided
         api_config_struct = None
@@ -58,4 +69,4 @@ class CreateConnectedAccountRequest(BaseModel):
 
     class Config:
         """Pydantic configuration"""
-        validate_assignment = True
+        validate_assignment = True