alita-sdk 0.3.427__py3-none-any.whl → 0.3.428b2__py3-none-any.whl

alita_sdk/runtime/langchain/langraph_agent.py

@@ -249,7 +249,7 @@ class PrinterNode(Runnable):
         formatted_output = mapping[PRINTER]
         # add info label to the printer's output
         if formatted_output:
-            formatted_output += f"\n\n-----\n*How to proceed?*\n* - to resume the pipeline - type anything"
+            formatted_output += f"\n\n-----\n*How to proceed?*\n* *to resume the pipeline - type anything...*"
         logger.debug(f"Formatted output: {formatted_output}")
         result[PRINTER_NODE_RS] = formatted_output
         return result

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
@@ -91,8 +92,16 @@ QtestCreateTestCase = create_model(
 
 QtestLinkTestCaseToJiraRequirement = create_model(
     "QtestLinkTestCaseToJiraRequirement",
-    requirement_external_id=(str, Field("Qtest requirement external id which represent jira issue id linked to Qtest as a requirement e.g. SITEPOD-4038")),
-    json_list_of_test_case_ids=(str, Field("""List of the test case ids to be linked to particular requirement. 
+    requirement_external_id=(str, Field(description="Qtest requirement external id which represent jira issue id linked to Qtest as a requirement e.g. SITEPOD-4038")),
+    json_list_of_test_case_ids=(str, Field(description="""List of the test case ids to be linked to particular requirement. 
+                                              Create a list of the test case ids in the following format '["TC-123", "TC-234", "TC-456"]' which represents json array as a string.
+                                              It should be capable to be extracted directly by python json.loads method."""))
+)
+
+QtestLinkTestCaseToQtestRequirement = create_model(
+    "QtestLinkTestCaseToQtestRequirement",
+    requirement_id=(str, Field(description="QTest internal requirement ID in format RQ-123")),
+    json_list_of_test_case_ids=(str, Field(description="""List of the test case ids to be linked to particular requirement. 
                                               Create a list of the test case ids in the following format '["TC-123", "TC-234", "TC-456"]' which represents json array as a string.
                                               It should be capable to be extracted directly by python json.loads method."""))
 )
@@ -186,11 +195,11 @@ class QtestApiWrapper(BaseToolApiWrapper):
 
     def __get_field_definitions_cached(self) -> dict:
         """Get field definitions with session-level caching.
-        
+
         Field definitions are cached for the lifetime of this wrapper instance.
         If project field configuration changes, call refresh_field_definitions_cache()
         to reload the definitions.
-        
+
         Returns:
             dict: Field definitions mapping
         """
@@ -200,11 +209,11 @@ class QtestApiWrapper(BaseToolApiWrapper):
 
     def refresh_field_definitions_cache(self) -> dict:
         """Manually refresh the field definitions cache.
-        
+
         Call this method if project field configuration has been updated
         (new fields added, dropdown values changed, etc.) and you need to
         reload the definitions within the same agent session.
-        
+
         Returns:
             dict: Freshly loaded field definitions
         """
@@ -215,15 +224,15 @@ class QtestApiWrapper(BaseToolApiWrapper):
                                        base_properties: list = None) -> list:
         """
         Convert user-friendly property names/values to QTest API PropertyResource format.
-        
+
         Args:
             test_case_data: Dict with property names as keys (e.g., {"Status": "New", "Priority": "High"})
             field_definitions: Output from __get_project_field_definitions()
             base_properties: Existing properties from a test case (for updates, optional)
-            
+
         Returns:
             list[PropertyResource]: Properties ready for API submission
-            
+
         Raises:
             ValueError: If any field names are unknown or values are invalid (shows ALL errors)
         """
@@ -239,32 +248,32 @@ class QtestApiWrapper(BaseToolApiWrapper):
                         'field_value': prop['field_value'],
                         'field_value_name': prop.get('field_value_name')
                     }
-        
+
         # Collect ALL validation errors before raising
         validation_errors = []
-        
+
         # Map incoming properties from test_case_data
         for field_name, field_value in test_case_data.items():
             # 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 == '':
                 continue
-            
+
             # Validate field exists in project - STRICT validation
             if field_name not in field_definitions:
                 validation_errors.append(
                     f"❌ Unknown field '{field_name}' - not defined in project configuration"
                 )
                 continue  # Skip to next field, keep collecting errors
-            
+
             field_def = field_definitions[field_name]
             field_id = field_def['field_id']
             data_type = field_def.get('data_type')
             is_multiple = field_def.get('multiple', False)
-            
+
             # Normalize field_value to list for consistent processing
             # Multi-select fields can receive: "value", ["value1", "value2"], or ["value1"]
             # Single-select fields: "value" only
@@ -274,13 +283,13 @@ class QtestApiWrapper(BaseToolApiWrapper):
             else:
                 # Single-select: keep as single value
                 values_to_process = [field_value]
-            
+
             # Validate value(s) for dropdown fields (only if field has allowed values)
             if field_def['values']:
                 # Field has allowed values (dropdown/combobox/user fields) - validate strictly
                 value_ids = []
                 value_names = []
-                
+
                 for single_value in values_to_process:
                     if single_value not in field_def['values']:
                         available = ", ".join(sorted(field_def['values'].keys()))
@@ -289,15 +298,15 @@ class QtestApiWrapper(BaseToolApiWrapper):
                             f"Allowed values: {available}"
                         )
                         continue  # Skip this value, but continue validating others
-                    
+
                     # Valid value - add to lists
                     value_ids.append(field_def['values'][single_value])
                     value_names.append(single_value)
-                
+
                 # If all values were invalid, skip this field
                 if not value_ids:
                     continue
-                
+
                 # Format based on field type and value count
                 if is_multiple and len(value_ids) == 1:
                     # Single value in multi-select field: bracketed string "[419950]"
@@ -318,7 +327,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 # No validation needed - users can write anything (by design)
                 field_value_id = field_value
                 field_value_name = field_value if isinstance(field_value, str) else None
-            
+
             # Update or add property (only if no errors for this field)
             props_dict[field_name] = {
                 'field_id': field_id,
@@ -326,7 +335,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 'field_value': field_value_id,
                 'field_value_name': field_value_name
             }
-        
+
         # If ANY validation errors found, raise comprehensive error with all issues
         if validation_errors:
             available_fields = ", ".join(sorted(field_definitions.keys()))
@@ -337,7 +346,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 f"💡 Tip: Use 'get_all_test_cases_fields_for_project' tool to see all fields with their allowed values."
             )
             raise ValueError(error_msg)
-        
+
         # Convert to PropertyResource list, filtering out special fields
         result = []
         for field_name, prop_data in props_dict.items():
@@ -349,25 +358,25 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 field_value=prop_data['field_value'],
                 field_value_name=prop_data.get('field_value_name')
             ))
-        
+
         return result
 
     def __build_body_for_create_test_case(self, test_cases_data: list[dict],
                                           folder_to_place_test_cases_to: str = '') -> list:
         # Get field definitions for property mapping (cached for session)
         field_definitions = self.__get_field_definitions_cached()
-        
+
         modules = self._parse_modules()
         parent_id = ''.join(str(module['module_id']) for module in modules if
                             folder_to_place_test_cases_to and module['full_module_name'] == folder_to_place_test_cases_to)
-        
+
         bodies = []
         for test_case in test_cases_data:
             # Map properties from user format to API format
             props = self.__map_properties_to_api_format(test_case, field_definitions)
-            
+
             body = swagger_client.TestCaseWithCustomFieldResource(properties=props)
-            
+
             # Only set fields if they are explicitly provided in the input
             # This prevents overwriting existing values with None during partial updates
             if 'Name' in test_case:
@@ -376,10 +385,10 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 body.precondition = test_case['Precondition']
             if 'Description' in test_case:
                 body.description = test_case['Description']
-            
+
             if parent_id:
                 body.parent_id = parent_id
-            
+
             # Only set test_steps if Steps are provided in the input
             # This prevents overwriting existing steps during partial updates
             if 'Steps' in test_case and test_case['Steps'] is not None:
@@ -389,7 +398,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
                         swagger_client.TestStepResource(description=step.get('Test Step Description'),
                                                         expected=step.get('Test Step Expected Result')))
                 body.test_steps = test_steps_resources
-            
+
             bodies.append(body)
         return bodies
 
@@ -406,10 +415,147 @@ 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.
-        
+
         Returns:
             dict: Mapping of field names to their IDs and allowed values.
                   Example: {
@@ -427,15 +573,24 @@ class QtestApiWrapper(BaseToolApiWrapper):
         """
         fields_api = self.__instantiate_fields_api_instance()
         qtest_object = 'test-cases'
-        
+
         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(
                 f"Unable to get test case fields for project {self.qtest_project_id}. Exception: \n {stacktrace}")
-        
+
         # Build structured mapping
         field_mapping = {}
         for field in fields:
@@ -447,7 +602,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 'multiple': getattr(field, 'multiple', False),  # True = multi-select, needs array format
                 'values': {}
             }
-            
+
             # Map allowed values if field has them (dropdown/combobox/user fields)
             # Only include active values (is_active=True)
             if hasattr(field, 'allowed_values') and field.allowed_values:
@@ -455,38 +610,38 @@ class QtestApiWrapper(BaseToolApiWrapper):
                     # Skip inactive values (deleted/deprecated options)
                     if hasattr(allowed_value, 'is_active') and not allowed_value.is_active:
                         continue
-                    
+
                     # AllowedValueResource has 'label' for the display name and 'value' for the ID
                     # Note: 'value' is the field_value, not 'id'
                     # For user fields (data_type=5), label is user name and value is user ID
                     value_label = allowed_value.label
                     value_id = allowed_value.value
                     field_mapping[field_name]['values'][value_label] = value_id
-        
+
         return field_mapping
 
     def __format_field_info_for_display(self, field_definitions: dict) -> str:
         """
         Format field definitions in human-readable format for LLM.
-        
+
         Args:
             field_definitions: Output from __get_project_field_definitions()
-            
+
         Returns:
             Formatted string with field information
         """
         output = [f"Available Test Case Fields for Project {self.qtest_project_id}:\n"]
-        
+
         for field_name, field_info in sorted(field_definitions.items()):
             required_marker = " (Required)" if field_info.get('required') else ""
             output.append(f"\n{field_name}{required_marker}:")
-            
+
             if field_info.get('values'):
                 for value_name, value_id in sorted(field_info['values'].items()):
                     output.append(f"  - {value_name} (id: {value_id})")
             else:
                 output.append("  Type: text")
-        
+
         output.append("\n\nUse these exact value names when creating or updating test cases.")
         return ''.join(output)
 
@@ -494,12 +649,12 @@ class QtestApiWrapper(BaseToolApiWrapper):
         """
         Get formatted information about available test case fields and their values.
         This method is exposed as a tool for LLM to query field information.
-        
+
         Args:
             force_refresh: If True, reload field definitions from API instead of using cache.
                           Use this if project configuration has changed (new fields added,
                           dropdown values modified, etc.).
-        
+
         Returns:
             Formatted string with field names and allowed values
         """
@@ -547,10 +702,10 @@ 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)
             parsed_data_row = {
@@ -565,31 +720,17 @@ class QtestApiWrapper(BaseToolApiWrapper):
                     'Test Step Expected Result':  self._process_image(step[1]['expected'], extract_images, prompt)
                 }, 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)
 
     def _process_image(self, content: str, extract: bool=False, prompt: str=None):
@@ -647,6 +788,38 @@ class QtestApiWrapper(BaseToolApiWrapper):
         parsed_data = self.__perform_search_by_dql(dql)
         return parsed_data[0]['QTest Id']
 
+    def __find_qtest_requirement_id_by_id(self, requirement_id: str) -> int:
+        """Search for requirement's internal QTest ID using requirement ID (RQ-xxx format).
+
+        Args:
+            requirement_id: Requirement ID in format RQ-123
+
+        Returns:
+            int: Internal QTest ID for the requirement
+
+        Raises:
+            ValueError: If requirement is not found
+        """
+        dql = f"Id = '{requirement_id}'"
+        search_instance: SearchApi = swagger_client.SearchApi(self._client)
+        body = swagger_client.ArtifactSearchParams(object_type='requirements', fields=['*'], query=dql)
+
+        try:
+            response = search_instance.search_artifact(self.qtest_project_id, body)
+            if response['total'] == 0:
+                raise ValueError(
+                    f"Requirement '{requirement_id}' not found in project {self.qtest_project_id}. "
+                    f"Please verify the requirement ID exists."
+                )
+            return response['items'][0]['id']
+        except ApiException as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when searching for requirement: \n {stacktrace}")
+            raise ToolException(
+                f"Unable to search for requirement '{requirement_id}' in project {self.qtest_project_id}. "
+                f"Exception: \n{stacktrace}"
+            ) from e
+
     def __is_jira_requirement_present(self, jira_issue_id: str) -> tuple[bool, dict]:
         """ Define if particular Jira requirement is present in qtest or not """
         dql = f"'External Id' = '{jira_issue_id}'"
@@ -663,31 +836,112 @@ class QtestApiWrapper(BaseToolApiWrapper):
             logger.error(f"Error: {format_exc()}")
             raise e
 
-    def _get_jira_requirement_id(self, jira_issue_id: str) -> int | None:
-        """ Search for requirement id using the linked jira_issue_id. """
+    def _get_jira_requirement_id(self, jira_issue_id: str) -> int:
+        """Search for requirement id using the linked jira_issue_id.
+
+        Args:
+            jira_issue_id: External Jira issue ID (e.g., PLAN-128)
+
+        Returns:
+            int: Internal QTest ID for the Jira requirement
+
+        Raises:
+            ValueError: If Jira requirement is not found in QTest
+        """
         is_present, response = self.__is_jira_requirement_present(jira_issue_id)
         if not is_present:
-            return None
+            raise ValueError(
+                f"Jira requirement '{jira_issue_id}' not found in QTest project {self.qtest_project_id}. "
+                f"Please ensure the Jira issue is linked to QTest as a requirement."
+            )
         return response['items'][0]['id']
 
 
     def link_tests_to_jira_requirement(self, requirement_external_id: str, json_list_of_test_case_ids: str) -> str:
-        """ Link the list of the test cases represented as string like this '["TC-123", "TC-234"]' to the Jira requirement represented as external id e.g. PLAN-128 which is the Jira Issue Id"""
+        """Link test cases to external Jira requirement.
+
+        Args:
+            requirement_external_id: Jira issue ID (e.g., PLAN-128)
+            json_list_of_test_case_ids: JSON array string of test case IDs (e.g., '["TC-123", "TC-234"]')
+
+        Returns:
+            Success message with linked test case IDs
+        """
         link_object_api_instance = swagger_client.ObjectLinkApi(self._client)
         source_type = "requirements"
         linked_type = "test-cases"
-        list = [self.__find_qtest_id_by_test_id(test_case_id) for test_case_id in json.loads(json_list_of_test_case_ids)]
+        test_case_ids = json.loads(json_list_of_test_case_ids)
+        qtest_test_case_ids = [self.__find_qtest_id_by_test_id(tc_id) for tc_id in test_case_ids]
         requirement_id = self._get_jira_requirement_id(requirement_external_id)
 
         try:
-            response = link_object_api_instance.link_artifacts(self.qtest_project_id, object_id=requirement_id,
-                                                               type=linked_type,
-                                                               object_type=source_type, body=list)
-            return f"The test cases with the following id's - {[link.pid for link in response[0].objects]} have been linked in following project {self.qtest_project_id} under following requirement {requirement_external_id}"
-        except Exception as e:
-            from traceback import format_exc
-            logger.error(f"Error: {format_exc()}")
-            raise e
+            response = link_object_api_instance.link_artifacts(
+                self.qtest_project_id,
+                object_id=requirement_id,
+                type=linked_type,
+                object_type=source_type,
+                body=qtest_test_case_ids
+            )
+            linked_test_cases = [link.pid for link in response[0].objects]
+            return (
+                f"Successfully linked {len(linked_test_cases)} test case(s) to Jira requirement '{requirement_external_id}' "
+                f"in project {self.qtest_project_id}.\n"
+                f"Linked test cases: {', '.join(linked_test_cases)}"
+            )
+        except ApiException as e:
+            stacktrace = format_exc()
+            logger.error(f"Error linking to Jira requirement: {stacktrace}")
+            raise ToolException(
+                f"Unable to link test cases to Jira requirement '{requirement_external_id}' "
+                f"in project {self.qtest_project_id}. Exception: \n{stacktrace}"
+            ) from e
+
+    def link_tests_to_qtest_requirement(self, requirement_id: str, json_list_of_test_case_ids: str) -> str:
+        """Link test cases to internal QTest requirement.
+
+        Args:
+            requirement_id: QTest requirement ID in format RQ-123
+            json_list_of_test_case_ids: JSON array string of test case IDs (e.g., '["TC-123", "TC-234"]')
+
+        Returns:
+            Success message with linked test case IDs
+
+        Raises:
+            ValueError: If requirement or test cases are not found
+            ToolException: If linking fails
+        """
+        link_object_api_instance = swagger_client.ObjectLinkApi(self._client)
+        source_type = "requirements"
+        linked_type = "test-cases"
+
+        # Parse and convert test case IDs
+        test_case_ids = json.loads(json_list_of_test_case_ids)
+        qtest_test_case_ids = [self.__find_qtest_id_by_test_id(tc_id) for tc_id in test_case_ids]
+
+        # Get internal QTest ID for the requirement
+        qtest_requirement_id = self.__find_qtest_requirement_id_by_id(requirement_id)
+
+        try:
+            response = link_object_api_instance.link_artifacts(
+                self.qtest_project_id,
+                object_id=qtest_requirement_id,
+                type=linked_type,
+                object_type=source_type,
+                body=qtest_test_case_ids
+            )
+            linked_test_cases = [link.pid for link in response[0].objects]
+            return (
+                f"Successfully linked {len(linked_test_cases)} test case(s) to QTest requirement '{requirement_id}' "
+                f"in project {self.qtest_project_id}.\n"
+                f"Linked test cases: {', '.join(linked_test_cases)}"
+            )
+        except ApiException as e:
+            stacktrace = format_exc()
+            logger.error(f"Error linking to QTest requirement: {stacktrace}")
+            raise ToolException(
+                f"Unable to link test cases to QTest 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 """
@@ -809,12 +1063,19 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 "ref": self.delete_test_case,
             },
             {
-                "name": "link_tests_to_requirement",
-                "mode": "link_tests_to_requirement",
-                "description": """Link tests to Jira requirements. The input is jira issue id and th list of test ids in format '["TC-123", "TC-234", "TC-345"]'""",
+                "name": "link_tests_to_jira_requirement",
+                "mode": "link_tests_to_jira_requirement",
+                "description": "Link test cases to external Jira requirement. Provide Jira issue ID (e.g., PLAN-128) and list of test case IDs in format '[\"TC-123\", \"TC-234\"]'",
                 "args_schema": QtestLinkTestCaseToJiraRequirement,
                 "ref": self.link_tests_to_jira_requirement,
             },
+            {
+                "name": "link_tests_to_qtest_requirement",
+                "mode": "link_tests_to_qtest_requirement",
+                "description": "Link test cases to internal QTest requirement. Provide QTest requirement ID (e.g., RQ-15) and list of test case IDs in format '[\"TC-123\", \"TC-234\"]'",
+                "args_schema": QtestLinkTestCaseToQtestRequirement,
+                "ref": self.link_tests_to_qtest_requirement,
+            },
             {
                 "name": "get_modules",
                 "mode": "get_modules",

{alita_sdk-0.3.427.dist-info → alita_sdk-0.3.428b2.dist-info}/METADATA

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

{alita_sdk-0.3.427.dist-info → alita_sdk-0.3.428b2.dist-info}/RECORD

@@ -45,7 +45,7 @@ alita_sdk/runtime/langchain/assistant.py,sha256=qKoEjbGuUnX-OZDHmSaK3plb1jON9unz
 alita_sdk/runtime/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
 alita_sdk/runtime/langchain/constants.py,sha256=I3dwexVp_Qq3MueRA2ClLgFDEhk4BkJhgR6m7V0gVPc,3404
 alita_sdk/runtime/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
-alita_sdk/runtime/langchain/langraph_agent.py,sha256=SGEjHdPiV7dQno6hcnKhbQMfU_gRU0kKD_0uXzt2bV4,51833
+alita_sdk/runtime/langchain/langraph_agent.py,sha256=CxDFfUTCG-i8koMR9PwOktvlcdUe5cyG4D8CQHrTH1E,51836
 alita_sdk/runtime/langchain/mixedAgentParser.py,sha256=M256lvtsL3YtYflBCEp-rWKrKtcY1dJIyRGVv7KW9ME,2611
 alita_sdk/runtime/langchain/mixedAgentRenderes.py,sha256=asBtKqm88QhZRILditjYICwFVKF5KfO38hu2O-WrSWE,5964
 alita_sdk/runtime/langchain/store_manager.py,sha256=i8Fl11IXJhrBXq1F1ukEVln57B1IBe-tqSUvfUmBV4A,2218
@@ -303,7 +303,7 @@ alita_sdk/tools/postman/postman_analysis.py,sha256=ckc2BfKEop0xnmLPksVRE_Y94ixuq
 alita_sdk/tools/pptx/__init__.py,sha256=vVUrWnj7KWJgEk9oxGSsCAQ2SMSXrp_SFOdUHYQKcAo,3444
 alita_sdk/tools/pptx/pptx_wrapper.py,sha256=yyCYcTlIY976kJ4VfPo4dyxj4yeii9j9TWP6W8ZIpN8,29195
 alita_sdk/tools/qtest/__init__.py,sha256=Jf0xo5S_4clXR2TfCbJbB1sFgCbcFQRM-YYX2ltWBzo,4461
-alita_sdk/tools/qtest/api_wrapper.py,sha256=kxH4H1mFm4-_xqJ3js92YzT9sJ-6XC30moC1WCExano,40926
+alita_sdk/tools/qtest/api_wrapper.py,sha256=Cds_TnyWhR-2NaoHio9ePYMLT7RGS0nx20KAqifIOWk,50977
 alita_sdk/tools/qtest/tool.py,sha256=kKzNPS4fUC76WQQttQ6kdVANViHEvKE8Kf174MQiNYU,562
 alita_sdk/tools/rally/__init__.py,sha256=2BPPXJxAOKgfmaxVFVvxndfK0JxOXDLkoRmzu2dUwOE,3512
 alita_sdk/tools/rally/api_wrapper.py,sha256=mouzU6g0KML4UNapdk0k6Q0pU3MpJuWnNo71n9PSEHM,11752
@@ -353,8 +353,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=kT0TbmMvuKhDUZc0i7KO18O38JM9S
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=0ne8XLJEQSLOWfzd2HdnqOYmQlUliKHbBED5kW_Vias,2895
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=kmw_xol8YIYFplBLWTqP_VKPRhL_1ItDD0_vXTe_UuI,14906
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=R371waHsms4sllHCbijKYs90C-9Yu0sSR3N4SUfQOgU,5066
-alita_sdk-0.3.427.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.427.dist-info/METADATA,sha256=J0tNPenigoEpUHXwQ5dQPc5lBEnwsgNFrXbplG0QAZs,19071
-alita_sdk-0.3.427.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.427.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.427.dist-info/RECORD,,
+alita_sdk-0.3.428b2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.428b2.dist-info/METADATA,sha256=WmL2Jo4Efefiq86rZ0hYJlMZx-epmDrwx-2qNTaWnEc,19073
+alita_sdk-0.3.428b2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.428b2.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.428b2.dist-info/RECORD,,