alita-sdk 0.3.182__tar.gz → 0.3.184__tar.gz

{alita_sdk-0.3.182 → alita_sdk-0.3.184}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.182
+Version: 0.3.184
 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 <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0
@@ -124,6 +124,7 @@ Requires-Dist: shortuuid==1.0.13; extra == "tools"
 Requires-Dist: yarl==1.17.1; extra == "tools"
 Requires-Dist: langmem==0.0.27; extra == "tools"
 Requires-Dist: textract-py3==2.1.1; extra == "tools"
+Requires-Dist: slack_sdk==3.35.0; extra == "tools"
 Provides-Extra: community
 Requires-Dist: retry-extended==0.2.3; extra == "community"
 Requires-Dist: pyobjtojson==0.3; extra == "community"

{alita_sdk-0.3.182 → alita_sdk-0.3.184}/alita_sdk/runtime/clients/client.py

@@ -432,3 +432,41 @@ class AlitaClient:
         except Exception as e:
             logger.warning(f"Error: Could not determine user ID for MCP tool: {e}")
             return None
+
+    def predict_agent(self, client: Any, instructions: str = "You are a helpful assistant.",
+                      tools: Optional[list] = None, chat_history: Optional[List[Any]] = None,
+                      memory=None, runtime='langchain', variables: Optional[list] = None,
+                      store: Optional[BaseStore] = None):
+        """
+        Create a predict-type agent with minimal configuration.
+        
+        Args:
+            client: The LLM client to use
+            instructions: System instructions for the agent
+            tools: Optional list of tools to provide to the agent
+            chat_history: Optional chat history
+            memory: Optional memory/checkpointer
+            runtime: Runtime type (default: 'langchain')
+            variables: Optional list of variables for the agent
+            store: Optional store for memory
+            
+        Returns:
+            Runnable agent ready for execution
+        """
+        if tools is None:
+            tools = []
+        if chat_history is None:
+            chat_history = []
+        if variables is None:
+            variables = []
+            
+        # Create a minimal data structure for predict agent
+        # All LLM settings are taken from the passed client instance
+        agent_data = {
+            'instructions': instructions,
+            'tools': tools,  # Tools are handled separately in predict agents
+            'variables': variables
+        }
+        return LangChainAssistant(self, agent_data, client,
+                                  chat_history, "predict", memory=memory, store=store).runnable()
+        

alita_sdk-0.3.184/alita_sdk/runtime/langchain/assistant.py

