alita-sdk 0.3.419__tar.gz → 0.3.421__tar.gz

{alita_sdk-0.3.419 → alita_sdk-0.3.421}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.419
+Version: 0.3.421
 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.419 → alita_sdk-0.3.421}/alita_sdk/runtime/langchain/utils.py

@@ -138,6 +138,7 @@ def create_state(data: Optional[dict] = None):
     for key, value in data.items():
         # support of old & new UI
         value = value['type'] if isinstance(value, dict) else value
+        value = 'str' if value == 'string' else value  # normalize string type (old state support)
         if key == 'messages':
             state_dict[key] = Annotated[list[AnyMessage], add_messages]
         elif value in ['str', 'int', 'float', 'bool', 'list', 'dict', 'number', 'dict']:
@@ -184,7 +185,7 @@ def propagate_the_input_mapping(input_mapping: dict[str, dict], input_variables:
                 logger.error(f"KeyError in fstring formatting for key '{key}'. Attempt to find proper data in state.\n{e}")
                 try:
                     # search for variables in state if not found in var_dict
-                    input_data[key] = value['value'].format(**state)
+                    input_data[key] = safe_format(value['value'], state)
                 except KeyError as no_var_exception:
                     logger.error(f"KeyError in fstring formatting for key '{key}' with state data.\n{no_var_exception}")
                     # leave value as is if still not found (could be a constant string marked as fstring by mistake)
@@ -195,6 +196,13 @@ def propagate_the_input_mapping(input_mapping: dict[str, dict], input_variables:
             input_data[key] = source.get(value['value'], "")
     return input_data
 
+def safe_format(template, mapping):
+    """Format a template string using a mapping, leaving placeholders unchanged if keys are missing."""
+
+    def replacer(match):
+        key = match.group(1)
+        return str(mapping.get(key, f'{{{key}}}'))
+    return re.sub(r'\{(\w+)\}', replacer, template)
 
 def create_pydantic_model(model_name: str, variables: dict[str, dict]):
     fields = {}

{alita_sdk-0.3.419 → alita_sdk-0.3.421}/alita_sdk/runtime/tools/llm.py

@@ -91,6 +91,10 @@ class LLMNode(BaseTool):
                                     f"Actual params: {func_args}")
             # cast to str in case user passes variable different from str
             messages = [SystemMessage(content=str(func_args.get('system'))), *func_args.get('chat_history', []), HumanMessage(content=str(func_args.get('task')))]
+            # Remove pre-last item if last two messages are same type and content
+            if len(messages) >= 2 and type(messages[-1]) == type(messages[-2]) and messages[-1].content == messages[
+                -2].content:
+                messages.pop(-2)
         else:
             # Flow for chat-based LLM node w/o prompt/task from pipeline but with messages in state
             # verify messages structure

{alita_sdk-0.3.419 → alita_sdk-0.3.421}/alita_sdk/tools/base_indexer_toolkit.py

@@ -474,9 +474,10 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
                 "index_configuration": index_configuration,
                 "created_on": created_on,
                 "updated_on": created_on,
-                "history": "[]",
                 "task_id": None,
+                "conversation_id": None,
             }
+            metadata["history"] = json.dumps([metadata])
             index_meta_doc = Document(page_content=f"{IndexerKeywords.INDEX_META_TYPE.value}_{index_name}", metadata=metadata)
             add_documents(vectorstore=self.vectorstore, documents=[index_meta_doc])
 
@@ -489,6 +490,20 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
             metadata["indexed"] = result
             metadata["state"] = state
             metadata["updated_on"] = time.time()
+            #
+            history_raw = metadata.pop("history", "[]")
+            try:
+                history = json.loads(history_raw) if history_raw.strip() else []
+                # replace the last history item with updated metadata
+                if history and isinstance(history, list):
+                    history[-1] = metadata
+                else:
+                    history = [metadata]
+            except (json.JSONDecodeError, TypeError):
+                logger.warning(f"Failed to load index history: {history_raw}. Create new with only current item.")
+                history = [metadata]
+            #
+            metadata["history"] = json.dumps(history)
             index_meta_doc = Document(page_content=index_meta_raw.get("content", ""), metadata=metadata)
             add_documents(vectorstore=self.vectorstore, documents=[index_meta_doc], ids=[index_meta_raw.get("id")])
 

{alita_sdk-0.3.419 → alita_sdk-0.3.421}/alita_sdk/tools/qtest/api_wrapper.py

@@ -9,7 +9,7 @@ import swagger_client
 from langchain_core.tools import ToolException
 from pydantic import Field, PrivateAttr, model_validator, create_model, SecretStr
 from sklearn.feature_extraction.text import strip_tags
