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

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']:
@@ -177,16 +180,49 @@ def propagate_the_input_mapping(input_mapping: dict[str, dict], input_variables:
             var_dict = create_params(input_variables, source)
 
         if value['type'] == 'fstring':
-            input_data[key] = value['value'].format(**var_dict)
+            try:
+                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}")
+                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