alita-sdk 0.3.379__py3-none-any.whl → 0.3.462__py3-none-any.whl

alita_sdk/runtime/langchain/langraph_agent.py

@@ -19,8 +19,9 @@ from langgraph.managed.base import is_managed_value
 from langgraph.prebuilt import InjectedStore
 from langgraph.store.base import BaseStore
 
+from .constants import PRINTER_NODE_RS, PRINTER, PRINTER_COMPLETED_STATE
 from .mixedAgentRenderes import convert_message_to_json
-from .utils import create_state, propagate_the_input_mapping
+from .utils import create_state, propagate_the_input_mapping, safe_format
 from ..tools.function import FunctionTool
 from ..tools.indexer_tool import IndexerNode
 from ..tools.llm import LLMNode
@@ -232,6 +233,32 @@ class StateDefaultNode(Runnable):
                     result[key] = temp_value
         return result
 
+class PrinterNode(Runnable):
+    name = "PrinterNode"
+
+    def __init__(self, input_mapping: Optional[dict[str, dict]]):
+        self.input_mapping = input_mapping
+
+    def invoke(self, state: BaseStore, config: Optional[RunnableConfig] = None) -> dict:
+        logger.info(f"Printer Node - Current state variables: {state}")
+        result = {}
+        logger.debug(f"Initial text pattern: {self.input_mapping}")
+        mapping = propagate_the_input_mapping(self.input_mapping, [], state)
+        # for printer node we expect that all the lists will be joined into strings already
+        # Join any lists that haven't been converted yet
+        for key, value in mapping.items():
+            if isinstance(value, list):
+                mapping[key] = ', '.join(str(item) for item in value)
+        if mapping.get(PRINTER) is None:
+            raise ToolException(f"PrinterNode requires '{PRINTER}' field in input mapping")
+        formatted_output = mapping[PRINTER]
+        # add info label to the printer's output
+        if not formatted_output == PRINTER_COMPLETED_STATE:
+            formatted_output += f"\n\n-----\n*How to proceed?*\n* *to resume the pipeline - type anything...*"
+        logger.debug(f"Formatted output: {formatted_output}")
+        result[PRINTER_NODE_RS] = formatted_output
+        return result
+
 
 class StateModifierNode(Runnable):
     name = "StateModifierNode"
@@ -348,8 +375,8 @@ class StateModifierNode(Runnable):
         return result
 
 
-
-def prepare_output_schema(lg_builder, memory, store, debug=False, interrupt_before=None, interrupt_after=None, state_class=None, output_variables=None):
+def prepare_output_schema(lg_builder, memory, store, debug=False, interrupt_before=None, interrupt_after=None,
+                          state_class=None, output_variables=None):
     # prepare output channels
     if interrupt_after is None:
         interrupt_after = []
