alita-sdk 0.3.351__py3-none-any.whl → 0.3.499__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,16 +131,22 @@ 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']:
+        elif value in ['str', 'int', 'float', 'bool', 'list', 'dict', 'number', 'dict']:
             state_dict[key] = parse_type(value)
+
+    state_dict["state_types"] = types_dict  # Default value for state_types
+    types_dict["state_types"] = dict
     logger.debug(f"Created state: {state_dict}")
     return TypedDict('State', state_dict)
 
@@ -173,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/llms/preloaded.py

@@ -105,8 +105,7 @@ class PreloadedChatModel(BaseChatModel):  # pylint: disable=R0903
     model_name: str = ""
     max_tokens: Optional[int] = 256
     temperature: Optional[float] = 0.9
-    top_p: Optional[float] = 0.9
-    top_k: Optional[int] = 20
+    reasoning_effort: Optional[str] = None
     token_limit: Optional[int] = 1024
 
     _local_streams: Any = PrivateAttr()
@@ -252,8 +251,7 @@ class PreloadedChatModel(BaseChatModel):  # pylint: disable=R0903
             "return_full_text": False,
             "temperature": self.temperature,
             "do_sample": True,
-            "top_k": self.top_k,
-            "top_p": self.top_p,
+            "reasoning_effort": self.reasoning_effort
         }
         #
         try:
@@ -302,8 +300,6 @@ class PreloadedChatModel(BaseChatModel):  # pylint: disable=R0903
             "return_full_text": False,
             "temperature": self.temperature,
             "do_sample": True,
-            "top_k": self.top_k,
-            "top_p": self.top_p,
         }
         #
         while True:

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,26 @@
+"""
+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 .planning import PlanningToolkit
+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",
+    "PlanningToolkit",
+    "PromptToolkit",
+    "SubgraphToolkit",
+    "VectorStoreToolkit",
+    "McpToolkit",
+    "MemoryToolkit"
+]

alita_sdk/runtime/toolkits/application.py

@@ -28,7 +28,7 @@ class ApplicationToolkit(BaseToolkit):
         version_details = client.get_app_version_details(application_id, application_version_id)
         model_settings = {
             "max_tokens": version_details['llm_settings']['max_tokens'],
-            "top_p": version_details['llm_settings']['top_p'],
+            "reasoning_effort": version_details['llm_settings'].get('reasoning_effort'),
             "temperature": version_details['llm_settings']['temperature'],
         }
 
@@ -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

@@ -1,6 +1,6 @@
 from typing import List, Any, Literal, Optional
 
-from alita_sdk.tools.utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from alita_sdk.tools.utils import clean_string, get_max_toolkit_length
 from langchain_community.agent_toolkits.base import BaseToolkit
 from langchain_core.tools import BaseTool
 from pydantic import create_model, BaseModel, ConfigDict, Field
@@ -21,7 +21,10 @@ class ArtifactToolkit(BaseToolkit):
         return create_model(
             "artifact",
             # client = (Any, FieldInfo(description="Client object", required=True, autopopulate=True)),
-            bucket = (str, FieldInfo(description="Bucket name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': ArtifactToolkit.toolkit_max_length})),
+            bucket=(str, FieldInfo(
+                description="Bucket name",
+                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
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None, description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
@@ -30,29 +33,38 @@ 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
     def get_toolkit(cls, client: Any, bucket: str, toolkit_name: Optional[str] = None, selected_tools: list[str] = [], **kwargs):
         if selected_tools is None:
             selected_tools = []
+        
         tools = []
         wrapper_payload = {
             **kwargs,
             **(kwargs.get('pgvector_configuration') or {}),
         }
         artifact_wrapper = ArtifactWrapper(alita=client, bucket=bucket, **wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
+        # Use clean toolkit name for context (max 1000 chars in description)
+        toolkit_context = f" [Toolkit: {clean_string(toolkit_name, 0)}]" if toolkit_name else ''
         available_tools = artifact_wrapper.get_available_tools()
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            # Add toolkit context to description with character limit
+            description = tool["description"]
+            if toolkit_context and len(description + toolkit_context) <= 1000:
+                description = description + toolkit_context
             tools.append(BaseAction(
                 api_wrapper=artifact_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/runtime/toolkits/datasource.py

@@ -3,7 +3,7 @@ from pydantic import create_model, BaseModel, Field
 from langchain_community.agent_toolkits.base import BaseToolkit
 from langchain_core.tools import BaseTool, ToolException
 from ..tools.datasource import DatasourcePredict, DatasourceSearch, datasourceToolSchema
-from alita_sdk.tools.utils import clean_string, TOOLKIT_SPLITTER
+from alita_sdk.tools.utils import clean_string
 
 
 class DatasourcesToolkit(BaseToolkit):
@@ -21,21 +21,28 @@ class DatasourcesToolkit(BaseToolkit):
     @classmethod
     def get_toolkit(cls, client: Any, datasource_ids: list[int], toolkit_name: Optional[str] = None, selected_tools: list[str] = []):
         tools = []
-        prefix = clean_string(toolkit_name) + TOOLKIT_SPLITTER if toolkit_name else ''
+        # Use clean toolkit name for context (max 1000 chars in description)
+        toolkit_context = f" [Toolkit: {clean_string(toolkit_name)}]" if toolkit_name else ''
         for datasource_id in datasource_ids:
             datasource = client.datasource(datasource_id)
             ds_name = clean_string(datasource.name)
             if len(ds_name) == 0:
                 raise ToolException(f'Datasource with id {datasource_id} has incorrect name (i.e. special characters, etc.)')
             if len(selected_tools) == 0 or 'chat' in selected_tools:
-                tools.append(DatasourcePredict(name=f'{prefix}chat',
-                                            description=f'Search and summarize. {datasource.description}',
+                description = f'Search and summarize. {datasource.description}'
+                if toolkit_context and len(description + toolkit_context) <= 1000:
+                    description = description + toolkit_context
+                tools.append(DatasourcePredict(name=f'chat',
+                                            description=description,
                                             datasource=datasource, 
                                             args_schema=datasourceToolSchema,
                                             return_type='str'))
             if len(selected_tools) == 0 or 'search' in selected_tools:
-                tools.append(DatasourceSearch(name=f'{prefix}search',
-                                                description=f'Search return results. {datasource.description}',
+                description = f'Search return results. {datasource.description}'
+                if toolkit_context and len(description + toolkit_context) <= 1000:
+                    description = description + toolkit_context
+                tools.append(DatasourceSearch(name=f'search',
+                                                description=description,
                                                 datasource=datasource, 
                                                 args_schema=datasourceToolSchema,
                                                 return_type='str'))