alita-sdk 0.3.181__tar.gz → 0.3.183__tar.gz

{alita_sdk-0.3.181 → alita_sdk-0.3.183}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.181
+Version: 0.3.183
 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
@@ -32,7 +32,7 @@ Requires-Dist: langchain-openai~=0.3.0; extra == "runtime"
 Requires-Dist: langgraph-checkpoint-sqlite~=2.0.0; extra == "runtime"
 Requires-Dist: langgraph-checkpoint-postgres~=2.0.1; extra == "runtime"
 Requires-Dist: langsmith>=0.3.45; extra == "runtime"
-Requires-Dist: langgraph>=0.5; extra == "runtime"
+Requires-Dist: langgraph<0.5,>=0.4.8; extra == "runtime"
 Requires-Dist: langchain_chroma~=0.2.2; extra == "runtime"
 Requires-Dist: langchain-unstructured~=0.1.6; extra == "runtime"
 Requires-Dist: langchain-postgres~=0.0.13; extra == "runtime"
@@ -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.181 → alita_sdk-0.3.183}/alita_sdk/runtime/clients/client.py

@@ -218,6 +218,8 @@ class AlitaClient:
             return LangChainAssistant(self, data, client,
                                       chat_history, app_type,
                                       tools=tools, memory=memory, store=store).runnable()
+        elif runtime == 'llama':
+            raise NotImplementedError("LLama runtime is not supported")
 
     def datasource(self, datasource_id: int) -> AlitaDataSource:
         url = f"{self.datasources}/{datasource_id}"

{alita_sdk-0.3.181 → alita_sdk-0.3.183}/alita_sdk/runtime/langchain/assistant.py

@@ -6,16 +6,10 @@ from langchain.agents import (
     AgentExecutor, create_openai_tools_agent,
     create_json_chat_agent)
 from langgraph.store.base import BaseStore
-
-# Note: Traditional LangChain agents (OpenAI, XML, JSON) do not support 
-# checkpointing natively. Only LangGraph agents support checkpointing.
-# For checkpointing in traditional agents, you need to migrate to LangGraph.
-
 from .agents.xml_chat import create_xml_chat_agent
-from .agents.react_agent import get_langgraph_agent_with_auto_continue
 from .langraph_agent import create_graph
 from langchain_core.messages import (
-    BaseMessage, SystemMessage, HumanMessage, AIMessage
+    BaseMessage, SystemMessage, HumanMessage
 )
 from langchain_core.prompts import MessagesPlaceholder
 from .constants import REACT_ADDON, REACT_VARS, XML_ADDON
@@ -34,8 +28,7 @@ class Assistant:
                  app_type: str = "openai",
                  tools: Optional[list] = [],
                  memory: Optional[Any] = None,
-                 store: Optional[BaseStore] = None,
-                 use_checkpointing: bool = False):
+                 store: Optional[BaseStore] = None):
 
         self.client = copy(client)
         self.client.max_tokens = data['llm_settings']['max_tokens']
@@ -48,7 +41,6 @@ class Assistant:
         self.app_type = app_type
         self.memory = memory
         self.store = store
-        self.use_checkpointing = use_checkpointing
 
         logger.debug("Data for agent creation: %s", data)
         logger.info("App type: %s", app_type)
@@ -74,33 +66,17 @@ class Assistant:
         # 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 app_type == "pipeline":
+        if app_type in ["pipeline", "predict", "react"]:
             self.prompt = data['instructions']
-        elif app_type == "react":
-            self.tools += tools
-            messages = [SystemMessage(content=data['instructions'])]
-            # messages.append(HumanMessage("{{input}}"))
-            self.prompt = Jinja2TemplatedChatMessagesTemplate(messages=messages)
-            variables = {}
-            input_variables = []
-            for variable in data['variables']:
-                if variable['value'] != "":
-                    variables[variable['name']] = variable['value']
-                else:
-                    input_variables.append(variable['name'])
-            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}")
+            if tools:
+                self.tools += tools
         else:
             self.tools += tools
             messages = [SystemMessage(content=data['instructions'])]
             messages.append(MessagesPlaceholder("chat_history"))
