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

alita_sdk/runtime/toolkits/skill_router.py

@@ -0,0 +1,238 @@
+"""
+SkillRouter Toolkit for configuring and accessing specialized skills.
+
+This toolkit provides a configurable way to set up the skill router with
+specific skills from filesystem or platform-hosted agents/pipelines.
+"""
+
+from typing import List, Optional, TYPE_CHECKING
+from pydantic import create_model, BaseModel, Field, ConfigDict
+from langchain_community.agent_toolkits.base import BaseToolkit
+from langchain_core.tools import BaseTool
+
+if TYPE_CHECKING:
+    from alita_sdk.clients import AlitaClient
+
+from alita_sdk.tools.base.tool import BaseAction
+from alita_sdk.tools.utils import clean_string
+from ..skills import SkillsRegistry, SkillMetadata, SkillType, SkillSource
+from ..tools.skill_router import SkillRouterWrapper
+
+
+class SkillConfig(BaseModel):
+    """Configuration for a single skill."""
+
+    # Platform skill fields (type is implicit from parent field: agents or pipelines)
+    id: int = Field(description="Platform ID (for agent/pipeline skills)")
+    version_id: int = Field(description="Platform version ID (for agent/pipeline skills)")
+    name: Optional[str] = Field(default=None, description="Skill name (optional override)")
+
+
+class SkillRouterToolkit(BaseToolkit):
+    """Toolkit for configuring skill router with specific skills."""
+
+    tools: List[BaseTool] = []
+
+    @staticmethod
+    def toolkit_config_schema() -> BaseModel:
+        """Define the configuration schema for the skill router toolkit."""
+        # Get available tools for selected_tools field
+        selected_tools_options = {x['name']: x['args_schema'].schema() for x in SkillRouterWrapper.model_construct().get_available_tools()}
+        
+        return create_model(
+            "skill_router",
+            # Separate fields for agents and pipelines - optional but default to empty lists
+            agents=(Optional[List[SkillConfig]], Field(
+                description="List of agents to make available as skills",
+                default=[],
+                json_schema_extra={
+                    "agent_tags": ["skill"]
+                }
+            )),
+            pipelines=(Optional[List[SkillConfig]], Field(
+                description="List of pipelines to make available as skills",
+                default=[],
+                json_schema_extra={
+                    "pipeline_tags": ["skill"]
+                }
+            )),
+            prompt=(Optional[str], Field(
+                description="Custom system prompt for skill routing",
+                default="",
+                json_schema_extra={"lines": 4}
+            )),
+            timeout=(Optional[int], Field(description="Default timeout in seconds for skill execution", default=300)),
+            execution_mode=(Optional[str], Field(
+                description="Default execution mode for skills",
+                default=None,
+                json_schema_extra={"enum": ["subprocess", "remote"]}
+            )),
+            selected_tools=(List[str], Field(
+                description="List of tools to enable",
+                default=list(selected_tools_options.keys()),
+                json_schema_extra={'args_schemas': selected_tools_options}
+            )),
+            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Skill Router", "icon_url": None, "hidden": True}})
+        )
+
+    @classmethod
+    def get_toolkit(
+        cls,
+        client: 'AlitaClient',
+        llm = None,
+        toolkit_name: Optional[str] = None,
+        selected_tools: List[str] = None,
+        agents: List[SkillConfig] = None,
+        pipelines: List[SkillConfig] = None,
+        prompt: Optional[str] = None,
+        timeout: Optional[int] = None,
+        execution_mode: Optional[str] = None
+    ):
+        """Create a skill router toolkit with configured skills."""
+        
+        if selected_tools is None:
+            selected_tools = []
+
+        # Create a custom registry for this toolkit
+        registry = SkillsRegistry(search_paths=[])
+
+        # Helper function to process skill configs
+        def add_skills_to_registry(skill_configs, skill_type):
+            if skill_configs:
+                for skill_config_dict in skill_configs:
+                    # Convert dict to SkillConfig object
+                    skill_config = SkillConfig(**skill_config_dict)
+                    skill_metadata = cls._create_skill_from_config(skill_config, client, skill_type)
+                    if skill_metadata:
+                        # Add skill to registry manually
+                        registry.discovery.cache[skill_metadata.name] = skill_metadata
+
+        # Add configured agents (if provided)
+        add_skills_to_registry(agents or [], "agent")
+
+        # Add configured pipelines (if provided)
+        add_skills_to_registry(pipelines or [], "pipeline")
+
+        # Create skill router wrapper with custom configuration
+        wrapper = SkillRouterWrapper(
+            registry=registry,
+            alita_client=client,
+            llm=llm,
+            enable_callbacks=True,
+            default_timeout=timeout,
+            default_execution_mode=execution_mode,
+            custom_prompt=prompt
+        )
+        
+        # Get available tools from wrapper
+        available_tools = wrapper.get_available_tools()
+        
+        # Filter by selected_tools if provided
+        tools = []
+        toolkit_context = f" [Toolkit: {clean_string(toolkit_name, 0)}]" if toolkit_name else ''
+        
+        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
+            
+            # Wrap in BaseAction
+            tools.append(BaseAction(
+                api_wrapper=wrapper,
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": "skill_router"} if toolkit_name else {}
+            ))
+
+        return cls(tools=tools)
+
+    @classmethod
+    def _create_skill_from_config(cls, config: SkillConfig, client: 'AlitaClient', skill_type: str) -> Optional[SkillMetadata]:
+        """Create SkillMetadata from SkillConfig.
+        
+        Args:
+            config: SkillConfig with id, version_id, and optional name
+            client: AlitaClient for fetching skill details
+            skill_type: Either "agent" or "pipeline" (from parent field)
+        """
+        try:
+            # Get skill details from platform
+            if skill_type == "agent":
+                skill_details = cls._get_agent_details(client, config.id, config.version_id)
+                metadata_type = SkillType.AGENT
+            else:  # pipeline
+                skill_details = cls._get_pipeline_details(client, config.id, config.version_id)
+                metadata_type = SkillType.PIPELINE
+
+            # Create SkillMetadata for platform skill
+            return SkillMetadata(
+                name=config.name or skill_details.get('name', f"{skill_type}_{config.id}"),
+                skill_type=metadata_type,
+                source=SkillSource.PLATFORM,
+                id=config.id,
+                version_id=config.version_id,
+                description=skill_details.get('description', ''),
+                capabilities=skill_details.get('capabilities', []),
+                tags=skill_details.get('tags', []),
+                version=skill_details.get('version', '1.0.0'),
+                # Set default execution config - platform skills run remotely
+                execution={"mode": "remote", "timeout": 300},
+                results={"format": "text_with_links"},
+                inputs={},
+                outputs={}
+            )
+
+        except Exception as e:
+            import logging
+            logging.getLogger(__name__).error(f"Failed to create skill from config {config}: {e}")
+            return None
+
+    @classmethod
+    def _get_agent_details(cls, client: 'AlitaClient', agent_id: int, version_id: int) -> dict:
+        """Get agent details from platform."""
+        try:
+            app_details = client.get_app_details(agent_id)
+            version_details = client.get_app_version_details(agent_id, version_id)
+
+            return {
+                'name': app_details.get('name', f'agent_{agent_id}'),
+                'description': app_details.get('description', ''),
+                'capabilities': [], # Could be extracted from app metadata
+                'tags': [], # Could be extracted from app metadata
+                'version': version_details.get('version', '1.0.0')
+            }
+        except Exception as e:
+            import logging
+            logging.getLogger(__name__).error(f"Failed to get agent details for {agent_id}/{version_id}: {e}")
+            return {'name': f'agent_{agent_id}', 'description': 'Platform-hosted agent'}
+
+    @classmethod
+    def _get_pipeline_details(cls, client: 'AlitaClient', pipeline_id: int, version_id: int) -> dict:
+        """Get pipeline details from platform."""
+        try:
+            # For now, use the same method as agents since they use the same API
+            # In the future, this might use a different endpoint for pipelines
+            app_details = client.get_app_details(pipeline_id)
+            version_details = client.get_app_version_details(pipeline_id, version_id)
+
+            return {
+                'name': app_details.get('name', f'pipeline_{pipeline_id}'),
+                'description': app_details.get('description', ''),
+                'capabilities': [], # Could be extracted from pipeline metadata
+                'tags': [], # Could be extracted from pipeline metadata
+                'version': version_details.get('version', '1.0.0')
+            }
+        except Exception as e:
+            import logging
+            logging.getLogger(__name__).error(f"Failed to get pipeline details for {pipeline_id}/{version_id}: {e}")
+            return {'name': f'pipeline_{pipeline_id}', 'description': 'Platform-hosted pipeline'}
+
+    def get_tools(self):
+        """Get the configured tools."""
+        return self.tools

