alita-sdk 0.3.451__tar.gz → 0.3.453__tar.gz

{alita_sdk-0.3.451 → alita_sdk-0.3.453}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.451
+Version: 0.3.453
 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.451 → alita_sdk-0.3.453}/alita_sdk/runtime/langchain/langraph_agent.py

@@ -475,10 +475,14 @@ def create_graph(
             if toolkit_name:
                 tool_name = f"{clean_string(toolkit_name)}{TOOLKIT_SPLITTER}{tool_name}"
             logger.info(f"Node: {node_id} : {node_type} - {tool_name}")
-            if node_type in ['function', 'tool', 'loop', 'loop_from_tool', 'indexer', 'subgraph', 'pipeline', 'agent']:
+            if node_type in ['function', 'toolkit', 'mcp', 'tool', 'loop', 'loop_from_tool', 'indexer', 'subgraph', 'pipeline', 'agent']:
+                if node_type == 'mcp' and tool_name not in [tool.name for tool in tools]:
+                    # MCP is not connected and node cannot be added
+                    raise ToolException(f"MCP tool '{tool_name}' not found in the provided tools. "
+                                        f"Make sure it is connected properly. Available tools: {[tool.name for tool in tools]}")
                 for tool in tools:
                     if tool.name == tool_name:
-                        if node_type == 'function':
+                        if node_type in ['function', 'toolkit', 'mcp']:
                             lg_builder.add_node(node_id, FunctionTool(
                                 tool=tool, name=node_id, return_type='dict',
                                 output_variables=node.get('output', []),
@@ -663,7 +667,7 @@ def create_graph(
                 lg_builder.add_node(reset_node_id, PrinterNode(
                     input_mapping={'printer': {'type': 'fixed', 'value': ''}}
                 ))
-                lg_builder.add_edge(node_id, reset_node_id)
+                lg_builder.add_conditional_edges(node_id, TransitionalEdge(reset_node_id))
                 lg_builder.add_conditional_edges(reset_node_id, TransitionalEdge(clean_string(node['transition'])))
                 continue
             if node.get('transition'):
@@ -814,35 +818,59 @@ class LangGraphAgentRunnable(CompiledStateGraph):
             input['messages'] = [convert_dict_to_message(msg) for msg in chat_history]
 
         # handler for LLM node: if no input (Chat perspective), then take last human message
+        # Track if input came from messages to handle content extraction properly
+        input_from_messages = False
         if not input.get('input'):
             if input.get('messages'):
-                input['input'] = [next((msg for msg in reversed(input['messages']) if isinstance(msg, HumanMessage)),
-                                          None)]
+                input['input'] = next((msg for msg in reversed(input['messages']) if isinstance(msg, HumanMessage)),
+                                      None)
+                if input['input'] is not None:
+                    input_from_messages = True
 
         # Append current input to existing messages instead of overwriting
         if input.get('input'):
-            if isinstance(input['input'], str):
-                current_message = input['input']
-            else:
-                current_message = input.get('input')[-1]
+            current_message = input['input']
 
             # TODO: add handler after we add 2+ inputs (filterByType, etc.)
             if isinstance(current_message, HumanMessage):
                 current_content = current_message.content
                 if isinstance(current_content, list):
-                    text_contents = [
-                        item['text'] if isinstance(item, dict) and item.get('type') == 'text'
-                        else item if isinstance(item, str)
-                        else None
-                        for item in current_content
-                    ]
-                    text_contents = [text for text in text_contents if text is not None]
-                    input['input'] = ". ".join(text_contents)
+                    # Extract text parts and keep non-text parts (images, etc.)
+                    text_contents = []
+                    non_text_parts = []
+                    
+                    for item in current_content:
+                        if isinstance(item, dict) and item.get('type') == 'text':
+                            text_contents.append(item['text'])
+                        elif isinstance(item, str):
+                            text_contents.append(item)
+                        else:
+                            # Keep image_url and other non-text content
+                            non_text_parts.append(item)
+                    
+                    # Set input to the joined text
+                    input['input'] = ". ".join(text_contents) if text_contents else ""
+                    
+                    # If this message came from input['messages'], update or remove it
+                    if input_from_messages:
+                        if non_text_parts:
+                            # Keep the message but only with non-text content (images, etc.)
+                            current_message.content = non_text_parts
+                        else:
+                            # All content was text, remove this message from the list
+                            input['messages'] = [msg for msg in input['messages'] if msg is not current_message]
+                
                 elif isinstance(current_content, str):
                     # on regenerate case
                     input['input'] = current_content
+                    # If from messages and all content is text, remove the message
+                    if input_from_messages:
+                        input['messages'] = [msg for msg in input['messages'] if msg is not current_message]
                 else:
                     input['input'] = str(current_content)
+                    # If from messages, remove since we extracted the content
+                    if input_from_messages:
+                        input['messages'] = [msg for msg in input['messages'] if msg is not current_message]
             elif isinstance(current_message, str):
                 input['input'] = current_message
             else:
@@ -852,9 +880,18 @@ class LangGraphAgentRunnable(CompiledStateGraph):
                 input['messages'] = [convert_dict_to_message(msg) for msg in input['messages']]
                 # Append to existing messages
                 # input['messages'].append(current_message)
-            else:
-                # No existing messages, create new list
-                input['messages'] = [current_message]
+            # else:
+                # NOTE: Commented out to prevent duplicates with input['input']
+                # input['messages'] = [current_message]
+        
+        # Validate that input is not empty after all processing
+        if not input.get('input'):
+            raise RuntimeError(
+                "Empty input after processing. Cannot send empty string to LLM. "
+                "This likely means the message contained only non-text content "
+                "with no accompanying text."
+            )
+        
         logging.info(f"Input: {thread_id} - {input}")
         if self.checkpointer and self.checkpointer.get_tuple(config):
             self.update_state(config, input)

{alita_sdk-0.3.451 → alita_sdk-0.3.453}/alita_sdk/runtime/toolkits/tools.py

@@ -110,6 +110,7 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                     toolkit_name=tool.get('toolkit_name', ''),
                     **tool['settings']).get_tools())
             elif tool['type'] == 'mcp':
+                # remote mcp tool initialization with token injection
                 settings = dict(tool['settings'])
                 url = settings.get('url')
                 headers = settings.get('headers')

{alita_sdk-0.3.451 → alita_sdk-0.3.453}/alita_sdk/runtime/tools/function.py

@@ -120,7 +120,8 @@ class FunctionTool(BaseTool):
                     messages_dict = {
                         "messages": [{
                             "role": "assistant",
-                            "content": dumps(tool_result) if not isinstance(tool_result, ToolException)
+                            "content": dumps(tool_result)
+                            if not isinstance(tool_result, ToolException) and not isinstance(tool_result, str)
                             else str(tool_result)
                         }]
                     }

{alita_sdk-0.3.451 → alita_sdk-0.3.453}/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
@@ -414,6 +415,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 +577,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(
@@ -556,8 +703,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 +721,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)
 

{alita_sdk-0.3.451 → alita_sdk-0.3.453}/alita_sdk.egg-info/PKG-INFO

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

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