scalekit-sdk-python 2.18.0__tar.gz → 2.19.1__tar.gz

{scalekit_sdk_python-2.18.0 → scalekit_sdk_python-2.19.1}/PKG-INFO

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

{scalekit_sdk_python-2.18.0 → scalekit_sdk_python-2.19.1}/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.18.0"
+__version__ = "2.19.1"

{scalekit_sdk_python-2.18.0 → scalekit_sdk_python-2.19.1}/scalekit/actions/actions.py

@@ -1,7 +1,7 @@
 from datetime import timedelta
 from typing import Optional, Any, List, Dict, Union
 import requests
-from scalekit.actions.types import ToolRequest,ExecuteToolResponse,MagicLinkResponse,ListConnectedAccountsResponse,DeleteConnectedAccountResponse,GetConnectedAccountAuthResponse,GetConnectedAccountDetailsResponse,ToolInput, \
+from scalekit.actions.types import ToolRequest,ExecuteToolResponse,MagicLinkResponse,ListConnectedAccountsResponse,ListToolsResponse,DeleteConnectedAccountResponse,GetConnectedAccountAuthResponse,GetConnectedAccountDetailsResponse,ToolInput, \
     UpdateConnectedAccountResponse,CreateMcpConfigResponse,ListMcpConfigsResponse,UpdateMcpConfigResponse,DeleteMcpConfigResponse, \
     EnsureMcpInstanceResponse,UpdateMcpInstanceResponse,GetMcpInstanceResponse,ListMcpInstancesResponse,DeleteMcpInstanceResponse,GetMcpInstanceAuthStateResponse, \
     McpConfig,McpConfigConnectionToolMapping,VerifyConnectedAccountUserResponse, \
@@ -16,6 +16,8 @@ from scalekit.actions.modifier import (
     apply_pre_modifiers, apply_post_modifiers
 )
 from scalekit.common.exceptions import ScalekitNotFoundException
+from scalekit.v1.tools.tools_pb2 import Filter
+from google.protobuf.wrappers_pb2 import BoolValue
 
 
 
@@ -168,9 +170,86 @@ class ActionClient:
         modified_response = apply_post_modifiers(tool_name, response.data, self._modifiers)
 
         response.data = modified_response
-        
+
         return response