-from swagger_client import TestCaseApi, SearchApi, PropertyResource, ModuleApi
+from swagger_client import TestCaseApi, SearchApi, PropertyResource, ModuleApi, ProjectApi, FieldApi
 from swagger_client.rest import ApiException
 
 from ..elitea_base import BaseToolApiWrapper
@@ -26,21 +26,25 @@ If generated data was used, put appropriate note to the test case description fi
 ### CRITERIA
 1. The structure should be as in EXAMPLE.
 2. Case and spaces for field names should be exactly the same as in NOTES.
-3. Extra fields are allowed.
+3. Extra fields are allowed and will be mapped to project's custom fields if they exist.
 4. "{QTEST_ID}" is required to update, change or replace values in test case.
 5. Do not provide "Id" and "{QTEST_ID}" to create test case.
-6  "Steps" is a list of test step objects with fields "Test Step Number", "Test Step Description", "Test Step Expected Result".
+6. "Steps" is a list of test step objects with fields "Test Step Number", "Test Step Description", "Test Step Expected Result".
+7. For updates, provide ONLY the fields you want to change. Omitted fields will remain unchanged.
 
 ### NOTES
-Id: Unique identifier (e.g., TC-123).
-QTest id: Unique identifier (e.g., 4626964).
-Name: Brief title.
-Description: Short purpose.
-Type: 'Manual' or 'Automation - UTAF'. Leave blank if unknown.
-Status: Default 'New'.
-Priority: Leave blank.
-Test Type: Default 'Functional'.
-Precondition: List prerequisites in one cell, formatted as: <Step1> <Step2> Leave blank if none..
+Id: Unique identifier (e.g., TC-123). Read-only.
+QTest id: Unique identifier (e.g., 4626964). Required for updates.
+Name: Brief title of the test case.
+Description: Short description of the test purpose.
+Type: Type of test (e.g., 'Manual', 'Automation - UTAF').
+Status: Current status (e.g., 'New', 'In Progress', 'Completed').
+Priority: Priority level (e.g., 'High', 'Medium', 'Low').
+Test Type: Category of test (e.g., 'Functional', 'Regression', 'Smoke').
+Precondition: Prerequisites for the test, formatted as: <Step1> <Step2> Leave blank if none.
+Steps: Array of test steps with Description and Expected Result.
+
+**For Updates**: Include only the fields you want to modify. The system will validate property values against project configuration.
 
 ### EXAMPLE
 {{
@@ -118,6 +122,17 @@ GetModules = create_model(
 
 )
 
+GetAllTestCasesFieldsForProject = create_model(
+    "GetAllTestCasesFieldsForProject",
+    force_refresh=(Optional[bool],
+                   Field(description="Set to true to reload field definitions from API if project configuration has changed (new fields added, dropdown values modified). Default: false (uses cached data).",
+                         default=False)),
+)
+
+NoInput = create_model(
+    "NoInput"
+)
+
 class QtestApiWrapper(BaseToolApiWrapper):
     base_url: str
     qtest_project_id: int
@@ -126,6 +141,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
     page: int = 1
     no_of_tests_shown_in_dql_search: int = 10
     _client: Any = PrivateAttr()
+    _field_definitions_cache: Optional[dict] = PrivateAttr(default=None)
     llm: Any
 
     @model_validator(mode='before')
@@ -160,33 +176,177 @@ class QtestApiWrapper(BaseToolApiWrapper):
     def __instantiate_module_api_instance(self) -> ModuleApi:
         return swagger_client.ModuleApi(self._client)
 
+    def __instantiate_fields_api_instance(self) -> FieldApi:
+        return swagger_client.FieldApi(self._client)
+
+    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
+        """
+        if self._field_definitions_cache is None:
+            self._field_definitions_cache = self.__get_project_field_definitions()
+        return self._field_definitions_cache
+
+    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
+        """
+        self._field_definitions_cache = None
+        return self.__get_field_definitions_cached()
+
+    def __map_properties_to_api_format(self, test_case_data: dict, field_definitions: dict,
+                                       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)
+        """
+        # Start with base properties or empty dict
+        props_dict = {}
+        if base_properties:
+            for prop in base_properties:
+                field_name = prop.get('field_name')
+                if field_name:
+                    props_dict[field_name] = {
+                        'field_id': prop['field_id'],
+                        'field_name': field_name,
+                        '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']
+            
+            # Validate value for dropdown fields (only if field has allowed values)
+            if field_def['values']:
+                # Field has allowed values (dropdown/combobox) - validate strictly
+                if field_value not in field_def['values']:
+                    available = ", ".join(sorted(field_def['values'].keys()))
+                    validation_errors.append(
+                        f"❌ Invalid value '{field_value}' for field '{field_name}'. "
+                        f"Allowed values: {available}"
+                    )
+                    continue  # Skip to next field, keep collecting errors
+                field_value_id = field_def['values'][field_value]
+                field_value_name = field_value
+            else:
+                # Text field or field without restricted values - use value directly
+                # 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,
+                'field_name': field_name,
+                '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()))
+            error_msg = (
+                f"Found {len(validation_errors)} validation error(s) in test case properties:\n\n" +
+                "\n".join(validation_errors) +
+                f"\n\n📋 Available fields for this project: {available_fields}\n\n"
+                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():
+            if field_name in ['Shared', 'Projects Shared to']:
+                continue
+            result.append(PropertyResource(
+                field_id=prop_data['field_id'],
+                field_name=prop_data['field_name'],
+                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:
-        initial_project_properties = self.__get_properties_form_project()
+        # 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)
-        props = []
-        for prop in initial_project_properties:
-            if prop.get('field_name', '') == 'Shared' or prop.get('field_name', '') == 'Projects Shared to':
-                continue
-            props.append(PropertyResource(field_id=prop['field_id'], field_name=prop['field_name'],
-                                          field_value_name=prop.get('field_value_name', None),
-                                          field_value=prop['field_value']))
+        
         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)
-            body.name = test_case.get('Name')
-            body.precondition = test_case.get('Precondition')
-            body.description = test_case.get('Description')
+            
+            # 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:
+                body.name = test_case['Name']
+            if 'Precondition' in test_case:
+                body.precondition = test_case['Precondition']
+            if 'Description' in test_case:
+                body.description = test_case['Description']
+            
             if parent_id:
                 body.parent_id = parent_id
-            test_steps_resources = []
-            for step in test_case.get('Steps'):
-                test_steps_resources.append(
-                    swagger_client.TestStepResource(description=step.get('Test Step Description'),
-                                                    expected=step.get('Test Step Expected Result')))
-            body.test_steps = test_steps_resources
+            
+            # 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:
+                test_steps_resources = []
+                for step in test_case['Steps']:
+                    test_steps_resources.append(
+                        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
 
@@ -203,6 +363,100 @@ class QtestApiWrapper(BaseToolApiWrapper):
                                 Exception: \n {stacktrace}""")
         return modules
 
+    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: {
+                      'Status': {
+                          'field_id': 12345,
+                          'required': True,
+                          'values': {'New': 1, 'In Progress': 2, 'Completed': 3}
+                      },
+                      'Priority': {
+                          'field_id': 12346,
+                          'required': False,
+                          'values': {'High': 1, 'Medium': 2, 'Low': 3}
+                      }
+                  }
+        """
+        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:
+            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:
+            field_name = field.label
+            field_mapping[field_name] = {
+                'field_id': field.id,
+                'required': getattr(field, 'required', False),
+                'values': {}
+            }
+            
+            # Map allowed values if field has them (dropdown/combobox fields)
+            if hasattr(field, 'allowed_values') and field.allowed_values:
+                for allowed_value in field.allowed_values:
+                    # AllowedValueResource has 'label' for the display name and 'value' for the ID
+                    # Note: 'value' is the field_value, not '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)
+
+    def get_all_test_cases_fields_for_project(self, force_refresh: bool = False) -> str:
+        """
+        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
+        """
+        if force_refresh:
+            self.refresh_field_definitions_cache()
+        field_defs = self.__get_field_definitions_cached()
+        return self.__format_field_info_for_display(field_defs)
+
     def _parse_modules(self) -> list[dict]:
         modules = self.__get_all_modules_for_project()
         result = []
@@ -320,18 +574,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
         parsed_data = self.__perform_search_by_dql(dql)
         return parsed_data[0]['QTest Id']
 
-    def __get_properties_form_project(self) -> list[dict] | None:
-        test_api_instance = self.__instantiate_test_api_instance()
-        expand_props = 'true'
-        try:
-            response = test_api_instance.get_test_cases(self.qtest_project_id, 1, 1, expand_props=expand_props)
-            return response[0]['properties']
-        except ApiException as e:
-            stacktrace = format_exc()
-            logger.error(f"Exception when calling TestCaseApi->get_test_cases: \n {stacktrace}")
-            raise e
-
-    def __is_jira_requirement_present(self, jira_issue_id: str) -> (bool, dict):
+    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}'"
         search_instance: SearchApi = swagger_client.SearchApi(self._client)
@@ -505,5 +748,12 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 "description": self.get_modules.__doc__,
                 "args_schema": GetModules,
                 "ref": self.get_modules,
+            },
+            {
+                "name": "get_all_test_cases_fields_for_project",
+                "mode": "get_all_test_cases_fields_for_project",
+                "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,
             }
         ]

{alita_sdk-0.3.419 → alita_sdk-0.3.421}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.419
+Version: 0.3.421
 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.419 → alita_sdk-0.3.421}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alita_sdk"
-version = "0.3.419"
+version = "0.3.421"
 description = "SDK for building langchain agents using resources from Alita"
 readme = "README.md"
 requires-python = ">=3.10"