alita-sdk 0.3.435__py3-none-any.whl → 0.3.457__py3-none-any.whl

alita_sdk/tools/google_places/__init__.py

@@ -30,7 +30,7 @@ class GooglePlacesToolkit(BaseToolkit):
         GooglePlacesToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            results_count=(Optional[int], Field(description="Results number to show", default=None, json_schema_extra={'toolkit_name': True, 'max_toolkit_length': GooglePlacesToolkit.toolkit_max_length})),
+            results_count=(Optional[int], Field(description="Results number to show", default=None)),
             google_places_configuration=(GooglePlacesConfiguration, Field(description="Google Places Configuration", json_schema_extra={'configuration_types': ['google_places']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra=
@@ -38,6 +38,7 @@ class GooglePlacesToolkit(BaseToolkit):
                                       'metadata':
                                           {
                                               "label": "Google Places", "icon_url": "gplaces-icon.svg",
+                                              "max_length": GooglePlacesToolkit.toolkit_max_length,
                                               "categories": ["other"],
                                               "extra_categories": ["google", "places", "maps", "location",
                                                                    "geolocation"],

alita_sdk/tools/jira/__init__.py

@@ -89,6 +89,7 @@ class JiraToolkit(BaseToolkit):
                 'metadata': {
                     "label": "Jira",
                     "icon_url": "jira-icon.svg",
+                    "max_length": JiraToolkit.toolkit_max_length,
                     "categories": ["project management"],
                     "extra_categories": ["jira", "atlassian", "issue tracking", "project management", "task management"],
                 }

alita_sdk/tools/memory/__init__.py

@@ -61,7 +61,7 @@ class MemoryToolkit(BaseToolkit):
 
         return create_model(
             'memory',
-            namespace=(str, Field(description="Memory namespace", json_schema_extra={'toolkit_name': True})),
+            namespace=(str, Field(description="Memory namespace")),
             pgvector_configuration=(PgVectorConfiguration, Field(description="PgVector Configuration",
                                                                            json_schema_extra={
                                                                                'configuration_types': ['pgvector']})),

alita_sdk/tools/pandas/__init__.py

@@ -29,7 +29,7 @@ class PandasToolkit(BaseToolkit):
         PandasToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            bucket_name=(str, Field(default=None, title="Bucket name", description="Bucket where the content file is stored", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': PandasToolkit.toolkit_max_length})),
+            bucket_name=(str, Field(default=None, title="Bucket name", description="Bucket where the content file is stored")),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Pandas", "icon_url": "pandas-icon.svg",
                                                                   "categories": ["analysis"],

alita_sdk/tools/postman/__init__.py

@@ -62,7 +62,8 @@ class PostmanToolkit(BaseToolkit):
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(
                 default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {
-                                  "label": "Postman", "icon_url": "postman.svg"}})
+                                  "label": "Postman", "icon_url": "postman.svg",
+                "max_length": PostmanToolkit.toolkit_max_length,}})
         )
 
         @check_connection_response

alita_sdk/tools/pptx/__init__.py

@@ -45,13 +45,13 @@ class PPTXToolkit(BaseToolkit):
         
         return create_model(
             name,
-            bucket_name=(str, Field(description="Bucket name where PPTX files are stored", 
-                                   json_schema_extra={'toolkit_name': True, 'max_toolkit_length': TOOLKIT_MAX_LENGTH})),
+            bucket_name=(str, Field(description="Bucket name where PPTX files are stored")),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {
                     "label": "PPTX",
                     "icon_url": "pptx.svg",
+                    "max_length": TOOLKIT_MAX_LENGTH,
                     "categories": ["office"],
                     "extra_categories": ["presentation", "office automation", "document"]
                 }

alita_sdk/tools/qtest/__init__.py

@@ -37,14 +37,14 @@ class QtestToolkit(BaseToolkit):
             name,
             qtest_configuration=(QtestConfiguration, Field(description="QTest API token", json_schema_extra={
                 'configuration_types': ['qtest']})),
-            qtest_project_id=(int, Field(default=None, description="QTest project id", json_schema_extra={'toolkit_name': True,
-                                                                                            'max_toolkit_length': QtestToolkit.toolkit_max_length})),
+            qtest_project_id=(int, Field(default=None, description="QTest project id")),
             no_of_tests_shown_in_dql_search=(Optional[int], Field(description="Max number of items returned by dql search",
                                                                   default=10)),
 
         selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "QTest", "icon_url": "qtest.svg",
+                                                                  "max_length": QtestToolkit.toolkit_max_length,
                                                                   "categories": ["test management"],
                                                                   "extra_categories": ["quality assurance",
                                                                                        "test case management",
@@ -93,4 +93,4 @@ class QtestToolkit(BaseToolkit):
         return cls(tools=tools)
 
     def get_tools(self):
-        return self.tools
+        return self.tools

alita_sdk/tools/qtest/api_wrapper.py

@@ -5,6 +5,7 @@ import re
 from traceback import format_exc
 from typing import Any, Optional
 
+import requests
 import swagger_client
 from langchain_core.tools import ToolException
 from pydantic import Field, PrivateAttr, model_validator, create_model, SecretStr
@@ -48,6 +49,11 @@ Steps: Array of test steps with Description and Expected Result.
 - Single value: "Team": "Epam"
 - Multiple values: "Team": ["Epam", "EJ"]
 
+**Clearing/Unsetting fields**: To clear a field value (unassign, set to empty/blank):
+- Use `null` in JSON: "Priority": null
+- Works for multi-select fields, user assignments, etc. (Note: single-select dropdowns have API limitations)
+- Example: {{"QTest Id": "4626964", "Assigned To": null, "Review status": null}}
+
 **For Updates**: Include only the fields you want to modify. The system will validate property values against project configuration.
 
 ### EXAMPLE
@@ -142,6 +148,12 @@ GetAllTestCasesFieldsForProject = create_model(
                          default=False)),
 )
 
+FindTestCasesByRequirementId = create_model(
+    "FindTestCasesByRequirementId",
+    requirement_id=(str, Field(description="QTest requirement ID in format RQ-123. This will find all test cases linked to this requirement.")),
+    include_details=(Optional[bool], Field(description="If true, returns full test case details. If false (default), returns Id, QTest Id, Name, and Description fields.", default=False)),
+)
+
 NoInput = create_model(
     "NoInput"
 )
@@ -155,6 +167,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
     no_of_tests_shown_in_dql_search: int = 10
     _client: Any = PrivateAttr()
     _field_definitions_cache: Optional[dict] = PrivateAttr(default=None)
+    _modules_cache: Optional[list] = PrivateAttr(default=None)
     llm: Any
 
     @model_validator(mode='before')
@@ -256,9 +269,41 @@ class QtestApiWrapper(BaseToolApiWrapper):
             # Skip non-property fields (these are handled separately)
             if field_name in ['Name', 'Description', 'Precondition', 'Steps', 'Id', QTEST_ID]:
                 continue
-            
-            # Skip None or empty string values (don't update these fields)
-            if field_value is None or field_value == '':
+
+            # Skip empty string values (don't update these fields)
+            if field_value == '':
+                continue
+
+            # Handle None value - this means "clear/unset this field"
+            if field_value is None:
+                # Validate field exists before attempting to clear
+                if field_name not in field_definitions:
+                    validation_errors.append(
+                        f"❌ Unknown field '{field_name}' - not defined in project configuration"
+                    )
+                    continue
+
+                field_def = field_definitions[field_name]
+                field_id = field_def['field_id']
+                is_multiple = field_def.get('multiple', False)
+
+                if is_multiple:
+                    # Multi-select/user fields: can clear using empty array "[]"
+                    props_dict[field_name] = {
+                        'field_id': field_id,
+                        'field_name': field_name,
+                        'field_value': "[]",
+                        'field_value_name': None
+                    }
+                else:
+                    # Single-select fields: QTest API limitation - cannot clear to empty
+                    # Note: Users CAN clear these fields from UI, but API doesn't expose this capability
+                    validation_errors.append(
+                        f"⚠️ Cannot clear single-select field '{field_name}' - this is a QTest API limitation "
+                        f"(clearing is possible from UI but not exposed via API). "
+                        f"Please select an alternative value instead. "
+                        f"Available values: {', '.join(field_def.get('values', {}).keys()) or 'none'}"
+                    )
                 continue
             
             # Validate field exists in project - STRICT validation
@@ -414,6 +459,143 @@ class QtestApiWrapper(BaseToolApiWrapper):
                                 Exception: \n {stacktrace}""")
         return modules
 
+    def __get_field_definitions_from_properties_api(self) -> dict:
+        """
+        Fallback method: Get field definitions using /properties and /properties-info APIs.
+        
+        These APIs don't require Field Management permission and are available to all users.
+        Requires 2 API calls + 1 search to get a test case ID.
+        
+        Returns:
+            dict: Same structure as __get_project_field_definitions()
+        """
+        logger.info(
+            "Using properties API fallback (no Field Management permission). "
+            "This requires getting a template test case first."
+        )
+        
+        # Step 1: Get any test case ID to query properties
+        search_instance = swagger_client.SearchApi(self._client)
+        body = swagger_client.ArtifactSearchParams(
+            object_type='test-cases',
+            fields=['*'],
+            query=''  # Empty query returns all test cases
+        )
+        
+        try:
+            # Search for any test case - just need one
+            response = search_instance.search_artifact(
+                self.qtest_project_id,
+                body,
+                page_size=1,
+                page=1
+            )
+        except ApiException as e:
+            stacktrace = format_exc()
+            logger.error(f"Failed to find test case for properties API: {stacktrace}")
+            raise ValueError(
+                f"Cannot find any test case to query field definitions. "
+                f"Please create at least one test case in project {self.qtest_project_id}"
+            ) from e
+        
+        if not response or not response.get('items') or len(response['items']) == 0:
+            raise ValueError(
+                f"No test cases found in project {self.qtest_project_id}. "
+                f"Please create at least one test case to retrieve field definitions."
+            )
+        
+        test_case_id = response['items'][0]['id']
+        logger.info(f"Using test case ID {test_case_id} to retrieve field definitions")
+        
+        # Step 2: Call /properties API
+        headers = {
+            "Authorization": f"Bearer {self.qtest_api_token.get_secret_value()}"
+        }
+        
+        properties_url = f"{self.base_url}/api/v3/projects/{self.qtest_project_id}/test-cases/{test_case_id}/properties"
+        properties_info_url = f"{self.base_url}/api/v3/projects/{self.qtest_project_id}/test-cases/{test_case_id}/properties-info"
+        
+        try:
+            # Get properties with current values and field metadata
+            props_response = requests.get(
+                properties_url,
+                headers=headers,
+                params={'calledBy': 'testcase_properties'}
+            )
+            props_response.raise_for_status()
+            properties_data = props_response.json()
+            
+            # Get properties-info with data types and allowed values
+            info_response = requests.get(properties_info_url, headers=headers)
+            info_response.raise_for_status()
+            info_data = info_response.json()
+            
+        except requests.exceptions.RequestException as e:
+            stacktrace = format_exc()
+            logger.error(f"Failed to call properties API: {stacktrace}")
+            raise ValueError(
+                f"Unable to retrieve field definitions using properties API. "
+                f"Error: {stacktrace}"
+            ) from e
+        
+        # Step 3: Build field mapping by merging both responses
+        field_mapping = {}
+        
+        # Create lookup by field ID from properties-info
+        metadata_by_id = {item['id']: item for item in info_data['metadata']}
+        
+        # Data type mapping to determine 'multiple' flag
+        MULTI_SELECT_TYPES = {
+            'UserListDataType',
+            'MultiSelectionDataType',
+            'CheckListDataType'
+        }
+        
+        USER_FIELD_TYPES = {'UserListDataType'}
+        
+        # System fields to exclude (same as in property mapping)
+        excluded_fields = {'Shared', 'Projects Shared to'}
+        
+        for prop in properties_data:
+            field_name = prop.get('name')
+            field_id = prop.get('id')
+            
+            if not field_name or field_name in excluded_fields:
+                continue
+            
+            # Get metadata for this field
+            metadata = metadata_by_id.get(field_id, {})
+            data_type_str = metadata.get('data_type')
+            
+            # Determine data_type number (5 for user fields, None for others)
+            data_type = 5 if data_type_str in USER_FIELD_TYPES else None
+            
+            # Determine if multi-select
+            is_multiple = data_type_str in MULTI_SELECT_TYPES
+            
+            field_mapping[field_name] = {
+                'field_id': field_id,
+                'required': prop.get('required', False),
+                'data_type': data_type,
+                'multiple': is_multiple,
+                'values': {}
+            }
+            
+            # Map allowed values from metadata
+            allowed_values = metadata.get('allowed_values', [])
+            for allowed_val in allowed_values:
+                value_text = allowed_val.get('value_text')
+                value_id = allowed_val.get('id')
+                if value_text and value_id:
+                    field_mapping[field_name]['values'][value_text] = value_id
+        
+        logger.info(
+            f"Retrieved {len(field_mapping)} field definitions using properties API. "
+            f"This method works for all users without Field Management permission."
+        )
+        
+        return field_mapping
+
     def __get_project_field_definitions(self) -> dict:
         """
         Get structured field definitions for test cases in the project.
@@ -439,6 +621,15 @@ class QtestApiWrapper(BaseToolApiWrapper):
         try:
             fields = fields_api.get_fields(self.qtest_project_id, qtest_object)
         except ApiException as e:
+            # Check if permission denied (403) - use fallback
+            if e.status == 403:
+                logger.warning(
+                    "get_fields permission denied (Field Management permission required). "
+                    "Using properties API fallback..."
+                )
+                return self.__get_field_definitions_from_properties_api()
+            
+            # Other API errors
             stacktrace = format_exc()
             logger.error(f"Exception when calling FieldAPI->get_fields:\n {stacktrace}")
             raise ValueError(
@@ -517,6 +708,10 @@ class QtestApiWrapper(BaseToolApiWrapper):
         return self.__format_field_info_for_display(field_defs)
 
     def _parse_modules(self) -> list[dict]:
+        """Get parsed modules list with caching for the session."""
+        if self._modules_cache is not None:
+            return self._modules_cache
+        
         modules = self.__get_all_modules_for_project()
         result = []
 
@@ -537,6 +732,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
         for module in modules:
             parse_module(module)
 
+        self._modules_cache = result
         return result
 
     def __execute_single_create_test_case_request(self, test_case_api_instance: TestCaseApi, body,
@@ -556,8 +752,8 @@ class QtestApiWrapper(BaseToolApiWrapper):
     def __parse_data(self, response_to_parse: dict, parsed_data: list, extract_images: bool=False, prompt: str=None):
         import html
         
-        # Get field definitions to ensure all fields are included (uses cached version)
-        field_definitions = self.__get_field_definitions_cached()
+        # PERMISSION-FREE: Parse properties directly from API response
+        # No get_fields call needed - works for all users
         
         for item in response_to_parse['items']:
             # Start with core fields (always present)
@@ -574,29 +770,15 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 }, enumerate(item['test_steps']))),
             }
             