alita_sdk/runtime/toolkits/tools.py

@@ -14,9 +14,12 @@ from .prompt import PromptToolkit
 from .subgraph import SubgraphToolkit
 from .vectorstore import VectorStoreToolkit
 from .mcp import McpToolkit
+from .mcp_config import McpConfigToolkit, get_mcp_config_toolkit_schemas
+from .skill_router import SkillRouterToolkit
 from ..tools.mcp_server_tool import McpServerTool
 from ..tools.sandbox import SandboxToolkit
 from ..tools.image_generation import ImageGenerationToolkit
+from ..tools.data_analysis import DataAnalysisToolkit
 # Import community tools
 from ...community import get_toolkits as community_toolkits, get_tools as community_tools
 from ...tools.memory import MemoryToolkit
@@ -35,19 +38,55 @@ def get_toolkits():
         VectorStoreToolkit.toolkit_config_schema(),
         SandboxToolkit.toolkit_config_schema(),
         ImageGenerationToolkit.toolkit_config_schema(),
-        McpToolkit.toolkit_config_schema()
+        DataAnalysisToolkit.toolkit_config_schema(),
+        McpToolkit.toolkit_config_schema(),
+        McpConfigToolkit.toolkit_config_schema(),
+        SkillRouterToolkit.toolkit_config_schema()
     ]
 
