alita-sdk 0.3.175__py3-none-any.whl → 0.3.177__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)}")