-            # Dynamically add all custom fields from project configuration
-            # This ensures consistency and includes fields even if they have null/empty values
-            for field_name in field_definitions.keys():
-                field_def = field_definitions[field_name]
-                is_multiple = field_def.get('multiple', False)
-                
-                # Find the property value in the response (if exists)
-                field_value = None
-                for prop in item['properties']:
-                    if prop['field_name'] == field_name:
-                        # Use field_value_name if available (for dropdowns), otherwise field_value
-                        field_value = prop.get('field_value_name') or prop.get('field_value') or ''
-                        break
-                
-                # Format based on field type
-                if is_multiple and (field_value is None or field_value == ''):
-                    # Multi-select field with no value: show empty array with hint
-                    parsed_data_row[field_name] = '[] (multi-select)'
-                elif field_value is not None:
-                    parsed_data_row[field_name] = field_value
-                else:
-                    # Regular field with no value
-                    parsed_data_row[field_name] = ''
+            # Add custom fields directly from API response properties
+            for prop in item['properties']:
+                field_name = prop.get('field_name')
+                if not field_name:
+                    continue
+                    
+                # Use field_value_name if available (for dropdowns/users), otherwise field_value
+                field_value = prop.get('field_value_name') or prop.get('field_value') or ''
+                parsed_data_row[field_name] = field_value
             
             parsed_data.append(parsed_data_row)
 
