alita-sdk 0.3.174__tar.gz → 0.3.176__tar.gz

{alita_sdk-0.3.174 → alita_sdk-0.3.176}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.174
+Version: 0.3.176
 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 <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0
@@ -123,6 +123,7 @@ Requires-Dist: pysnc==1.1.10; extra == "tools"
 Requires-Dist: shortuuid==1.0.13; extra == "tools"
 Requires-Dist: yarl==1.17.1; extra == "tools"
 Requires-Dist: langmem==0.0.27; extra == "tools"
+Requires-Dist: textract-py3==2.1.1; extra == "tools"
 Provides-Extra: community
 Requires-Dist: retry-extended==0.2.3; extra == "community"
 Requires-Dist: browser-use==0.1.43; extra == "community"

{alita_sdk-0.3.174 → alita_sdk-0.3.176}/alita_sdk/tools/ado/repos/__init__.py

@@ -46,9 +46,18 @@ class AzureDevOpsReposToolkit(BaseToolkit):
         AzureDevOpsReposToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            organization_url=(Optional[str], Field(default="", title="Organization URL", description="ADO organization url", json_schema_extra={'configuration': True})),
+            organization_url=(Optional[str], Field(default="", title="Organization URL",
+                                                   description="ADO organization url",
+                                                   json_schema_extra={
+                                                       'configuration': True,
+                                                       "configuration_title": True
+                                                   })),
             project=(Optional[str], Field(default="", title="Project", description="ADO project", json_schema_extra={'configuration': True})),
-            repository_id=(Optional[str], Field(default="", title="Repository ID", description="ADO repository ID", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsReposToolkit.toolkit_max_length, 'configuration': True})),
+            repository_id=(Optional[str], Field(default="", title="Repository ID", description="ADO repository ID",
+                                                json_schema_extra={
+                                                    'toolkit_name': True,
+                                                    'max_toolkit_length': AzureDevOpsReposToolkit.toolkit_max_length,
+                                                    'configuration': True})),
             token=(Optional[SecretStr], Field(default="", title="Token", description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             base_branch=(Optional[str], Field(default="", title="Base branch", description="ADO base branch (e.g., main)")),
             active_branch=(Optional[str], Field(default="", title="Active branch", description="ADO active branch (e.g., main)")),

{alita_sdk-0.3.174 → alita_sdk-0.3.176}/alita_sdk/tools/ado/test_plan/__init__.py

@@ -24,7 +24,12 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
         m = create_model(
             name_alias,
             name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsPlansToolkit.toolkit_max_length})),
-            organization_url=(str, Field(description="ADO organization url", json_schema_extra={'configuration': True})),
+            organization_url=(str, Field(default="", title="Organization URL",
+                                                   description="ADO organization url",
+                                                   json_schema_extra={
+                                                       'configuration': True,
+                                                       "configuration_title": True
+                                                   })),
             limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),
             token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),

{alita_sdk-0.3.174 → alita_sdk-0.3.176}/alita_sdk/tools/ado/wiki/__init__.py

@@ -25,7 +25,12 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
                                  'toolkit_name': True,
                                  'max_toolkit_length': AzureDevOpsWikiToolkit.toolkit_max_length})
                   ),
-            organization_url=(str, Field(description="ADO organization url", json_schema_extra={'configuration': True})),
+            organization_url=(str, Field(default="", title="Organization URL",
+                                                   description="ADO organization url",
+                                                   json_schema_extra={
+                                                       'configuration': True,
+                                                       "configuration_title": True
+                                                   })),
             project=(str, Field(description="ADO project", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsWikiToolkit.toolkit_max_length, 'configuration': True})),
             token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             selected_tools=(List[Literal[tuple(selected_tools)]],

{alita_sdk-0.3.174 → alita_sdk-0.3.176}/alita_sdk/tools/ado/work_item/__init__.py

@@ -24,7 +24,12 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
                                  'toolkit_name': True,
                                  'max_toolkit_length': AzureDevOpsWorkItemsToolkit.toolkit_max_length})
                   ),
-            organization_url=(str, Field(description="ADO organization url", json_schema_extra={'configuration': True})),
+            organization_url=(str, Field(default="", title="Organization URL",
+                                                   description="ADO organization url",
+                                                   json_schema_extra={
+                                                       'configuration': True,
+                                                       "configuration_title": True
+                                                   })),
             project=(str, Field(description="ADO project", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsWorkItemsToolkit.toolkit_max_length, 'configuration': True})),
             token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),

{alita_sdk-0.3.174 → alita_sdk-0.3.176}/alita_sdk/tools/azure_ai/search/__init__.py