-    return core_toolkits + community_toolkits() + alita_toolkits()
+    # Add configured MCP servers (stdio and http) as available toolkits
+    mcp_config_toolkits = get_mcp_config_toolkit_schemas()
+
+    return core_toolkits + mcp_config_toolkits + community_toolkits() + alita_toolkits()
 
 
 def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseStore = None, debug_mode: Optional[bool] = False, mcp_tokens: Optional[dict] = None, conversation_id: Optional[str] = None, ignored_mcp_servers: Optional[list] = None) -> list:
+    # Sanitize tools_list to handle corrupted tool configurations
+    sanitized_tools = []
+    for tool in tools_list:
+        if isinstance(tool, dict):
+            # Check for corrupted structure where 'type' and 'name' contain the full tool config
+            if 'type' in tool and isinstance(tool['type'], dict):
+                # This is a corrupted tool - use the inner dict instead
+                logger.warning(f"Detected corrupted tool configuration (type=dict), fixing: {tool}")
+                actual_tool = tool['type']  # or tool['name'], they should be the same
+                sanitized_tools.append(actual_tool)
+            elif 'name' in tool and isinstance(tool['name'], dict):
+                # Another corruption pattern where name contains the full config
+                logger.warning(f"Detected corrupted tool configuration (name=dict), fixing: {tool}")
+                actual_tool = tool['name']
+                sanitized_tools.append(actual_tool)
+            elif 'type' in tool and isinstance(tool['type'], str):
+                # Valid tool configuration
+                sanitized_tools.append(tool)
+            else:
+                # Skip invalid/corrupted tools that can't be fixed
+                logger.warning(f"Skipping invalid tool configuration: {tool}")
+        else:
+            logger.warning(f"Skipping non-dict tool: {tool}")
+            # Skip non-dict tools
+
     prompts = []
     tools = []
+    unhandled_tools = []  # Track tools not handled by main processing
 
-    for tool in tools_list:
+    for tool in sanitized_tools:
+        # Flag to track if this tool was processed by the main loop
+        # Used to prevent double processing by fallback systems
+        tool_handled = False
         try:
             if tool['type'] == 'datasource':
+                tool_handled = True
                 tools.extend(DatasourcesToolkit.get_toolkit(
                     alita_client,
                     datasource_ids=[int(tool['settings']['datasource_id'])],
@@ -55,6 +94,7 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                     toolkit_name=tool.get('toolkit_name', '') or tool.get('name', '')
                 ).get_tools())
             elif tool['type'] == 'application':
+                tool_handled = True
                 tools.extend(ApplicationToolkit.get_toolkit(
                     alita_client,
                     application_id=int(tool['settings']['application_id']),
@@ -74,6 +114,7 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                         llm=llm
                     ))
             elif tool['type'] == 'memory':