@@ -810,6 +992,120 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 f"in project {self.qtest_project_id}. Exception: \n{stacktrace}"
             ) from e
 
+    def find_test_cases_by_requirement_id(self, requirement_id: str, include_details: bool = False) -> dict:
+        """Find all test cases linked to a QTest requirement.
+        
+        This method uses the ObjectLinkApi.find() to discover test cases that are 
+        linked to a specific requirement. This is the correct way to find linked 
+        test cases - DQL queries cannot search test cases by linked requirement.
+        
+        Args:
+            requirement_id: QTest requirement ID in format RQ-123
+            include_details: If True, fetches full test case details. If False, returns summary with Id, Name, Description.
+            
+        Returns:
+            dict with requirement_id, total count, and test_cases list
+            
+        Raises:
+            ValueError: If requirement is not found
+            ToolException: If API call fails
+        """
+        # Get internal QTest ID for the requirement
+        qtest_requirement_id = self.__find_qtest_requirement_id_by_id(requirement_id)
+        
+        link_object_api_instance = swagger_client.ObjectLinkApi(self._client)
+        
+        try:
+            # Use ObjectLinkApi.find() to get linked artifacts
+            # type='requirements' means we're searching from requirements
+            # ids=[qtest_requirement_id] specifies which requirement(s) to check
+            response = link_object_api_instance.find(
+                self.qtest_project_id,
+                type='requirements',
+                ids=[qtest_requirement_id]
+            )
+            
+            # Parse the response to extract linked test cases
+            # Response structure: [{id: req_internal_id, pid: 'RQ-15', objects: [{id: tc_internal_id, pid: 'TC-123'}, ...]}]
+            linked_test_cases = []
+            if response and len(response) > 0:
+                for container in response:
+                    # Convert to dict if it's an object
+                    container_data = container.to_dict() if hasattr(container, 'to_dict') else container
+                    objects = container_data.get('objects', []) if isinstance(container_data, dict) else []
+                    
+                    for obj in objects:
+                        obj_data = obj.to_dict() if hasattr(obj, 'to_dict') else obj
+                        if isinstance(obj_data, dict):
+                            pid = obj_data.get('pid', '')
+                            internal_id = obj_data.get('id')
+                            if pid and pid.startswith('TC-'):
+                                linked_test_cases.append({
+                                    'Id': pid,
+                                    QTEST_ID: internal_id
+                                })
+            
+            if not linked_test_cases:
+                return {
+                    'requirement_id': requirement_id,
+                    'total': 0,
+                    'test_cases': [],
+                    'message': f"No test cases are linked to requirement '{requirement_id}'"
+                }
+            
+            # Build result based on detail level
+            test_cases_result = []
+            
+            if not include_details:
+                # Short view: fetch Name, Description via DQL for each test case
+                for tc in linked_test_cases:
+                    try:
+                        parsed_data = self.__perform_search_by_dql(f"Id = '{tc['Id']}'")
+                        if parsed_data:
+                            tc_data = parsed_data[0]
+                            test_cases_result.append({
+                                'Id': tc['Id'],
+                                QTEST_ID: tc[QTEST_ID],
+                                'Name': tc_data.get('Name'),
+                                'Description': tc_data.get('Description', '')
+                            })
+                    except Exception as e:
+                        logger.warning(f"Could not fetch details for {tc['Id']}: {e}")
+                        test_cases_result.append({
+                            'Id': tc['Id'],
+                            QTEST_ID: tc[QTEST_ID],
+                            'Name': 'Unable to fetch',
+                            'Description': ''
+                        })
+            else:
+                # Full details: fetch complete test case data
+                for tc in linked_test_cases:
+                    try:
+                        parsed_data = self.__perform_search_by_dql(f"Id = '{tc['Id']}'")
+                        if parsed_data:
+                            test_cases_result.append(parsed_data[0])
+                    except Exception as e:
+                        logger.warning(f"Could not fetch details for {tc['Id']}: {e}")
+                        test_cases_result.append({
+                            'Id': tc['Id'],
+                            QTEST_ID: tc[QTEST_ID],
+                            'error': f'Unable to fetch details: {str(e)}'
+                        })
+            
+            return {
+                'requirement_id': requirement_id,
+                'total': len(test_cases_result),
+                'test_cases': test_cases_result
+            }
+            
+        except ApiException as e:
+            stacktrace = format_exc()
+            logger.error(f"Error finding test cases by requirement: {stacktrace}")
+            raise ToolException(
+                f"Unable to find test cases linked to requirement '{requirement_id}' "
+                f"in project {self.qtest_project_id}. Exception: \n{stacktrace}"
+            ) from e
+
     def search_by_dql(self, dql: str, extract_images:bool=False, prompt: str=None):
         """Search for the test cases in qTest using Data Query Language """
         parsed_data = self.__perform_search_by_dql(dql, extract_images, prompt)
