alita-sdk 0.3.350__tar.gz → 0.3.351__tar.gz

{alita_sdk-0.3.350 → alita_sdk-0.3.351}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.350
+Version: 0.3.351
 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.350 → alita_sdk-0.3.351}/alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -255,7 +255,7 @@ document_loaders_map = {
     },
     '.xml': {
         'class': UnstructuredXMLLoader,
-        'mime_type': 'application/xml',
+        'mime_type': 'text/xml',
         'is_multimodal_processing': False,
         'kwargs': {},
         'allowed_to_override': [

{alita_sdk-0.3.350 → alita_sdk-0.3.351}/alita_sdk/runtime/langchain/langraph_agent.py

@@ -583,11 +583,10 @@ def create_graph(
                     available_tools = [tool for tool in tools if isinstance(tool, BaseTool)]
                 
                 lg_builder.add_node(node_id, LLMNode(
-                    client=client, 
-                    prompt=node.get('prompt', {}),
-                    name=node['id'], 
+                    client=client,
+                    input_mapping=node.get('input_mapping', {'messages': {'type': 'variable', 'value': 'messages'}}),
+                    name=node['id'],
                     return_type='dict',
-                    response_key=node.get('response_key', 'messages'),
                     structured_output_dict=output_vars_dict,
                     output_variables=output_vars,
                     input_variables=node.get('input', ['messages']),

{alita_sdk-0.3.350 → alita_sdk-0.3.351}/alita_sdk/runtime/tools/llm.py

@@ -1,73 +1,31 @@
-import json
 import logging
 from traceback import format_exc
-from typing import Any, Optional, Dict, List, Union
+from typing import Any, Optional, List, Union
 
-from langchain_core.messages import HumanMessage, BaseMessage, SystemMessage, AIMessage
-from langchain_core.tools import BaseTool, ToolException
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
 from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import BaseTool, ToolException
 from pydantic import Field
 
-from ..langchain.utils import _extract_json, create_pydantic_model, create_params
+from ..langchain.utils import create_pydantic_model, propagate_the_input_mapping
 
 logger = logging.getLogger(__name__)
 
-
-def create_llm_input_with_messages(
-    prompt: Dict[str, str],
-    params: Dict[str, Any]
-) -> List[BaseMessage]:
-    """
-    Create LLM input by combining system prompt with chat history messages.
-    
-    Args:
-        prompt: The prompt configuration with template
-        params: Additional parameters for prompt formatting
-        
-    Returns:
-        List of messages to send to LLM
-    """
-    logger.info(f"Creating LLM input with params: {params}")
-    
-    # Build the input messages
-    input_messages = []
-    messages = params.get('messages', [])
-    
-    # Add system message from prompt if available
-    if prompt:
-        try:
-            # Format the system message using the prompt template or value and params
-            prompt_str = prompt['template'] if 'template' in prompt else prompt['value']
-            prompt_content = prompt_str.format(**params) if params else prompt_str
-            # if user hasn't specified chat history, add system message as HumanMessage
-            input_messages.append(SystemMessage(content=prompt_content) if messages else HumanMessage(content=prompt_content))
-        except KeyError as e:
-            error_msg = f"KeyError in prompt formatting: {e}. Available params: {list(params.keys())}"
-            logger.error(error_msg)
-            raise ToolException(error_msg)
-    
-    # Add the chat history messages
-
-    if messages:
-        input_messages.extend(messages)
-
-    return input_messages
-
-
 class LLMNode(BaseTool):
     """Enhanced LLM node with chat history and tool binding support"""
     
     # Override BaseTool required fields
     name: str = Field(default='LLMNode', description='Name of the LLM node')
-    description: str = Field(default='This is tool node for LLM with chat history and tool support', description='Description of the LLM node')
-    
+    description: str = Field(default='This is tool node for LLM with chat history and tool support',
+                             description='Description of the LLM node')
+
     # LLM-specific fields
-    prompt: Dict[str, str] = Field(default_factory=dict, description='Prompt configuration')
     client: Any = Field(default=None, description='LLM client instance')
     return_type: str = Field(default="str", description='Return type')
     response_key: str = Field(default="messages", description='Response key')
     structured_output_dict: Optional[dict[str, str]] = Field(default=None, description='Structured output dictionary')
     output_variables: Optional[List[str]] = Field(default=None, description='Output variables')
+    input_mapping: Optional[dict[str, dict]] = Field(default=None, description='Input mapping')
     input_variables: Optional[List[str]] = Field(default=None, description='Input variables')
     structured_output: Optional[bool] = Field(default=False, description='Whether to use structured output')
     available_tools: Optional[List[BaseTool]] = Field(default=None, description='Available tools for binding')
@@ -101,10 +59,10 @@ class LLMNode(BaseTool):
         return filtered_tools
 
     def invoke(
-        self,
-        state: Union[str, dict],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Any,
+            self,
+            state: Union[str, dict],
+            config: Optional[RunnableConfig] = None,
+            **kwargs: Any,
     ) -> dict:
         """
         Invoke the LLM node with proper message handling and tool binding.
@@ -118,24 +76,33 @@ class LLMNode(BaseTool):
             Updated state with LLM response
         """
         # Extract messages from state
-        
-        messages = state.get("messages", []) if isinstance(state, dict) else []
-        logger.info(f"Invoking LLMNode with {len(messages)} messages")
-        logger.info("Messages: %s", messages)
-        # Create parameters for prompt formatting from state
-        params = {}
-        if isinstance(state, dict):
-            params = {var: state[var] for var in (self.input_variables or []) if var != "messages" and var in state}
-            # message as a part of chat history added ONLY if "messages" is in input_variables
-            if "messages" in (self.input_variables or []):
-                params["messages"] = messages
-        
-        # Create LLM input with proper message handling
-        llm_input = create_llm_input_with_messages(self.prompt, params)
-        
+
+        func_args = propagate_the_input_mapping(input_mapping=self.input_mapping, input_variables=self.input_variables,
+                                                state=state)
+
+        # there are 2 possible flows here: LLM node from pipeline (with prompt and task)
+        # or standalone LLM node for chat (with messages only)
+        if 'system' in func_args.keys():
+            # Flow for LLM node with prompt/task from pipeline
+            if not func_args.get('system') or not func_args.get('task'):
+                raise ToolException(f"LLMNode requires 'system' and 'task' parameters in input mapping. "
+                                    f"Actual params: {func_args}")
+            messages = [SystemMessage(content=func_args.get('system')), HumanMessage(content=func_args.get('task'))]
+            messages.extend(func_args.get('chat_history', []))
+        else:
+            # Flow for chat-based LLM node w/o prompt/task from pipeline but with messages in state
+            # verify messages structure
+            messages = state.get("messages", []) if isinstance(state, dict) else []
+            if messages:
+                # the last message has to be HumanMessage
+                if not isinstance(messages[:1][0], HumanMessage):
+                    raise ToolException("LLMNode requires the last message to be a HumanMessage")
+            else:
+                raise ToolException("LLMNode requires 'messages' in state for chat-based interaction")
+
         # Get the LLM client, potentially with tools bound
         llm_client = self.client
-        
+
         if len(self.tool_names or []) > 0:
             filtered_tools = self.get_filtered_tools()
             if filtered_tools:
@@ -143,7 +110,7 @@ class LLMNode(BaseTool):
                 llm_client = self.client.bind_tools(filtered_tools)
             else:
                 logger.warning("No tools to bind to LLM")
-        
+
         try:
             if self.structured_output and self.output_variables:
                 # Handle structured output
@@ -156,17 +123,17 @@ class LLMNode(BaseTool):
                 }
                 struct_model = create_pydantic_model(f"LLMOutput", struct_params)
                 llm = llm_client.with_structured_output(struct_model)
-                completion = llm.invoke(llm_input, config=config)
+                completion = llm.invoke(messages, config=config)
                 result = completion.model_dump()
-                
+
                 # Ensure messages are properly formatted
                 if result.get('messages') and isinstance(result['messages'], list):
                     result['messages'] = [{'role': 'assistant', 'content': '\n'.join(result['messages'])}]
-                
+
                 return result
             else:
                 # Handle regular completion
-                completion = llm_client.invoke(llm_input, config=config)
+                completion = llm_client.invoke(messages, config=config)
                 logger.info(f"Initial completion: {completion}")
                 # Handle both tool-calling and regular responses
                 if hasattr(completion, 'tool_calls') and completion.tool_calls:
@@ -174,24 +141,30 @@ class LLMNode(BaseTool):
                     new_messages = messages + [completion]
                     max_iterations = 15
                     iteration = 0
-                    
+
                     # Continue executing tools until no more tool calls or max iterations reached
                     current_completion = completion
-                    while (hasattr(current_completion, 'tool_calls') and 
-                           current_completion.tool_calls and 
+                    while (hasattr(current_completion, 'tool_calls') and
+                           current_completion.tool_calls and
                            iteration < max_iterations):
-                        
+
                         iteration += 1
                         logger.info(f"Tool execution iteration {iteration}/{max_iterations}")
-                        
+
                         # Execute each tool call in the current completion
-                        tool_calls = current_completion.tool_calls if hasattr(current_completion.tool_calls, '__iter__') else []
-                        
+                        tool_calls = current_completion.tool_calls if hasattr(current_completion.tool_calls,
+                                                                              '__iter__') else []
+
                         for tool_call in tool_calls:
-                            tool_name = tool_call.get('name', '') if isinstance(tool_call, dict) else getattr(tool_call, 'name', '')
-                            tool_args = tool_call.get('args', {}) if isinstance(tool_call, dict) else getattr(tool_call, 'args', {})
-                            tool_call_id = tool_call.get('id', '') if isinstance(tool_call, dict) else getattr(tool_call, 'id', '')
-                            
+                            tool_name = tool_call.get('name', '') if isinstance(tool_call, dict) else getattr(tool_call,
+                                                                                                              'name',
+                                                                                                              '')
+                            tool_args = tool_call.get('args', {}) if isinstance(tool_call, dict) else getattr(tool_call,
+                                                                                                              'args',
+                                                                                                              {})
+                            tool_call_id = tool_call.get('id', '') if isinstance(tool_call, dict) else getattr(
+                                tool_call, 'id', '')
+
                             # Find the tool in filtered tools
                             filtered_tools = self.get_filtered_tools()
                             tool_to_execute = None
@@ -199,12 +172,12 @@ class LLMNode(BaseTool):
                                 if tool.name == tool_name:
                                     tool_to_execute = tool
                                     break
-                            
+
                             if tool_to_execute:
                                 try:
                                     logger.info(f"Executing tool '{tool_name}' with args: {tool_args}")
                                     tool_result = tool_to_execute.invoke(tool_args)
-                                    
+
                                     # Create tool message with result
                                     from langchain_core.messages import ToolMessage
                                     tool_message = ToolMessage(
@@ -212,7 +185,7 @@ class LLMNode(BaseTool):
                                         tool_call_id=tool_call_id
                                     )
                                     new_messages.append(tool_message)
-                                    
+
                                 except Exception as e:
                                     logger.error(f"Error executing tool '{tool_name}': {e}")
                                     # Create error tool message
@@ -231,26 +204,26 @@ class LLMNode(BaseTool):
                                     tool_call_id=tool_call_id
                                 )
                                 new_messages.append(tool_message)
-                        
+
                         # Call LLM again with tool results to get next response
                         try:
                             current_completion = llm_client.invoke(new_messages, config=config)
                             new_messages.append(current_completion)
-                            
+
                             # Check if we still have tool calls
                             if hasattr(current_completion, 'tool_calls') and current_completion.tool_calls:
                                 logger.info(f"LLM requested {len(current_completion.tool_calls)} more tool calls")
                             else:
                                 logger.info("LLM completed without requesting more tools")
                                 break
-                                
+
                         except Exception as e:
                             logger.error(f"Error in LLM call during iteration {iteration}: {e}")
                             # Add error message and break the loop
                             error_msg = f"Error processing tool results in iteration {iteration}: {str(e)}"
                             new_messages.append(AIMessage(content=error_msg))
                             break
-                    
+
                     # Log completion status
                     if iteration >= max_iterations:
                         logger.warning(f"Reached maximum iterations ({max_iterations}) for tool execution")
@@ -259,30 +232,25 @@ class LLMNode(BaseTool):
                         new_messages.append(AIMessage(content=warning_msg))
                     else:
                         logger.info(f"Tool execution completed after {iteration} iterations")
-                    
+
                     return {"messages": new_messages}
                 else:
                     # Regular text response
                     content = completion.content.strip() if hasattr(completion, 'content') else str(completion)
-                    
+
                     # Try to extract JSON if output variables are specified (but exclude 'messages' which is handled separately)
                     json_output_vars = [var for var in (self.output_variables or []) if var != 'messages']
                     if json_output_vars:
-                        try:
-                            response = _extract_json(content) or {}
-                            response_data = {key: response.get(key, content) for key in json_output_vars}
-                        except (ValueError, json.JSONDecodeError) as e:
-                            logger.warning(
-                                f"Expected JSON output but got plain text. Output variables specified: {json_output_vars}. Error: {e}")
-                            response_data = {var: content for var in json_output_vars}
+                        # set response to be the first output variable for non-structured output
+                        response_data = {json_output_vars[0]: content}
                         new_messages = messages + [AIMessage(content=content)]
                         response_data['messages'] = new_messages
                         return response_data
-                    
+
                     # Simple text response (either no output variables or JSON parsing failed)
                     new_messages = messages + [AIMessage(content=content)]
                     return {"messages": new_messages}
-                        
+
         except Exception as e:
             logger.error(f"Error in LLM Node: {format_exc()}")
             error_msg = f"Error: {e}"
@@ -291,4 +259,4 @@ class LLMNode(BaseTool):
 
     def _run(self, *args, **kwargs):
         # Legacy support for old interface
-        return self.invoke(kwargs, **kwargs)
+        return self.invoke(kwargs, **kwargs)

{alita_sdk-0.3.350 → alita_sdk-0.3.351}/alita_sdk.egg-info/PKG-INFO

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

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