alita-sdk 0.3.257__py3-none-any.whl → 0.3.562__py3-none-any.whl

alita_sdk/runtime/langchain/utils.py

@@ -2,15 +2,62 @@ 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__)
 
 
+def extract_text_from_completion(completion) -> str:
+    """Extract text content from LLM completion, handling both string and list formats.
+    
+    For thinking-enabled models (like Claude with extended thinking), completion.content
+    can be a list of content blocks. This function extracts only the text blocks and
+    concatenates them into a single string.
+    
+    Args:
+        completion: LLM completion object with content attribute
+        
+    Returns:
+        str: Extracted text content (never a list)
+    """
+    if not hasattr(completion, 'content'):
+        return ""
+        
+    content = completion.content
+    
+    # Handle list of content blocks (Anthropic extended thinking format)
+    if isinstance(content, list):
+        text_blocks = []
+        
+        for block in content:
+            if isinstance(block, dict):
+                block_type = block.get('type', '')
+                if block_type == 'text':
+                    text_blocks.append(block.get('text', ''))
+                elif block_type == 'thinking':
+                    # Skip thinking blocks - we only want the actual text response
+                    continue
+            elif hasattr(block, 'type'):
+                # Handle object format
+                if block.type == 'text':
+                    text_blocks.append(getattr(block, 'text', ''))
+                # Skip thinking blocks
+        
+        return '\n\n'.join(text_blocks) if text_blocks else ""
+    
+    # Handle simple string content
+    elif isinstance(content, str):
+        return content
+    
+    # Fallback
+    return str(content) if content else ""
+
+
 def _find_json_bounds(json_string: str) -> Tuple[int, int] | Tuple[None, None]:
     stack = []
     json_start = None
@@ -121,6 +168,8 @@ def parse_type(type_str):
     """Parse a type string into an actual Python type."""
     try:
         # Evaluate the type string using builtins and imported modules
+        if type_str == 'number':
+            type_str = 'int'
         return eval(type_str, {**vars(builtins), **globals()})
     except Exception as e:
         print(f"Error parsing type: {e}")
@@ -128,16 +177,23 @@ 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)
 
 def create_typed_dict_from_yaml(data):
@@ -170,16 +226,54 @@ 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)
+        if 'default' in var_data:
+            # allow user to define if it is required or not
+            fields[var_name] = (parse_pydantic_type(var_data['type']),
+                                Field(description=var_data.get('description', None), default=var_data.get('default')))
+        else:
+            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/skills/__init__.py

@@ -0,0 +1,91 @@
+"""
+Skills Registry system for alita_sdk.
+
+This package provides a comprehensive skills registry system that supports
+both graph-based and agent-based skills with isolated execution and
+callback support.
+
+Key Components:
+- models: Core data models and types
+- discovery: Skill discovery from filesystem
+- registry: Thread-safe registry service
+- executor: Skill execution with isolation
+- callbacks: Event system for execution transparency
+
+Usage:
+    from alita_sdk.runtime.skills import get_default_registry
+
+    registry = get_default_registry()
+    skills = registry.list()
+    skill = registry.get("my_skill")
+
+    # Execute skill through SkillRouterTool or direct execution
+"""
+
+from .models import (
+    SkillMetadata,
+    SkillType,
+    SkillSource,
+    ExecutionMode,
+    SkillStatus,
+    SkillEventType,
+    ExecutionConfig,
+    ResultsConfig,
+    SkillInputSchema,
+    SkillOutputSchema,
+    SkillExecutionResult,
+    SkillOutputFile,
+    SkillEvent,
+    SkillValidationError,
+    SkillExecutionError
+)
+
+from .discovery import SkillDiscovery
+from .registry import SkillsRegistry, get_default_registry, reset_default_registry
+from .executor import SkillExecutor
+from .input_builder import SkillInputBuilder
+from .callbacks import (
+    SkillCallback, CallbackManager, LoggingCallback, ProgressCallback,
+    FileCallback, SkillLangChainCallback, CallbackEmitter,
+    create_default_callbacks, create_debug_callbacks
+)
+
+__all__ = [
+    # Core models
+    "SkillMetadata",
+    "SkillType",
+    "SkillSource",
+    "ExecutionMode",
+    "SkillStatus",
+    "SkillEventType",
+    "ExecutionConfig",
+    "ResultsConfig",
+    "SkillInputSchema",
+    "SkillOutputSchema",
+    "SkillExecutionResult",
+    "SkillOutputFile",
+    "SkillEvent",
+
+    # Exceptions
+    "SkillValidationError",
+    "SkillExecutionError",
+
+    # Services
+    "SkillDiscovery",
+    "SkillsRegistry",
+    "get_default_registry",
+    "reset_default_registry",
+    "SkillExecutor",
+    "SkillInputBuilder",
+
+    # Callbacks
+    "SkillCallback",
+    "CallbackManager",
+    "LoggingCallback",
+    "ProgressCallback",
+    "FileCallback",
+    "SkillLangChainCallback",
+    "CallbackEmitter",
+    "create_default_callbacks",
+    "create_debug_callbacks"
+]