@@ -453,10 +480,14 @@ def create_graph(
             if toolkit_name:
                 tool_name = f"{clean_string(toolkit_name)}{TOOLKIT_SPLITTER}{tool_name}"
             logger.info(f"Node: {node_id} : {node_type} - {tool_name}")
-            if node_type in ['function', 'tool', 'loop', 'loop_from_tool', 'indexer', 'subgraph', 'pipeline', 'agent']:
+            if node_type in ['function', 'toolkit', 'mcp', 'tool', 'loop', 'loop_from_tool', 'indexer', 'subgraph', 'pipeline', 'agent']:
+                if node_type == 'mcp' and tool_name not in [tool.name for tool in tools]:
+                    # MCP is not connected and node cannot be added
+                    raise ToolException(f"MCP tool '{tool_name}' not found in the provided tools. "
+                                        f"Make sure it is connected properly. Available tools: {[tool.name for tool in tools]}")
                 for tool in tools:
                     if tool.name == tool_name:
-                        if node_type == 'function':
+                        if node_type in ['function', 'toolkit', 'mcp']:
                             lg_builder.add_node(node_id, FunctionTool(
                                 tool=tool, name=node_id, return_type='dict',
                                 output_variables=node.get('output', []),
@@ -466,11 +497,12 @@ def create_graph(
                         elif node_type == 'agent':
                             input_params = node.get('input', ['messages'])
                             input_mapping = node.get('input_mapping',
-                                                       {'messages': {'type': 'variable', 'value': 'messages'}})
+                                                     {'messages': {'type': 'variable', 'value': 'messages'}})
+                            output_vars = node.get('output', [])
                             lg_builder.add_node(node_id, FunctionTool(
                                 client=client, tool=tool,
                                 name=node_id, return_type='str',
-                                output_variables=node.get('output', []),
+                                output_variables=output_vars + ['messages'] if 'messages' not in output_vars else output_vars,
                                 input_variables=input_params,
                                 input_mapping= input_mapping
                             ))
@@ -481,7 +513,8 @@ def create_graph(
                             # wrap with mappings
                             pipeline_name = node.get('tool', None)
                             if not pipeline_name:
-                                raise ValueError("Subgraph must have a 'tool' node: add required tool to the subgraph node")
+                                raise ValueError(
+                                    "Subgraph must have a 'tool' node: add required tool to the subgraph node")
                             node_fn = SubgraphRunnable(
                                 inner=tool.graph,
                                 name=pipeline_name,
@@ -499,15 +532,6 @@ def create_graph(
                                 structured_output=node.get('structured_output', False),
                                 task=node.get('task')
                             ))
-                        # TODO: decide on struct output for agent nodes
-                        # elif node_type == 'agent':
-                        #     lg_builder.add_node(node_id, AgentNode(
-                        #         client=client, tool=tool,
-                        #         name=node['id'], return_type='dict',
-                        #         output_variables=node.get('output', []),
-                        #         input_variables=node.get('input', ['messages']),
-                        #         task=node.get('task')
-                        #     ))
                         elif node_type == 'loop':
                             lg_builder.add_node(node_id, LoopNode(
                                 client=client, tool=tool,
@@ -520,7 +544,8 @@ def create_graph(
                             loop_toolkit_name = node.get('loop_toolkit_name')
                             loop_tool_name = node.get('loop_tool')
                             if (loop_toolkit_name and loop_tool_name) or loop_tool_name:
-                                loop_tool_name = f"{clean_string(loop_toolkit_name)}{TOOLKIT_SPLITTER}{loop_tool_name}" if loop_toolkit_name else clean_string(loop_tool_name)
+                                loop_tool_name = f"{clean_string(loop_toolkit_name)}{TOOLKIT_SPLITTER}{loop_tool_name}" if loop_toolkit_name else clean_string(
+                                    loop_tool_name)
                                 for t in tools:
                                     if t.name == loop_tool_name:
                                         logger.debug(f"Loop tool discovered: {t}")
@@ -555,7 +580,8 @@ def create_graph(
                         break
             elif node_type == 'code':
                 from ..tools.sandbox import create_sandbox_tool
-                sandbox_tool = create_sandbox_tool(stateful=False, allow_net=True)
+                sandbox_tool = create_sandbox_tool(stateful=False, allow_net=True,
+                                                   alita_client=kwargs.get('alita_client', None))
                 code_data = node.get('code', {'type': 'fixed', 'value': "return 'Code block is empty'"})
                 lg_builder.add_node(node_id, FunctionTool(
                     tool=sandbox_tool, name=node['id'], return_type='dict',
@@ -593,7 +619,7 @@ def create_graph(
                 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,
                     input_mapping=node.get('input_mapping', {'messages': {'type': 'variable', 'value': 'messages'}}),
@@ -604,7 +630,9 @@ def create_graph(
                     input_variables=node.get('input', ['messages']),
                     structured_output=node.get('structured_output', False),
                     available_tools=available_tools,
-                    tool_names=tool_names))
+                    tool_names=tool_names,
+                    steps_limit=kwargs.get('steps_limit', 25)
+                ))
             elif node_type == 'router':
                 # Add a RouterNode as an independent node
                 lg_builder.add_node(node_id, RouterNode(
@@ -624,6 +652,7 @@ def create_graph(
                         default_output=node.get('default_output', 'END')
                     )
                 )
+                continue
             elif node_type == 'state_modifier':
                 lg_builder.add_node(node_id, StateModifierNode(
                     template=node.get('template', ''),
@@ -631,6 +660,22 @@ def create_graph(
                     input_variables=node.get('input', ['messages']),
                     output_variables=node.get('output', [])
                 ))
+            elif node_type == 'printer':
+                lg_builder.add_node(node_id, PrinterNode(
+                    input_mapping=node.get('input_mapping', {'printer': {'type': 'fixed', 'value': ''}}),
+                ))
+
+                # add interrupts after printer node if specified
+                interrupt_after.append(clean_string(node_id))
+
+                # reset printer output variable to avoid carrying over
+                reset_node_id = f"{node_id}_reset"
+                lg_builder.add_node(reset_node_id, PrinterNode(
+                    input_mapping={'printer': {'type': 'fixed', 'value': PRINTER_COMPLETED_STATE}}
+                ))
+                lg_builder.add_conditional_edges(node_id, TransitionalEdge(reset_node_id))
+                lg_builder.add_conditional_edges(reset_node_id, TransitionalEdge(clean_string(node['transition'])))
+                continue
             if node.get('transition'):
                 next_step = clean_string(node['transition'])
                 logger.info(f'Adding transition: {next_step}')
@@ -777,31 +822,103 @@ class LangGraphAgentRunnable(CompiledStateGraph):
             # 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]
-        
+
+        # handler for LLM node: if no input (Chat perspective), then take last human message
+        # Track if input came from messages to handle content extraction properly
+        input_from_messages = False
+        if not input.get('input'):
+            if input.get('messages'):
+                input['input'] = [next((msg for msg in reversed(input['messages']) if isinstance(msg, HumanMessage)),
+                                      None)]
+                if input['input'] is not None:
+                    input_from_messages = True
+
         # Append current input to existing messages instead of overwriting
         if input.get('input'):
             if isinstance(input['input'], str):
                 current_message = input['input']
             else:
+                # input can be a list of messages or a single message object
                 current_message = input.get('input')[-1]
+
             # TODO: add handler after we add 2+ inputs (filterByType, etc.)
-            input['input'] = current_message if isinstance(current_message, str) else str(current_message)
+            if isinstance(current_message, HumanMessage):
+                current_content = current_message.content
+                if isinstance(current_content, list):
+                    # Extract text parts and keep non-text parts (images, etc.)
+                    text_contents = []
+                    non_text_parts = []
+                    
+                    for item in current_content:
+                        if isinstance(item, dict) and item.get('type') == 'text':
+                            text_contents.append(item['text'])
+                        elif isinstance(item, str):
+                            text_contents.append(item)
+                        else:
+                            # Keep image_url and other non-text content
+                            non_text_parts.append(item)
+                    
+                    # Set input to the joined text
+                    input['input'] = ". ".join(text_contents) if text_contents else ""
+                    
+                    # If this message came from input['messages'], update or remove it
+                    if input_from_messages:
+                        if non_text_parts:
+                            # Keep the message but only with non-text content (images, etc.)
+                            current_message.content = non_text_parts
+                        else:
+                            # All content was text, remove this message from the list
+                            input['messages'] = [msg for msg in input['messages'] if msg is not current_message]
+                
+                elif isinstance(current_content, str):
+                    # on regenerate case
+                    input['input'] = current_content
+                    # If from messages and all content is text, remove the message
+                    if input_from_messages:
+                        input['messages'] = [msg for msg in input['messages'] if msg is not current_message]
+                else:
+                    input['input'] = str(current_content)
+                    # If from messages, remove since we extracted the content
+                    if input_from_messages:
+                        input['messages'] = [msg for msg in input['messages'] if msg is not current_message]
+            elif isinstance(current_message, str):
+                input['input'] = current_message
+            else:
+                input['input'] = str(current_message)
             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]
+                # input['messages'].append(current_message)
+            # else:
+                # NOTE: Commented out to prevent duplicates with input['input']
+                # input['messages'] = [current_message]
+        
+        # Validate that input is not empty after all processing
+        if not input.get('input'):
+            raise RuntimeError(
+                "Empty input after processing. Cannot send empty string to LLM. "
+                "This likely means the message contained only non-text content "
+                "with no accompanying text."
+            )
+        
         logging.info(f"Input: {thread_id} - {input}")
         if self.checkpointer and self.checkpointer.get_tuple(config):
             self.update_state(config, input)
-            result = super().invoke(None, config=config, *args, **kwargs)
+            if config.pop("should_continue", False):
+                invoke_input = input
+            else:
+                invoke_input = None
+            result = super().invoke(invoke_input, config=config, *args, **kwargs)
         else:
             result = super().invoke(input, config=config, *args, **kwargs)
         try:
-            output = next((msg.content for msg in reversed(result['messages']) if not isinstance(msg, HumanMessage)), result['messages'][-1].content)
+            if result.get(PRINTER_NODE_RS) == PRINTER_COMPLETED_STATE:
+                output = next((msg.content for msg in reversed(result['messages']) if not isinstance(msg, HumanMessage)),
+                              result['messages'][-1].content)
+            else:
+                # used for printer node output - it will be reset by next `reset` node
+                output = result.get(PRINTER_NODE_RS)
         except:
             output = list(result.values())[-1]
         config_state = self.get_state(config)
@@ -809,8 +926,6 @@ class LangGraphAgentRunnable(CompiledStateGraph):
         if is_execution_finished:
             thread_id = None
 
-
-
         result_with_state = {
             "output": output,
             "thread_id": thread_id,

alita_sdk/runtime/langchain/utils.py

@@ -2,11 +2,12 @@ import builtins
 import json
 import logging
 import re
-from pydantic import create_model, Field
+from pydantic import create_model, Field, Json
 from typing import Tuple, TypedDict, Any, Optional, Annotated
 from langchain_core.messages import AnyMessage
-from langchain_core.prompts import PromptTemplate
-from langgraph.graph import MessagesState, add_messages
+from langgraph.graph import add_messages
+
+from ...runtime.langchain.constants import ELITEA_RS, PRINTER_NODE_RS
 
 logger = logging.getLogger(__name__)
 
@@ -130,13 +131,15 @@ def parse_type(type_str):
 
 
 def create_state(data: Optional[dict] = None):
-    state_dict = {'input': str, 'router_output': str}  # Always include router_output
+    state_dict = {'input': str, 'messages': 'list[str]', 'router_output': str,
+                  ELITEA_RS: str, PRINTER_NODE_RS: str}  # Always include router_output
     types_dict = {}
     if not data:
         data = {'messages': 'list[str]'}
     for key, value in data.items():
         # support of old & new UI
         value = value['type'] if isinstance(value, dict) else value
+        value = 'str' if value == 'string' else value  # normalize string type (old state support)
         if key == 'messages':
             state_dict[key] = Annotated[list[AnyMessage], add_messages]
         elif value in ['str', 'int', 'float', 'bool', 'list', 'dict', 'number', 'dict']:
@@ -181,16 +184,45 @@ def propagate_the_input_mapping(input_mapping: dict[str, dict], input_variables:
                 input_data[key] = value['value'].format(**var_dict)
             except KeyError as e:
                 logger.error(f"KeyError in fstring formatting for key '{key}'. Attempt to find proper data in state.\n{e}")
-                input_data[key] = value['value'].format(**state)
+                try:
+                    # search for variables in state if not found in var_dict
+                    input_data[key] = safe_format(value['value'], state)
+                except KeyError as no_var_exception:
+                    logger.error(f"KeyError in fstring formatting for key '{key}' with state data.\n{no_var_exception}")
+                    # leave value as is if still not found (could be a constant string marked as fstring by mistake)
+                    input_data[key] = value['value']
         elif value['type'] == 'fixed':
             input_data[key] = value['value']
         else:
             input_data[key] = source.get(value['value'], "")
     return input_data
 
+def safe_format(template, mapping):
+    """Format a template string using a mapping, leaving placeholders unchanged if keys are missing."""
+
+    def replacer(match):
+        key = match.group(1)
+        return str(mapping.get(key, f'{{{key}}}'))
+    return re.sub(r'\{(\w+)\}', replacer, template)
 
 def create_pydantic_model(model_name: str, variables: dict[str, dict]):
     fields = {}
     for var_name, var_data in variables.items():
-        fields[var_name] = (parse_type(var_data['type']), Field(description=var_data.get('description', None)))
-    return create_model(model_name, **fields)
+        fields[var_name] = (parse_pydantic_type(var_data['type']), Field(description=var_data.get('description', None)))
+    return create_model(model_name, **fields)
+
+def parse_pydantic_type(type_name: str):
+    """
+    Helper function to parse type names into Python types.
+    Extend this function to handle custom types like 'dict' -> Json[Any].
+    """
+    type_mapping = {
+        'str': str,
+        'int': int,
+        'float': float,
+        'bool': bool,
+        'dict': Json[Any],  # Map 'dict' to Pydantic's Json type
+        'list': list,
+        'any': Any
+    }
+    return type_mapping.get(type_name, Any)

alita_sdk/runtime/models/mcp_models.py

@@ -0,0 +1,61 @@
+"""
+Models for MCP (Model Context Protocol) configuration.
+Following MCP specification for remote HTTP servers only.
+"""
+
+from typing import Optional, List, Dict, Any
+from pydantic import BaseModel, Field, validator
+from urllib.parse import urlparse
+
+
+class McpConnectionConfig(BaseModel):
+    """
+    MCP connection configuration for remote HTTP servers.
+    Based on https://modelcontextprotocol.io/specification/2025-06-18
+    """
+
+    url: str = Field(description="MCP server HTTP URL (http:// or https://)")
+    headers: Optional[Dict[str, str]] = Field(
+        default=None,
+        description="HTTP headers for the connection (JSON object)"
+    )
+    session_id: Optional[str] = Field(
+        default=None,
+        description="MCP session ID for stateful SSE servers (managed by client)"
+    )
+
+    @validator('url')
+    def validate_url(cls, v):
+        """Validate URL is HTTP/HTTPS."""
+        if not v:
+            raise ValueError("URL cannot be empty")
+
+        parsed = urlparse(v)
+        if parsed.scheme not in ['http', 'https']:
+            raise ValueError("URL must use http:// or https:// scheme for remote MCP servers")
+
+        if not parsed.netloc:
+            raise ValueError("URL must include host and port")
+
+        return v
+
+
+class McpToolkitConfig(BaseModel):
+    """Configuration for a single remote MCP server toolkit."""
+
+    server_name: str = Field(description="MCP server name/identifier")
+    connection: McpConnectionConfig = Field(description="MCP connection configuration")
+    timeout: int = Field(default=60, description="Request timeout in seconds", ge=1, le=3600)
+    selected_tools: List[str] = Field(default_factory=list, description="Specific tools to enable (empty = all)")
+    enable_caching: bool = Field(default=True, description="Enable tool schema caching")
+    cache_ttl: int = Field(default=300, description="Cache TTL in seconds", ge=60, le=3600)
+
+
+class McpToolMetadata(BaseModel):
+    """Metadata about an MCP tool."""
+
+    name: str = Field(description="Tool name")
+    description: str = Field(description="Tool description")
+    server: str = Field(description="Source server name")
+    input_schema: Dict[str, Any] = Field(description="Tool input schema")
+    enabled: bool = Field(default=True, description="Whether tool is enabled")

alita_sdk/runtime/toolkits/__init__.py

@@ -0,0 +1,24 @@
+"""
+Runtime toolkits module for Alita SDK.
+This module provides various toolkit implementations for LangGraph agents.
+"""
+
+from .application import ApplicationToolkit
+from .artifact import ArtifactToolkit
+from .datasource import DatasourcesToolkit
+from .prompt import PromptToolkit
+from .subgraph import SubgraphToolkit
+from .vectorstore import VectorStoreToolkit
+from .mcp import McpToolkit
+from ...tools.memory import MemoryToolkit
+
+__all__ = [
+    "ApplicationToolkit",
+    "ArtifactToolkit",
+    "DatasourcesToolkit",
+    "PromptToolkit",
+    "SubgraphToolkit",
+    "VectorStoreToolkit",
+    "McpToolkit",
+    "MemoryToolkit"
+]

alita_sdk/runtime/toolkits/application.py

@@ -39,7 +39,14 @@ class ApplicationToolkit(BaseToolkit):
                                       description=app_details.get("description"), 
                                       application=app, 
                                       args_schema=applicationToolSchema,
-                                      return_type='str')])
+                                      return_type='str',
+                                      client=client,
+                                      args_runnable={
+                                          "application_id": application_id,
+                                          "application_version_id": application_version_id,
+                                          "store": store,
+                                          "llm": client.get_llm(version_details['llm_settings']['model_name'], model_settings),
+                                      })])
             
     def get_tools(self):
         return self.tools

alita_sdk/runtime/toolkits/artifact.py

@@ -23,11 +23,7 @@ class ArtifactToolkit(BaseToolkit):
             # client = (Any, FieldInfo(description="Client object", required=True, autopopulate=True)),
             bucket=(str, FieldInfo(
                 description="Bucket name",
-                pattern=r'^[a-z][a-z0-9-]*$',
-                json_schema_extra={
-                    'toolkit_name': True,
-                    'max_toolkit_length': ArtifactToolkit.toolkit_max_length
-                }
+                pattern=r'^[a-z][a-z0-9-]*$'
             )),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             # indexer settings
@@ -37,7 +33,10 @@ class ArtifactToolkit(BaseToolkit):
             embedding_model=(Optional[str], Field(default=None, description="Embedding configuration.",
                                                   json_schema_extra={'configuration_model': 'embedding'})),
 
-            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Artifact", "icon_url": None}})
+            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Artifact",
+                                                                  "icon_url": None,
+                                                                  "max_length": ArtifactToolkit.toolkit_max_length
+                                                                  }})
         )
     
     @classmethod