alita-sdk 0.3.175__py3-none-any.whl → 0.3.176__py3-none-any.whl

alita_sdk/tools/carrier/create_ui_test_tool.py

@@ -6,6 +6,7 @@ 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__)
 
@@ -16,39 +17,26 @@ class CreateUITestTool(BaseTool):
     description: str = "Create a new UI test in the Carrier platform."
     args_schema: Type[BaseModel] = create_model(
         "CreateUITestInput",
-        **{
-            "name": (str, Field(default="", description="Test name")),
-            "test_type": (str, Field(default="", description="Test type")),
-            "env_type": (str, Field(default="", description="Environment type")),
-            "entrypoint": (str, Field(default="", description="Entry point file (e.g., my_test.js)")),
-            "runner": (str, Field(default="", description="Test runner type")),
-            "repo": (str, Field(default="", description="Git repository URL")),
-            "branch": (str, Field(default="", description="Git branch name")),
-            "username": (str, Field(default="", description="Git username")),
-            "password": (str, Field(default="", description="Git password")),
-            "cpu_quota": (int, Field(default=2, description="CPU quota (cores)")),
-            "memory_quota": (int, Field(default=5, description="Memory quota (GB)")),
-            "custom_cmd": (str, Field(default="", description="Optional custom command")),
-            "parallel_runners": (int, Field(default=1, description="Number of parallel runners")),
-            "loops": (int, Field(default=1, description="Number of loops")),
-            "aggregation": (str, Field(default="max", description="Aggregation method (max, min, avg)")),
-        }
+        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:
-            # Check if all required parameters are provided
-            required_params = ["name", "test_type", "env_type", "entrypoint", "runner", "repo", "branch", "username", "password"]
-            missing_params = []
-            
-            for param in required_params:
-                if not kwargs.get(param) or kwargs.get(param).strip() == "":
-                    missing_params.append(param)
-            
-            if missing_params:
-                return self._missing_parameters_response(missing_params)
-            
-            # Create the UI test
+            # Create the UI test with provided parameters
             return self._create_ui_test(kwargs)
             
         except Exception:
@@ -56,71 +44,34 @@ class CreateUITestTool(BaseTool):
             logger.error(f"Error creating UI test: {stacktrace}")
             raise ToolException(stacktrace)
 
-    def _missing_parameters_response(self, missing_params=None):
-        """Response when required parameters are missing."""
-        available_runners = [
-            "Lighthouse-NPM_V12",
-            "Lighthouse-Nodejs", 
-            "Lighthouse-NPM",
-            "Lighthouse-NPM_V11",
-            "Sitespeed (Browsertime)",
-            "Sitespeed (New Entrypoint BETA)",
-            "Sitespeed (New Version BETA)",
-            "Sitespeed V36"
-        ]
-        
-        message = [
-            "# 📝 Create UI Test - Required Parameters",
-            "",
-            "To create a new UI test, please provide the following parameters:",
-            "",
-            "## 🔴 Required Parameters:",
-            "- **name**: Test name (e.g., 'My UI Test')",
-            "- **test_type**: Test type (e.g., 'performance')",
-            "- **env_type**: Environment type (e.g., 'staging')",
-            "- **entrypoint**: Entry point file (e.g., 'my_test.js')",
-            "- **runner**: Test runner (see available options below)",
-            "- **repo**: Git repository URL (e.g., 'https://github.com/user/repo.git')",
-            "- **branch**: Git branch name (e.g., 'main')",
-            "- **username**: Git username",
-            "- **password**: Git password",
-            "",
-            "## 🟡 Optional Parameters:",
-            "- **cpu_quota**: CPU quota in cores (default: 2)",
-            "- **memory_quota**: Memory quota in GB (default: 5)",            "- **custom_cmd**: Optional custom command (e.g., '--login=\"qwerty\"')",
-            "- **parallel_runners**: Number of parallel runners (default: 1)",
-            "- **loops**: Number of loops (default: 1)",
-            "",
-            "## 🚀 Available Runners:",
-        ]
-        
-        for runner in available_runners:
-            message.append(f"- {runner}")
-        
-        message.extend([
-            "",
-            "## 💡 Example:",
-            "```",
-            "name: 'My Performance Test'",
-            "test_type: 'performance'",
-            "env_type: 'staging'",
-            "entrypoint: 'lighthouse_test.js'",
-            "runner: 'Lighthouse-NPM_V12'",
-            "repo: 'https://github.com/mycompany/tests.git'",            "branch: 'main'",
-            "username: 'myusername'",
-            "password: 'mypassword'",
-            "```",
-            "",
-            "**Note:** Aggregation method is automatically set to 'max'."
-        ])
-        
-        if missing_params:
-            message.insert(2, f"❌ **Missing parameters:** {', '.join(missing_params)}")
-            message.insert(3, "")
-        
-        return {
-            "message": "\n".join(message)
-        }
+    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."""
@@ -139,25 +90,23 @@ class CreateUITestTool(BaseTool):
                         "branch": params["branch"],
                         "username": params["username"],
                         "password": params["password"]
-                    },
-                    "env_vars": {
-                        "cpu_quota": params.get("cpu_quota", 2),
-                        "memory_quota": params.get("memory_quota", 5),
+                    },                    "env_vars": {
+                        "cpu_quota": params["cpu_quota"],
+                        "memory_quota": params["memory_quota"],
                         "cloud_settings": {}
                     },
-                    "parallel_runners": params.get("parallel_runners", 1),
+                    "parallel_runners": params["parallel_runners"],
                     "cc_env_vars": {},
                     "location": "default",
-                    "loops": params.get("loops", 1),
-                    "aggregation": params.get("aggregation", "max")
+                    "loops": params["loops"],
+                    "aggregation": "max"
                 },
                 "test_parameters": [],
                 "integrations": {},
                 "schedules": [],
                 "run_test": False
             }
-            
-            # Add custom_cmd if provided
+              # 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"]
             
@@ -180,11 +129,11 @@ class CreateUITestTool(BaseTool):
 - **Entry Point:** `{params['entrypoint']}`
 
 ## Configuration:
-- **CPU Quota:** {params.get('cpu_quota', 2)} cores
-- **Memory Quota:** {params.get('memory_quota', 5)} GB
-- **Parallel Runners:** {params.get('parallel_runners', 1)}
-- **Loops:** {params.get('loops', 1)}
-- **Aggregation:** {params.get('aggregation', 'max')}
+- **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:
@@ -194,6 +143,38 @@ class CreateUITestTool(BaseTool):
             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)}")
+            raise ToolException(f"Failed to create UI test: {str(e)}")

alita_sdk/tools/carrier/run_ui_test_tool.py

@@ -16,30 +16,32 @@ class RunUITestTool(BaseTool):
     name: str = "run_ui_test"
     description: str = ("Run and execute UI tests from the Carrier platform. Use this tool when user wants to run, execute, or start a UI test. "
                         "Provide either test ID or test name, or leave empty to see available tests. "
-                        "Optionally provide custom parameters like loops, cpu_quota, memory_quota, cloud_settings, or custom_cmd.")
+                        "When no custom parameters are provided, the tool will show default configuration and ask for confirmation. "
+                        "You can override parameters like cpu_quota, memory_quota, cloud_settings, custom_cmd, or loops. "
+                        )
     args_schema: Type[BaseModel] = create_model(
         "RunUITestInput",
         test_id=(str, Field(default="", description="Test ID to execute")),
         test_name=(str, Field(default="", description="Test name to execute")),
-        loops=(int, Field(default=None, description="Number of loops to run the test")),
         cpu_quota=(str, Field(default=None, description="CPU quota for the test runner")),
         memory_quota=(str, Field(default=None, description="Memory quota for the test runner")),
         cloud_settings=(str, Field(default=None, description="Cloud settings name for the test runner")),
         custom_cmd=(str, Field(default=None, description="Custom command to run with the test")),
+        loops=(str, Field(default=None, description="Number of loops to run the test")),
+        proceed_with_defaults=(bool, Field(default=False, description="Proceed with default configuration. True ONLY when user directly wants to run the test with default parameters." \
+        " If cpu_quota, memory_quota, cloud_settings, custom_cmd, or loops are provided, proceed_with_defaults must be False")),
     )
     
-    def _run(self, test_id: str = "", test_name: str = "", loops: int = None, 
+    def _run(self, test_id: str = "", test_name: str = "", 
              cpu_quota: str = None, memory_quota: str = None, 
-             cloud_settings: str = None, custom_cmd: str = None):
+             cloud_settings: str = None, custom_cmd: str = None, loops: str = None,
+             proceed_with_defaults: bool = False):
         try:
             # Check if neither test_id nor test_name is provided
             if (not test_id or test_id.strip() == "") and (not test_name or test_name.strip() == ""):
                 return self._missing_input_response()
-            
-            # Check if user wants to see the list of tests (can be in test_name field)
-            if test_name.lower() in ["show me the list of ui tests", "list ui tests", "show ui tests"]:
-                return self._show_ui_tests_list()
-              # Get UI tests list only when we need to search for and run a test
+              
+            # Get UI tests list only when we need to search for and run a test
             ui_tests = self.api_wrapper.get_ui_tests_list()
             
             # Find the test by ID or name
@@ -91,36 +93,81 @@ class RunUITestTool(BaseTool):
                 for test in ui_tests:
                     available_tests.append(f"ID: {test.get('id')}, Name: {test.get('name')}")
                 
+                available_locations = self._get_available_locations()
+                
                 search_criteria = []
                 if test_id:
                     search_criteria.append(f"ID: {test_id}")
                 if test_name:
                     search_criteria.append(f"Name: {test_name}")
                 
-                return f"Test not found for {' or '.join(search_criteria)}. Available UI tests:\n" + "\n".join(available_tests)
+                error_message = []
+                error_message.append(f"Test not found for {' or '.join(search_criteria)}.")
+                error_message.append("")
+                error_message.append("Available UI tests:")
+                error_message.extend(available_tests)
+                error_message.append("")
+                error_message.append("Available runners/locations:")
+                error_message.extend(available_locations)
+                
+                return "\n".join(error_message)
             
-            # Check if custom parameters are provided
-            has_custom_params = any([loops is not None, cpu_quota is not None, memory_quota is not None, 
-                                   cloud_settings is not None, custom_cmd is not None])
+            # Check if custom parameters are provided (including cloud_settings)
+            has_custom_params = any([cpu_quota is not None, memory_quota is not None, 
+                                   cloud_settings is not None, custom_cmd is not None, loops is not None])
             
-            # If no custom parameters provided, show info message with default values and available options
-            if not has_custom_params:
-                return self._show_test_parameter_info(test_data, ui_test_id)
-            
-            # Get detailed test configuration for the POST request
-            test_details = self._get_ui_test_details(ui_test_id)
+            if has_custom_params:
+                proceed_with_defaults = False  # If any custom params are provided, do not proceed with defaults
+
+            # Get detailed test configuration from API (not from UI tests list)
+            test_details = self.api_wrapper.get_ui_test_details(str(ui_test_id))
             
             if not test_details:
                 return f"Could not retrieve test details for test ID {ui_test_id}."
             
-            # Prepare POST request data with custom parameters
-            post_data = self._prepare_post_data_with_custom_params(test_details, loops, cpu_quota, memory_quota, cloud_settings, custom_cmd)
+            # Validate cloud_settings location if provided
+            if cloud_settings and not self._validate_cloud_settings_location(cloud_settings):
+                available_locations = self._get_available_locations()
+                error_message = []
+                error_message.append(f"❌ Invalid location/cloud_settings: '{cloud_settings}'")
+                error_message.append("")
+                error_message.append("Available runners/locations:")
+                error_message.extend(available_locations)
+                error_message.append("")
+                error_message.append("Please choose a valid location name from the list above.")
+                return "\n".join(error_message)
+            
+            # If no custom parameters provided, check if user wants to proceed with defaults
+            if not has_custom_params:
+                if not proceed_with_defaults:
+                    # Show default configuration and ask user if they want to change anything
+                    default_message = self._show_default_configuration_message(test_details)
+                    if isinstance(default_message, dict) and "message" in default_message:
+                        message_str = "\n".join(default_message["message"])
+                    else:
+                        message_str = str(default_message)
+                    return message_str + "\n\nTo proceed with default configuration, type `Run test with default configuration` or specify any parameters you want to override."
+                else:
+                    # User confirmed to proceed with defaults
+                    post_data = self._prepare_post_data_default(test_details)
+            else:
+                # Prepare POST request data with custom parameters or cloud settings
+                post_data = self._prepare_post_data_with_overrides(test_details, cpu_quota, memory_quota, cloud_settings, custom_cmd, loops)
             
             # Execute the UI test
             result_id = self.api_wrapper.run_ui_test(str(ui_test_id), post_data)
             
-            return f"UI test started successfully. Result ID: {result_id}. " \
-                   f"Link to report: {self.api_wrapper.url.rstrip('/')}/-/performance/ui/results?result_id={result_id}"
+            # Show location info in success message
+            location_used = "default"
+            if cloud_settings:
+                location_used = cloud_settings
+            elif post_data.get("common_params", {}).get("location"):
+                location_used = post_data["common_params"]["location"]
+            
+            return f"✅ UI test started successfully!\n" \
+                   f"Result ID: {result_id}\n" \
+                   f"Location used: {location_used}\n" \
+                   f"Link to report: {self.api_wrapper._client.credentials.url.rstrip('/')}/-/performance/ui/results?result_id={result_id}"
             
         except Exception:
             stacktrace = traceback.format_exc()
@@ -146,122 +193,95 @@ class RunUITestTool(BaseTool):
             logger.error(f"Error fetching UI tests list: {stacktrace}")
             raise ToolException(stacktrace)
     
-    def _get_ui_test_details(self, test_id: int):
-        """Get detailed test configuration from the UI tests list."""
+    def _prepare_post_data_default(self, test_details):
+        """Prepare POST request data with default parameters."""
         try:
-            ui_tests = self.api_wrapper.get_ui_tests_list()
+            # Extract values from the test details
+            test_parameters = test_details.get("test_parameters", [])
+            env_vars = test_details.get("env_vars", {})
+            integrations = test_details.get("integrations", {})
+            location = test_details.get("location", "")
+            parallel_runners = test_details.get("parallel_runners", 1)
+            aggregation = test_details.get("aggregation", "max")
+            loops = test_details.get("loops", 1)
             
-            for test in ui_tests:
-                if test.get("id") == test_id:
-                    return test
+            # Find specific test parameters by name
+            def find_param_by_name(params, name):
+                for param in params:
+                    if param.get("name") == name:
+                        return param
+                return {}
             
-            return None
+            # Extract S3 integration
+            s3_integration = integrations.get("system", {}).get("s3_integration", {})
             
-        except Exception:
-            stacktrace = traceback.format_exc()
-            logger.error(f"Error getting UI test details: {stacktrace}")
-            return None
-      
-    def _show_test_parameter_info(self, test_data, test_id):
-        """Show information about test parameters that can be changed."""
-        try:
-            # Get current default values from test data
-            env_vars = test_data.get("env_vars", {})
-            
-            info_message = []
-            info_message.append(f"Test '{test_data.get('name')}' (ID: {test_id}) found!")
-            info_message.append("\nCurrent default parameters:")
-            info_message.append(f"- loops: 1 (default override)")
-            info_message.append(f"- cpu_quota: {env_vars.get('cpu_quota', 'Not set')}")
-            info_message.append(f"- memory_quota: {env_vars.get('memory_quota', 'Not set')}")
-            info_message.append(f"- cloud_settings: {env_vars.get('cloud_settings', 'Not set')}")
-            info_message.append(f"- custom_cmd: {env_vars.get('custom_cmd', 'Not set')}")
-              # Always try to get and display available cloud settings - this is critical information
-            info_message.append("\n" + "="*60)
-            info_message.append("🏃 AVAILABLE RUNNERS - CHOOSE ONE FOR cloud_settings:")
-            info_message.append("="*60)
-            
-            try:
-                locations_data = self.api_wrapper.get_locations()
-                if not locations_data:
-                    info_message.append("⚠️  Could not fetch locations data - API returned empty response")
-                else:
-                    cloud_regions = locations_data.get("cloud_regions", [])
-                    public_regions = locations_data.get("public_regions", [])
-                    project_regions = locations_data.get("project_regions", [])
-                      # Add public regions information (these are the most commonly used)
-                    info_message.append("\n🌐 PUBLIC REGIONS (use these names):")
-                    if public_regions:
-                        for region in public_regions:
-                            info_message.append(f"  ✅ '{region}'")
-                    else:
-                        info_message.append("  ❌ No public regions available")
-                    
-                    # Add project regions information
-                    if project_regions:
-                        info_message.append("\n🏢 PROJECT REGIONS (use these names):")
-                        for region in project_regions:
-                            info_message.append(f"  ✅ '{region}'")
-                    
-                    # Add cloud regions information
-                    if cloud_regions:
-                        info_message.append("\n☁️  CLOUD REGIONS (advanced - use full names):")
-                        for region in cloud_regions:
-                            region_name = region.get("name", "Unknown")
-                            info_message.append(f"  ✅ '{region_name}'")
-                        
-            except Exception as e:
-                logger.error(f"Error fetching locations: {e}")
-                info_message.append("❌ ERROR: Could not fetch available runners!")
-                info_message.append(f"   Reason: {str(e)}")
-                info_message.append("   Please check your API connection and try again.")
-            
-            info_message.append("="*60)            
-            info_message.append("\n📋 HOW TO USE:")
-            info_message.append("To run this test with custom parameters, specify the values you want to change.")
-            info_message.append("\n💡 EXAMPLES:")
-            info_message.append("  • Use default runner: cloud_settings='default'")
-            info_message.append("  • Change loops: loops=5")
-            info_message.append("  • Change resources: cpu_quota='2', memory_quota='4Gi'")
-            info_message.append("  • Full example: loops=3, cloud_settings='default', cpu_quota='2'")
-            info_message.append("\n📝 RUNNER TYPES:")
-            info_message.append("  • Public regions: Use empty cloud_settings {}, location = runner name")
-            info_message.append("  • Project regions: Use empty cloud_settings {}, location = runner name") 
-            info_message.append("  • Cloud regions: Use full cloud configuration object")
-            
-            return "\n".join(info_message)
+            # Get actual cloud_settings from test details (could be empty {} or have actual settings)
+            actual_cloud_settings = env_vars.get("cloud_settings", {})
+            
+            # Prepare the POST request body with default parameters
+            post_data = {
+                "common_params": {
+                    "name": find_param_by_name(test_parameters, "test_name"),
+                    "test_type": find_param_by_name(test_parameters, "test_type"),
+                    "env_type": find_param_by_name(test_parameters, "env_type"),
+                    "env_vars": {
+                        "cpu_quota": env_vars.get("cpu_quota"),
+                        "memory_quota": env_vars.get("memory_quota"),
+                        "cloud_settings": actual_cloud_settings,  # Use actual cloud settings from test details
+                        "ENV": env_vars.get("ENV", "prod"),
+                        "custom_cmd": env_vars.get("custom_cmd", "")
+                    },
+                    "parallel_runners": parallel_runners,
+                    "location": location
+                },
+                "test_parameters": test_parameters,
+                "integrations": {
+                    "system": {
+                        "s3_integration": {
+                            "integration_id": s3_integration.get("integration_id"),
+                            "is_local": s3_integration.get("is_local")
+                        }
+                    }
+                },
+                "loops": loops,
+                "aggregation": aggregation
+            }
+            
+            return post_data
             
         except Exception:
             stacktrace = traceback.format_exc()
-            logger.error(f"Error showing test parameter info: {stacktrace}")
+            logger.error(f"Error preparing default POST data: {stacktrace}")
             raise ToolException(stacktrace)
-    
-    def _prepare_post_data_with_custom_params(self, test_data, loops=None, cpu_quota=None, 
-                                            memory_quota=None, cloud_settings=None, custom_cmd=None):
-        """Prepare POST request data with custom parameters."""
+
+    def _prepare_post_data_with_overrides(self, test_details, cpu_quota=None, 
+                                         memory_quota=None, cloud_settings=None, custom_cmd=None, loops=None):
+        """Prepare POST request data with overrides or cloud settings."""
         try:
-            # Extract values from the test data
-            test_parameters = test_data.get("test_parameters", [])
-            env_vars = test_data.get("env_vars", {})
-            integrations = test_data.get("integrations", {})
-            location = test_data.get("location", "")
-            parallel_runners = test_data.get("parallel_runners", 1)
-            aggregation = test_data.get("aggregation", "max")
+            # Extract values from the test details
+            test_parameters = test_details.get("test_parameters", [])
+            env_vars = test_details.get("env_vars", {})
+            integrations = test_details.get("integrations", {})
+            location = test_details.get("location", "")
+            parallel_runners = test_details.get("parallel_runners", 1)
+            aggregation = test_details.get("aggregation", "max")
+            default_loops = test_details.get("loops", 1)
+            # Use provided loops parameter or default
+            final_loops = loops if loops is not None else default_loops
             
-            # Extract reporter email for integrations
-            reporter_email = integrations.get("reporters", {}).get("reporter_email", {})
-            
-            # Extract S3 integration
-            s3_integration = integrations.get("system", {}).get("s3_integration", {})
-              # Find specific test parameters by name
+            # Find specific test parameters by name
             def find_param_by_name(params, name):
                 for param in params:
                     if param.get("name") == name:
                         return param
-                return {}            
-            # Handle cloud_settings parameter and location
-            final_cloud_settings = env_vars.get("cloud_settings")
-            final_location = location  # Use original location as default
+                return {}
+            
+            # Extract S3 integration
+            s3_integration = integrations.get("system", {}).get("s3_integration", {})
+            
+            # Handle cloud_settings parameter and determine the scenario
+            final_cloud_settings = {}
+            final_location = location
             
             if cloud_settings:
                 try:
@@ -270,65 +290,59 @@ class RunUITestTool(BaseTool):
                     public_regions = locations_data.get("public_regions", [])
                     project_regions = locations_data.get("project_regions", [])
                     
-                    # Check if it's a public region first
-                    if cloud_settings in public_regions:
-                        # For public regions, use empty cloud_settings and set location to the runner name
-                        final_cloud_settings = {}
-                        final_location = cloud_settings
-                    # Check if it's a project region
-                    elif cloud_settings in project_regions:
-                        # For project regions, use empty cloud_settings and set location to the runner name
+                    # Check if it's a public or project region (scenario 1)
+                    if cloud_settings in public_regions or cloud_settings in project_regions:
+                        # For public/project regions, use empty cloud_settings and set location
                         final_cloud_settings = {}
                         final_location = cloud_settings
                     else:
-                        # Try to find exact match in cloud regions
-                        found_match = False
+                        # Check if it's a cloud region (scenario 2)
+                        found_cloud_region = None
                         for region in cloud_regions:
                             if region.get("name", "").lower() == cloud_settings.lower():
-                                # Get the complete cloud_settings object and add the missing fields
-                                region_cloud_settings = region.get("cloud_settings", {})
-                                # Add the additional fields that are expected in the POST request
-                                region_cloud_settings.update({
-                                    "instance_type": "on-demand",
-                                    "ec2_instance_type": "t2.xlarge", 
-                                    "cpu_cores_limit": int(cpu_quota) if cpu_quota else env_vars.get("cpu_quota", 1),
-                                    "memory_limit": int(memory_quota) if memory_quota else env_vars.get("memory_quota", 8),
-                                    "concurrency": 1
-                                })
-                                final_cloud_settings = region_cloud_settings
-                                final_location = location  # Keep original location for cloud regions
-                                found_match = True
+                                found_cloud_region = region
                                 break
                         
-                        # If no exact match in cloud regions, try partial match
-                        if not found_match:
+                        # If not exact match, try partial match
+                        if not found_cloud_region:
                             for region in cloud_regions:
                                 if cloud_settings.lower() in region.get("name", "").lower():
-                                    region_cloud_settings = region.get("cloud_settings", {})
-                                    region_cloud_settings.update({
-                                        "instance_type": "on-demand",
-                                        "ec2_instance_type": "t2.xlarge",
-                                        "cpu_cores_limit": int(cpu_quota) if cpu_quota else env_vars.get("cpu_quota", 1),
-                                        "memory_limit": int(memory_quota) if memory_quota else env_vars.get("memory_quota", 8),
-                                        "concurrency": 1
-                                    })
-                                    final_cloud_settings = region_cloud_settings
-                                    final_location = location  # Keep original location for cloud regions
-                                    found_match = True
+                                    found_cloud_region = region
                                     break
                         
-                        # If still no match found, treat as public region fallback
-                        if not found_match:
+                        if found_cloud_region:
+                            # Extract cloud settings details for scenario 2
+                            # cloud_name = found_cloud_region.get("name", "")
+                            cloud_config = found_cloud_region.get("cloud_settings", {})
+                            final_cloud_settings = {
+                                "integration_name": cloud_config.get("integration_name"),
+                                "id": cloud_config.get("id"),
+                                "project_id": cloud_config.get("project_id"),
+                                "aws_access_key": cloud_config.get("aws_access_key"),
+                                "aws_secret_access_key": cloud_config.get("aws_secret_access_key", {}),
+                                "region_name": cloud_config.get("region_name"),
+                                "security_groups": cloud_config.get("security_groups"),
+                                "image_id": cloud_config.get("image_id"),
+                                "key_name": cloud_config.get("key_name", ""),
+                                "instance_type": "spot",
+                                "ec2_instance_type": "t2.xlarge"
+                            }
+                            final_location = found_cloud_region.get("name")
+                        else:
+                            # If no match found, treat as public region fallback
                             final_cloud_settings = {}
                             final_location = cloud_settings
                             
                 except Exception as e:
                     logger.error(f"Error processing cloud_settings: {e}")
-                    # Use the provided value as-is if we can't process it
-                    final_cloud_settings = cloud_settings
-                    final_location = location
-            
-            # Prepare the POST request body with custom parameters
+                    # Use empty cloud_settings as fallback
+                    final_cloud_settings = {}
+                    final_location = cloud_settings if cloud_settings else location
+            else:
+                # If no cloud_settings provided, use default from test details
+                final_cloud_settings = env_vars.get("cloud_settings", {})
+
+            # Prepare the POST request body with overrides
             post_data = {
                 "common_params": {
                     "name": find_param_by_name(test_parameters, "test_name"),
@@ -338,21 +352,14 @@ class RunUITestTool(BaseTool):
                         "cpu_quota": cpu_quota if cpu_quota is not None else env_vars.get("cpu_quota"),
                         "memory_quota": memory_quota if memory_quota is not None else env_vars.get("memory_quota"),
                         "cloud_settings": final_cloud_settings,
-                        "ENV": "prod",  # Override as per reference code
+                        "ENV": env_vars.get("ENV", "prod"),
                         "custom_cmd": custom_cmd if custom_cmd is not None else env_vars.get("custom_cmd", "")
-                    },                    "parallel_runners": parallel_runners,
+                    },
+                    "parallel_runners": parallel_runners,
                     "location": final_location
                 },
                 "test_parameters": test_parameters,
                 "integrations": {
-                    "reporters": {
-                        "reporter_email": {
-                            "id": reporter_email.get("id"),
-                            "is_local": reporter_email.get("is_local"),
-                            "project_id": reporter_email.get("project_id"),
-                            "recipients": reporter_email.get("recipients")
-                        }
-                    },
                     "system": {
                         "s3_integration": {
                             "integration_id": s3_integration.get("integration_id"),
@@ -360,7 +367,7 @@ class RunUITestTool(BaseTool):
                         }
                     }
                 },
-                "loops": loops if loops is not None else 1,  # Use custom loops or default to 1
+                "loops": final_loops,
                 "aggregation": aggregation
             }
             
@@ -368,20 +375,29 @@ class RunUITestTool(BaseTool):
             
         except Exception:
             stacktrace = traceback.format_exc()
-            logger.error(f"Error preparing POST data with custom parameters: {stacktrace}")
+            logger.error(f"Error preparing POST data with overrides: {stacktrace}")
             raise ToolException(stacktrace)
 
     def _missing_input_response(self):
         """Response when required input is missing."""
         try:
             available_tests = self._show_ui_tests_list()
+            available_locations = self._get_available_locations()
+            
+            location_info = "Available runners/locations for cloud_settings:\n" + "\n".join(available_locations)
+            
             return {
-                "message": "Please provide test ID or test name of your UI test.",
+                "message": {
+                    "text": (
+                        "Please provide test ID or test name of your UI test.\n\n"
+                        "Available UI tests:\n" + available_tests + "\n\n"
+                        "Available runners/locations for cloud_settings:\n" + location_info
+                    ),
+                },
                 "parameters": {
                     "test_id": None,
                     "test_name": None,
-                },
-                "available_tests": available_tests
+                }
             }
         except Exception:
             return {
@@ -390,5 +406,116 @@ class RunUITestTool(BaseTool):
                     "test_id": None,
                     "test_name": None,
                 },
-                "available_tests": "Error fetching available tests."
+                "available_tests": "Error fetching available tests.",
+                "available_locations": "Error fetching available locations."
             }
+    
+    def _show_default_configuration_message(self, test_details):
+        """Show information about default configuration and available override parameters."""
+        try:
+            env_vars = test_details.get("env_vars", {})
+            test_name = test_details.get("name", "Unknown")
+            loops = test_details.get("loops", 1)
+            
+            # Get available locations
+            available_locations = self._get_available_locations()
+            
+            message = []
+            message.append("Current default parameters:")
+            message.append(f"  • CPU Quota: {env_vars.get('cpu_quota', 'Not set')}")
+            message.append(f"  • Memory Quota: {env_vars.get('memory_quota', 'Not set')}")
+            message.append(f"  • Custom Command: {env_vars.get('custom_cmd', 'Not set')}")
+            message.append(f"  • Loops: {loops}")
+            message.append(f"  • Cloud Settings: Default location")
+            message.append("")
+            message.append("Available parameters to override:")
+            message.append("  • cpu_quota - Set CPU quota for the test runner")
+            message.append("  • memory_quota - Set memory quota for the test runner")
+            message.append("  • custom_cmd - Set custom command to run with the test")
+            message.append("  • loops - Set number of loops to run the test")
+            message.append("  • cloud_settings - Set cloud settings name for the test runner")
+            message.append("")
+            message.append("Available runners/locations:")
+            message.extend(available_locations)
+            
+            return {"message": message}
+            
+        except Exception:
+            stacktrace = traceback.format_exc()
+            logger.error(f"Error showing default configuration: {stacktrace}")
+            return "Default configuration available for this test."
+    
+    def _get_available_locations(self):
+        """Get formatted list of available locations for user selection."""
+        try:
+            locations_data = self.api_wrapper.get_locations()
+            location_list = []
+            
+            # Add public regions
+            public_regions = locations_data.get("public_regions", [])
+            if public_regions:
+                location_list.append("  Public Regions:")
+                for region in public_regions:
+                    location_list.append(f"    - {region}")
+            
+            # Add project regions
+            project_regions = locations_data.get("project_regions", [])
+            if project_regions:
+                location_list.append("  Project Regions:")
+                for region in project_regions:
+                    location_list.append(f"    - {region}")
+            
+            # Add cloud regions
+            cloud_regions = locations_data.get("cloud_regions", [])
+            if cloud_regions:
+                location_list.append("  Cloud Regions:")
+                for region in cloud_regions:
+                    region_name = region.get("name", "Unknown")
+                    cloud_config = region.get("cloud_settings", {})
+                    aws_region = cloud_config.get("region_name", "")
+                    location_list.append(f"    - {region_name} ({aws_region})")
+            
+            if not location_list:
+                location_list.append("  No locations available")
+                
+            return location_list
+            
+        except Exception:
+            stacktrace = traceback.format_exc()
+            logger.error(f"Error getting available locations: {stacktrace}")
+            return ["  Error loading locations"]
+
+    def _validate_cloud_settings_location(self, cloud_settings):
+        """Validate if the provided cloud_settings location exists and is available."""
+        try:
+            if not cloud_settings:
+                return True  # No cloud_settings provided, use default
+                
+            locations_data = self.api_wrapper.get_locations()
+            
+            # Check in public regions
+            public_regions = locations_data.get("public_regions", [])
+            if cloud_settings in public_regions:
+                return True
+            
+            # Check in project regions
+            project_regions = locations_data.get("project_regions", [])
+            if cloud_settings in project_regions:
+                return True
+            
+            # Check in cloud regions (by name)
+            cloud_regions = locations_data.get("cloud_regions", [])
+            for region in cloud_regions:
+                region_name = region.get("name", "")
+                if region_name.lower() == cloud_settings.lower():
+                    return True
+                # Also check partial match
+                if cloud_settings.lower() in region_name.lower():
+                    return True
+            
+            return False
+            
+        except Exception:
+            stacktrace = traceback.format_exc()
+            logger.error(f"Error validating cloud settings location: {stacktrace}")
+            return True  # Allow execution if validation fails

alita_sdk/tools/confluence/api_wrapper.py

@@ -1507,6 +1507,7 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
                         'application/doc',  'application/docx',
                         'application/xls', 'application/xlsx',
                         'application/svg', 'application/html',
+                        'application/octet-stream'
                     ]
                     or file_ext in [
                         'xml', 'json', 'md', 'markdown', 'txt',

{alita_sdk-0.3.175.dist-info → alita_sdk-0.3.176.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.175
+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.175.dist-info → alita_sdk-0.3.176.dist-info}/RECORD

@@ -166,10 +166,10 @@ alita_sdk/tools/carrier/backend_tests_tool.py,sha256=Y1Va-VxDtnbRvrEdlwe63t-oDvq
 alita_sdk/tools/carrier/cancel_ui_test_tool.py,sha256=pD1sKEcZGBWJqFpgjeohMk93uuUPWruVJRPVVg90rpo,6438
 alita_sdk/tools/carrier/carrier_sdk.py,sha256=wb3d1W6dvo5NRLMiJcBcKy663J6IkbTwpKFTZX30QFQ,13672
 alita_sdk/tools/carrier/create_ui_excel_report_tool.py,sha256=8aSpkyIGXsOBTo8Ye_6p19v8OOl1y7QW47IJxZ6QDgM,20163
-alita_sdk/tools/carrier/create_ui_test_tool.py,sha256=sHi7-D1uqIUHEyoywI92h6MdUVybKfBXs_XttTu-Ck4,8624
+alita_sdk/tools/carrier/create_ui_test_tool.py,sha256=knKvPOo9usI2XHqZtcbBEBzKwB9tS7GEl9KIX78vJiA,8184
 alita_sdk/tools/carrier/excel_reporter.py,sha256=fXptz7iaBDBcFSc8Ah8nZ9CSgugTONc5JMC1XcQEnfM,21487
 alita_sdk/tools/carrier/lighthouse_excel_reporter.py,sha256=mVuU63tl2n-Gntx9RuedjEU0U5AP1APKsSx1DvJs7wk,6684
-alita_sdk/tools/carrier/run_ui_test_tool.py,sha256=vmEtP-cpnOCyLLZfbw9Nq2ItGUFlcnsf1LmI_XyLrM8,21053
+alita_sdk/tools/carrier/run_ui_test_tool.py,sha256=Wqfxi_jyOU6XxYGsTje2ftgm8O7PJRXRDHUwWcw8opM,26277
 alita_sdk/tools/carrier/tickets_tool.py,sha256=d-wFyFWWTvV01o-hyssb2S-oLnr51b6tlNTUqA_CohY,8099
 alita_sdk/tools/carrier/tools.py,sha256=cCLYcNzC_z0-AaqB46fyt7iOeP20LStVQKI5Dg1zWA4,1588
 alita_sdk/tools/carrier/ui_reports_tool.py,sha256=Y6EstTRCa9d11ipFUFGOYlpiEhFx7aOQcgZ_M5Gd1lQ,13708
@@ -217,7 +217,7 @@ alita_sdk/tools/code/loaders/codesearcher.py,sha256=XoXXZtIQZhvjIwZlnl_4wVGHC-3s
 alita_sdk/tools/code/sonar/__init__.py,sha256=u8wpgXJ_shToLl3G9-XEtGDor5dhmsnurIImh1-e-U0,3165
 alita_sdk/tools/code/sonar/api_wrapper.py,sha256=nNqxcWN_6W8c0ckj-Er9HkNuAdgQLoWBXh5UyzNutis,2653
 alita_sdk/tools/confluence/__init__.py,sha256=1wGSP4CjPbfpdZLsjC1SVftTV7XSvW3QCAMHuh9tIxA,6885
-alita_sdk/tools/confluence/api_wrapper.py,sha256=nCU4wAh3f6EN3NVXya3BVZQX47mi7JYAzylxJJOvMMc,88725
+alita_sdk/tools/confluence/api_wrapper.py,sha256=zP8S85oVulhqrom1wlgelN-TSuKtPuYxwwGAlOSn_I0,88776
 alita_sdk/tools/confluence/loader.py,sha256=aHqgdIQMqkyRry8feHAhyd-a_ASEyW3JrV6epTRG6-c,9162
 alita_sdk/tools/confluence/utils.py,sha256=Lxo6dBD0OlvM4o0JuK6qeB_4LV9BptiwJA9e1vqNcDw,435
 alita_sdk/tools/custom_open_api/__init__.py,sha256=9aT5SPNPWcJC6jMZEM-3rUCXVULj_3-qJLQKmnreKNo,2537
@@ -326,8 +326,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=UHVQUVqcBc3SZvDfO78HSuBzwAsRw
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=rq4jOb3lRW2GXvAguk4H1KinO5f-zpygzhBJf-E1Ucw,2773
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=iOMxyE7vOc_LwFB_nBMiSFXkNtvbptA4i-BrTlo7M0A,5854
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=IYUJoMFOMA70knLhLtAnuGoy3OK80RuqeQZ710oyIxE,3631
-alita_sdk-0.3.175.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.175.dist-info/METADATA,sha256=3ecYvmsESpDa4HnPLjEW0y_G05ofONK9nPClKYPNah4,18757
-alita_sdk-0.3.175.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.175.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.175.dist-info/RECORD,,
+alita_sdk-0.3.176.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.176.dist-info/METADATA,sha256=0TeMFPCFp22pMbxrY1OgvQt-GhpOzAZwNVhvhw17Wcw,18810
+alita_sdk-0.3.176.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.176.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.176.dist-info/RECORD,,