+                tool_handled = True
                 tools += MemoryToolkit.get_toolkit(
                     namespace=tool['settings'].get('namespace', str(tool['id'])),
                     pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
@@ -81,6 +122,7 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                 ).get_tools()
             # TODO: update configuration of internal tools
             elif tool['type'] == 'internal_tool':
+                tool_handled = True
                 if tool['name'] == 'pyodide':
                     tools += SandboxToolkit.get_toolkit(
                         stateful=False,
@@ -100,7 +142,22 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                         pgvector_configuration=tool.get('settings', {}).get('pgvector_configuration'),
                         conversation_id=conversation_id,
                     ).get_tools()
+                elif tool['name'] == 'data_analysis':
+                    # Data Analysis internal tool - uses conversation attachment bucket
+                    settings = tool.get('settings', {})
+                    bucket_name = settings.get('bucket_name')
+                    if bucket_name:
+                        tools += DataAnalysisToolkit.get_toolkit(
+                            alita_client=alita_client,
+                            llm=llm,
+                            bucket_name=bucket_name,
+                            toolkit_name="Data Analyst",
+                        ).get_tools()
+                    else:
+                        logger.warning("Data Analysis internal tool requested "
+                                       "but no bucket_name provided in settings")
             elif tool['type'] == 'artifact':
+                tool_handled = True
                 toolkit_tools = ArtifactToolkit.get_toolkit(
                     client=alita_client,
                     bucket=tool['settings']['bucket'],
@@ -119,11 +176,13 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                 tools.extend(toolkit_tools)
 
             elif tool['type'] == 'vectorstore':
+                tool_handled = True
                 tools.extend(VectorStoreToolkit.get_toolkit(
                     llm=llm,
                     toolkit_name=tool.get('toolkit_name', ''),
                     **tool['settings']).get_tools())
             elif tool['type'] == 'planning':
+                tool_handled = True
                 # Planning toolkit for multi-step task tracking
                 settings = tool.get('settings', {})
                 
@@ -163,6 +222,7 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                     conversation_id=conversation_id or settings.get('conversation_id'),
                 ).get_tools())
             elif tool['type'] == 'mcp':
+                tool_handled = True
                 # remote mcp tool initialization with token injection
                 settings = dict(tool['settings'])
                 url = settings.get('url')
@@ -214,6 +274,69 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                     toolkit_name=tool.get('toolkit_name', ''),
                     client=alita_client,
                     **settings).get_tools())
+            elif tool['type'] == 'skill_router':
+                tool_handled = True
+                # Skills Registry Router Toolkit
+                logger.info(f"Processing skill_router toolkit: {tool}")
+                try:
+                    settings = tool.get('settings', {})
+                    toolkit_name = tool.get('toolkit_name', '')
+                    selected_tools = settings.get('selected_tools', [])
+
+                    toolkit_tools = SkillRouterToolkit.get_toolkit(
+                        client=alita_client,
+                        llm=llm,
+                        toolkit_name=toolkit_name,
+                        selected_tools=selected_tools,
+                        **settings
+                    ).get_tools()
+
+                    tools.extend(toolkit_tools)
+                    logger.info(f"✅ Successfully added {len(toolkit_tools)} tools from SkillRouterToolkit")
+                except Exception as e:
+                    logger.error(f"❌ Failed to initialize SkillRouterToolkit: {e}")
+                    raise
+            elif tool['type'] == 'mcp_config' or tool['type'].startswith('mcp_'):
+                tool_handled = True
+                # MCP Config toolkit - pre-configured MCP servers (stdio or http)
+                # Handle both explicit 'mcp_config' type and dynamic names like 'mcp_playwright'
+                logger.info(f"Processing mcp_config toolkit: {tool}")
+                try:
+                    settings = tool.get('settings', {})
+
+                    # Server name can come from settings or be extracted from type name
+                    server_name = settings.get('server_name')
+                    if not server_name and tool['type'].startswith('mcp_') and tool['type'] != 'mcp_config':
+                        # Extract server name from type (e.g., 'mcp_playwright' -> 'playwright')
+                        server_name = tool['type'][4:]  # Remove 'mcp_' prefix
+
+                    if not server_name:
+                        logger.error(f"❌ No server_name found for mcp_config toolkit: {tool}")
+                        continue
+
+                    toolkit_name = tool.get('toolkit_name', '') or server_name
+                    selected_tools = settings.get('selected_tools', [])
+                    excluded_tools = settings.get('excluded_tools', [])
+
+                    # Get server config (may be in settings or from global config)
+                    server_config = settings.get('server_config')
+
+                    toolkit_tools = McpConfigToolkit.get_toolkit(
+                        server_name=server_name,
+                        server_config=server_config,
+                        user_config=settings,
+                        selected_tools=selected_tools if selected_tools else None,
+                        excluded_tools=excluded_tools if excluded_tools else None,
+                        toolkit_name=toolkit_name,
+                        client=alita_client,
+                    ).get_tools()
+
+                    tools.extend(toolkit_tools)
+                    logger.info(f"✅ Successfully added {len(toolkit_tools)} tools from McpConfigToolkit ({server_name})")
+                except Exception as e:
+                    logger.error(f"❌ Failed to initialize McpConfigToolkit: {e}")
+                    if not debug_mode:
+                        raise
         except McpAuthorizationRequired:
             # Re-raise auth required exceptions directly
             raise
