scalekit-sdk-python 2.3.2__tar.gz → 2.3.3__tar.gz

{scalekit_sdk_python-2.3.2 → scalekit_sdk_python-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scalekit-sdk-python
-Version: 2.3.2
+Version: 2.3.3
 Summary: Scalekit official Python SDK
 Home-page: https://github.com/scalekit-inc/scalekit-sdk-python
 Author: Team Scalekit
@@ -25,6 +25,7 @@ Requires-Dist: googleapis-common-protos<1.66.0,>=1.56.1
 Requires-Dist: deprecation>=2.1.0
 Requires-Dist: python-dotenv~=1.0.1
 Requires-Dist: Faker~=25.8.0
+Requires-Dist: pydantic~=2.10.6
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{scalekit_sdk_python-2.3.2 → scalekit_sdk_python-2.3.3}/scalekit/client.py

@@ -16,7 +16,11 @@ from scalekit.organization import OrganizationClient
 from scalekit.directory import DirectoryClient
 from scalekit.users import UserClient
 from scalekit.role import RoleClient
+from scalekit.connected_accounts import ConnectedAccountsClient
+from scalekit.tools import ToolsClient
+from scalekit.connect import ConnectClient
 from scalekit.passwordless import PasswordlessClient
+from scalekit.mcp import McpClient
 from scalekit.common.scalekit import (
     AuthorizationUrlOptions,
     CodeAuthenticationOptions,
@@ -62,6 +66,10 @@ class ScalekitClient:
             self.m2m_client = M2MClient(self.core_client)
             self.users = UserClient(self.core_client)
             self.roles = RoleClient(self.core_client)
+            self.connected_accounts = ConnectedAccountsClient(self.core_client)
+            self.tools = ToolsClient(self.core_client)
+            self.mcp = McpClient(self.core_client)
+            self.connect = ConnectClient(self.tools, self.connected_accounts, self.mcp)
             self.passwordless = PasswordlessClient(self.core_client)
         except Exception as exp:
             raise exp

{scalekit_sdk_python-2.3.2 → scalekit_sdk_python-2.3.3}/scalekit/common/scalekit.py

@@ -64,10 +64,10 @@ class IdpInitiatedLoginClaims:
 class LogoutUrlOptions:
     """Options for logout URL generation"""
     def __init__(
-        self,
-        id_token_hint: Optional[str] = None,
-        post_logout_redirect_uri: Optional[str] = None,
-        state: Optional[str] = None
+            self,
+            id_token_hint: Optional[str] = None,
+            post_logout_redirect_uri: Optional[str] = None,
+            state: Optional[str] = None
     ):
         self.id_token_hint = id_token_hint
         self.post_logout_redirect_uri = post_logout_redirect_uri
@@ -77,10 +77,10 @@ class LogoutUrlOptions:
 class TokenValidationOptions:
     """Options for token validation including issuer, audience, and scope validation"""
     def __init__(
-        self,
-        issuer: Optional[str] = None,
-        audience: Optional[List[str]] = None,
-        required_scopes: Optional[List[str]] = None
+            self,
+            issuer: Optional[str] = None,
+            audience: Optional[List[str]] = None,
+            required_scopes: Optional[List[str]] = None
     ):
         self.issuer = issuer
         self.audience = audience

scalekit_sdk_python-2.3.3/scalekit/connect/__init__.py

@@ -0,0 +1,6 @@
+from .connect import ConnectClient
+from .models import *
+
+__all__ = [
+    'ConnectClient',
+]

scalekit_sdk_python-2.3.3/scalekit/connect/connect.py

@@ -0,0 +1,361 @@
+from typing import Optional, Dict, Any, List
+from scalekit.v1.mcp.mcp_pb2 import Mcp
+from scalekit.v1.mcp.mcp_pb2 import ToolMapping as ProtoToolMapping
+
+from scalekit.connect.models.tool_mapping import ToolMapping
+from scalekit.connect.types import ToolRequest,ExecuteToolResponse,MagicLinkResponse,ListConnectedAccountsResponse,DeleteConnectedAccountResponse,GetConnectedAccountAuthResponse,ToolInput,ToolOutput,McpRequest,CreateMcpResponse,GetMcpResponse
+from scalekit.connect.modifier import (
+    Modifier, ModifierType, ToolNames,
+    apply_pre_modifiers, apply_post_modifiers
+)
+
+
+
+
+class ConnectClient:
+    """Class definition for Connect Client"""
+
+    def __init__(self,tools_client, connected_accounts_client, mcp_client=None):
+        """
+        Initialize ConnectClient 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
+        
+        :returns:
+            None
+        """
+
+        self.tools = tools_client
+        self.connected_accounts = connected_accounts_client
+        self.mcp = mcp_client
+        self._modifiers: List[Modifier] = []
+
+    def execute_tool(
+        self,
+        tool_input:ToolInput,
+        tool_name: str,
+        identifier: Optional[str] = None,
+        tool_request: Optional[ToolRequest] = None,
+        connected_account_id: Optional[str] = None,
+        **kwargs
+    ) -> ExecuteToolResponse:
+        """
+        Execute a tool with the given parameters.
+        
+        Args:
+            tool_input: Input data for the tool execution (required)
+            tool_name: Name of the tool to execute (required)
+            identifier: Unique identifier for this execution (required)
+            tool_request: Optional ToolRequest configuration object
+            connected_account_id: Optional connected account ID string
+            **kwargs: Additional optional parameters
+            
+        Returns:
+            ExecuteToolResponse containing execution results
+        """
+        # Validate required parameters
+        if not tool_input:
+            raise ValueError("tool_input is required")
+        if not tool_name:
+            raise ValueError("tool_name is required")
+        
+        # Apply pre-modifications to the input parameters
+        modified_tool_input = apply_pre_modifiers(tool_name, tool_input, self._modifiers)
+        
+        # Call the existing tools.execute_tool which returns (response, metadata) tuple
+        result_tuple = self.tools.execute_tool(
+            tool_name=tool_name,
+            identifier=identifier,
+            params=modified_tool_input,
+            connected_account_id=connected_account_id
+        )
+        
+        # Extract the response[0] (the actual ExecuteToolResponse proto object)
+        proto_response = result_tuple[0]
+        
+        # Convert proto to our ExecuteToolResponse class
+        response = ExecuteToolResponse.from_proto(proto_response)
+        
+        # Apply post-modifications to the result
+        modified_response = apply_post_modifiers(tool_name, response.data, self._modifiers)
+
+        response.data = modified_response
+        
+        return response
+    
+    def get_authorization_link(
+            self,
+            identifier: Optional[str] = None,
+            connection_name: Optional[str] = None,
+            connected_account_id: Optional[str] = None,
+            **kwargs
+    ) -> MagicLinkResponse:
+        """
+        Get authorization magic link for a connected account
+        
+        :param connection_name: Connector identifier
+        :type: str
+        :param identifier: Connected account identifier
+        :type: str
+        :param connected_account_id: Connected account ID (optional)
+        :type: str
+        
+        :returns:
+            MagicLinkResponse containing magic link and expiry
+        """
+        # Call the existing connected_accounts method which returns (response, metadata) tuple
+        result_tuple = self.connected_accounts.get_magic_link_for_connected_account(
+            connector=connection_name,
+            identifier=identifier,
+            connected_account_id=connected_account_id
+        )
+        
+        # Extract the response[0] (the actual GetMagicLinkForConnectedAccountResponse proto object)
+        proto_response = result_tuple[0]
+        
+        # Convert proto to our MagicLinkResponse class
+        return MagicLinkResponse.from_proto(proto_response)
+    
+    def list_connected_accounts(
+        self, 
+        connection_name: Optional[str] = None,
+        identifier: Optional[str] = None,
+        provider: Optional[str] = None,
+        **kwargs
+    ) -> ListConnectedAccountsResponse:
+        """
+        List connected accounts with optional filtering
+        
+        :param connection_name: Connector identifier (optional)
+        :type: str
+        :param identifier: Identifier filter (optional)
+        :type: str
+        :param provider: Provider filter (optional)
+        :type: str
+        
+        :returns:
+            ListConnectedAccountsResponse containing list of connected accounts
+        """
+        # Call the existing connected_accounts method which returns (response, metadata) tuple
+        result_tuple = self.connected_accounts.list_connected_accounts(
+            connector=connection_name,
+            identifier=identifier,
+            provider=provider
+        )
+        
+        # Extract the response[0] (the actual ListConnectedAccountsResponse proto object)
+        proto_response = result_tuple[0]
+        
+        # Convert proto to our ListConnectedAccountsResponse class
+        return ListConnectedAccountsResponse.from_proto(proto_response)
+    
+    def delete_connected_account(
+        self,
+        connection_name: Optional[str] = None,
+        identifier: Optional[str] = None,
+        connected_account_id: Optional[str] = None,
+        **kwargs
+    ) -> DeleteConnectedAccountResponse:
+        """
+        Delete a connected account
+        
+        :param connection_name: Connector identifier (required)
+        :type: str
+        :param identifier: Connected account identifier (required)
+        :type: str
+        :param connected_account_id: Connected account ID (optional)
+        :type: str
+        
+        :returns:
+            DeleteConnectedAccountResponse containing deletion status
+        """
+            
+        # Call the existing connected_accounts method which returns (response, metadata) tuple
+        result_tuple = self.connected_accounts.delete_connected_account(
+            connector=connection_name,
+            identifier=identifier,
+            connected_account_id=connected_account_id
+        )
+        
+        # Extract the response[0] (the actual DeleteConnectedAccountResponse proto object)
+        proto_response = result_tuple[0]
+        
+        # Convert proto to our DeleteConnectedAccountResponse class
+        return DeleteConnectedAccountResponse.from_proto(proto_response)
+    
+    def get_connected_account(
+        self,
+        connection_name: Optional[str] = None,
+        identifier: Optional[str] = None,
+        connected_account_id: Optional[str] = None,
+        **kwargs
+    ) -> GetConnectedAccountAuthResponse:
+        """
+        Get connected account authorization details by identifier
+        
+        :param connection_name: Connector identifier (required)
+        :type: str
+        :param identifier: Connected account identifier (required)
+        :type: str
+        :param connected_account_id: Connected account ID (optional)
+        :type: str
+        
+        :returns:
+            GetConnectedAccountAuthResponse containing connected account details
+        """
+
+
+            
+        # Call the existing connected_accounts method which returns (response, metadata) tuple
+        result_tuple = self.connected_accounts.get_connected_account_by_identifier(
+            connector=connection_name,
+            identifier=identifier,
+            connected_account_id=connected_account_id
+        )
+        
+        # Extract the response[0] (the actual GetConnectedAccountByIdentifierResponse proto object)
+        proto_response = result_tuple[0]
+        
+        # Convert proto to our GetConnectedAccountAuthResponse class
+        return GetConnectedAccountAuthResponse.from_proto(proto_response)
+    
+    def add_modifier(self, modifier: Modifier) -> None:
+        """Add a modifier to the private list"""
+        self._modifiers.append(modifier)
+    
+    def get_modifiers(
+        self, 
+        tool_name: Optional[str] = None, 
+        modifier_type: Optional[ModifierType] = None
+    ) -> List[Modifier]:
+        """Get modifiers, optionally filtered by tool_name and/or type"""
+        filtered = self._modifiers
+        
+        if tool_name:
+            filtered = [m for m in filtered if tool_name in m.tool_names]
+        
+        if modifier_type:
+            filtered = [m for m in filtered if m.type == modifier_type]
+            
+        return filtered
+    
+    def pre_modifier(self, tool_names: ToolNames, **kwargs: Any):
+        """Decorator for pre-modification that registers with this Connect instance
+        
+        Usage:
+            @connect.premodifier(tool_names="my_tool", priority=1)
+            def my_modifier(tool_name, data):
+                return modified_data
+        """
+        def decorator(func):
+            modifier = Modifier(tool_names=tool_names, modifier_type="pre", **kwargs)
+            modifier.func = func
+            self.add_modifier(modifier)
+            return func
+        return decorator
+    
+    def post_modifier(self, tool_names: ToolNames, **kwargs: Any):
+        """Decorator for post-modification that registers with this Connect instance
+        
+        Usage:
+            @connect.postmodifier(tool_names=["tool1", "tool2"])
+            def my_modifier(tool_name, result):
+                return modified_result
+        """
+        def decorator(func):
+            modifier = Modifier(tool_names=tool_names, modifier_type="post", **kwargs)
+            modifier.func = func
+            self.add_modifier(modifier)
+            return func
+        return decorator
+
+    def get_mcp(
+        self,
+        mcp_id: str,
+        mcp_request: Optional[McpRequest] = None,
+        **kwargs
+    ) -> GetMcpResponse:
+        """
+        Get an existing MCP by ID via the connect interface
+        
+        :param mcp_id: ID of the MCP to retrieve (required)
+        :type: str
+        :param mcp_request: Optional McpRequest configuration object
+        :type: McpRequest
+        
+        :returns:
+            GetMcpResponse containing MCP details
+        """
+        if not self.mcp:
+            raise ValueError("MCP client not initialized. Please ensure MCP client is available.")
+        
+        if not mcp_id:
+            raise ValueError("mcp_id is required")
+        
+        # Call the MCP client's get_mcp method which returns (response, metadata) tuple
+        result_tuple = self.mcp.get_mcp(mcp_id=mcp_id)
+        
+        # Extract the response[0] (the actual GetMcpResponse proto object)
+        proto_response = result_tuple[0]
+        
+        # Convert proto to our GetMcpResponse class
+        return GetMcpResponse.from_proto(proto_response)
+
+    def create_mcp(
+        self,
+        identifier: str,
+        tool_mappings: List[ToolMapping],
+        mcp_request: Optional[McpRequest] = None,
+        **kwargs
+    ) -> CreateMcpResponse:
+        """
+        Create or return existing MCP with given configuration via the connect interface
+        
+        :param identifier: Identifier for the connected account (required)
+        :type: str
+        :param tool_mappings: List of tool mappings for the MCP (required)
+        :type: List[ToolMapping]
+        :param mcp_request: Optional McpRequest configuration object
+        :type: McpRequest
+        
+        :returns:
+            CreateMcpResponse containing created MCP details
+        """
+        if not self.mcp:
+            raise ValueError("MCP client not initialized. Please ensure MCP client is available.")
+        
+        # Validate required parameters
+        if not identifier:
+            raise ValueError("connected_account_identifier is required")
+        if not tool_mappings:
+            raise ValueError("tool_mappings is required")
+
+
+
+        # Create ToolMapping objects from the provided tool_mappings
+        proto_tool_mappings = []
+        for mapping in tool_mappings:
+            proto_mapping = ProtoToolMapping(
+                tool_names=mapping.tool_names,
+                connection_name=mapping.connection_name,
+            )
+            proto_tool_mappings.append(proto_mapping)
+        
+        # Create the MCP proto object
+        mcp_proto = Mcp(
+            connected_account_identifier=identifier,
+            tool_mappings=proto_tool_mappings,
+        )
+
+        result_tuple = self.mcp.create_mcp(mcp=mcp_proto)
+        
+        # Extract the response[0] (the actual CreateMcpResponse proto object)
+        proto_response = result_tuple[0]
+        
+        # Convert proto to our CreateMcpResponse class
+        return CreateMcpResponse.from_proto(proto_response)

scalekit_sdk_python-2.3.3/scalekit/connect/models/requests/mcp_request.py

@@ -0,0 +1,17 @@
+from typing import Optional, List
+from pydantic import BaseModel, Field, field_validator
+
+from scalekit.connect.models.tool_mapping import ToolMapping
+
+# TODO: Add validation for tool_mappings to ensure unique tool names across mappings
+class McpRequest(BaseModel):
+    """MCP request configuration with validation"""
+
+
+    identifier: Optional[str] = Field(
+        None,
+        description="Identifier for the connected account", 
+        min_length=1,
+        max_length=255
+    )
+    tool_mappings: List[ToolMapping]

scalekit_sdk_python-2.3.3/scalekit/connect/models/requests/tool_request.py

@@ -0,0 +1,76 @@
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator
+
+
+class ToolRequest(BaseModel):
+    """Tool request configuration with validation"""
+    
+    tool_version: Optional[str] = Field(
+        None, 
+        description="Version of the tool to use",
+        min_length=1,
+        max_length=50
+    )
+    tool_name: Optional[str] = Field(
+        None, 
+        description="Name of the tool",
+        min_length=1,
+        max_length=100
+    )
+    identifier: Optional[str] = Field(
+        None, 
+        description="Unique identifier for execution",
+        min_length=1,
+        max_length=255
+    )
+
+    @field_validator('tool_version')
+    @classmethod
+    def validate_tool_version(cls, v):
+        """Validate tool version format"""
+        if v is not None:
+            if not isinstance(v, str):
+                raise ValueError('tool_version must be a string')
+            v = v.strip()
+            if not v:
+                raise ValueError('tool_version cannot be empty or whitespace only')
+            # Basic semantic version validation (optional)
+            if '.' in v and not all(part.isdigit() for part in v.split('.')):
+                raise ValueError('tool_version should follow semantic versioning (e.g., 1.0.0)')
+        return v
+
+    @field_validator('tool_name')
+    @classmethod
+    def validate_tool_name(cls, v):
+        """Validate tool name format"""
+        if v is not None:
+            if not isinstance(v, str):
+                raise ValueError('tool_name must be a string')
+            v = v.strip()
+            if not v:
+                raise ValueError('tool_name cannot be empty or whitespace only')
+            # Tool name should contain valid characters
+            if not all(c.isalnum() or c in '.-_' for c in v):
+                raise ValueError('tool_name can only contain alphanumeric characters, dots, hyphens, and underscores')
+        return v
+
+    @field_validator('identifier')
+    @classmethod
+    def validate_identifier(cls, v):
+        """Validate identifier format"""
+        if v is not None:
+            if not isinstance(v, str):
+                raise ValueError('identifier must be a string')
+            v = v.strip()
+            if not v:
+                raise ValueError('identifier cannot be empty or whitespace only')
+            # Identifier should be alphanumeric with some special characters
+            if not all(c.isalnum() or c in '-_.' for c in v):
+                raise ValueError('identifier can only contain alphanumeric characters, hyphens, underscores, and dots')
+        return v
+
+    class Config:
+        """Pydantic configuration"""
+        validate_assignment = True
+        str_strip_whitespace = True
+        use_enum_values = True

scalekit_sdk_python-2.3.3/scalekit/connect/models/responses/create_mcp_response.py

@@ -0,0 +1,59 @@
+from typing import Optional, Dict, Any, List
+from pydantic import BaseModel, Field
+from google.protobuf.json_format import MessageToDict
+
+from scalekit.connect.models.tool_mapping import ToolMapping
+
+
+class CreateMcpResponse(BaseModel):
+    """Create MCP response with one-to-one mapping to proto CreateMcpResponse"""
+    
+    id: Optional[str]
+    identifier: Optional[str]
+    url: Optional[str]
+    tool_mappings: Optional[List[ToolMapping]]
+
+    @classmethod
+    def from_proto(cls, proto_response) -> 'CreateMcpResponse':
+        """
+        Create CreateMcpResponse from protobuf CreateMcpResponse
+        
+        :param proto_response: The protobuf CreateMcpResponse object
+        :type proto_response: CreateMcpResponse (from mcp_pb2)
+        
+        :returns:
+            CreateMcpResponse instance
+        """
+        mcp = proto_response.mcp if proto_response.mcp else None
+        
+        if mcp:
+            # Convert tool_mappings from protobuf to dict
+            tool_mappings = []
+            if mcp.tool_mappings:
+                for mapping in mcp.tool_mappings:
+                    tool_mappings.append(
+                        ToolMapping.from_proto(mapping)
+                    )
+            
+            return cls(
+                id=mcp.id if mcp.id else None,
+                identifier=mcp.connected_account_identifier if mcp.connected_account_identifier else None,
+                tool_mappings=tool_mappings if tool_mappings else None,
+                url=mcp.url if mcp.url else None
+            )
+        
+        return cls()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert to dictionary representation
+        
+        :returns:
+            Dictionary representation of the response
+        """
+        return {
+            "id": self.mcp_id,
+            "identifier": self.connected_account_identifier,
+            "tool_mappings": self.tool_mappings,
+            "url": self.url
+        }

scalekit_sdk_python-2.3.3/scalekit/connect/models/responses/delete_connected_account_response.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+
+
+class DeleteConnectedAccountResponse(BaseModel):
+    """Delete connected account response with one-to-one mapping to proto DeleteConnectedAccountResponse"""
+
+    @classmethod
+    def from_proto(cls, proto_response) -> 'DeleteConnectedAccountResponse':
+        """
+        Create DeleteConnectedAccountResponse from protobuf DeleteConnectedAccountResponse
+        
+        :param proto_response: The protobuf DeleteConnectedAccountResponse object
+        :type proto_response: DeleteConnectedAccountResponse (from connected_accounts_pb2)
+        
+        :returns:
+            DeleteConnectedAccountResponse instance
+        """
+
+        # Since the DeleteConnectedAccountResponse does not have any fields
+        return cls()
+
+    def to_dict(self) -> dict:
+        """
+        Convert to dictionary representation
+        
+        :returns:
+            Dictionary representation of the response
+        """
+        return {}
+
+    class Config:
+        """Pydantic configuration"""
+        validate_assignment = True

scalekit_sdk_python-2.3.3/scalekit/connect/models/responses/execute_tool_response.py

@@ -0,0 +1,57 @@
+from typing import Optional, Dict, Any
+
+from  ..tool_input_output import ToolOutput
+from pydantic import BaseModel, Field
+from google.protobuf.json_format import MessageToDict
+
+
+
+class ExecuteToolResponse(BaseModel):
+    """Execute tool response with one-to-one mapping to proto ExecuteToolResponse"""
+    
+    data: Optional[ToolOutput] = Field(
+        None,
+        description="Free-flowing JSON parameters for the tool execution"
+    )
+    execution_id: Optional[str] = Field(
+        None,
+        description="Unique identifier for the tool execution"
+    )
+
+    @classmethod
+    def from_proto(cls, proto_response) -> 'ExecuteToolResponse':
+        """
+        Create ExecuteToolResponse from protobuf ExecuteToolResponse
+        
+        :param proto_response: The protobuf ExecuteToolResponse object
+        :type proto_response: ExecuteToolResponse (from tools_pb2)
+        
+        :returns:
+            ExecuteToolResponse instance
+        """
+        # Convert protobuf Struct to dict
+        data = None
+        if proto_response.data:
+            data = MessageToDict(proto_response.data)
+
+        return cls(
+            data=data,
+            execution_id=proto_response.execution_id if proto_response.execution_id else None
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert to dictionary representation
+        
+        :returns:
+            Dictionary representation of the response
+        """
+        return {
+            "data": self.data,
+            "execution_id": self.execution_id
+        }
+
+    class Config:
+        """Pydantic configuration"""
+        validate_assignment = True
+        arbitrary_types_allowed = True