@@ -0,0 +1,305 @@
+import logging
+import importlib
+from copy import deepcopy as copy
+from typing import Any, Optional
+from langchain.agents import (
+    AgentExecutor, create_openai_tools_agent,
+    create_json_chat_agent)
+from langgraph.store.base import BaseStore
+from .agents.xml_chat import create_xml_chat_agent
+from .langraph_agent import create_graph
+from langchain_core.messages import (
+    BaseMessage, SystemMessage, HumanMessage
+)
+from langchain_core.prompts import MessagesPlaceholder
+from .constants import REACT_ADDON, REACT_VARS, XML_ADDON
+from .chat_message_template import Jinja2TemplatedChatMessagesTemplate
+from ..tools.echo import EchoTool
+from langchain_core.tools import BaseTool, ToolException
+
+logger = logging.getLogger(__name__)
+
+class Assistant:
+    def __init__(self,
+                 alita: 'AlitaClient',
+                 data: dict,
+                 client: 'LLMLikeObject',
+                 chat_history: list[BaseMessage] = [],
+                 app_type: str = "openai",
+                 tools: Optional[list] = [],
+                 memory: Optional[Any] = None,
+                 store: Optional[BaseStore] = None):
+
+        self.app_type = app_type
+        self.memory = memory
+        self.store = store
+
+        logger.debug("Data for agent creation: %s", data)
+        logger.info("App type: %s", app_type)
+
+        # For predict agents, use the client as-is since it's already configured
+        if app_type == "predict":
+            self.client = client
+        else:
+            # For other agent types, configure client from llm_settings
+            self.client = copy(client)
+            self.client.max_tokens = data['llm_settings']['max_tokens']
+            self.client.temperature = data['llm_settings']['temperature']
+            self.client.top_p = data['llm_settings']['top_p']
+            self.client.top_k = data['llm_settings']['top_k']
+            self.client.model_name = data['llm_settings']['model_name']
+            self.client.integration_uid = data['llm_settings']['integration_uid']
+
+            model_type = data["llm_settings"]["indexer_config"]["ai_model"]
+            model_params = data["llm_settings"]["indexer_config"]["ai_model_params"]
+            #
+            target_pkg, target_name = model_type.rsplit(".", 1)
+            target_cls = getattr(
+                importlib.import_module(target_pkg),
+                target_name
+            )
+            self.client = target_cls(**model_params)
+        # validate agents compatibility: non-pipeline agents cannot have pipelines as toolkits
+        if app_type not in ["pipeline", "predict"]:
+            tools_to_check = data.get('tools', [])
+            if any(tool['agent_type'] == 'pipeline' for tool in tools_to_check):
+                raise ToolException("Non-pipeline agents cannot have pipelines as a toolkits. "
+                                    "Review toolkits configuration or use pipeline as master agent.")
+
+        # configure memory store if memory tool is defined (not needed for predict agents)
+        if app_type != "predict":
+            memory_tool = next((tool for tool in data.get('tools', []) if tool['type'] == 'memory'), None)
+            self._configure_store(memory_tool)
+        else:
+            # For predict agents, initialize memory store to None since they don't use memory
+            self.store = None
+        
+        # Lazy import to avoid circular dependency
+        from ..toolkits.tools import get_tools
+        
+        self.tools = get_tools(data['tools'], alita_client=alita, llm=self.client, memory_store=self.store)
+        if tools:
+            self.tools += tools
+        # Handle prompt setup
+        if app_type in ["pipeline", "predict", "react"]:
+            self.prompt = data['instructions']
+        else:
+            messages = [SystemMessage(content=data['instructions'])]
+            messages.append(MessagesPlaceholder("chat_history"))
+            if app_type == "react":
+                messages.append(HumanMessage(REACT_ADDON))
+            elif app_type == "xml":
+                messages.append(HumanMessage(XML_ADDON))
+            elif app_type in ['openai', 'dial']:
+                messages.append(HumanMessage("{{input}}"))
+            messages.append(MessagesPlaceholder("agent_scratchpad"))
+            variables = {}
+            input_variables = []
+            for variable in data['variables']:
+                if variable['value'] != "":
+                    variables[variable['name']] = variable['value']
+                else:
+                    input_variables.append(variable['name'])
+            if app_type in ["react", "xml"]:
+                input_variables = list(set(input_variables + REACT_VARS))
+
+            if chat_history and isinstance(chat_history, list):
+                messages.extend(chat_history)
+            self.prompt = Jinja2TemplatedChatMessagesTemplate(messages=messages)
+            if input_variables:
+                self.prompt.input_variables = input_variables
+            if variables:
+                self.prompt.partial_variables = variables
+            try:
+                logger.info(f"Client was created with client setting: temperature - {self.client._get_model_default_parameters}")
+            except Exception as e:
+                logger.info(f"Client was created with client setting: temperature - {self.client.temperature} : {self.client.max_tokens}")
+
+    def _configure_store(self, memory_tool: dict | None) -> None:
+        """
+        Configure the memory store based on a memory_tool definition.
+        Only creates a new store if one does not already exist.
+        """
+        if not memory_tool or self.store is not None:
+            return
+        from .store_manager import get_manager
+        conn_str = memory_tool.get('settings', {}).get('connection_string', '')
+        store = get_manager().get_store(conn_str)
+        self.store = store
+
+    def runnable(self):
+        if self.app_type == 'pipeline':
+            return self.pipeline()
+        elif self.app_type == 'openai':
+            return self.getOpenAIToolsAgentExecutor()
+        elif self.app_type == 'xml':
+            return self.getXMLAgentExecutor()
+        elif self.app_type in ['predict', 'react']:
+            return self.getLangGraphReactAgent()
+        else:
+            self.tools = [EchoTool()] + self.tools
+            return self.getAgentExecutor()
+
+    def _agent_executor(self, agent: Any):
+        return AgentExecutor.from_agent_and_tools(agent=agent, tools=self.tools,
+                                                  verbose=True, handle_parsing_errors=True,
+                                                  max_execution_time=None, return_intermediate_steps=True)
+
+    def getAgentExecutor(self):
+        # Exclude compiled graph runnables from simple tool agents
+        simple_tools = [t for t in self.tools if isinstance(t, BaseTool)]
+        agent = create_json_chat_agent(llm=self.client, tools=simple_tools, prompt=self.prompt)
+        return self._agent_executor(agent)
+
+
+    def getXMLAgentExecutor(self):
+        # Exclude compiled graph runnables from simple tool agents
+        simple_tools = [t for t in self.tools if isinstance(t, BaseTool)]
+        agent = create_xml_chat_agent(llm=self.client, tools=simple_tools, prompt=self.prompt)
+        return self._agent_executor(agent)
+
+    def getOpenAIToolsAgentExecutor(self):
+        # Exclude compiled graph runnables from simple tool agents
+        simple_tools = [t for t in self.tools if isinstance(t, BaseTool)]
+        agent = create_openai_tools_agent(llm=self.client, tools=simple_tools, prompt=self.prompt)
+        return self._agent_executor(agent)
+
+    def getLangGraphReactAgent(self):
+        """
+        Create a LangGraph react agent using a tool-calling agent pattern.
+        This creates a proper LangGraphAgentRunnable with modern tool support.
+        """
+        # Exclude compiled graph runnables from simple tool agents
+        simple_tools = [t for t in self.tools if isinstance(t, BaseTool)]
+        
+        # Set up memory/checkpointer if available
+        checkpointer = None
+        if self.memory is not None:
+            checkpointer = self.memory
+        elif self.store is not None:
+            # Convert store to checkpointer if needed
+            from langgraph.checkpoint.memory import MemorySaver
+            checkpointer = MemorySaver()
+        else:
+            # Ensure we have a checkpointer for conversation persistence
+            from langgraph.checkpoint.memory import MemorySaver
+            checkpointer = MemorySaver()
+            logger.info("Using default MemorySaver for conversation persistence")
+        
+        # Extract all messages from prompt/chat history for LangGraph
+        chat_history_messages = []
+        prompt_instructions = None
+        
+        if hasattr(self.prompt, 'messages') and self.prompt.messages:
+            # Extract all messages from the prompt to use as chat history
+            for message in self.prompt.messages:
+                # Skip placeholders (MessagesPlaceholder instances) as they are not actual messages
+                if hasattr(message, 'variable_name'):  # MessagesPlaceholder has variable_name attribute
+                    continue
+                # Skip template messages (contains {{variable}} patterns)
+                if hasattr(message, 'content') and isinstance(message.content, str) and '{{' in message.content and '}}' in message.content:
+                    continue
+                # Include actual chat history messages
+                chat_history_messages.append(message)
+        
+        # Only use prompt_instructions if explicitly specified (for predict app_type)
+        if self.app_type == "predict" and isinstance(self.prompt, str):
+            prompt_instructions = self.prompt
+        
+        # Create a unified YAML schema with conditional tool binding
+        # Build the base node configuration
+        node_config = {
+            'id': 'agent',
+            'type': 'llm',
+            'prompt': {
+                'template': prompt_instructions or "You are a helpful assistant."
+            },
+            'input': ['messages'],
+            'output': ['messages'],
+            'transition': 'END'
+        }
+        
+        # Add tool binding only if tools are present
+        if simple_tools:
+            tool_names = [tool.name for tool in simple_tools]
+            tool_names_yaml = str(tool_names).replace("'", '"')  # Convert to YAML-compatible format
+            node_config['tool_names'] = tool_names_yaml
+            logger.info("Binding tools: %s", tool_names)
+        
+        # Properly setup the prompt for YAML
+        import yaml
+        escaped_prompt = prompt_instructions or "You are a helpful assistant."
+        
+        # Create the schema as a dictionary first, then convert to YAML
+        state_messages_config = {'type': 'list'}
+        
+        # Only set initial messages if there's actual conversation history (not just system prompts)
+        actual_conversation_messages = [
+            msg for msg in chat_history_messages 
+            if not isinstance(msg, SystemMessage)  # Exclude system messages as they're handled by prompt template
+        ]
+        
+        if actual_conversation_messages:
+            state_messages_config['value'] = actual_conversation_messages
+            logger.info(f"Setting initial conversation history with {len(actual_conversation_messages)} messages")
+        
+        schema_dict = {
+            'name': 'react_agent',
+            'state': {
+                'messages': state_messages_config
+            },
+            'nodes': [{
+                'id': 'agent',
+                'type': 'llm',
+                'prompt': {
+                    'template': escaped_prompt
+                },
+                'input': ['messages'],
+                'output': ['messages'],
+                'transition': 'END'
+            }],
+            'entry_point': 'agent'
+        }
+        
+        # Add tool-specific parameters only if tools exist
+        if simple_tools:
+            schema_dict['nodes'][0]['tool_names'] = tool_names
+        
+        # Convert to YAML string
+        yaml_schema = yaml.dump(schema_dict, default_flow_style=False, allow_unicode=True)
+        
+        # Use create_graph function to build the agent like other graph types
+        from .langraph_agent import create_graph
+    
+        agent = create_graph(
+            client=self.client,
+            yaml_schema=yaml_schema,
+            tools=simple_tools,
+            memory=checkpointer,
+            store=self.store,
+            debug=False,
+            for_subgraph=False
+        )
+        
+        return agent
+
+    def pipeline(self):
+        memory = self.memory
+        #
+        if memory is None:
+            from langgraph.checkpoint.memory import MemorySaver  # pylint: disable=E0401,C0415
+            memory = MemorySaver()
+        #
+        agent = create_graph(
+            client=self.client, tools=self.tools,
+            yaml_schema=self.prompt, memory=memory
+        )
+        #
+        return agent
+
+    # This one is used only in Alita and OpenAI
+    def apredict(self, messages: list[BaseMessage]):
+        yield from self.client.ainvoke(messages)
+
+    def predict(self, messages: list[BaseMessage]):
+        return self.client.invoke(messages)