-            if app_type == "xml":
+            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}}"))
@@ -112,7 +88,7 @@ class Assistant:
                     variables[variable['name']] = variable['value']
                 else:
                     input_variables.append(variable['name'])
-            if app_type in ["xml"]:
+            if app_type in ["react", "xml"]:
                 input_variables = list(set(input_variables + REACT_VARS))
 
             if chat_history and isinstance(chat_history, list):
@@ -143,17 +119,14 @@ class Assistant:
         if self.app_type == 'pipeline':
             return self.pipeline()
         elif self.app_type == 'openai':
-            # Check if checkpointing is enabled - if so, use LangGraph for auto-continue capability
-            if self.use_checkpointing:
-                return self.getLangGraphAgentWithAutoContinue()
             return self.getOpenAIToolsAgentExecutor()
         elif self.app_type == 'xml':
-            # Check if checkpointing is enabled - if so, use LangGraph for auto-continue capability
-            if self.use_checkpointing:
-                return self.getLangGraphAgentWithAutoContinue()
             return self.getXMLAgentExecutor()
+        elif self.app_type in ['predict', 'react']:
+            return self.getLangGraphReactAgent()
         else:
-            return self.getLangGraphAgentWithAutoContinue()
+            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,
@@ -179,6 +152,125 @@ class Assistant:
         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
         #
@@ -199,22 +291,3 @@ class Assistant:
 
     def predict(self, messages: list[BaseMessage]):
         return self.client.invoke(messages)
-
-    def getLangGraphAgentWithAutoContinue(self):
-        """
-        Create a LangGraph agent with auto-continue capability for when responses get truncated.
-        This provides better handling of length-limited responses compared to traditional AgentExecutor.
-        Uses simple in-memory checkpointing for auto-continue functionality.
-        
-        Note: Requires LangGraph 0.5.x or higher that supports post_model_hook.
-        """
-
-        # Use the function from react_agent.py to create the agent
-        return get_langgraph_agent_with_auto_continue(
-            prompt=self.prompt,
-            model=self.client,
-            tools=self.tools,
-            memory=self.memory,
-            debug=True
-        )
-

{alita_sdk-0.3.181 → alita_sdk-0.3.183}/alita_sdk/runtime/langchain/langraph_agent.py

@@ -6,13 +6,13 @@ 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
 from langgraph.channels.ephemeral_value import EphemeralValue
 from langgraph.graph import StateGraph
-from langgraph.graph import END, START
+from langgraph.graph.graph import END, START
 from langgraph.graph.state import CompiledStateGraph
 from langgraph.managed.base import is_managed_value
 from langgraph.prebuilt import InjectedStore
@@ -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.181 → alita_sdk-0.3.183}/alita_sdk/runtime/llms/alita.py

@@ -12,24 +12,31 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
+#
+#  This is adoption of https://github.com/langchain-ai/langchain/blob/master/libs/community/langchain_community/chat_models/openai.py
+#
+
 import logging
 import requests
 from time import sleep
 from traceback import format_exc
 
-from typing import Any, List, Optional, AsyncIterator, Dict, Iterator
+from typing import Any, List, Optional, AsyncIterator, Dict, Iterator, Mapping, Type
 from tiktoken import get_encoding, encoding_for_model
 from langchain_core.callbacks import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import AIMessageChunk, BaseMessage
+from langchain_core.language_models import BaseChatModel, SimpleChatModel
+from langchain_core.messages import (AIMessageChunk, BaseMessage, HumanMessage, HumanMessageChunk, ChatMessageChunk, 
+                                     FunctionMessageChunk, SystemMessageChunk, ToolMessageChunk, BaseMessageChunk,
+                                     AIMessage)
 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 pydantic import Field, model_validator
+from ..clients.client import AlitaClient
+from pydantic import Field, model_validator, field_validator, ValidationInfo
 
 logger = logging.getLogger(__name__)