alita-sdk 0.3.162__py3-none-any.whl → 0.3.164__py3-none-any.whl

alita_sdk/tools/postman/api_wrapper.py

@@ -256,6 +256,12 @@ PostmanGetRequestScript = create_model(
     script_type=(str, Field(description="The type of script to retrieve: 'test' or 'prerequest'", default="prerequest"))
 )
 
+PostmanExecuteRequest = create_model(
+    "PostmanExecuteRequest",
+    request_path=(str, Field(description="The path to the request in the collection (e.g., 'API/Users/Get User')")),
+    override_variables=(Optional[Dict[str, Any]], Field(description="Optional variables to override environment/collection variables", default=None))
+)
+
 
 class PostmanApiWrapper(BaseToolApiWrapper):
     """Wrapper for Postman API."""
@@ -264,6 +270,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
     base_url: str = "https://api.getpostman.com"
     collection_id: Optional[str] = None
     workspace_id: Optional[str] = None
+    environment_config: dict = {}
     timeout: int = 30
     session: Any = None
     analyzer: PostmanAnalyzer = None
@@ -318,6 +325,108 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Invalid JSON response from Postman API: {str(e)}")
 
+    def _apply_authentication(self, headers, params, all_variables, resolve_variables):
+        """Apply authentication based on environment_config auth settings.
+        
+        Supports multiple authentication types:
+        - bearer: Bearer token in Authorization header
+        - basic: Basic authentication in Authorization header  
+        - api_key: API key in header, query parameter, or cookie
+        - oauth2: OAuth2 access token in Authorization header
+        - custom: Custom headers, cookies, or query parameters
+        
+        Required format:
+        environment_config = {
+            "auth": {
+                "type": "bearer|basic|api_key|oauth2|custom",
+                "params": {
+                    # type-specific parameters
+                }
+            }
+        }
+        """
+        import base64
+        
+        # Handle structured auth configuration only - no backward compatibility
+        auth_config = self.environment_config.get('auth')
+        if auth_config and isinstance(auth_config, dict):
+            auth_type = auth_config.get('type', '').lower()
+            auth_params = auth_config.get('params', {})
+            
+            if auth_type == 'bearer':
+                # Bearer token authentication
+                token = resolve_variables(str(auth_params.get('token', '')))
+                if token:
+                    headers['Authorization'] = f'Bearer {token}'
+                    
+            elif auth_type == 'basic':
+                # Basic authentication
+                username = resolve_variables(str(auth_params.get('username', '')))
+                password = resolve_variables(str(auth_params.get('password', '')))
+                if username and password:
+                    credentials = base64.b64encode(f"{username}:{password}".encode()).decode()
+                    headers['Authorization'] = f'Basic {credentials}'
+                    
+            elif auth_type == 'api_key':
+                # API key authentication
+                key_name = resolve_variables(str(auth_params.get('key', '')))
+                key_value = resolve_variables(str(auth_params.get('value', '')))
+                key_location = auth_params.get('in', 'header').lower()
+                
+                if key_name and key_value:
+                    if key_location == 'header':
+                        headers[key_name] = key_value
+                    elif key_location == 'query':
+                        params[key_name] = key_value
+                    elif key_location == 'cookie':
+                        # Add to Cookie header
+                        existing_cookies = headers.get('Cookie', '')
+                        new_cookie = f"{key_name}={key_value}"
+                        if existing_cookies:
+                            headers['Cookie'] = f"{existing_cookies}; {new_cookie}"
+                        else:
+                            headers['Cookie'] = new_cookie
+                            
+            elif auth_type == 'oauth2':
+                # OAuth2 access token
+                access_token = resolve_variables(str(auth_params.get('access_token', '')))
+                if access_token:
+                    headers['Authorization'] = f'Bearer {access_token}'
+                    
+            elif auth_type == 'custom':
+                # Custom authentication - allows full control
+                custom_headers = auth_params.get('headers', {})
+                custom_cookies = auth_params.get('cookies', {})
+                custom_query = auth_params.get('query', {})
+                
+                # Add custom headers
+                for key, value in custom_headers.items():
+                    resolved_key = resolve_variables(str(key))
+                    resolved_value = resolve_variables(str(value))
+                    headers[resolved_key] = resolved_value
+                
+                # Add custom query parameters
+                for key, value in custom_query.items():
+                    resolved_key = resolve_variables(str(key))
+                    resolved_value = resolve_variables(str(value))
+                    params[resolved_key] = resolved_value
+                
+                # Add custom cookies
+                if custom_cookies:
+                    cookie_parts = []
+                    for key, value in custom_cookies.items():
+                        resolved_key = resolve_variables(str(key))
+                        resolved_value = resolve_variables(str(value))
+                        cookie_parts.append(f"{resolved_key}={resolved_value}")
+                    
+                    existing_cookies = headers.get('Cookie', '')
+                    new_cookies = "; ".join(cookie_parts)
+                    if existing_cookies:
+                        headers['Cookie'] = f"{existing_cookies}; {new_cookies}"
+                    else:
+                        headers['Cookie'] = new_cookies
+
+
     def get_available_tools(self):
         """Return list of available tools with their configurations."""
         return [
@@ -398,6 +507,13 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 "args_schema": PostmanAnalyze,
                 "ref": self.analyze
             },