-    
+
+    def list_tools(
+        self,
+        connection_name: Optional[str] = None,
+        identifier: Optional[str] = None,
+        provider: Optional[str] = None,
+        tool_name: Optional[List[str]] = None,
+        query: Optional[str] = None,
+        organization_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        connected_account_id: Optional[str] = None,
+        summary: Optional[bool] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+        **kwargs
+    ) -> ListToolsResponse:
+        """
+        List tools available in your workspace, optionally scoped to a connected account.
+
+        Thin wrapper around ToolsClient.list_tools.
+
+        :param connection_name: Filter by connector identifier, e.g. 'github-connect' (optional)
+        :type: str
+        :param identifier: Filter/resolve by connected-account identifier (optional)
+        :type: str
+        :param provider: Filter by provider key, e.g. 'github' (optional)
+        :type: str
+        :param tool_name: Filter to specific tool names (optional)
+        :type: List[str]
+        :param query: Free-form search query across tool metadata (optional)
+        :type: str
+        :param organization_id: Organization ID to scope the connected-account lookup (optional)
+        :type: str
+        :param user_id: User ID to scope the connected-account lookup (optional)
+        :type: str
+        :param connected_account_id: Direct connected account ID, as an alternative to
+            identifier + connection_name (optional)
+        :type: str
+        :param summary: Whether to return a summarized tool definition (optional)
+        :type: bool
+        :param page_size: Maximum number of tools to return per page (optional)
+        :type: int
+        :param page_token: Token from a previous response for pagination (optional)
+        :type: str
+
+        :returns:
+            ListToolsResponse containing the matching tools
+        """
+        has_filter_fields = any([
+            connection_name, identifier, provider, tool_name,
+            query, organization_id, user_id, connected_account_id,
+            summary is not None,
+        ])
+        filter_kwargs = {
+            "connector": connection_name,
+            "identifier": identifier,
+            "provider": provider,
+            "tool_name": tool_name,
+            "query": query,
+            "organization_id": organization_id,
+            "user_id": user_id,
+            "connected_account_id": connected_account_id,
+        }
+        if summary is not None:
+            filter_kwargs["summary"] = BoolValue(value=summary)
+        filter_obj = Filter(**filter_kwargs) if has_filter_fields else None
+
+        # Call the existing tools.list_tools which returns (response, metadata) tuple
+        result_tuple = self.tools.list_tools(
+            filter=filter_obj,
+            page_size=page_size,
+            page_token=page_token
+        )
+
+        proto_response = result_tuple[0]
+
+        return ListToolsResponse.from_proto(proto_response)
+
     def get_authorization_link(
             self,
             identifier: Optional[str] = None,

scalekit_sdk_python-2.19.1/scalekit/actions/models/responses/list_tools_response.py

@@ -0,0 +1,165 @@
+from typing import List, Optional
+from datetime import datetime
+from pydantic import BaseModel, Field
+from google.protobuf.json_format import MessageToDict
+
+
+class Tool(BaseModel):
+    """Tool item in list response with one-to-one mapping to proto Tool"""
+
+    id: Optional[str] = Field(
+        None,
+        description="Unique identifier for the tool"
+    )
+    provider: Optional[str] = Field(
+        None,
+        description="Provider that exposes this tool (e.g., 'github', 'slack')"
+    )
+    definition: Optional[dict] = Field(
+        None,
+        description="Tool definition (schema/parameters) as a dictionary"
+    )
+    metadata: Optional[dict] = Field(
+        None,
+        description="Additional metadata for the tool"
+    )
+    tags: List[str] = Field(
+        default_factory=list,
+        description="Tags associated with the tool"
+    )
+    is_default: Optional[bool] = Field(
+        None,
+        description="Whether this is a default tool for its provider"
+    )
+    updated_at: Optional[datetime] = Field(
+        None,
+        description="Timestamp when the tool was last updated"
+    )
+
+    @classmethod
+    def from_proto(cls, proto_tool) -> 'Tool':
+        """
+        Create Tool from protobuf Tool
+
+        :param proto_tool: The protobuf Tool object
+        :type proto_tool: Tool (from tools_pb2)
+
+        :returns:
+            Tool instance
+        """
+        definition = None
+        if proto_tool.HasField("definition"):
+            definition = MessageToDict(proto_tool.definition)
+
+        metadata = None
+        if proto_tool.HasField("metadata"):
+            metadata = MessageToDict(proto_tool.metadata)
+
+        updated_at = None
+        if proto_tool.HasField("updated_at"):
+            updated_at = proto_tool.updated_at.ToDatetime()
+
+        return cls(
+            id=proto_tool.id if proto_tool.id else None,
+            provider=proto_tool.provider if proto_tool.provider else None,
+            definition=definition,
+            metadata=metadata,
+            tags=list(proto_tool.tags),
+            is_default=proto_tool.is_default.value if proto_tool.HasField("is_default") else None,
+            updated_at=updated_at
+        )
+
+    def to_dict(self) -> dict:
+        """
+        Convert to dictionary representation
+
+        :returns:
+            Dictionary representation of the tool
+        """
+        return {
+            "id": self.id,
+            "provider": self.provider,
+            "definition": self.definition,
+            "metadata": self.metadata,
+            "tags": self.tags,
+            "is_default": self.is_default,
+            "updated_at": self.updated_at.isoformat() if self.updated_at else None
+        }
+
+    class Config:
+        """Pydantic configuration"""
+        validate_assignment = True
+        json_encoders = {
+            datetime: lambda v: v.isoformat() if v else None
+        }
+
+
+class ListToolsResponse(BaseModel):
+    """List tools response with one-to-one mapping to proto ListToolsResponse"""
+
+    tools: List[Tool] = Field(
+        default_factory=list,
+        description="List of tools"
+    )
+    tool_names: List[str] = Field(
+        default_factory=list,
+        description="Names of the tools in this page"
+    )
+    total_count: Optional[int] = Field(
+        None,
+        description="Total number of tools matching the request",
+        alias="total_size"
+    )
+    next_page_token: Optional[str] = Field(
+        None,
+        description="Token for the next page of results"
+    )
+    previous_page_token: Optional[str] = Field(
+        None,
+        description="Token for the previous page of results",
+        alias="prev_page_token"
+    )
+
+    @classmethod
+    def from_proto(cls, proto_response) -> 'ListToolsResponse':
+        """
+        Create ListToolsResponse from protobuf ListToolsResponse
+
+        :param proto_response: The protobuf ListToolsResponse object
+        :type proto_response: ListToolsResponse (from tools_pb2)
+
+        :returns:
+            ListToolsResponse instance
+        """
+        tools = [Tool.from_proto(proto_tool) for proto_tool in proto_response.tools]
+
+        return cls(
+            tools=tools,
+            tool_names=list(proto_response.tool_names),
+            total_count=proto_response.total_size,
+            next_page_token=proto_response.next_page_token if proto_response.next_page_token else None,
+            previous_page_token=proto_response.prev_page_token if proto_response.prev_page_token else None
+        )
+
+    def to_dict(self) -> dict:
+        """
+        Convert to dictionary representation
+
+        :returns:
+            Dictionary representation of the response
+        """
+        return {
+            "tools": [tool.to_dict() for tool in self.tools],
+            "tool_names": self.tool_names,
+            "total_count": self.total_count,
+            "next_page_token": self.next_page_token,
+            "previous_page_token": self.previous_page_token
+        }
+
+    class Config:
+        """Pydantic configuration"""
+        validate_assignment = True
+        populate_by_name = True
+        json_encoders = {
+            datetime: lambda v: v.isoformat() if v else None
+        }

{scalekit_sdk_python-2.18.0 → scalekit_sdk_python-2.19.1}/scalekit/actions/types.py

@@ -5,6 +5,7 @@ from .models.requests.update_connected_account_request import UpdateConnectedAcc
 from .models.responses.execute_tool_response import ExecuteToolResponse
 from .models.responses.magic_link_response import MagicLinkResponse
 from .models.responses.list_connected_accounts_response import ListConnectedAccountsResponse
+from .models.responses.list_tools_response import Tool, ListToolsResponse
 from .models.responses.delete_connected_account_response import DeleteConnectedAccountResponse
 from .models.responses.get_connected_account_auth_response import GetConnectedAccountAuthResponse, GetConnectedAccountDetailsResponse
 from .models.responses.create_connected_account_response import CreateConnectedAccountResponse
@@ -48,6 +49,8 @@ __all__ = [
     'ExecuteToolResponse',
     'MagicLinkResponse',
     'ListConnectedAccountsResponse',
+    'Tool',
+    'ListToolsResponse',
     'DeleteConnectedAccountResponse',
     'GetConnectedAccountAuthResponse',
     'GetConnectedAccountDetailsResponse',

{scalekit_sdk_python-2.18.0 → scalekit_sdk_python-2.19.1}/scalekit/client.py

@@ -9,10 +9,17 @@ import hmac
 import hashlib
 import base64
 from datetime import datetime, timedelta, timezone
-from scalekit.core import CoreClient, DEFAULT_KEEPALIVE_TIME_MS, DEFAULT_KEEPALIVE_TIMEOUT_MS
+from scalekit.core import (
+    CoreClient,
+    DEFAULT_KEEPALIVE_TIME_MS,
+    DEFAULT_KEEPALIVE_TIMEOUT_MS,
+    DEFAULT_CALL_TIMEOUT_S,
+    DEFAULT_TOOL_CALL_TIMEOUT_S,
+)
 from scalekit.domain import DomainClient
 from scalekit.connection import ConnectionClient
 from scalekit.m2m_client import M2MClient
+from scalekit.resource import ResourceClient
 from scalekit.organization import OrganizationClient
 from scalekit.directory import DirectoryClient
 from scalekit.users import UserClient
@@ -57,6 +64,8 @@ class ScalekitClient:
         client_secret: str,
         keepalive_time_ms: int = DEFAULT_KEEPALIVE_TIME_MS,
         keepalive_timeout_ms: int = DEFAULT_KEEPALIVE_TIMEOUT_MS,
+        call_timeout_s: float = DEFAULT_CALL_TIMEOUT_S,
+        tool_call_timeout_s: float = DEFAULT_TOOL_CALL_TIMEOUT_S,
     ):
         """
         Initializer for Scalekit base class
@@ -69,15 +78,42 @@ class ScalekitClient:
         :type                        : ``` str ```
         :param keepalive_time_ms     : How often, in milliseconds, an idle gRPC
                                         connection is verified before reuse.
+                                        Also derives grpc.client_idle_timeout_ms
+                                        (see CLIENT_IDLE_TIMEOUT_CEILING_MS),
+                                        which proactively recycles a connection
+                                        with zero active calls before the
+                                        backend's own MaxConnectionIdle would.
                                         Defaults to 60000; most callers never
                                         need to set this. Set to 0 to disable
-                                        keepalive entirely.
+                                        both of this SDK's own settings for
+                                        these — grpc-core still applies its own
+                                        (much larger) default idle behavior
+                                        when no options are passed at all, so
+                                        this isn't "no idle handling," just no
+                                        SDK-configured one.
         :type                        : ``` int ```
         :param keepalive_timeout_ms  : How long, in milliseconds, to wait for a
                                         keepalive response before treating an
                                         idle connection as dead. Defaults to
                                         10000.
         :type                        : ``` int ```
+        :param call_timeout_s        : Deadline, in seconds, applied to every gRPC
+                                        call except ToolsClient calls (list_tools,
+                                        list_scoped_tools, execute_tool — see
+                                        tool_call_timeout_s). Without this, a call
+                                        can block forever on a connection that
+                                        looks fine to the client but is silently
+                                        dead. Bounds each attempt individually,
+                                        not the total call across retries — a
+                                        call that retries can take a multiple of
+                                        this value in the worst case. Defaults
+                                        to 20.
+        :type                        : ``` float ```
+        :param tool_call_timeout_s   : Deadline, in seconds, for tool-execution
+                                        calls, which proxy to third-party APIs and
+                                        can legitimately run longer than ordinary
+                                        control-plane calls. Defaults to 60.
+        :type                        : ``` float ```
 
         :returns:
             None
@@ -89,12 +125,15 @@ class ScalekitClient:
                 client_secret=client_secret,
                 keepalive_time_ms=keepalive_time_ms,
                 keepalive_timeout_ms=keepalive_timeout_ms,
+                call_timeout_s=call_timeout_s,
+                tool_call_timeout_s=tool_call_timeout_s,
             )
             self.domain = DomainClient(self.core_client)
             self.connection = ConnectionClient(self.core_client)
             self.organization = OrganizationClient(self.core_client)
             self.directory = DirectoryClient(self.core_client)
             self.m2m_client = M2MClient(self.core_client)
+            self.resources = ResourceClient(self.core_client)
             self.users = UserClient(self.core_client)
             self.roles = RoleClient(self.core_client)
             self.permissions = PermissionClient(self.core_client)

{scalekit_sdk_python-2.18.0 → scalekit_sdk_python-2.19.1}/scalekit/common/exceptions.py

@@ -1,4 +1,6 @@
 
+import enum
+
 import grpc
 from grpc import StatusCode
 from http import HTTPStatus
@@ -7,6 +9,13 @@ from requests.models import Response
 from scalekit.v1.errdetails.errdetails_pb2 import ErrorInfo
 
 
+class NonStandardHTTPStatus(enum.IntEnum):
+    """HTTP status codes not in the stdlib http.HTTPStatus enum, needed so
+    __str__ can read .name/.value the same way it does for every HTTPStatus
+    entry in GRPC_TO_HTTP."""
+    CLIENT_CLOSED_REQUEST = 499
+
+
 GRPC_TO_HTTP = {
     StatusCode.OK: HTTPStatus.OK,
     StatusCode.INVALID_ARGUMENT: HTTPStatus.BAD_REQUEST,
@@ -18,7 +27,7 @@ GRPC_TO_HTTP = {
     StatusCode.ALREADY_EXISTS: HTTPStatus.CONFLICT,
     StatusCode.ABORTED: HTTPStatus.CONFLICT,
     StatusCode.RESOURCE_EXHAUSTED: HTTPStatus.TOO_MANY_REQUESTS,
-    StatusCode.CANCELLED: 499,
+    StatusCode.CANCELLED: NonStandardHTTPStatus.CLIENT_CLOSED_REQUEST,
     StatusCode.DATA_LOSS: HTTPStatus.INTERNAL_SERVER_ERROR,
     StatusCode.UNKNOWN: HTTPStatus.INTERNAL_SERVER_ERROR,
     StatusCode.INTERNAL: HTTPStatus.INTERNAL_SERVER_ERROR,
@@ -91,9 +100,29 @@ class ScalekitServerException(ScalekitException):
             self._message = None
         elif isinstance(error, grpc.RpcError):
             self._grpc_status = error.code()
-            self._http_status = GRPC_TO_HTTP.get(self._grpc_status)
-            self._message = rpc_status.from_call(error).message
-            self._err_details = rpc_status.from_call(error).details
+            # Every current StatusCode is mapped, so this default is latent today —
+            # but without it, any future/unmapped code gives None here and __str__
+            # crashes on None.name, the same shape as the CANCELLED-as-bare-int bug.
+            self._http_status = GRPC_TO_HTTP.get(self._grpc_status, HTTPStatus.INTERNAL_SERVER_ERROR)
+            try:
+                # rpc_status.from_call raises ValueError (not just returning None)
+                # when grpc-status-details-bin is present but internally
+                # inconsistent with the call's own code/message — a malformed or
+                # tampered status must not crash the exception meant to describe it.
+                status = rpc_status.from_call(error)
+            except ValueError:
+                status = None
+            if status:
+                self._message = status.message
+            else:
+                # error.details() is grpc's documented accessor for the plain-text
+                # message; str(error) falls back to _InactiveRpcError's multi-line
+                # debug repr (or '' for other RpcError subclasses), which is a
+                # weaker signal than what details() gives when it's available.
+                details_fn = getattr(error, "details", None)
+                details_text = details_fn() if callable(details_fn) else None
+                self._message = details_text or str(error)
+            self._err_details = status.details if status else []
             self._error_code = None
 
             for detail in self._err_details:
@@ -187,11 +216,16 @@ class ScalekitServerException(ScalekitException):
                     f"{self._message}: {details_str}\n{border}\n")
         else:
             border = "=" * 40
+            # _err_details is empty exactly when there was no trailing
+            # google.rpc.Status to unpack (e.g. a transport-level failure with
+            # no response from the server) — _message is where the real error
+            # text lives in that case, so fall back to it rather than printing
+            # an empty list and hiding the one thing this render is for.
             return (f"\n{border}\n"
                     f"Error Code: {self._error_code}\n"
                     f"GRPC: ({self._grpc_status.name}: {self._grpc_status.value})\n"
                     f"HTTP: ({self._http_status.name}: {self._http_status.value})\n"
-                    f"Error Details: {self._err_details}\n{border}\n")
+                    f"Error Details: {self._err_details or self._message}\n{border}\n")
 
     @property
     def http_status(self):