alita-sdk 0.3.532__py3-none-any.whl → 0.3.554__py3-none-any.whl

alita_sdk/community/__init__.py

@@ -96,18 +96,22 @@ def get_toolkits():
 def get_tools(tools_list: list, alita_client, llm) -> list:
     """Get community tools based on the tools list configuration."""
     tools = []
-    
+
     # Tool type to class mapping
     _tool_mapping = {
         'analyse_jira': 'AnalyseJira',
         'analyse_ado': 'AnalyseAdo',
-        'analyse_gitlab': 'AnalyseGitLab', 
+        'analyse_gitlab': 'AnalyseGitLab',
         'analyse_github': 'AnalyseGithub',
         'inventory': 'InventoryToolkit'
     }
-    
+
     for tool in tools_list:
-        tool_type = tool.get('type')
+        if isinstance(tool, dict):
+            tool_type = tool.get('type')
+        else:
+            logger.error(f"Community tools received non-dict tool: {tool} (type: {type(tool)})")
+            continue
         class_name = _tool_mapping.get(tool_type)
         
         if class_name and class_name in globals():

alita_sdk/configurations/__init__.py

@@ -53,6 +53,7 @@ _safe_import_configuration('sharepoint', 'sharepoint', 'SharepointConfiguration'
 _safe_import_configuration('carrier', 'carrier', 'CarrierConfiguration')
 _safe_import_configuration('report_portal', 'report_portal', 'ReportPortalConfiguration')
 _safe_import_configuration('testio', 'testio', 'TestIOConfiguration')
+_safe_import_configuration('openapi', 'openapi', 'OpenApiConfiguration')
 
 # Log import summary
 available_count = len(AVAILABLE_CONFIGURATIONS)

alita_sdk/configurations/openapi.py

@@ -0,0 +1,111 @@
+from typing import Any, Literal, Optional
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, model_validator
+
+
+class OpenApiConfiguration(BaseModel):
+    model_config = ConfigDict(
+        extra='allow',
+        json_schema_extra={
+            "metadata": {
+                "label": "OpenAPI",
+                "icon_url": "openapi.svg",
+                "categories": ["integrations"],
+                "type": "openapi",
+                "extra_categories": ["api", "openapi", "swagger"],
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "API Key",
+                                "fields": ["api_key", "auth_type", "custom_header_name"],
+                            },
+                            {
+                                "name": "OAuth",
+                                "fields": [
+                                    "client_id",
+                                    "client_secret",
+                                    "auth_url",
+                                    "token_url",
+                                    "scope",
+                                    "method",
+                                ],
+                            },
+                        ],
+                    },
+                },
+                "section": "credentials",
+            }
+        }
+    )
+
+    api_key: Optional[SecretStr] = Field(
+        default=None,
+        description=(
+            "API key value (stored as a secret). Used when selecting 'API Key' authentication subsection."
+        ),
+    )
+    auth_type: Optional[Literal['Basic', 'Bearer', 'Custom']] = Field(
+        default='Bearer',
+        description=(
+            "How to apply the API key. "
+            "- 'Bearer': sets 'Authorization: Bearer <api_key>' "
+            "- 'Basic': sets 'Authorization: Basic <api_key>' "
+            "- 'custom': sets '<custom_header_name>: <api_key>'"
+        ),
+    )
+    custom_header_name: Optional[str] = Field(
+        default=None,
+        description="Custom header name to use when auth_type='custom' (e.g. 'X-Api-Key').",
+        json_schema_extra={'visible_when': {'field': 'auth_type', 'value': 'custom'}},
+    )
+
+    client_id: Optional[str] = Field(default=None, description='OAuth client ID')
+    client_secret: Optional[SecretStr] = Field(default=None, description='OAuth client secret (stored as a secret)')
+    auth_url: Optional[str] = Field(default=None, description='OAuth authorization URL')
+    token_url: Optional[str] = Field(default=None, description='OAuth token URL')
+    scope: Optional[str] = Field(default=None, description='OAuth scope(s)')
+    method: Optional[Literal['default', 'Basic']] = Field(
+        default='default',
+        description=(
+            "Token exchange method. 'default' uses standard POST body; 'Basic' uses a Basic authorization header."
+        ),
+    )
+
+    @model_validator(mode='before')
+    @classmethod
+    def _validate_auth_consistency(cls, values):
+        if not isinstance(values, dict):
+            return values
+
+        # OAuth: if any OAuth field is provided, require the key ones.
+        has_any_oauth = any(
+            (values.get('client_id'), values.get('client_secret'), values.get('auth_url'), values.get('token_url'))
+        )
+        if has_any_oauth:
+            missing = []
+            if not values.get('client_id'):
+                missing.append('client_id')
+            if not values.get('client_secret'):
+                missing.append('client_secret')
+            if not values.get('token_url'):
+                missing.append('token_url')
+            if missing:
+                raise ValueError(f"OAuth is misconfigured; missing: {', '.join(missing)}")
+
+        # API key: if auth_type is custom, custom_header_name must be present.
+        auth_type = values.get('auth_type')
+        if isinstance(auth_type, str) and auth_type.strip().lower() == 'custom' and values.get('api_key'):
+            if not values.get('custom_header_name'):
+                raise ValueError("custom_header_name is required when auth_type='custom'")
+
+        return values
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """Best-effort validation for OpenAPI credentials.
+
+        This model is intended to store reusable credentials only.
+        Spec/base_url validation happens at toolkit configuration level.
+        """
+        return None