@@ -897,7 +1193,37 @@ class QtestApiWrapper(BaseToolApiWrapper):
             {
                 "name": "search_by_dql",
                 "mode": "search_by_dql",
-                "description": 'Search the test cases in qTest using Data Query Language. The input of the tool will be in following format - Module in \'MD-78 Master Test Suite\' and Type = \'Automation - UTAF\'. If keyword or value to check against has 2 words in it it should be surrounded with single quotes',
+                "description": """Search test cases in qTest using Data Query Language (DQL).
+
+CRITICAL: USE SINGLE QUOTES ONLY - DQL does not support double quotes!
+- ✓ CORRECT: Description ~ 'Forgot Password'
+- ✗ WRONG: Description ~ "Forgot Password"
+
+LIMITATION - CANNOT SEARCH BY LINKED OBJECTS:
+- ✗ 'Requirement Id' = 'RQ-15' will fail - use 'find_test_cases_by_requirement_id' tool instead
+- ✗ Linked defects or other relationship queries are not supported
+
+SEARCHABLE FIELDS:
+- Direct fields: Id, Name, Description, Status, Type, Priority, Automation, etc.
+- Module: Use 'Module in' syntax
+- Custom fields: Use exact field name from project configuration
+- Date fields: Use ISO DateTime format (e.g., 'Created Date' > '2021-05-07T03:15:37.652Z')
+
+SYNTAX RULES:
+1. ALL string values MUST use single quotes (never double quotes)
+2. Field names with spaces MUST be in single quotes: 'Created Date' > '2024-01-01'
+3. Use ~ for 'contains', !~ for 'not contains': Description ~ 'login'
+4. Use 'is not empty' for non-empty check: Name is 'not empty'
+5. Operators: =, !=, <, >, <=, >=, in, ~, !~
+
+EXAMPLES:
+- Id = 'TC-123'
+- Description ~ 'Forgot Password'
+- Status = 'New' and Priority = 'High'
+- Module in 'MD-78 Master Test Suite'
+- Name ~ 'login'
+- 'Created Date' > '2024-01-01T00:00:00.000Z'
+""",
                 "args_schema": QtestDataQuerySearch,
                 "ref": self.search_by_dql,
             },
