Support XML/SOAP proxy requests and expose connected account details (#148)

* Add raw_body support to ActionClient.request() for non-JSON payloads

Adds a raw_body parameter (Union[bytes, str]) that bypasses JSON
serialization, enabling XML/SOAP and other non-JSON request bodies to
be proxied as-is. Includes a docstring update and a Salesforce SOAP
integration test.

* make generate

* Support XML/SOAP proxy requests and expose connected account details without credentials

- ActionClient.request() now accepts a raw_body (str or bytes) parameter
  for sending non-JSON payloads (e.g. XML/SOAP). Previously only JSON and
  form-encoded bodies were supported.

- Added get_connected_account_details() method that returns account metadata
  (status, connector, api_config, etc.) without auth credentials. Useful for
  customers who need to inspect the api_config version before constructing a
  SOAP request, without exposing access/refresh tokens.

- Added integration tests covering Salesforce SOAP deploy + checkDeployStatus
  flow, the REST SObjects list endpoint, and get_connected_account_details.

* bumping up version

* Address CodeRabbit review comments

- Fix 401 retry dropping raw_body: retry now uses the same json/data
  logic as the original request instead of always falling back to body/form_data
- Normalize selectors in get_connected_account_details: when connected_account_id
  is supplied, connection_name and identifier are cleared before the call; raises
  ValueError if neither selector set is provided
- Strip authorization_details in GetConnectedAccountDetailsResponse.from_proto
  as defense-in-depth, regardless of what the server returns

* Revert selector normalization and credential stripping — server handles these

Author: AkshayParihar33

Makefile

@@ -12,7 +12,7 @@ VENV_PYTHON := $(VENV_DIR)/bin/python
 VENV_PIP := $(VENV_PYTHON) -m pip
 
 PROTO_REPO_URL := https://github.com/scalekit-inc/scalekit.git
-PROTO_REF ?= v0.1.114.0
+PROTO_REF ?= v0.1.116.0
 PROTO_SUBDIR := proto
 
 TEMP_DIR := temp_scalekit

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.9.0"

scalekit/actions/actions.py

@@ -1,6 +1,6 @@
 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
@@ -323,7 +323,51 @@ def get_connected_account(
 
         # 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 +427,7 @@ def request(
         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 +448,14 @@ def request(
         :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 +492,8 @@ def request(
             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 +507,8 @@ def request(
                 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,

scalekit/actions/models/responses/get_connected_account_auth_response.py

@@ -119,6 +119,41 @@ def to_dict(self) -> dict:
 
     class Config:
         """Pydantic configuration"""
+        validate_assignment = True
+        json_encoders = {
+            datetime: lambda v: v.isoformat() if v else None
+        }
+
+
+class GetConnectedAccountDetailsResponse(BaseModel):
+    """Connected account details response — same structure as GetConnectedAccountAuthResponse
+    but auth credentials (access/refresh tokens) are omitted by the server."""
+
+    connected_account: Optional[ConnectedAccount] = Field(
+        None,
+        description="Connected account details (without auth credentials)"
+    )
+
+    @classmethod
+    def from_proto(cls, proto_response) -> 'GetConnectedAccountDetailsResponse':
+        """
+        Create GetConnectedAccountDetailsResponse from protobuf GetConnectedAccountByIdentifierResponse
+
+        :param proto_response: The protobuf GetConnectedAccountByIdentifierResponse object
+        :returns:
+            GetConnectedAccountDetailsResponse instance
+        """
+        connected_account = None
+        if proto_response.connected_account:
+            connected_account = ConnectedAccount.from_proto(proto_response.connected_account)
+        return cls(connected_account=connected_account)
+
+    def to_dict(self) -> dict:
+        return {
+            "connected_account": self.connected_account.model_dump() if self.connected_account else None
+        }
+
+    class Config:
         validate_assignment = True
         json_encoders = {
             datetime: lambda v: v.isoformat() if v else None

scalekit/actions/types.py

@@ -6,7 +6,7 @@
 from .models.responses.magic_link_response import MagicLinkResponse
 from .models.responses.list_connected_accounts_response import ListConnectedAccountsResponse
 from .models.responses.delete_connected_account_response import DeleteConnectedAccountResponse
-from .models.responses.get_connected_account_auth_response import GetConnectedAccountAuthResponse
+from .models.responses.get_connected_account_auth_response import GetConnectedAccountAuthResponse, GetConnectedAccountDetailsResponse
 from .models.responses.create_connected_account_response import CreateConnectedAccountResponse
 from .models.responses.update_connected_account_response import UpdateConnectedAccountResponse
 from .models.responses.create_mcp_response import CreateMcpResponse
@@ -38,6 +38,7 @@
     'ListConnectedAccountsResponse',
     'DeleteConnectedAccountResponse',
     'GetConnectedAccountAuthResponse',
+    'GetConnectedAccountDetailsResponse',
     'CreateConnectedAccountResponse',
     'UpdateConnectedAccountResponse',
     'CreateMcpResponse',

scalekit/connected_accounts.py

@@ -275,6 +275,42 @@ def get_connected_account_by_identifier(
             ),
         )
 
+    def get_connected_account_details_by_identifier(
+        self,
+        connector: str,
+        identifier: str,
+        organization_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        connected_account_id: Optional[str] = None
+    ) -> GetConnectedAccountByIdentifierResponse:
+        """
+        Method to get connected account details (without auth credentials) by identifier
+
+        :param connector        : Connector identifier
+        :type                   : ``` str ```
+        :param identifier       : Identifier for the connector
+        :type                   : ``` str ```
+        :param organization_id  : Organization ID
+        :type                   : ``` str ```
+        :param user_id          : User ID
+        :type                   : ``` str ```
+        :param connected_account_id : ID of the connected account
+        :type                   : ``` str ```
+
+        :returns:
+            Get Connected Account By Identifier Response (without auth credentials)
+        """
+        return self.core_client.grpc_exec(
+            self.connected_accounts_service.GetConnectedAccountDetails.with_call,
+            GetConnectedAccountByIdentifierRequest(
+                organization_id=organization_id,
+                user_id=user_id,
+                connector=connector,
+                identifier=identifier,
+                id=connected_account_id
+            ),
+        )
+
     def verify_connected_account_user(
         self,
         auth_request_id: str,

scalekit/core.py

@@ -29,7 +29,7 @@ class CoreClient:
 
     sdk_version = f"Scalekit-Python/{_sdk_version}"
     # YYYYMMDD
-    api_version = "20260421"
+    api_version = "20260428"
     user_agent = f"{sdk_version} Python/{platform.python_version()} ({platform.system()}; {platform.architecture()}"
 
     def __init__(self, env_url, client_id, client_secret):