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

alita_sdk/runtime/langchain/utils.py

@@ -2,7 +2,7 @@ import builtins
 import json
 import logging
 import re
-from pydantic import create_model, Field, Json
+from pydantic import create_model, Field, JsonValue
 from typing import Tuple, TypedDict, Any, Optional, Annotated
 from langchain_core.messages import AnyMessage
 from langgraph.graph import add_messages
@@ -12,6 +12,52 @@ 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
@@ -208,21 +254,42 @@ def safe_format(template, mapping):
 def create_pydantic_model(model_name: str, variables: dict[str, dict]):
     fields = {}
     for var_name, var_data in variables.items():
-        fields[var_name] = (parse_pydantic_type(var_data['type']), Field(description=var_data.get('description', None)))
+        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
+    t = (type_name or "any").strip().lower()
+
+    base = {
+        "str": str,
+        "int": int,
+        "float": float,
+        "bool": bool,
+        # "dict" means JSON object
+        "dict": dict[str, JsonValue],
+        # "list" means array of JSON values (or pick str if you want)
+        "list": list[JsonValue],
+        # IMPORTANT: don't return bare Any -> it produces {} schema
+        "any": JsonValue,
     }
-    return type_mapping.get(type_name, Any)
+    if t in base:
+        return base[t]
+
+    m = re.fullmatch(r"list\[(.+)\]", t)
+    if m:
+        return list[parse_pydantic_type(m.group(1))]
+
+    m = re.fullmatch(r"dict\[(.+?),(.+)\]", t)
+    if m:
+        k = parse_pydantic_type(m.group(1))
+        v = parse_pydantic_type(m.group(2))
+        # restrict keys to str for JSON objects
+        return dict[str, v] if k is not str else dict[str, v]
+
+    # fallback: avoid Any
+    return JsonValue

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/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"
+]