@@ -956,5 +1282,24 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 "description": "Get information about available test case fields and their valid values for the project. Shows which property values are allowed (e.g., Status: 'New', 'In Progress', 'Completed') based on the project configuration. Use force_refresh=true if project configuration has changed.",
                 "args_schema": GetAllTestCasesFieldsForProject,
                 "ref": self.get_all_test_cases_fields_for_project,
+            },
+            {
+                "name": "find_test_cases_by_requirement_id",
+                "mode": "find_test_cases_by_requirement_id",
+                "description": """Find all test cases linked to a QTest requirement.
+
+Use this tool to find test cases associated with a specific requirement.
+DQL search cannot query by linked requirement - use this tool instead.
+
+Parameters:
+- requirement_id: QTest requirement ID in format RQ-123
+- include_details: If true, returns full test case data. If false (default), returns Id, QTest Id, Name, and Description.
+
+Examples:
+- Find test cases for RQ-15: requirement_id='RQ-15'
+- Get full details: requirement_id='RQ-15', include_details=true
+""",
+                "args_schema": FindTestCasesByRequirementId,
+                "ref": self.find_test_cases_by_requirement_id,
             }
         ]

alita_sdk/tools/rally/__init__.py

@@ -29,8 +29,6 @@ class RallyToolkit(BaseToolkit):
         RallyToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True,