alita_sdk/runtime/clients/client.py

@@ -259,21 +259,22 @@ class AlitaClient:
                     use_responses_api = True
                     break
 
-        # handle case when max_tokens are auto-configurable == -1
+        # handle case when max_tokens are auto-configurable == -1 or None
         llm_max_tokens = model_config.get("max_tokens", None)
-        if llm_max_tokens and llm_max_tokens == -1:
-            logger.warning(f'User selected `MAX COMPLETION TOKENS` as `auto`')
-            # default nuber for a case when auto is selected for an agent
+        if llm_max_tokens is None or llm_max_tokens == -1:
+            logger.warning(f'User selected `MAX COMPLETION TOKENS` as `auto` or value is None/missing')
+            # default number for a case when auto is selected for an agent
             llm_max_tokens = 4000
 
         if is_anthropic:
             # ChatAnthropic configuration
+            # Anthropic requires max_tokens to be an integer, never None
             target_kwargs = {
                 "base_url": f"{self.base_url}{self.allm_path}",
                 "model": model_name,
                 "api_key": self.auth_token,
                 "streaming": model_config.get("streaming", True),
-                "max_tokens": llm_max_tokens,
+                "max_tokens": llm_max_tokens,  # Always an integer now
                 "temperature": model_config.get("temperature"),
                 "max_retries": model_config.get("max_retries", 3),
                 "default_headers": {"openai-organization": str(self.project_id),
@@ -1153,3 +1154,158 @@ class AlitaClient:
                 "events_dispatched": [],
                 "execution_time_seconds": 0.0
             }
+
+    def test_mcp_connection(self, toolkit_config: dict, mcp_tokens: dict = None) -> dict:
+        """
+        Test MCP server connection using protocol-level list_tools.
+
+        This method verifies MCP server connectivity and authentication by calling
+        the protocol-level tools/list JSON-RPC method (NOT executing a tool).
+        This is ideal for auth checks as it validates the connection without
+        requiring any tool execution.
+
+        Args:
+            toolkit_config: Configuration dictionary for the MCP toolkit containing:
+                - toolkit_name: Name of the toolkit
+                - settings: Dictionary with 'url', optional 'headers', 'session_id'
+            mcp_tokens: Optional dictionary of MCP OAuth tokens by server URL
+                Format: {canonical_url: {access_token: str, session_id: str}}
+
+        Returns:
+            Dictionary containing:
+                - success: Boolean indicating if the connection was successful
+                - tools: List of tool names available on the MCP server (if successful)
+                - tools_count: Number of tools discovered
+                - server_session_id: Session ID provided by the server (if any)
+                - error: Error message (if unsuccessful)
+                - toolkit_config: Original toolkit configuration
+
+        Raises:
+            McpAuthorizationRequired: If MCP server requires OAuth authorization
+
+        Example:
+            >>> config = {
+            ...     'toolkit_name': 'my-mcp-server',
+            ...     'type': 'mcp',
+            ...     'settings': {
+            ...         'url': 'https://mcp-server.example.com/mcp',
+            ...         'headers': {'X-Custom': 'value'}
+            ...     }
+            ... }
+            >>> result = client.test_mcp_connection(config)
+            >>> if result['success']:
+            ...     print(f"Connected! Found {result['tools_count']} tools")
+        """
+        import asyncio
+        import time
+        from ..utils.mcp_client import McpClient
+        from ..utils.mcp_oauth import canonical_resource
+
+        toolkit_name = toolkit_config.get('toolkit_name', 'unknown')
+        settings = toolkit_config.get('settings', {})
+
+        # Extract connection parameters
+        url = settings.get('url')
+        if not url:
+            return {
+                "success": False,
+                "error": "MCP toolkit configuration missing 'url' in settings",
+                "toolkit_config": toolkit_config,
+                "tools": [],
+                "tools_count": 0
+            }
+
+        headers = settings.get('headers') or {}
+        session_id = settings.get('session_id')
+
+        # Apply OAuth token if available
+        if mcp_tokens and url:
+            canonical_url = canonical_resource(url)
+            token_data = mcp_tokens.get(canonical_url)
+            if token_data:
+                if isinstance(token_data, dict):
+                    access_token = token_data.get('access_token')
+                    if not session_id:
+                        session_id = token_data.get('session_id')
+                else:
+                    # Backward compatibility: plain token string
+                    access_token = token_data
+
+                if access_token:
+                    headers = dict(headers)  # Copy to avoid mutating original
+                    headers.setdefault('Authorization', f'Bearer {access_token}')
+                    logger.info(f"[MCP Auth Check] Applied OAuth token for {canonical_url}")
+
+        logger.info(f"Testing MCP connection to '{toolkit_name}' at {url}")
+
+        start_time = time.time()
+
+        async def _test_connection():
+            client = McpClient(
+                url=url,
+                session_id=session_id,
+                headers=headers,
+                timeout=60  # Reasonable timeout for connection test
+            )
+
+            async with client:
+                # Initialize MCP protocol session
+                await client.initialize()
+                logger.info(f"[MCP Auth Check] Session initialized (transport={client.detected_transport})")
+
+                # Call protocol-level list_tools (tools/list JSON-RPC method)
+                tools = await client.list_tools()
+
+                return {
+                    "tools": tools,
+                    "server_session_id": client.server_session_id,
+                    "transport": client.detected_transport
+                }
+
+        try:
+            # Run async operation
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    # If we're already in an async context, create a new task
+                    import concurrent.futures
+                    with concurrent.futures.ThreadPoolExecutor() as executor:
+                        future = executor.submit(asyncio.run, _test_connection())
+                        result = future.result(timeout=120)
+                else:
+                    result = loop.run_until_complete(_test_connection())
+            except RuntimeError:
+                # No event loop, create one
+                result = asyncio.run(_test_connection())
+
+            execution_time = time.time() - start_time
+
+            # Extract tool names for the response
+            tool_names = [tool.get('name', 'unknown') for tool in result.get('tools', [])]
+
+            logger.info(f"[MCP Auth Check] Connection successful to '{toolkit_name}': {len(tool_names)} tools in {execution_time:.3f}s")
+
+            return {
+                "success": True,
+                "tools": tool_names,
+                "tools_count": len(tool_names),
+                "server_session_id": result.get('server_session_id'),
+                "transport": result.get('transport'),
+                "toolkit_config": toolkit_config,
+                "execution_time_seconds": execution_time
+            }
+
+        except McpAuthorizationRequired:
+            # Re-raise to allow proper handling upstream
+            raise
+        except Exception as e:
+            execution_time = time.time() - start_time
+            logger.error(f"[MCP Auth Check] Connection failed to '{toolkit_name}': {str(e)}")
+            return {
+                "success": False,
+                "error": f"MCP connection failed: {str(e)}",
+                "toolkit_config": toolkit_config,
+                "tools": [],
+                "tools_count": 0,
+                "execution_time_seconds": execution_time
+            }

alita_sdk/runtime/langchain/langraph_agent.py

@@ -967,7 +967,7 @@ class LangGraphAgentRunnable(CompiledStateGraph):
                     (msg.content for msg in reversed(messages)
                      if not isinstance(msg, HumanMessage)),
                     messages[-1].content
-                )
+                ) if messages else result.get('output')
             elif printer_output is not None:
                 # Printer node has output (interrupted state)
                 output = printer_output
@@ -981,7 +981,7 @@ class LangGraphAgentRunnable(CompiledStateGraph):
                 )
         except Exception:
             # Fallback: try to get last value or last message
-            output = list(result.values())[-1] if result else None
+            output = str(list(result.values())[-1]) if result else 'Output is undefined'
         config_state = self.get_state(config)
         is_execution_finished = not config_state.next
         if is_execution_finished:

alita_sdk/runtime/langchain/utils.py

@@ -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

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