alita-sdk 0.3.412__py3-none-any.whl → 0.3.413__py3-none-any.whl

alita_sdk/configurations/bitbucket.py

@@ -1,5 +1,6 @@
 from typing import Optional
 
+from atlassian import Bitbucket
 from pydantic import BaseModel, ConfigDict, Field, SecretStr
 
 
@@ -30,3 +31,97 @@ class BitbucketConfiguration(BaseModel):
     url: str = Field(description="Bitbucket URL")
     username: str = Field(description="Bitbucket Username")
     password: SecretStr = Field(description="Bitbucket Password/App Password")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Bitbucket.
+        
+        Args:
+            settings: Dictionary containing Bitbucket configuration
+                - url: Bitbucket instance URL (required)
+                - username: Bitbucket username (required)
+                - password: Password or App Password (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        from requests.auth import HTTPBasicAuth
+        
+        # Validate url
+        url = settings.get("url", "").strip()
+        if not url:
+            return "Bitbucket URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        url = url.rstrip("/")
+        
+        # Basic URL validation
+        if not url.startswith(("http://", "https://")):
+            return "Bitbucket URL must start with http:// or https://"
+        
+        # Validate username
+        username = settings.get("username", "").strip()
+        if not username:
+            return "Bitbucket username is required"
+        
+        # Validate password
+        password = settings.get("password")
+        if not password:
+            return "Bitbucket password is required"
+        
+        # Extract password value if it's a SecretStr
+        password_value = password.get_secret_value() if hasattr(password, 'get_secret_value') else password
+        
+        if not password_value or not str(password_value).strip():
+            return "Bitbucket password cannot be empty"
+        
+        # Detect if this is Bitbucket Cloud or Server/Data Center
+        is_cloud = "bitbucket.org" in url.lower() or "api.bitbucket.org" in url.lower()
+        is_correct_bitbucket_domain = "bitbucket" in url.lower()
+        
+        if is_cloud:
+            # Bitbucket Cloud: Use API v2.0
+            # Endpoint: /2.0/user - returns current authenticated user
+            test_url = f"{url}/2.0/user"
+        else:
+            # Bitbucket Server/Data Center: Use API v1.0
+            # Endpoint: /rest/api/1.0/users/{username}
+            test_url = f"{url}/rest/api/1.0/users/{username}"
+        
+        try:
+            response = requests.get(
+                test_url,
+                auth=HTTPBasicAuth(username, str(password_value).strip()),
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected and authenticated
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid username or password"
+            elif response.status_code == 403:
+                return "Access forbidden: check user permissions"
+            elif response.status_code == 404:
+                if not is_correct_bitbucket_domain:
+                    return f"Url you provided is incorrect. Please provide correct server or cloud bitbucket url."
+                if is_cloud:
+                    return "Bitbucket API endpoint not found: please provide the correct bitbucket cloud URL"
+                else:
+                    return "Bitbucket API endpoint not found: please provide the correct bitbucket server URL"
+            else:
+                return f"Bitbucket API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Bitbucket at {url if not is_cloud else 'api.bitbucket.org'}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Bitbucket at {url if not is_cloud else 'api.bitbucket.org'} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Bitbucket: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/confluence.py

@@ -34,4 +34,99 @@ class ConfluenceConfiguration(BaseModel):
     base_url: str = Field(description="Confluence URL")
     username: Optional[str] = Field(description="Confluence Username", default=None)
     api_key: Optional[SecretStr] = Field(description="Confluence API Key", default=None)
-    token: Optional[SecretStr] = Field(description="Confluence Token", default=None)
+    token: Optional[SecretStr] = Field(description="Confluence Token", default=None)
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Confluence.
+        
+        Args:
+            settings: Dictionary containing Confluence configuration
+                - base_url: Confluence instance URL (required)
+                - username: Username for Basic Auth (optional)
+                - api_key: API key/password for Basic Auth (optional)
+                - token: Bearer token for authentication (optional)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        from requests.auth import HTTPBasicAuth
+        
+        # Validate base_url
+        base_url = settings.get("base_url", "").strip()
+        if not base_url:
+            return "Confluence URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        base_url = base_url.rstrip("/")
+        
+        # Basic URL validation
+        if not base_url.startswith(("http://", "https://")):
+            return "Confluence URL must start with http:// or https://"
+        
+        # Check authentication credentials
+        username = settings.get("username")
+        api_key = settings.get("api_key")
+        token = settings.get("token")
+
+        # Validate authentication - at least one method must be provided
+        has_basic_auth = bool(username and api_key)
+        has_token = bool(token and str(token).strip())
+        
+        # Determine authentication method
+        auth_headers = {}
+        auth = None
+        
+        if has_token:
+            # Bearer token authentication
+            token_value = token.get_secret_value() if hasattr(token, 'get_secret_value') else token
+            auth_headers["Authorization"] = f"Bearer {token_value}"
+        elif has_basic_auth:
+            # Basic authentication
+            api_key_value = api_key.get_secret_value() if hasattr(api_key, 'get_secret_value') else api_key
+            auth = HTTPBasicAuth(username, api_key_value)
+        else:
+            return "Authentication required: provide either token or both username and api_key"
+        
+        # Test connection using /rest/api/user/current endpoint
+        # This endpoint returns current user info and validates authentication
+        test_url = f"{base_url}/rest/api/user/current"
+        
+        try:
+            response = requests.get(
+                test_url,
+                auth=auth,
+                headers=auth_headers,
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected and authenticated
+                return None
+            elif response.status_code == 401:
+                # Authentication failed
+                if has_token:
+                    return "Authentication failed: Invalid token"
+                else:
+                    return "Authentication failed: Invalid username or API key"
+            elif response.status_code == 403:
+                return """Access forbidden: check permissions and verify the credentials you provided.
+Most probably you provided incorrect credentials (user name and api key or token)"""
+            elif response.status_code == 404:
+                return "Confluence API endpoint not found: verify the Confluence URL"
+            else:
+                return f"Confluence API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Confluence at {base_url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Confluence at {base_url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Confluence: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/gitlab.py

@@ -29,3 +29,82 @@ class GitlabConfiguration(BaseModel):
     )
     url: str = Field(description="GitLab URL")
     private_token: SecretStr = Field(description="GitLab private token")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to GitLab.
+        
+        Args:
+            settings: Dictionary containing GitLab configuration
+                - url: GitLab instance URL (required)
+                - private_token: GitLab private token for authentication (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Validate url
+        url = settings.get("url", "").strip()
+        if not url:
+            return "GitLab URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        url = url.rstrip("/")
+        
+        # Basic URL validation
+        if not url.startswith(("http://", "https://")):
+            return "GitLab URL must start with http:// or https://"
+        
+        # Validate private_token
+        private_token = settings.get("private_token")
+        if not private_token:
+            return "GitLab private token is required"
+        
+        # Extract token value if it's a SecretStr
+        token_value = private_token.get_secret_value() if hasattr(private_token, 'get_secret_value') else private_token
+        
+        if not token_value or not str(token_value).strip():
+            return "GitLab private token cannot be empty"
+        
+        # Test connection using /api/v4/user endpoint
+        # This endpoint returns current authenticated user info
+        test_url = f"{url}/api/v4/user"
+        
+        # GitLab supports both PRIVATE-TOKEN header and Authorization Bearer
+        # Using PRIVATE-TOKEN is GitLab-specific and more explicit
+        headers = {
+            "PRIVATE-TOKEN": str(token_value).strip()
+        }
+        
+        try:
+            response = requests.get(
+                test_url,
+                headers=headers,
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected and authenticated
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid private token"
+            elif response.status_code == 403:
+                return "Access forbidden: token lacks required permissions"
+            elif response.status_code == 404:
+                return "GitLab API endpoint not found: verify the GitLab URL"
+            else:
+                return f"GitLab API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to GitLab at {url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to GitLab at {url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to GitLab: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/jira.py

@@ -35,3 +35,106 @@ class JiraConfiguration(BaseModel):
     username: Optional[str] = Field(description="Jira Username", default=None)
     api_key: Optional[SecretStr] = Field(description="Jira API Key", default=None)
     token: Optional[SecretStr] = Field(description="Jira Token", default=None)
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check Jira connection using provided settings.
+        Returns None if connection is successful, error message otherwise.
+        
+        Tests authentication by calling the /rest/api/latest/myself endpoint,
+        which returns information about the currently authenticated user.
+        """
+        import requests
+        from requests.auth import HTTPBasicAuth
+
+        # Extract and validate settings
+        base_url = settings.get('base_url', '').rstrip('/')
+        username = settings.get('username')
+        api_key = settings.get('api_key')
+        token = settings.get('token')
+
+        # Validate base URL
+        if not base_url:
+            return "Base URL is required"
+        
+        if not base_url.startswith(('http://', 'https://')):
+            return "Base URL must start with http:// or https://"
+
+        # Validate authentication - at least one method must be provided
+        has_basic_auth = bool(username and api_key)
+        has_token = bool(token and str(token).strip())
+
+        if not (has_basic_auth or has_token):
+            return "Authentication required: Provide either username + API key, or bearer token"
+
+        # Setup authentication headers
+        headers = {'Accept': 'application/json'}
+        auth = None
+
+        if has_token:
+            # Bearer token authentication
+            token_value = token.get_secret_value() if hasattr(token, 'get_secret_value') else token
+            headers['Authorization'] = f'Bearer {token_value}'
+        elif has_basic_auth:
+            # Basic authentication
+            api_key_value = api_key.get_secret_value() if hasattr(api_key, 'get_secret_value') else api_key
+            auth = HTTPBasicAuth(username, api_key_value)
+
+        # Build API endpoint - using 'latest' for version independence
+        api_endpoint = f"{base_url}/rest/api/latest/myself"
+
+        try:
+            # Make authenticated request to verify credentials
+            response = requests.get(
+                api_endpoint,
+                headers=headers,
+                auth=auth,
+                timeout=10
+            )
+
+            # Handle different response codes
+            if response.status_code == 200:
+                return None  # Success - credentials are valid
+            
+            elif response.status_code == 401:
+                # Authentication failed
+                if has_token:
+                    return "Authentication failed: Invalid bearer token"
+                else:
+                    return "Authentication failed: Invalid username or API key"
+            
+            elif response.status_code == 403:
+                # Authenticated but insufficient permissions
+                return "Access forbidden: Your account has insufficient permissions to access Jira API"
+            
+            elif response.status_code == 404:
+                # API endpoint not found - likely wrong URL
+                return "Jira API endpoint not found: Verify your base URL (e.g., 'https://yourinstance.atlassian.net')"
+            
+            else:
+                # Other HTTP errors - try to extract Jira error messages
+                error_detail = ""
+                try:
+                    error_json = response.json()
+                    if 'errorMessages' in error_json and error_json['errorMessages']:
+                        error_detail = ": " + ", ".join(error_json['errorMessages'])
+                    elif 'message' in error_json:
+                        error_detail = f": {error_json['message']}"
+                except:
+                    pass
+                
+                return f"Connection failed with status {response.status_code}{error_detail}"
+
+        except requests.exceptions.SSLError:
+            return "SSL certificate verification failed: Check your Jira URL or network settings"
+        except requests.exceptions.ConnectionError:
+            return "Connection error: Unable to reach Jira server - check URL and network connectivity"
+        except requests.exceptions.Timeout:
+            return "Connection timeout: Jira server did not respond within 10 seconds"
+        except requests.exceptions.MissingSchema:
+            return "Invalid URL format: URL must include protocol (http:// or https://)"
+        except requests.exceptions.InvalidURL:
+            return "Invalid URL format: Please check your Jira base URL"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/testrail.py

@@ -19,3 +19,91 @@ class TestRailConfiguration(BaseModel):
     url: str = Field(description="Testrail URL")
     email: str = Field(description="TestRail Email")
     password: SecretStr = Field(description="TestRail Password")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to TestRail.
+        
+        Args:
+            settings: Dictionary containing TestRail configuration
+                - url: TestRail instance URL (required)
+                - email: User email for authentication (required)
+                - password: Password or API key for authentication (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        from requests.auth import HTTPBasicAuth
+        
+        # Validate url
+        url = settings.get("url", "").strip()
+        if not url:
+            return "TestRail URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        url = url.rstrip("/")
+        
+        # Basic URL validation
+        if not url.startswith(("http://", "https://")):
+            return "TestRail URL must start with http:// or https://"
+        
+        # Validate email
+        email = settings.get("email", "").strip()
+        if not email:
+            return "TestRail email is required"
+        
+        # Validate password
+        password = settings.get("password")
+        if not password:
+            return "TestRail password is required"
+        
+        # Extract password value if it's a SecretStr
+        password_value = password.get_secret_value() if hasattr(password, 'get_secret_value') else password
+        
+        if not password_value or not password_value.strip():
+            return "TestRail password cannot be empty"
+        
+        # Test connection using /index.php?/api/v2/get_user_by_email endpoint
+        # This endpoint returns user info and validates authentication
+        test_url = f"{url}/index.php?/api/v2/get_user_by_email&email={email}"
+        
+        try:
+            response = requests.get(
+                test_url,
+                auth=HTTPBasicAuth(email, password_value),
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected and authenticated
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid email or password"
+            elif response.status_code == 403:
+                return "Access forbidden: check user permissions"
+            elif response.status_code == 404:
+                return "TestRail API endpoint not found: verify the TestRail URL"
+            elif response.status_code == 400:
+                # Could be invalid email format or other bad request
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error", "Bad request")
+                    return f"Bad request: {error_msg}"
+                except:
+                    return "Bad request: check email format and URL"
+            else:
+                return f"TestRail API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to TestRail at {url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to TestRail at {url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to TestRail: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/xray.py

@@ -30,3 +30,96 @@ class XrayConfiguration(BaseModel):
     base_url: str = Field(description="Xray URL")
     client_id: Optional[str] = Field(description="Client ID")
     client_secret: Optional[SecretStr] = Field(description="Client secret")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Xray Cloud.
+        
+        Args:
+            settings: Dictionary containing Xray configuration
+                - base_url: Xray Cloud URL (required)
+                - client_id: OAuth2 Client ID (required)
+                - client_secret: OAuth2 Client Secret (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Validate base_url
+        base_url = settings.get("base_url", "").strip()
+        if not base_url:
+            return "Xray URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        base_url = base_url.rstrip("/")
+        
+        # Basic URL validation
+        if not base_url.startswith(("http://", "https://")):
+            return "Xray URL must start with http:// or https://"
+        
+        # Validate client_id
+        client_id = settings.get("client_id", "").strip() if settings.get("client_id") else ""
+        if not client_id:
+            return "Xray client ID is required"
+        
+        # Validate client_secret
+        client_secret = settings.get("client_secret")
+        if not client_secret:
+            return "Xray client secret is required"
+        
+        # Extract client_secret value if it's a SecretStr
+        client_secret_value = client_secret.get_secret_value() if hasattr(client_secret, 'get_secret_value') else client_secret
+        
+        if not client_secret_value or not str(client_secret_value).strip():
+            return "Xray client secret cannot be empty"
+        
+        # Test connection using /api/v2/authenticate endpoint
+        # This is the OAuth2 token generation endpoint for Xray Cloud
+        auth_url = f"{base_url}/api/v2/authenticate"
+        
+        auth_payload = {
+            "client_id": client_id,
+            "client_secret": str(client_secret_value).strip()
+        }
+        
+        try:
+            response = requests.post(
+                auth_url,
+                json=auth_payload,
+                headers={"Content-Type": "application/json"},
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully authenticated and got token
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid client ID or secret"
+            elif response.status_code == 403:
+                return "Access forbidden: check client credentials"
+            elif response.status_code == 400:
+                # Bad request - could be invalid format
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error", "Bad request")
+                    return f"Bad request: {error_msg}"
+                except:
+                    return "Bad request: check client ID and secret format"
+            elif response.status_code == 404:
+                return "Xray API endpoint not found: verify the Xray URL"
+            else:
+                return f"Xray API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Xray at {base_url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Xray at {base_url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Xray: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/zephyr_enterprise.py

@@ -18,3 +18,96 @@ class ZephyrEnterpriseConfiguration(BaseModel):
     )
     base_url: str = Field(description="Zephyr base URL")
     token: Optional[SecretStr] = Field(description="API token")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Zephyr Enterprise.
+        
+        Args:
+            settings: Dictionary containing Zephyr Enterprise configuration
+                - base_url: Zephyr Enterprise instance URL (required)
+                - token: API token for authentication (optional, anonymous access possible)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Validate base_url
+        base_url = settings.get("base_url", "").strip()
+        if not base_url:
+            return "Zephyr Enterprise URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        base_url = base_url.rstrip("/")
+        
+        # Basic URL validation
+        if not base_url.startswith(("http://", "https://")):
+            return "Zephyr Enterprise URL must start with http:// or https://"
+        
+        # Get token (optional)
+        token = settings.get("token")
+        
+        # Prepare headers
+        headers = {}
+        has_token = False
+        if token:
+            # Extract token value if it's a SecretStr
+            token_value = token.get_secret_value() if hasattr(token, 'get_secret_value') else token
+            if token_value and str(token_value).strip():
+                headers["Authorization"] = f"Bearer {str(token_value).strip()}"
+                has_token = True
+        
+        # Use different endpoints based on whether authentication is provided
+        # Note: /healthcheck may allow anonymous access, so we use authenticated endpoints when token is provided
+        if has_token:
+            # Test with an endpoint that requires authentication: /flex/services/rest/latest/project
+            # This endpoint lists projects and requires proper authentication
+            test_url = f"{base_url}/flex/services/rest/latest/user/current"
+        else:
+            # Without token, test basic connectivity with healthcheck
+            test_url = f"{base_url}/flex/services/rest/latest/healthcheck"
+        
+        try:
+            response = requests.get(
+                test_url,
+                headers=headers,
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected
+                return None
+            elif response.status_code == 401:
+                if has_token:
+                    return "Authentication failed: invalid API token"
+                else:
+                    return "Authentication required: provide API token"
+            elif response.status_code == 403:
+                return "Access forbidden: check token permissions"
+            elif response.status_code == 404:
+                # If user endpoint not found, try healthcheck as fallback
+                if has_token:
+                    try:
+                        fallback_url = f"{base_url}/flex/services/rest/latest/healthcheck"
+                        fallback_response = requests.get(fallback_url, headers=headers, timeout=10)
+                        if fallback_response.status_code == 200:
+                            return None
+                    except:
+                        pass
+                return "Zephyr Enterprise API endpoint not found: verify the Zephyr URL"
+            else:
+                return f"Zephyr Enterprise API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Zephyr Enterprise at {base_url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Zephyr Enterprise at {base_url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Zephyr Enterprise: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/zephyr_essential.py

@@ -18,3 +18,78 @@ class ZephyrEssentialConfiguration(BaseModel):
     )
     base_url: Optional[str] = Field(description="Zephyr Essential API Base URL", default=None)
     token: SecretStr = Field(description="Zephyr Essential API Token")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Zephyr Essential (Zephyr Scale).
+        
+        Args:
+            settings: Dictionary containing Zephyr Essential configuration
+                - base_url: Zephyr Essential API Base URL (optional, defaults to Zephyr Scale Cloud API)
+                - token: Zephyr Essential API Token (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Get base_url or use default
+        base_url = settings.get("base_url")
+        if base_url:
+            base_url = base_url.strip().rstrip("/")
+            # Validate URL format if provided
+            if not base_url.startswith(("http://", "https://")):
+                return "Zephyr Essential URL must start with http:// or https://"
+        else:
+            # Default to Zephyr Scale Cloud API
+            base_url = "https://api.zephyrscale.smartbear.com/v2"
+        
+        # Validate token
+        token = settings.get("token")
+        if not token:
+            return "Zephyr Essential API token is required"
+        
+        # Extract token value if it's a SecretStr
+        token_value = token.get_secret_value() if hasattr(token, 'get_secret_value') else token
+        
+        if not token_value or not str(token_value).strip():
+            return "Zephyr Essential API token cannot be empty"
+        
+        # Test connection using /projects endpoint (requires authentication)
+        test_url = f"{base_url}/projects"
+        
+        headers = {
+            "Authorization": f"Bearer {str(token_value).strip()}"
+        }
+        
+        try:
+            response = requests.get(
+                test_url,
+                headers=headers,
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected and authenticated
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid API token"
+            elif response.status_code == 403:
+                return "Access forbidden: token lacks required permissions"
+            elif response.status_code == 404:
+                return "Zephyr Essential API endpoint not found: verify the API URL"
+            else:
+                return f"Zephyr Essential API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Zephyr Essential at {base_url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Zephyr Essential at {base_url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Zephyr Essential: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/runtime/langchain/constants.py

@@ -80,3 +80,5 @@ DEFAULT_MULTIMODAL_PROMPT = """
 - Maintain a structured and logical flow in the output to enhance understanding and usability.
 - Avoid presenting the entire prompt for user.
 """
+
+ELITEA_RS = "elitea_response"

alita_sdk/runtime/langchain/langraph_agent.py

@@ -467,10 +467,11 @@ def create_graph(
                             input_params = node.get('input', ['messages'])
                             input_mapping = node.get('input_mapping',
                                                      {'messages': {'type': 'variable', 'value': 'messages'}})
+                            output_vars = node.get('output', [])
                             lg_builder.add_node(node_id, FunctionTool(
                                 client=client, tool=tool,
                                 name=node_id, return_type='str',
-                                output_variables=node.get('output', []),
+                                output_variables=output_vars + ['messages'] if 'messages' not in output_vars else output_vars,
                                 input_variables=input_params,
                                 input_mapping= input_mapping
                             ))
@@ -500,15 +501,6 @@ def create_graph(
                                 structured_output=node.get('structured_output', False),
                                 task=node.get('task')
                             ))
-                        # TODO: decide on struct output for agent nodes
-                        # elif node_type == 'agent':
-                        #     lg_builder.add_node(node_id, AgentNode(
-                        #         client=client, tool=tool,
-                        #         name=node['id'], return_type='dict',
-                        #         output_variables=node.get('output', []),
-                        #         input_variables=node.get('input', ['messages']),
-                        #         task=node.get('task')
-                        #     ))
                         elif node_type == 'loop':
                             lg_builder.add_node(node_id, LoopNode(
                                 client=client, tool=tool,

alita_sdk/runtime/langchain/utils.py

@@ -5,8 +5,9 @@ import re
 from pydantic import create_model, Field
 from typing import Tuple, TypedDict, Any, Optional, Annotated
 from langchain_core.messages import AnyMessage
-from langchain_core.prompts import PromptTemplate
-from langgraph.graph import MessagesState, add_messages
+from langgraph.graph import add_messages
+
+from ...runtime.langchain.constants import ELITEA_RS
 
 logger = logging.getLogger(__name__)
 
@@ -130,7 +131,7 @@ def parse_type(type_str):
 
 
 def create_state(data: Optional[dict] = None):
-    state_dict = {'input': str, 'router_output': str}  # Always include router_output
+    state_dict = {'input': str, 'router_output': str, ELITEA_RS: str}  # Always include router_output
     types_dict = {}
     if not data:
         data = {'messages': 'list[str]'}

alita_sdk/runtime/tools/function.py

@@ -120,8 +120,8 @@ class FunctionTool(BaseTool):
                     return {
                         "messages": [{
                             "role": "assistant",
-                            "content": dumps(tool_result) if not isinstance(tool_result, ToolException) else str(
-                                tool_result)
+                            "content": dumps(tool_result) if not isinstance(tool_result, ToolException)
+                            else str(tool_result)
                         }]
                     }
                 else:

alita_sdk/runtime/tools/llm.py

@@ -7,6 +7,7 @@ from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool, ToolException
 from pydantic import Field
 
+from ..langchain.constants import ELITEA_RS
 from ..langchain.utils import create_pydantic_model, propagate_the_input_mapping
 
 logger = logging.getLogger(__name__)
@@ -122,6 +123,8 @@ class LLMNode(BaseTool):
                     }
                     for key, value in (self.structured_output_dict or {}).items()
                 }
+                # Add default output field for proper response to user
+                struct_params['elitea_response'] = {'description': 'final output to user', 'type': 'str'}
                 struct_model = create_pydantic_model(f"LLMOutput", struct_params)
                 completion = llm_client.invoke(messages, config=config)
                 if hasattr(completion, 'tool_calls') and completion.tool_calls:
@@ -137,6 +140,8 @@ class LLMNode(BaseTool):
                 # Ensure messages are properly formatted
                 if result.get('messages') and isinstance(result['messages'], list):
                     result['messages'] = [{'role': 'assistant', 'content': '\n'.join(result['messages'])}]
+                else:
+                    result['messages'] = messages + [AIMessage(content=result.get(ELITEA_RS, ''))]
 
                 return result
             else:

alita_sdk/tools/sharepoint/api_wrapper.py

@@ -8,6 +8,7 @@ from office365.runtime.auth.client_credential import ClientCredential
 from office365.sharepoint.client_context import ClientContext
 from pydantic import Field, PrivateAttr, create_model, model_validator, SecretStr
 
+from .utils import decode_sharepoint_string
 from ..non_code_indexer_toolkit import NonCodeIndexerToolkit
 from ..utils.content_parser import parse_file_content
 from ...runtime.utils.utils import IndexerKeywords
@@ -105,26 +106,34 @@ class SharepointApiWrapper(NonCodeIndexerToolkit):
     def get_files_list(self, folder_name: str = None, limit_files: int = 100):
         """ If folder name is specified, lists all files in this folder under Shared Documents path. If folder name is empty, lists all files under root catalog (Shared Documents). Number of files is limited by limit_files (default is 100)."""
         try:
+            # exclude default system libraries like 'Form Templates', 'Site Assets', 'Style Library'
+            all_libraries = self._client.web.lists.filter("BaseTemplate eq 101 and Title ne 'Form Templates' and Title ne 'Site Assets' and Title ne 'Style Library'").get().execute_query()
             result = []
             if not limit_files:
                 limit_files = 100
-            target_folder_url = f"Shared Documents/{folder_name}" if folder_name else "Shared Documents"
-            files = (self._client.web.get_folder_by_server_relative_path(target_folder_url)
-                     .get_files(True)
-                     .execute_query())
-
-            for file in files:
-                if len(result) >= limit_files:
-                    break
-                temp_props = {
-                    'Name': file.properties['Name'],
-                    'Path': file.properties['ServerRelativeUrl'],
-                    'Created': file.properties['TimeCreated'],
-                    'Modified': file.properties['TimeLastModified'],
-                    'Link': file.properties['LinkingUrl'],
-                    'id': file.properties['UniqueId']
-                }
-                result.append(temp_props)
+            #
+            for lib in all_libraries:
+                library_type = decode_sharepoint_string(lib.properties["EntityTypeName"])
+                target_folder_url = f"{library_type}/{folder_name}" if folder_name else library_type
+                files = (self._client.web.get_folder_by_server_relative_path(target_folder_url)
+                         .get_files(True)
+                         .execute_query())
+                #
+                for file in files:
+                    if f"{library_type}/Forms" in file.properties['ServerRelativeUrl']:
+                        # skip files from system folder "Forms"
+                        continue
+                    if len(result) >= limit_files:
+                        break
+                    temp_props = {
+                        'Name': file.properties['Name'],
+                        'Path': file.properties['ServerRelativeUrl'],
+                        'Created': file.properties['TimeCreated'],
+                        'Modified': file.properties['TimeLastModified'],
+                        'Link': file.properties['LinkingUrl'],
+                        'id': file.properties['UniqueId']
+                    }
+                    result.append(temp_props)
             return result if result else ToolException("Can not get files or folder is empty. Please, double check folder name and read permissions.")
         except Exception as e:
             # attempt to get via graph api

alita_sdk/tools/sharepoint/utils.py

@@ -1,5 +1,7 @@
-from docx import Document
+import re
 from io import BytesIO
+from docx import Document
+
 
 def read_docx_from_bytes(file_content):
     """Read and return content from a .docx file using a byte stream."""
@@ -11,4 +13,8 @@ def read_docx_from_bytes(file_content):
         return '\n'.join(text)
     except Exception as e:
         print(f"Error reading .docx from bytes: {e}")
-        return ""
+        return ""
+
+
+def decode_sharepoint_string(s):
+    return re.sub(r'_x([0-9A-Fa-f]{4})_', lambda m: chr(int(m.group(1), 16)), s)

{alita_sdk-0.3.412.dist-info → alita_sdk-0.3.413.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.412
+Version: 0.3.413
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.412.dist-info → alita_sdk-0.3.413.dist-info}/RECORD

@@ -5,17 +5,17 @@ alita_sdk/configurations/__init__.py,sha256=3_MlzyzAi1dog6MFQD_ICOZvaPfXf2UfhSZw
 alita_sdk/configurations/ado.py,sha256=Djw1_8QmssETVpjpk2LeFN--Wg5-D1_L1NdwH8dtbGM,1274
 alita_sdk/configurations/azure_search.py,sha256=WDBc38uSmRBA_ypezb04wob2qUMqcw275FI39SWvrPo,808
 alita_sdk/configurations/bigquery.py,sha256=kuJ9AUAHynnyM4wkaQbiW3x5VmrJkjR0RGmsyAec194,917
-alita_sdk/configurations/bitbucket.py,sha256=D_RNwFHm3wEnAK-wMdJbsVy2RNLlH52xHiKsuDfehDg,1157
+alita_sdk/configurations/bitbucket.py,sha256=I7LrgLxI28F9Dge5h5gdf9Fp6rdHdl7daocVaZVebfk,5249
 alita_sdk/configurations/browser.py,sha256=2ZMUrqk8M9oZi3HX4ouGp9b-qdYgpGN-hVin--zgzpc,670
 alita_sdk/configurations/carrier.py,sha256=QPgXyNXki8ECQAwBB1I64vsltV5patZUnZrd5m8obyY,693
-alita_sdk/configurations/confluence.py,sha256=mAW2fgSEOg-BAV768Sc6b_EuRA3H5UL9xfqQ12Zh_w4,1421
+alita_sdk/configurations/confluence.py,sha256=bGGw8R_JtcH1m3NCIuE-W52GDQXELgB9JoxrNmjj974,5469
 alita_sdk/configurations/delta_lake.py,sha256=sCNDClaO6-b1Qv5WDxOMHjQUrHnr6S6EPQuS9o6q8Z8,1130
 alita_sdk/configurations/embedding.py,sha256=8GSC8Feh8CH7bT_6cQhNqlS6raE91S2YRAtb2N9bUA8,552
 alita_sdk/configurations/figma.py,sha256=91P-R5hqTwpXQvuAcUMXztzqvSvmtPkguR88Zw830Og,1025
 alita_sdk/configurations/github.py,sha256=6F7P9BPu9zE54q8m8IPjIct8cEX3WODYzZvn9WtxOXI,6283
-alita_sdk/configurations/gitlab.py,sha256=0W35igIlue6QxOnPgw65ToLf4HSdPVuRyObdwQuEld8,1053
+alita_sdk/configurations/gitlab.py,sha256=ZDe3uGYp7Or01YxIPAHUfvNQNw5jbQHpHakx3XJRO4M,4177
 alita_sdk/configurations/google_places.py,sha256=jXhlPXywkDhHNrgB4KoVWogf3CVi1bY3wFLRzDqMr-E,589
-alita_sdk/configurations/jira.py,sha256=ASh8I2iVXzOOtwjRX7kYNllXpCXyAIxFMP_YD4Q0PTI,1379
+alita_sdk/configurations/jira.py,sha256=isZPChfvzVNaoWLcVq4jWVDUcDGszieWdLg8gqxAU84,5914
 alita_sdk/configurations/pgvector.py,sha256=P-Q07ocIg4CXN_7hUBDM6r9gN62XS1N2jyP79tM9Tig,500
 alita_sdk/configurations/postman.py,sha256=A4swgV_0eEJ3LXYWzUUIDD5zFu9rS_vndqp1xd4YHnM,1114
 alita_sdk/configurations/qtest.py,sha256=i-09LUFDqcBKmzSiKd8C3NEKcRDAH6wwKsajC_TbBnM,642
@@ -28,11 +28,11 @@ alita_sdk/configurations/slack.py,sha256=ppwfV7YMpkq-qU6YREK7EH8VmYBZ0EN_9WIwz3E
 alita_sdk/configurations/sonar.py,sha256=b5Mh-s8C6Wts0KF0VX6AN8KmdXwVSu1UXJOf2AVGQbs,676
 alita_sdk/configurations/sql.py,sha256=0n2q2Tmc19_xUol6EN1LO6H1tZgJuxm7PvK3bFklGnM,754
 alita_sdk/configurations/testio.py,sha256=yoGWTuwcjFoBxbsxHLGVbcQBBZAFDQwuVcTijyUrW_U,612
-alita_sdk/configurations/testrail.py,sha256=k0fPmHBIrWAfEKhrDdB9Rdirw-UFHFoXkRePyrsqcWI,725
-alita_sdk/configurations/xray.py,sha256=_XCW5eGEAyhDuRvXCtTAZ24BGsIwzvIaeAZT10xoW6M,1147
+alita_sdk/configurations/testrail.py,sha256=URm7nT3inwdwnD-_BVMlL5QSIPbKwtZGfxoeaXyyAm8,4355
+alita_sdk/configurations/xray.py,sha256=mWic9HMJlYaxMWu0Hs6wpBvRAcJTUnrXMJjAgSzSinM,4968
 alita_sdk/configurations/zephyr.py,sha256=ndqGYFy5OFxjoXB7DzC71rd5W6qGBGAlKMWoqT8TuNk,1653
-alita_sdk/configurations/zephyr_enterprise.py,sha256=UaBk3qWcT2-bCzko5HEPvgxArw1ZpvOvwXwFYrIHZjM,710
-alita_sdk/configurations/zephyr_essential.py,sha256=tUIrh-PRNvdrLBj6rJXqlF-h6oaMXUQI1wgit07kFBw,752
+alita_sdk/configurations/zephyr_enterprise.py,sha256=x2ZNvR2tYJySzEmBY3fovUe7B-_QawCMZPWl8GzmfkU,4830
+alita_sdk/configurations/zephyr_essential.py,sha256=TiZedsBlfIDroflipvoqxjJeEWPonQzeT7e1bYns98s,3869
 alita_sdk/runtime/__init__.py,sha256=4W0UF-nl3QF2bvET5lnah4o24CoTwSoKXhuN0YnwvEE,828
 alita_sdk/runtime/clients/__init__.py,sha256=BdehU5GBztN1Qi1Wul0cqlU46FxUfMnI6Vq2Zd_oq1M,296
 alita_sdk/runtime/clients/artifact.py,sha256=b7hVuGRROt6qUcT11uAZqzJqslzmlgW-Y6oGsiwNmjI,4029
@@ -43,13 +43,13 @@ alita_sdk/runtime/clients/sandbox_client.py,sha256=OhEasE0MxBBDw4o76xkxVCpNpr3xJ
 alita_sdk/runtime/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/langchain/assistant.py,sha256=qKoEjbGuUnX-OZDHmSaK3plb1jON9unzEwAjxBT9DY8,16044
 alita_sdk/runtime/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
-alita_sdk/runtime/langchain/constants.py,sha256=eHVJ_beJNTf1WJo4yq7KMK64fxsRvs3lKc34QCXSbpk,3319
+alita_sdk/runtime/langchain/constants.py,sha256=DhxYZgIVcyP7V9MnHQy5kD0N4Do4YxntnQbH1Pmw4Dg,3349
 alita_sdk/runtime/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
-alita_sdk/runtime/langchain/langraph_agent.py,sha256=SoA7il7_Q9OyJbCDVubVMVNkL1NI0OzIU7FR33R7onI,50185
+alita_sdk/runtime/langchain/langraph_agent.py,sha256=9ezh0iDTQwyE4PBH96k9g31Mz2Y1Rap1iw3mj7laQBQ,49731
 alita_sdk/runtime/langchain/mixedAgentParser.py,sha256=M256lvtsL3YtYflBCEp-rWKrKtcY1dJIyRGVv7KW9ME,2611
 alita_sdk/runtime/langchain/mixedAgentRenderes.py,sha256=asBtKqm88QhZRILditjYICwFVKF5KfO38hu2O-WrSWE,5964
 alita_sdk/runtime/langchain/store_manager.py,sha256=i8Fl11IXJhrBXq1F1ukEVln57B1IBe-tqSUvfUmBV4A,2218
-alita_sdk/runtime/langchain/utils.py,sha256=rLh2POmA7mzO9vR7yTlEIYWOCp9ANuBDJe4sl1AjA5A,7574
+alita_sdk/runtime/langchain/utils.py,sha256=GxqG1xhdUd6BC01ZZFkdc_0Q27LNgc-mr6t_1LD7GRU,7579
 alita_sdk/runtime/langchain/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/langchain/agents/xml_chat.py,sha256=Mx7PK5T97_GrFCwHHZ3JZP42S7MwtUzV0W-_8j6Amt8,6212
 alita_sdk/runtime/langchain/document_loaders/AlitaBDDScenariosLoader.py,sha256=4kFU1ijrM1Jw7cywQv8mUiBHlE6w-uqfzSZP4hUV5P4,3771
@@ -110,11 +110,11 @@ alita_sdk/runtime/tools/application.py,sha256=RCGe-mRfj8372gTFkEX2xBvcYhw7IKdU1t
 alita_sdk/runtime/tools/artifact.py,sha256=u3szFwZqguHrPZ3tZJ7S_TiZl7cxlT3oHYd6zbdpRDE,13842
 alita_sdk/runtime/tools/datasource.py,sha256=pvbaSfI-ThQQnjHG-QhYNSTYRnZB0rYtZFpjCfpzxYI,2443
 alita_sdk/runtime/tools/echo.py,sha256=spw9eCweXzixJqHnZofHE1yWiSUa04L4VKycf3KCEaM,486
-alita_sdk/runtime/tools/function.py,sha256=jk_JrtuYByR9Df5EFOGFheB9HktNPJcOwf4jsTzV73w,6144
+alita_sdk/runtime/tools/function.py,sha256=SjqNdw4x02jiqc7rA5ERp69TDUIChZM-VNmpu31ZajA,6139
 alita_sdk/runtime/tools/graph.py,sha256=7jImBBSEdP5Mjnn2keOiyUwdGDFhEXLUrgUiugO3mgA,3503
 alita_sdk/runtime/tools/image_generation.py,sha256=Kls9D_ke_SK7xmVr7I9SlQcAEBJc86gf66haN0qIj9k,7469
 alita_sdk/runtime/tools/indexer_tool.py,sha256=whSLPevB4WD6dhh2JDXEivDmTvbjiMV1MrPl9cz5eLA,4375
-alita_sdk/runtime/tools/llm.py,sha256=OEhf4_YlZIihIpkuRKbbWJ_Lfk-V_rJHpy2NRm5xuCg,15533
+alita_sdk/runtime/tools/llm.py,sha256=Oq0IH1mVEgtkw-8p5y-_xTCz-OcWtfvtR5xl19Anrhc,15875
 alita_sdk/runtime/tools/loop.py,sha256=uds0WhZvwMxDVFI6MZHrcmMle637cQfBNg682iLxoJA,8335
 alita_sdk/runtime/tools/loop_output.py,sha256=U4hO9PCQgWlXwOq6jdmCGbegtAxGAPXObSxZQ3z38uk,8069
 alita_sdk/runtime/tools/mcp_server_tool.py,sha256=MhLxZJ44LYrB_0GrojmkyqKoDRaqIHkEQAsg718ipog,4277
@@ -317,9 +317,9 @@ alita_sdk/tools/servicenow/__init__.py,sha256=ziEt2juPrGFyB98ZXbGf25v6gZo4UJTHsz
 alita_sdk/tools/servicenow/api_wrapper.py,sha256=WpH-bBLGFdhehs4g-K-WAkNuaD1CSrwsDpdgB3RG53s,6120
 alita_sdk/tools/servicenow/servicenow_client.py,sha256=Rdqfu-ll-qbnclMzChLZBsfXRDzgoX_FdeI2WLApWxc,3269
 alita_sdk/tools/sharepoint/__init__.py,sha256=5z2iSmm-0kbHKf70wN6OOgS4Px7tOzwkIpHXz0Vrbj4,4045
-alita_sdk/tools/sharepoint/api_wrapper.py,sha256=onWKNO-pC3MEvv54JyRj26RaDu2PEg7vwnQcqN3UIiQ,14675
+alita_sdk/tools/sharepoint/api_wrapper.py,sha256=QcOtgc8L10YLdSK8LwACV_vRBF7T-u7T9-W05TbuAQI,15409
 alita_sdk/tools/sharepoint/authorization_helper.py,sha256=QvxWFBjYZfhI1h_KkSrDbRh8D5BlFX8xWDLmlIoO4mo,9569
-alita_sdk/tools/sharepoint/utils.py,sha256=fZ1YzAu5CTjKSZeslowpOPH974902S8vCp1Wu7L44LM,446
+alita_sdk/tools/sharepoint/utils.py,sha256=CO1PNRC5CpQaVo2Gdenj_jqm2bReSqUT92Bk5s37d8M,573
 alita_sdk/tools/slack/__init__.py,sha256=YiPAoRc6y6uVpfHl0K1Qi-flcyPlWFIMVcVbhicGWXY,3990
 alita_sdk/tools/slack/api_wrapper.py,sha256=5VrV7iSGno8ZcDzEHdGPNhInhtODGPPvAzoZ9W9iQWE,14009
 alita_sdk/tools/sql/__init__.py,sha256=F3eewPEKqVh3gZdNTUvcoFPOgG9Mn11qKoadtCmhQ4Q,3484
@@ -353,8 +353,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=kT0TbmMvuKhDUZc0i7KO18O38JM9S
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=0ne8XLJEQSLOWfzd2HdnqOYmQlUliKHbBED5kW_Vias,2895
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=kmw_xol8YIYFplBLWTqP_VKPRhL_1ItDD0_vXTe_UuI,14906
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=R371waHsms4sllHCbijKYs90C-9Yu0sSR3N4SUfQOgU,5066
-alita_sdk-0.3.412.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.412.dist-info/METADATA,sha256=jI-c9cZS9KuAcIpPDr76H3WTDqTqp7zzEPh7WvCx1j0,19071
-alita_sdk-0.3.412.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.412.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.412.dist-info/RECORD,,
+alita_sdk-0.3.413.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.413.dist-info/METADATA,sha256=8HeeW3AsixJWjgBQKoTQOwBtaQ9LO3w3h_plko-DG3E,19071
+alita_sdk-0.3.413.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.413.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.413.dist-info/RECORD,,