-                                                                            'max_toolkit_length': RallyToolkit.toolkit_max_length})),
             rally_configuration=(RallyConfiguration, Field(description="Rally configuration", json_schema_extra={'configuration_types': ['rally']})),
             workspace=(Optional[str], Field(default=None, description="Rally workspace")),
             project=(Optional[str], Field(default=None, description="Rally project")),
@@ -39,6 +37,7 @@ class RallyToolkit(BaseToolkit):
                 'metadata': {
                     "label": "Rally",
                     "icon_url": "rally.svg",
+                    "max_length": RallyToolkit.toolkit_max_length,
                     "categories": ["project management"],
                     "extra_categories": ["agile management", "test management", "scrum", "kanban"]
                 }

alita_sdk/tools/report_portal/__init__.py

@@ -33,6 +33,7 @@ class ReportPortalToolkit(BaseToolkit):
             report_portal_configuration=(ReportPortalConfiguration, Field(description="Report Portal Configuration", json_schema_extra={'configuration_types': ['report_portal']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Report Portal", "icon_url": "reportportal-icon.svg",
+                                                                  "max_length": ReportPortalToolkit.toolkit_max_length,
                                                                   "categories": ["testing"],
                                                                   "extra_categories": ["test reporting", "test automation"]}})
         )

alita_sdk/tools/salesforce/__init__.py