@@ -39,9 +39,18 @@ class AzureSearchToolkit(BaseToolkit):
         m = create_model(
             name,
             api_key=(SecretStr, Field(description="API key", json_schema_extra={'secret': True, 'configuration': True})),
-            endpoint=(str, Field(description="Azure Search endpoint")),
+            endpoint=(str, Field(title="Azure Search endpoint",
+                                                   description="Azure Search endpoint",
+                                                   json_schema_extra={
+                                                       'configuration': True,
+                                                       "configuration_title": True
+                                                   })),
             index_name=(str, Field(description="Azure Search index name")),
-            api_base=(Optional[str], Field(description="Azure OpenAI base URL", default=None, json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureSearchToolkit.toolkit_max_length, 'configuration': True})),
+            api_base=(Optional[str], Field(description="Azure OpenAI base URL", default=None,
+                                           json_schema_extra={
+                                               'toolkit_name': True,
+                                               'max_toolkit_length': AzureSearchToolkit.toolkit_max_length,
+                                               'configuration': True})),
             api_version=(Optional[str], Field(description="API version", default=None)),
             openai_api_key=(Optional[str], Field(description="Azure OpenAI API Key", default=None, json_schema_extra={'secret': True})),
             model_name=(str, Field(description="Model name for Embeddings model", default=None)),

{alita_sdk-0.3.174 → alita_sdk-0.3.176}/alita_sdk/tools/bitbucket/__init__.py

@@ -41,7 +41,7 @@ class AlitaBitbucketToolkit(BaseToolkit):
         AlitaBitbucketToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            url=(str, Field(description="Bitbucket URL", json_schema_extra={'configuration': True})),
+            url=(str, Field(description="Bitbucket URL", json_schema_extra={'configuration': True, 'configuration_title': True})),
             project=(str, Field(description="Project/Workspace", json_schema_extra={'configuration': True})),
             repository=(str, Field(description="Repository", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AlitaBitbucketToolkit.toolkit_max_length, 'configuration': True})),
             branch=(str, Field(description="Main branch", default="main")),

alita_sdk-0.3.176/alita_sdk/tools/carrier/create_ui_test_tool.py