{alita_sdk-0.3.182 → alita_sdk-0.3.184}/alita_sdk/runtime/langchain/langraph_agent.py

@@ -6,7 +6,7 @@ from typing import Dict
 import yaml
 import ast
 from langchain_core.callbacks import dispatch_custom_event
-from langchain_core.messages import HumanMessage
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, BaseMessage
 from langchain_core.runnables import Runnable
 from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool
@@ -498,14 +498,36 @@ def create_graph(
                     var: get_type_hints(state_class).get(var, str).__name__
                     for var in output_vars
                 }
+                
+                # Check if tools should be bound to this LLM node
+                tool_names = node.get('tool_names', []) if isinstance(node.get('tool_names'), list) else []
+                
+                # Filter tools if specific tool names are provided
+                available_tools = []
+            
+                if tool_names:
+                    # Filter tools by name
+                    tool_dict = {tool.name: tool for tool in tools if isinstance(tool, BaseTool)}
+                    available_tools = [tool_dict[name] for name in tool_names if name in tool_dict]
+                    if len(available_tools) != len(tool_names):
+                        missing_tools = [name for name in tool_names if name not in tool_dict]
+                        logger.warning(f"Some tools not found for LLM node {node_id}: {missing_tools}")
+                else:
+                    # Use all available tools
+                    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'], return_type='dict',
+                    client=client, 
+                    prompt=node.get('prompt', {}),
+                    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']),
-                    structured_output=node.get('structured_output', False)))
+                    structured_output=node.get('structured_output', False),
+                    available_tools=available_tools,
+                    tool_names=tool_names))
             elif node_type == 'router':
                 # Add a RouterNode as an independent node
                 lg_builder.add_node(node_id, RouterNode(
@@ -604,6 +626,29 @@ def create_graph(
     return compiled.validate()
 
 
+def convert_dict_to_message(msg_dict):
+    """Convert a dictionary message to a LangChain message object."""
+    if isinstance(msg_dict, BaseMessage):
+        return msg_dict  # Already a LangChain message
+    
+    if isinstance(msg_dict, dict):
+        role = msg_dict.get('role', 'user')
+        content = msg_dict.get('content', '')
+        
+        if role == 'user':
+            return HumanMessage(content=content)
+        elif role == 'assistant':
+            return AIMessage(content=content)
+        elif role == 'system':
+            return SystemMessage(content=content)
+        else:
+            # Default to HumanMessage for unknown roles
+            return HumanMessage(content=content)
+    
+    # If it's neither dict nor BaseMessage, convert to string and make HumanMessage
+    return HumanMessage(content=str(msg_dict))
+
+
 class LangGraphAgentRunnable(CompiledStateGraph):
     def __init__(self, *args, output_variables=None, **kwargs):
         super().__init__(*args, **kwargs)
@@ -612,16 +657,28 @@ class LangGraphAgentRunnable(CompiledStateGraph):
     def invoke(self, input: Union[dict[str, Any], Any],
                config: Optional[RunnableConfig] = None,
                *args, **kwargs):
-
+        logger.info(f"Incomming Input: {input}")
         if not config.get("configurable", {}).get("thread_id"):
             config["configurable"] = {"thread_id": str(uuid4())}
         thread_id = config.get("configurable", {}).get("thread_id")
+        # Handle chat history and current input properly
         if input.get('chat_history') and not input.get('messages'):
-            input['messages'] = input.pop('chat_history')
+            # Convert chat history dict messages to LangChain message objects
+            chat_history = input.pop('chat_history')
+            input['messages'] = [convert_dict_to_message(msg) for msg in chat_history]
+        
+        # Append current input to existing messages instead of overwriting
         if input.get('input'):
-            input['messages'] = [{"role": "user", "content": input.get('input')}]
+            current_message = HumanMessage(content=input.get('input'))
+            if input.get('messages'):
+                # Ensure existing messages are LangChain objects
+                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]
         logging.info(f"Input: {thread_id} - {input}")
-
         if self.checkpointer and self.checkpointer.get_tuple(config):
             self.update_state(config, input)
             result = super().invoke(None, config=config, *args, **kwargs)

{alita_sdk-0.3.182 → alita_sdk-0.3.184}/alita_sdk/runtime/llms/alita.py

@@ -35,7 +35,7 @@ from langchain_core.messages import (AIMessageChunk, BaseMessage, HumanMessage,
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
 from langchain_core.runnables import run_in_executor
 from langchain_community.chat_models.openai import generate_from_stream, _convert_delta_to_message_chunk
-from ..clients import AlitaClient
+from ..clients.client import AlitaClient
 from pydantic import Field, model_validator, field_validator, ValidationInfo
 
 logger = logging.getLogger(__name__)

{alita_sdk-0.3.182 → alita_sdk-0.3.184}/alita_sdk/runtime/toolkits/tools.py

@@ -99,9 +99,57 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
     # Add MCP tools
     tools += _mcp_tools(tools_list, alita_client)
     
+    # Sanitize tool names to meet OpenAI's function naming requirements
+    tools = _sanitize_tool_names(tools)
+    
     return tools
 
 
+def _sanitize_tool_names(tools: list) -> list:
+    """
+    Sanitize tool names to meet OpenAI's function naming requirements.
+    OpenAI function names must match pattern ^[a-zA-Z0-9_\\.-]+$
+    """
+    import re
+    from langchain_core.tools import BaseTool
+    
+    def sanitize_name(name):
+        """Sanitize a single tool name"""
+        # Replace spaces and other invalid characters with underscores
+        sanitized = re.sub(r'[^a-zA-Z0-9_.-]', '_', name)
+        # Remove multiple consecutive underscores
+        sanitized = re.sub(r'_{2,}', '_', sanitized)
+        # Remove leading/trailing underscores
+        sanitized = sanitized.strip('_')
+        return sanitized
+    
+    sanitized_tools = []
+    name_mapping = {}
+    
+    for tool in tools:
+        if isinstance(tool, BaseTool):
+            original_name = tool.name
+            sanitized_name = sanitize_name(original_name)
+            
+            # Only update if the name actually changed
+            if original_name != sanitized_name:
+                logger.info(f"Sanitizing tool name: '{original_name}' -> '{sanitized_name}'")
+                # Create a new tool instance with the sanitized name
+                # We need to be careful here to preserve all other tool properties
+                tool.name = sanitized_name
+                name_mapping[original_name] = sanitized_name
+            
+            sanitized_tools.append(tool)
+        else:
+            # For non-BaseTool objects (like CompiledStateGraph), just pass through
+            sanitized_tools.append(tool)
+    
+    if name_mapping:
+        logger.info(f"Tool name sanitization complete. Mapped {len(name_mapping)} tool names.")
+    
+    return sanitized_tools
+
+
 def _mcp_tools(tools_list, alita):
     try:
         all_available_toolkits = alita.get_mcp_toolkits()