+            {
+                "name": "execute_request",
+                "mode": "execute_request",
+                "description": "Execute a Postman request with environment variables and custom configuration",
+                "args_schema": PostmanExecuteRequest,
+                "ref": self.execute_request
+            },
             # {
             #     "name": "create_collection",
             #     "mode": "create_collection",
@@ -583,6 +699,224 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             logger.error(f"Exception when getting collections: {stacktrace}")
             raise ToolException(f"Unable to get collections: {str(e)}")
 
+    def execute_request(self, request_path: str, override_variables: Dict = None, **kwargs) -> str:
+        """Execute a Postman request with environment variables and custom configuration.
+        
+        This method uses the environment_config to make actual HTTP requests 
+        using the requests library with structured authentication.
+        
+        Args:
+            request_path: The path to the request in the collection
+            override_variables: Optional variables to override environment/collection variables
+        
+        Returns:
+            JSON string with comprehensive response data
+        """
+        try:
+            import time
+            from urllib.parse import urlencode, parse_qs, urlparse
+            
+            # Get the request from the collection
+            request_item, _, collection_data = self._get_request_item_and_id(request_path)
+            request_data = request_item.get('request', {})
+            
+            # Gather all variables from different sources
+            all_variables = {}
+            
+            # 1. Start with environment_config variables (lowest priority)
+            all_variables.update(self.environment_config)
+            
+            # 2. Add collection variables
+            collection_variables = collection_data.get('variable', [])
+            for var in collection_variables:
+                if isinstance(var, dict) and 'key' in var:
+                    all_variables[var['key']] = var.get('value', '')
+            
+            # 3. Add override variables (highest priority)
+            if override_variables:
+                all_variables.update(override_variables)
+            
+            # Helper function to resolve variables in strings
+            def resolve_variables(text):
+                if not isinstance(text, str):
+                    return text
+                
+                # Replace {{variable}} patterns
+                import re
+                def replace_var(match):
+                    var_name = match.group(1)
+                    return str(all_variables.get(var_name, match.group(0)))
+                
+                return re.sub(r'\{\{([^}]+)\}\}', replace_var, text)
+            
+            # Prepare the request
+            method = request_data.get('method', 'GET').upper()
+            
+            # Handle URL
+            url_data = request_data.get('url', '')
+            if isinstance(url_data, str):
+                url = resolve_variables(url_data)
+                params = {}
+            else:
+                # URL is an object
+                raw_url = resolve_variables(url_data.get('raw', ''))
+                url = raw_url
+                
+                # Extract query parameters
+                params = {}
+                query_params = url_data.get('query', [])
+                for param in query_params:
+                    if isinstance(param, dict) and not param.get('disabled', False):
+                        key = resolve_variables(param.get('key', ''))
+                        value = resolve_variables(param.get('value', ''))
+                        if key:
+                            params[key] = value
+            
+            # Prepare headers
+            headers = {}
+            
+            # Handle authentication from environment_config
+            self._apply_authentication(headers, params, all_variables, resolve_variables)
+            
+            # Add headers from request
+            request_headers = request_data.get('header', [])
+            for header in request_headers:
+                if isinstance(header, dict) and not header.get('disabled', False):
+                    key = resolve_variables(header.get('key', ''))
+                    value = resolve_variables(header.get('value', ''))
+                    if key:
+                        headers[key] = value
+            
+            # Prepare body
+            body = None
+            content_type = headers.get('Content-Type', '').lower()
+            
+            request_body = request_data.get('body', {})
+            if request_body:
+                body_mode = request_body.get('mode', '')
+                
+                if body_mode == 'raw':
+                    raw_body = request_body.get('raw', '')
+                    body = resolve_variables(raw_body)
+                    
+                    # Try to parse as JSON if content type suggests it
+                    if 'application/json' in content_type:
+                        try:
+                            # Validate JSON
+                            json.loads(body)
+                        except json.JSONDecodeError:
+                            logger.warning("Body is not valid JSON despite Content-Type")
+                    
+                elif body_mode == 'formdata':
+                    # Handle form data
+                    form_data = {}
+                    formdata_items = request_body.get('formdata', [])
+                    for item in formdata_items:
+                        if isinstance(item, dict) and not item.get('disabled', False):
+                            key = resolve_variables(item.get('key', ''))
+                            value = resolve_variables(item.get('value', ''))
+                            if key:
+                                form_data[key] = value
+                    body = form_data
+                    
+                elif body_mode == 'urlencoded':
+                    # Handle URL encoded data
+                    urlencoded_data = {}
+                    urlencoded_items = request_body.get('urlencoded', [])
+                    for item in urlencoded_items:
+                        if isinstance(item, dict) and not item.get('disabled', False):
+                            key = resolve_variables(item.get('key', ''))
+                            value = resolve_variables(item.get('value', ''))
+                            if key:
+                                urlencoded_data[key] = value
+                    body = urlencode(urlencoded_data)
+                    if 'content-type' not in [h.lower() for h in headers.keys()]:
+                        headers['Content-Type'] = 'application/x-www-form-urlencoded'
+            
+            # Execute the request
+            start_time = time.time()
+            
+            logger.info(f"Executing {method} request to {url}")
+            
+            # Create a new session for this request (separate from Postman API session)
+            exec_session = requests.Session()
+            
+            # Prepare request kwargs
+            request_kwargs = {
+                'timeout': self.timeout,
+                'params': params if params else None,
+                'headers': headers if headers else None
+            }
+            
+            # Add body based on content type and method
+            if body is not None and method in ['POST', 'PUT', 'PATCH']:
+                if isinstance(body, dict):
+                    # Form data
+                    request_kwargs['data'] = body
+                elif isinstance(body, str):
+                    if 'application/json' in content_type:
+                        request_kwargs['json'] = json.loads(body) if body.strip() else {}
+                    else:
+                        request_kwargs['data'] = body
+                else:
+                    request_kwargs['data'] = body
+            
+            # Execute the request
+            response = exec_session.request(method, url, **request_kwargs)
+            
+            end_time = time.time()
+            elapsed_time = end_time - start_time
+            
+            # Parse response
+            response_data = {
+                "request": {
+                    "path": request_path,
+                    "method": method,
+                    "url": url,
+                    "headers": dict(headers) if headers else {},
+                    "params": dict(params) if params else {},
+                    "body": body if body is not None else None
+                },
+                "response": {
+                    "status_code": response.status_code,
+                    "status_text": response.reason,
+                    "headers": dict(response.headers),
+                    "elapsed_time_seconds": round(elapsed_time, 3),
+                    "size_bytes": len(response.content)
+                },
+                "variables_used": dict(all_variables),
+                "success": response.ok
+            }
+            
+            # Add response body
+            try:
+                # Try to parse as JSON
+                response_data["response"]["body"] = response.json()
+                response_data["response"]["content_type"] = "application/json"
+            except json.JSONDecodeError:
+                # Fall back to text
+                try:
+                    response_data["response"]["body"] = response.text
+                    response_data["response"]["content_type"] = "text/plain"
+                except UnicodeDecodeError:
+                    # Binary content
+                    response_data["response"]["body"] = f"<binary content: {len(response.content)} bytes>"
+                    response_data["response"]["content_type"] = "binary"
+            
+            # Add error details if request failed
+            if not response.ok:
+                response_data["error"] = {
+                    "message": f"HTTP {response.status_code}: {response.reason}",
+                    "status_code": response.status_code
+                }
+            
+            return json.dumps(response_data, indent=2)
+            
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when executing request: {stacktrace}")
+            raise ToolException(f"Unable to execute request '{request_path}': {str(e)}")
+
     def get_collection(self, **kwargs) -> str:
         """Get a specific collection by ID."""
         try:
@@ -1699,6 +2033,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 # Check if this is a folder (has 'item' property) or a request
                 if 'item' in item:
                     # This is a folder
+                   
                     result['items'][current_path] = {
                         "type": "folder",
                         "id": item.get('id'),

alita_sdk/tools/zephyr_squad/__init__.py

@@ -0,0 +1,62 @@
+from typing import List, Literal, Optional
+
+from langchain_community.agent_toolkits.base import BaseToolkit
+from langchain_core.tools import BaseTool
+from pydantic import create_model, BaseModel, Field, SecretStr
+
+from .api_wrapper import ZephyrSquadApiWrapper
+from ..base.tool import BaseAction
+from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+
+name = "zephyr"
+
+def get_tools(tool):
+    return ZephyrSquadToolkit().get_toolkit(
+        selected_tools=tool['settings'].get('selected_tools', []),
+        account_id=tool['settings']["account_id"],
+        access_key=tool['settings']["access_key"],
+        secret_key=tool['settings']["secret_key"],
+        toolkit_name=tool.get('toolkit_name')
+    ).get_tools()
+
+class ZephyrSquadToolkit(BaseToolkit):
+    tools: List[BaseTool] = []
+    toolkit_max_length: int = 0
+
+    @staticmethod
+    def toolkit_config_schema() -> BaseModel:
+        selected_tools = {x['name']: x['args_schema'].schema() for x in ZephyrSquadApiWrapper.model_construct().get_available_tools()}
+        ZephyrSquadToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
+        return create_model(
+            "zephyr_squad",
+            account_id=(str, Field(description="AccountID for the user that is going to be authenticating")),
+            access_key=(str, Field(description="Generated access key")),
+            secret_key=(SecretStr, Field(description="Generated secret key")),
+            selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
+            __config__={'json_schema_extra': {'metadata': {"label": "Zephyr Squad", "icon_url": "zephyr.svg",
+                            "categories": ["test management"],
+                            "extra_categories": ["test automation", "test case management", "test planning"]
+                        }}}
+        )
+
+    @classmethod
+    def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
+        zephyr_api_wrapper = ZephyrSquadApiWrapper(**kwargs)
+        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
+        available_tools = zephyr_api_wrapper.get_available_tools()
+        tools = []
+        for tool in available_tools:
+            if selected_tools:
+                if tool["name"] not in selected_tools:
+                    continue
+            tools.append(BaseAction(
+                api_wrapper=zephyr_api_wrapper,
+                name=prefix + tool["name"],
+                description=tool["description"],
+                args_schema=tool["args_schema"]
+            ))
+        return cls(tools=tools)
+
+    def get_tools(self):
+        return self.tools
+

alita_sdk/tools/zephyr_squad/api_wrapper.py

@@ -0,0 +1,135 @@
+from typing import List, Literal
+
+from pydantic import model_validator, create_model, Field, SecretStr, BaseModel, PrivateAttr
+
+from .zephyr_squad_cloud_client import ZephyrSquadCloud
+from ..elitea_base import BaseToolApiWrapper
+
+
+class ZephyrSquadApiWrapper(BaseToolApiWrapper):
+    account_id: str
+    access_key: str
+    secret_key: SecretStr
+    _client: ZephyrSquadCloud = PrivateAttr()
+
+    @model_validator(mode='before')
+    @classmethod
+    def validate_toolkit(cls, values):
+        account_id = values.get("account_id", None)
+        access_key = values.get("access_key", None)
+        secret_key = values.get("secret_key", None)
+        if not account_id:
+            raise ValueError("account_id is required.")
+        if not access_key:
+            raise ValueError("access_key is required.")
+        if not secret_key:
+            raise ValueError("secret_key is required.")
+        cls._client = ZephyrSquadCloud(
+            account_id=account_id,
+            access_key=access_key,
+            secret_key=secret_key
+        )
+        return values
+
+    def get_test_step(self, issue_id, step_id, project_id):
+        """Retrieve details for a specific test step in a Jira test case."""
+        return self._client.get_test_step(issue_id, step_id, project_id)
+
+    def update_test_step(self, issue_id, step_id, project_id, json):
+        """Update the content or a specific test step in a Jira test case."""
+        return self._client.update_test_step(issue_id, step_id, project_id, json)
+
+    def delete_test_step(self, issue_id, step_id, project_id):
+        """Remove a specific test step from a Jira test case."""
+        return self._client.delete_test_step(issue_id, step_id, project_id)
+
+    def create_new_test_step(self, issue_id, project_id, json):
+        """Add a new test step to a Jira test case."""
+        return self._client.create_new_test_step(issue_id, project_id, json)
+
+    def get_all_test_steps(self, issue_id, project_id):
+        """List all test steps associated with a Jira test case."""
+        return self._client.get_all_test_steps(issue_id, project_id)
+
+    def get_all_test_step_statuses(self):
+        """Retrieve all possible statuses for test steps in Jira."""
+        return self._client.get_all_test_step_statuses()
+
+    def get_available_tools(self):
+        return [
+            {
+                "name": "get_test_step",
+                "description": self.get_test_step.__doc__,
+                "args_schema": ProjectIssueStep,
+                "ref": self.get_test_step,
+            },
+            {
+                "name": "update_test_step",
+                "description": self.update_test_step.__doc__,
+                "args_schema": UpdateTestStep,
+                "ref": self.update_test_step,
+            },
+            {
+                "name": "delete_test_step",
+                "description": self.delete_test_step.__doc__,
+                "args_schema": ProjectIssueStep,
+                "ref": self.delete_test_step,
+            },
+            {
+                "name": "create_new_test_step",
+                "description": self.create_new_test_step.__doc__,
+                "args_schema": CreateNewTestStep,
+                "ref": self.create_new_test_step,
+            },
+            {
+                "name": "get_all_test_steps",
+                "description": self.get_all_test_steps.__doc__,
+                "args_schema": ProjectIssue,
+                "ref": self.get_all_test_steps,
+            },
+            {
+                "name": "get_all_test_step_statuses",
+                "description": self.get_all_test_step_statuses.__doc__,
+                "args_schema": create_model("NoInput"),
+                "ref": self.get_all_test_step_statuses,
+            }
+        ]
+
+
+ProjectIssue = create_model(
+    "ProjectIssue",
+    issue_id=(int, Field(description="Jira ticket id of test case to which the test step belongs.")),
+    project_id=(int, Field(description="Jira project id to which test case belongs."))
+)
+
+ProjectIssueStep = create_model(
+    "ProjectIssueStep",
+    step_id=(str, Field(description="Test step id to operate.")),
+    __base__=ProjectIssue
+)
+
+UpdateTestStep = create_model(
+    "UpdateTestStep",
+    json=(str, Field(description=(
+            "JSON body to update a Zephyr test step. Fields:\n"
+            "- id (string, required): Unique identifier for the test step. Example: \"0001481146115453-3a0480a3ffffc384-0001\"\n"
+            "- step (string, required): Description of the test step. Example: \"Sample Test Step\"\n"
+            "- data (string, optional): Test data used in this step. Example: \"Sample Test Data\"\n"
+            "- result (string, optional): Expected result after executing the step. Example: \"Expected Test Result\"\n"
+            "- customFieldValues (array[object], optional): List of custom field values for the test step. Each object contains:\n"
+            "    - customFieldId (string, required): ID of the custom field. Example: \"3ce1c679-7c43-4d37-89f6-757603379e31\"\n"
+            "    - value (object, required): Value for the custom field. Example: {\"value\": \"08/21/2018\"}\n"
+            "*IMPORTANT*: Use double quotes for all field names and string values."))),
+    __base__=ProjectIssueStep
+)
+
+CreateNewTestStep = create_model(
+    "CreateNewTestStep",
+    json=(str, Field(description=(
+            "JSON body to create a Zephyr test step. Fields:\n"
+            "- step (string, required): Description of the test step. Example: \"Sample Test Step\"\n"
+            "- data (string, optional): Test data used in this step. Example: \"Sample Test Data\"\n"
+            "- result (string, optional): Expected result after executing the step. Example: \"Expected Test Result\"\n"
+            "*IMPORTANT*: Use double quotes for all field names and string values."))),
+    __base__=ProjectIssue
+)

alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py

@@ -0,0 +1,79 @@
+import hashlib
+import time
+
+import jwt
+import requests
+from langchain_core.tools import ToolException
+
+
+class ZephyrSquadCloud(object):
+    """
+    Reference: https://zephyrsquad.docs.apiary.io//
+    """
+
+    def __init__(self, account_id, access_key, secret_key):
+        self.account_id = account_id
+        self.access_key = access_key
+        self.secret_key = secret_key
+        self.base_url = "https://prod-api.zephyr4jiracloud.com/connect"
+
+    def get_test_step(self, issue_id, step_id, project_id):
+        canonical_path = "/public/rest/api/1.0/teststep/issueId/id?projectId="
+        api_path = f"/public/rest/api/1.0/teststep/{issue_id}/{step_id}?projectId={project_id}"
+        return self._do_request(method="GET", api_path=api_path, canonical_path=canonical_path)
+
+    def update_test_step(self, issue_id, step_id, project_id, json):
+        canonical_path = "/public/rest/api/1.0/teststep/issueId/id?projectId="
+        api_path = f"/public/rest/api/1.0/teststep/{issue_id}/{step_id}?projectId={project_id}"
+        return self._do_request(method="PUT", api_path=api_path, canonical_path=canonical_path, json=json)
+
+    def delete_test_step(self, issue_id, step_id, project_id):
+        canonical_path = "/public/rest/api/1.0/teststep/issueId/id?projectId="
+        api_path = f"/public/rest/api/1.0/teststep/{issue_id}/{step_id}?projectId={project_id}"
+        return self._do_request(method="DELETE", api_path=api_path, canonical_path=canonical_path)
+
+    def create_new_test_step(self, issue_id, project_id, json):
+        canonical_path = "/public/rest/api/1.0/teststep/issueId?projectId="
+        api_path = f"/public/rest/api/1.0/teststep/{issue_id}?projectId={project_id}"
+        return self._do_request(method="POST", api_path=api_path, canonical_path=canonical_path, json=json)
+
+    def get_all_test_steps(self, issue_id, project_id):
+        canonical_path = "/public/rest/api/2.0/teststep/issueId?projectId="
+        api_path = f"/public/rest/api/2.0/teststep/{issue_id}?projectId={project_id}"
+        return self._do_request(method='GET', api_path=api_path, canonical_path=canonical_path)
+
+    def get_all_test_step_statuses(self):
+        api_path = "/public/rest/api/1.0/teststep/statuses"
+        return self._do_request(method='GET', api_path=api_path)
+
+    def _do_request(self, method, api_path, canonical_path=None, json=None):
+        url = f"{self.base_url}{api_path}"
+        headers = {
+            "Authorization": f"JWT {self._generate_jwt_token(method, canonical_path or api_path)}",
+            "zapiAccessKey": self.access_key,
+            "Content-Type": "application/json"
+        }
+
+        try:
+            resp = requests.request(method=method, url=url, json=json, headers=headers)
+
+            if resp.ok:
+                if resp.headers.get("Content-Type", "").startswith("application/json"):
+                    return str(resp.json())
+                else:
+                    return resp.text
+            else:
+                raise ToolException(f"Request failed with status {resp.status_code}: {resp.text}")
+        except Exception as e:
+            raise ToolException(f"Error performing request {method}:{api_path}: {e}")
+
+    def _generate_jwt_token(self, method, path):
+        canonical_path = f"{method}&{path}&"
+        payload_token = {
+            'sub': self.account_id,
+            'qsh': hashlib.sha256(canonical_path.encode('utf-8')).hexdigest(),
+            'iss': self.access_key,
+            'exp': int(time.time()) + 3600,
+            'iat': int(time.time())
+        }
+        return jwt.encode(payload_token, self.secret_key, algorithm='HS256').strip()