@@ -0,0 +1,180 @@
+import logging
+import json
+import traceback
+from typing import Type
+from langchain_core.tools import BaseTool, ToolException
+from pydantic.fields import Field
+from pydantic import create_model, BaseModel
+from .api_wrapper import CarrierAPIWrapper
+from .carrier_sdk import CarrierAPIError
+
+logger = logging.getLogger(__name__)
+
+
+class CreateUITestTool(BaseTool):
+    api_wrapper: CarrierAPIWrapper = Field(..., description="Carrier API Wrapper instance")
+    name: str = "create_ui_test"
+    description: str = "Create a new UI test in the Carrier platform."
+    args_schema: Type[BaseModel] = create_model(
+        "CreateUITestInput",
+        message=(str, Field(description="User request message for creating UI test")),
+        name=(str, Field(description="Test name (e.g., 'My UI Test')")),
+        test_type=(str, Field(description="Test type (e.g., 'performance')")),
+        env_type=(str, Field(description="Environment type (e.g., 'staging')")),
+        entrypoint=(str, Field(description="Entry point file (e.g., 'my_test.js')")),
+        runner=(str, Field(description="Test runner type. Available runners: Lighthouse-NPM_V12, Lighthouse-Nodejs, Lighthouse-NPM, Lighthouse-NPM_V11, Sitespeed (Browsertime), Sitespeed (New Entrypoint BETA), Sitespeed (New Version BETA), Sitespeed V36")),
+        repo=(str, Field(description="Git repository URL (e.g., 'https://github.com/user/repo.git')")),
+        branch=(str, Field(description="Git branch name (e.g., 'main')")),
+        username=(str, Field(description="Git username")),
+        password=(str, Field(description="Git password")),
+        cpu_quota=(int, Field(description="CPU quota in cores (e.g., 2)")),
+        memory_quota=(int, Field(description="Memory quota in GB (e.g., 5)")),
+        parallel_runners=(int, Field(description="Number of parallel runners (e.g., 1)")),
+        loops=(int, Field(description="Number of loops (e.g., 1)")),
+        **{"custom_cmd": (str, Field(default="", description="Optional custom command (e.g., '--login=\"qwerty\"')"))}
+    )
+
+    def _run(self, **kwargs):
+        try:
+            # Create the UI test with provided parameters
+            return self._create_ui_test(kwargs)
+            
+        except Exception:
+            stacktrace = traceback.format_exc()
+            logger.error(f"Error creating UI test: {stacktrace}")
+            raise ToolException(stacktrace)
+
+    def _parse_validation_error(self, error_message: str) -> str:
+        """Parse validation error message and format it for user display."""
+        try:
+            # Try to extract JSON validation errors from the message
+            import re
+            json_match = re.search(r'\[.*\]', error_message)
+            if json_match:
+                json_str = json_match.group(0)
+                try:
+                    validation_errors = json.loads(json_str)
+                    if isinstance(validation_errors, list):
+                        formatted_errors = []
+                        for error in validation_errors:
+                            if isinstance(error, dict):
+                                field = error.get("loc", ["unknown"])[0] if error.get("loc") else "unknown"
+                                message = error.get("msg", "Invalid value")
+                                formatted_errors.append(f"- **{field}**: {message}")
+                        
+                        if formatted_errors:
+                            return "\n".join(formatted_errors)
+                except json.JSONDecodeError:
+                    pass
+            
+            # If we can't parse JSON, return the original message
+            return error_message
+            
+        except Exception:
+            return error_message
+
+    def _create_ui_test(self, params):
+        """Create UI test using the provided parameters."""
+        try:
+            # Construct the POST body
+            post_body = {
+                "common_params": {
+                    "name": params["name"],
+                    "test_type": params["test_type"],
+                    "env_type": params["env_type"],
+                    "entrypoint": params["entrypoint"],
+                    "runner": params["runner"],
+                    "source": {
+                        "name": "git_https",
+                        "repo": params["repo"],
+                        "branch": params["branch"],
+                        "username": params["username"],
+                        "password": params["password"]
+                    },                    "env_vars": {
+                        "cpu_quota": params["cpu_quota"],
+                        "memory_quota": params["memory_quota"],
+                        "cloud_settings": {}
+                    },
+                    "parallel_runners": params["parallel_runners"],
+                    "cc_env_vars": {},
+                    "location": "default",
+                    "loops": params["loops"],
+                    "aggregation": "max"
+                },
+                "test_parameters": [],
+                "integrations": {},
+                "schedules": [],
+                "run_test": False
+            }
+              # Add custom_cmd if provided
+            if params.get("custom_cmd") and params["custom_cmd"].strip():
+                post_body["common_params"]["env_vars"]["custom_cmd"] = params["custom_cmd"]
+            
+            # Make the API call to create the UI test using the API wrapper
+            response = self.api_wrapper.create_ui_test(post_body)
+            
+            if response:
+                test_id = response.get("id") if isinstance(response, dict) else "Unknown"
+                
+                return f"""# ✅ UI Test Created Successfully!
+
+## Test Information:
+- **Test ID:** `{test_id}`
+- **Name:** `{params['name']}`
+- **Type:** `{params['test_type']}`
+- **Environment:** `{params['env_type']}`
+- **Runner:** `{params['runner']}`
+- **Repository:** `{params['repo']}`
+- **Branch:** `{params['branch']}`
+- **Entry Point:** `{params['entrypoint']}`
+
+## Configuration:
+- **CPU Quota:** {params['cpu_quota']} cores
+- **Memory Quota:** {params['memory_quota']} GB
+- **Parallel Runners:** {params['parallel_runners']}
+- **Loops:** {params['loops']}
+- **Aggregation:** max
+{f"- **Custom Command:** `{params['custom_cmd']}`" if params.get('custom_cmd') else ""}
+
+## 🎯 Next Steps:
+- Your UI test has been created and is ready to run
+- You can execute it using the UI test runner tools
+- Configure schedules and integrations as needed"""
+            else:
+                return "❌ **Failed to create UI test. Please check your parameters and try again.**"
+                
+        except CarrierAPIError as api_error:
+            # Handle API-specific errors with detailed validation messages
+            error_message = str(api_error)
+            logger.error(f"CarrierAPIError creating UI test: {error_message}")
+              # Try to extract validation details from the error message
+            if "400" in error_message:
+                parsed_errors = self._parse_validation_error(error_message)
+                return f"""# ❌ UI Test Creation Failed - Validation Error
+
+## 🚫 Invalid Input Parameters:
+The Carrier platform rejected your request due to validation errors.
+
+## 📋 Validation Errors:
+{parsed_errors}
+
+## 💡 Common Issues:
+- **Test name**: Only letters, numbers, and "_" are allowed
+- **Repository URL**: Must be a valid Git repository URL
+- **Runner**: Must be one of the available runner types: Lighthouse-NPM_V12, Lighthouse-Nodejs, Lighthouse-NPM, Lighthouse-NPM_V11, Sitespeed (Browsertime), Sitespeed (New Entrypoint BETA), Sitespeed (New Version BETA), Sitespeed V36
+- **Numeric values**: CPU quota, memory quota, parallel runners, and loops must be positive integers
+
+## 🔧 Please fix the validation errors above and try again."""
+            else:
+                return f"""# ❌ UI Test Creation Failed
+
+## 🚫 API Error:
+```
+{error_message}
+```
+
+## 💡 Please check your parameters and try again."""
+                
+        except Exception as e:
+            logger.error(f"Error creating UI test: {e}")
+            raise ToolException(f"Failed to create UI test: {str(e)}")