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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.182
+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
@@ -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.183}/alita_sdk/runtime/langchain/assistant.py

@@ -6,7 +6,6 @@ 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 (
@@ -67,8 +66,10 @@ 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']
+            if tools:
+                self.tools += tools
         else:
             self.tools += tools
             messages = [SystemMessage(content=data['instructions'])]
@@ -121,6 +122,8 @@ class Assistant:
             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()
@@ -149,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
         #

{alita_sdk-0.3.182 → alita_sdk-0.3.183}/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.183}/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.183/alita_sdk/runtime/tools/llm.py

@@ -0,0 +1,293 @@
+import json
+import logging
+from traceback import format_exc
+from typing import Any, Optional, Dict, List, Union
+
+from langchain_core.messages import HumanMessage, BaseMessage, SystemMessage, AIMessage
+from langchain_core.tools import BaseTool, ToolException
+from langchain_core.runnables import RunnableConfig
+from pydantic import Field
+
+from ..langchain.utils import _extract_json, create_pydantic_model, create_params
+
+logger = logging.getLogger(__name__)
+
+
+def create_llm_input_with_messages(
+    prompt: Dict[str, str], 
+    messages: List[BaseMessage], 
+    params: Dict[str, Any]
+) -> List[BaseMessage]:
+    """
+    Create LLM input by combining system prompt with chat history messages.
+    
+    Args:
+        prompt: The prompt configuration with template
+        messages: List of chat history messages
+        params: Additional parameters for prompt formatting
+        
+    Returns:
+        List of messages to send to LLM
+    """
+    logger.info(f"Creating LLM input with messages: {len(messages)} messages, params: {params}")
+    
+    # Build the input messages
+    input_messages = []
+    
+    # Add system message from prompt if available
+    if prompt and prompt.get('template'):
+        try:
+            system_content = prompt['template'].format(**params) if params else prompt['template']
+            input_messages.append(SystemMessage(content=system_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')
+    
+    # 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_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')
+    tool_names: Optional[List[str]] = Field(default=None, description='Specific tool names to filter')
+
+    def get_filtered_tools(self) -> List[BaseTool]:
+        """
+        Filter available tools based on tool_names list.
+        
+        Returns:
+            List of filtered tools
+        """
+        if not self.available_tools:
+            return []
+            
+        if not self.tool_names:
+            # If no specific tool names provided, return all available tools
+            return self.available_tools
+            
+        # Filter tools by name
+        filtered_tools = []
+        available_tool_names = {tool.name: tool for tool in self.available_tools}
+        
+        for tool_name in self.tool_names:
+            if tool_name in available_tool_names:
+                filtered_tools.append(available_tool_names[tool_name])
+                logger.debug(f"Added tool '{tool_name}' to LLM node")
+            else:
+                logger.warning(f"Tool '{tool_name}' not found in available tools: {list(available_tool_names.keys())}")
+        
+        return filtered_tools
+
+    def invoke(
+        self,
+        state: Union[str, dict],
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
+    ) -> dict:
+        """
+        Invoke the LLM node with proper message handling and tool binding.
+        
+        Args:
+            state: The current state containing messages and other variables
+            config: Optional runnable config
+            **kwargs: Additional keyword arguments
+            
+        Returns:
+            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):
+            for var in self.input_variables or []:
+                if var != "messages" and var in state:
+                    params[var] = state[var]
+        
+        # Create LLM input with proper message handling
+        llm_input = create_llm_input_with_messages(self.prompt, messages, params)
+        
+        # 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:
+                logger.info(f"Binding {len(filtered_tools)} tools to LLM: {[t.name for t in filtered_tools]}")
+                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
+                struct_params = {
+                    key: {
+                        "type": 'list[str]' if 'list' in value else value,
+                        "description": ""
+                    }
+                    for key, value in (self.structured_output_dict or {}).items()
+                }
+                struct_model = create_pydantic_model(f"LLMOutput", struct_params)
+                llm = llm_client.with_structured_output(struct_model)
+                completion = llm.invoke(llm_input, 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)
+                logger.info(f"Initial completion: {completion}")
+                # Handle both tool-calling and regular responses
+                if hasattr(completion, 'tool_calls') and completion.tool_calls:
+                    # Handle iterative tool-calling and execution
+                    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 
+                           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 []
+                        
+                        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', '')
+                            
+                            # Find the tool in filtered tools
+                            filtered_tools = self.get_filtered_tools()
+                            tool_to_execute = None
+                            for tool in filtered_tools:
+                                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(
+                                        content=str(tool_result),
+                                        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
+                                    from langchain_core.messages import ToolMessage
+                                    tool_message = ToolMessage(
+                                        content=f"Error executing {tool_name}: {str(e)}",
+                                        tool_call_id=tool_call_id
+                                    )
+                                    new_messages.append(tool_message)
+                            else:
+                                logger.warning(f"Tool '{tool_name}' not found in available tools")
+                                # Create error tool message for missing tool
+                                from langchain_core.messages import ToolMessage
+                                tool_message = ToolMessage(
+                                    content=f"Tool '{tool_name}' not available",
+                                    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")
+                        # Add a warning message to the chat
+                        warning_msg = f"Maximum tool execution iterations ({max_iterations}) reached. Stopping tool execution."
+                        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) for key in json_output_vars if key in response}
+                            
+                            # Always add the messages to the response
+                            new_messages = messages + [AIMessage(content=content)]
+                            response_data['messages'] = new_messages
+                            
+                            return response_data
+                        except (ValueError, json.JSONDecodeError) as e:
+                            # LLM returned non-JSON content, treat as plain text
+                            logger.warning(f"Expected JSON output but got plain text. Output variables specified: {json_output_vars}. Error: {e}")
+                            # Fall through to plain text handling
+                    
+                    # 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}"
+            new_messages = messages + [AIMessage(content=error_msg)]
+            return {"messages": new_messages}
+
+    def _run(self, *args, **kwargs):
+        # Legacy support for old interface
+        return self.invoke(kwargs, **kwargs)

{alita_sdk-0.3.182 → alita_sdk-0.3.183}/alita_sdk/runtime/tools/mcp_server_tool.py

@@ -35,6 +35,21 @@ class McpServerTool(BaseTool):
                 field_type = float
             elif field_type == 'boolean':
                 field_type = bool
+            elif field_type == 'object':#Dict[str, Any]
+                nested_model = McpServerTool.create_pydantic_model_from_schema(field_info)
+                field_type = nested_model
+            elif field_type == 'array':
+                item_schema = field_info['items']
+                item_type = McpServerTool.create_pydantic_model_from_schema(item_schema) if item_schema['type'] == 'object' else (
+                    str if item_schema['type'] == 'string' else
+                    int if item_schema['type'] == 'integer' else
+                    float if item_schema['type'] == 'number' else
+                    bool if item_schema['type'] == 'boolean' else
+                    None
+                )
+                if item_type is None:
+                    raise ValueError(f"Unsupported array item type: {item_schema['type']}")
+                field_type = list[item_type]
             else:
                 raise ValueError(f"Unsupported field type: {field_type}")
 

{alita_sdk-0.3.182 → alita_sdk-0.3.183}/alita_sdk/runtime/utils/streamlit.py

@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 
 ai_icon = b'<plain_txt_msg:img>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<!plain_txt_msg>'
 user_icon = b'<plain_txt_msg:img>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<!plain_txt_msg>'
-agent_types = ["pipeline", "react", "xml", "openai"]
+agent_types = ["pipeline", "react", "xml", "openai", "predict"]
 
 def img_to_txt(filename):
     msg = b"<plain_txt_msg:img>"
@@ -1034,6 +1034,7 @@ def run_streamlit(st, ai_icon=None, user_icon=None):
             st.session_state.messages.append({"role": "user", "content": prompt})
             with st.chat_message("assistant", avatar=ai_icon):
                 st_cb = AlitaStreamlitCallback(st)
+                logger.info(st.session_state.messages)
                 response = st.session_state.agent_executor.invoke(
                     {"input": prompt, "chat_history": st.session_state.messages[:-1]},
                     { 'callbacks': [st_cb], 'configurable': {"thread_id": st.session_state.thread_id}}

{alita_sdk-0.3.182 → alita_sdk-0.3.183}/alita_sdk/tools/__init__.py

@@ -79,6 +79,7 @@ _safe_import_tool('pptx', 'pptx', 'get_tools', 'PPTXToolkit')
 _safe_import_tool('postman', 'postman', 'get_tools', 'PostmanToolkit')
 _safe_import_tool('memory', 'memory', 'get_tools', 'MemoryToolkit')
 _safe_import_tool('zephyr_squad', 'zephyr_squad', 'get_tools', 'ZephyrSquadToolkit')
+_safe_import_tool('slack', 'slack', 'get_tools', 'SlackToolkit')
 
 # Log import summary
 available_count = len(AVAILABLE_TOOLS)