@@ -31,6 +31,7 @@ class SalesforceToolkit(BaseToolkit):
             selected_tools=(List[Literal[tuple(available_tools)]], Field(default=[], json_schema_extra={'args_schemas': available_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {
                 "label": "Salesforce", "icon_url": "salesforce-icon.svg",
+                "max_length": SalesforceToolkit.toolkit_max_length,
                 "categories": ["other"],
                 "extra_categories": ["customer relationship management", "cloud computing", "marketing automation", "salesforce"]
                                                                   }})

alita_sdk/tools/servicenow/__init__.py

@@ -35,9 +35,7 @@ class ServiceNowToolkit(BaseToolkit):
         ServiceNowToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            name=(str, Field(description="Toolkit name",
-                             json_schema_extra={
-                                 'toolkit_name': True, 'max_toolkit_length': ServiceNowToolkit.toolkit_max_length})),
+            name=(str, Field(description="Toolkit name")),
             response_fields=(Optional[str], Field(description="Response fields", default=None)),
             servicenow_configuration=(ServiceNowConfiguration, Field(description="ServiceNow Configuration",
                                                                                json_schema_extra={
@@ -49,6 +47,7 @@ class ServiceNowToolkit(BaseToolkit):
                 'metadata': {
                     "label": "ServiceNow",
                     "icon_url": "service-now.svg",
+                    "max_length": ServiceNowToolkit.toolkit_max_length,
                     "hidden": False,
                     "sections": {
                         "auth": {