@@ -224,17 +347,23 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                 continue
             else:
                 raise ToolException(f"Error initializing toolkit for tool '{tool.get('name', 'unknown')}': {e}")
-    
+
+        # Track unhandled tools (make a copy to avoid reference issues)
+        if not tool_handled:
+            # Ensure we only add valid tool configurations to unhandled_tools
+            if isinstance(tool, dict) and 'type' in tool and isinstance(tool['type'], str):
+                unhandled_tools.append(dict(tool))
+
     if len(prompts) > 0:
         tools += PromptToolkit.get_toolkit(alita_client, prompts).get_tools()
-    
-    # Add community tools
-    tools += community_tools(tools_list, alita_client, llm)
-    # Add alita tools
-    tools += alita_tools(tools_list, alita_client, llm, memory_store)
+
+    # Add community tools (only for unhandled tools)
+    tools += community_tools(unhandled_tools, alita_client, llm)
+    # Add alita tools (only for unhandled tools)
+    tools += alita_tools(unhandled_tools, alita_client, llm, memory_store)
     # Add MCP tools registered via alita-mcp CLI (static registry)
     # Note: Tools with type='mcp' are already handled in main loop above
-    tools += _mcp_tools(tools_list, alita_client)
+    tools += _mcp_tools(unhandled_tools, alita_client)
     
     # Sanitize tool names to meet OpenAI's function naming requirements
     # tools = _sanitize_tool_names(tools)

alita_sdk/runtime/toolkits/vectorstore.py

@@ -56,7 +56,7 @@ class VectorStoreToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": "vectorstore"} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/runtime/tools/__init__.py

@@ -10,6 +10,7 @@ from .image_generation import (
     create_image_generation_tool,
     ImageGenerationToolkit
 )
+from .skill_router import SkillRouterWrapper
 
 __all__ = [
     "PyodideSandboxTool",
@@ -18,5 +19,6 @@ __all__ = [
     "EchoTool",
     "ImageGenerationTool",
     "ImageGenerationToolkit",
-    "create_image_generation_tool"
+    "create_image_generation_tool",
+    "SkillRouterWrapper"
 ]

alita_sdk/runtime/tools/artifact.py

@@ -350,6 +350,21 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
 
         include_extensions = kwargs.get('include_extensions', [])
         skip_extensions = kwargs.get('skip_extensions', [])
+        chunking_config = kwargs.get('chunking_config', {})
+        
+        # Auto-include extensions from chunking_config if include_extensions is specified
+        # This allows chunking config to work without manually adding extensions to include_extensions
+        if chunking_config and include_extensions:
+            for ext_pattern in chunking_config.keys():
+                # Normalize extension pattern (both ".cbl" and "*.cbl" should work)
+                normalized = ext_pattern if ext_pattern.startswith('*') else f'*{ext_pattern}'
+                if normalized not in include_extensions:
+                    include_extensions.append(normalized)
+                    self._log_tool_event(
+                        message=f"Auto-included extension '{normalized}' from chunking_config",
+                        tool_name="loader"
+                    )
+        
         self._log_tool_event(message=f"Files filtering started. Include extensions: {include_extensions}. "
                                      f"Skip extensions: {skip_extensions}", tool_name="loader")
         # show the progress of filtering