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

alita_sdk/runtime/toolkits/skill_router.py

@@ -72,7 +72,7 @@ class SkillRouterToolkit(BaseToolkit):
                 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}})
+            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Skill Router", "icon_url": None, "hidden": True}})
         )
 
     @classmethod
@@ -147,7 +147,7 @@ class SkillRouterToolkit(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": "skill_router"} if toolkit_name else {}
             ))
 
         return cls(tools=tools)

alita_sdk/runtime/toolkits/tools.py

@@ -14,10 +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
@@ -36,11 +38,16 @@ def get_toolkits():
         VectorStoreToolkit.toolkit_config_schema(),
         SandboxToolkit.toolkit_config_schema(),
         ImageGenerationToolkit.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:
@@ -135,6 +142,20 @@ 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(
@@ -261,7 +282,7 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                     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,
@@ -275,6 +296,47 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                 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

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

alita_sdk/runtime/tools/data_analysis.py

@@ -0,0 +1,183 @@
+"""
+Data Analysis internal tool for Alita SDK.
+
+This tool provides Pandas-based data analysis capabilities as an internal tool,
+accessible through the "Enable internal tools" dropdown menu.
+
+It uses the conversation attachment bucket for file storage, providing seamless
+integration with drag-and-drop file uploads in chat.
+"""
+import logging
+from typing import Any, List, Literal, Optional, Type
+
+from langchain_core.tools import BaseTool, BaseToolkit
+from pydantic import BaseModel, ConfigDict, create_model, Field
+
+logger = logging.getLogger(__name__)
+
+name = "data_analysis"
+
+
+def get_tools(tools_list: list, alita_client=None, llm=None, memory_store=None):
+    """
+    Get data analysis tools for the provided tool configurations.
+
+    Args:
+        tools_list: List of tool configurations
+        alita_client: Alita client instance (required for data analysis)
+        llm: LLM client instance (required for code generation)
+        memory_store: Optional memory store instance (unused)
+
+    Returns:
+        List of data analysis tools
+    """
+    all_tools = []
+
+    for tool in tools_list:
+        if (tool.get('type') == 'data_analysis' or
+                tool.get('toolkit_name') == 'data_analysis'):
+            try:
+                if not alita_client:
+                    logger.error("Alita client is required for data analysis tools")
+                    continue
+
+                settings = tool.get('settings', {})
+                bucket_name = settings.get('bucket_name')
+
+                if not bucket_name:
+                    logger.error("bucket_name is required for data analysis tools")
+                    continue
+
+                toolkit_instance = DataAnalysisToolkit.get_toolkit(
+                    alita_client=alita_client,
+                    llm=llm,
+                    bucket_name=bucket_name,
+                    toolkit_name=tool.get('toolkit_name', '')
+                )
+                all_tools.extend(toolkit_instance.get_tools())
+            except Exception as e:
+                logger.error(f"Error in data analysis toolkit get_tools: {e}")
+                logger.error(f"Tool config: {tool}")
+                raise
+
+    return all_tools
+
+
+class DataAnalysisToolkit(BaseToolkit):
+    """
+    Data Analysis toolkit providing Pandas-based data analysis capabilities.
+
+    This is an internal tool that uses the conversation attachment bucket
+    for file storage, enabling seamless integration with chat file uploads.
+    """
+    tools: List[BaseTool] = []
+
+    @staticmethod
+    def toolkit_config_schema() -> Type[BaseModel]:
+        """Get the configuration schema for the data analysis toolkit."""
+        # Import PandasWrapper to get available tools schema
+        from alita_sdk.tools.pandas.api_wrapper import PandasWrapper
+
+        selected_tools = {
+            x['name']: x['args_schema'].model_json_schema()
+            for x in PandasWrapper.model_construct().get_available_tools()
+        }
+
+        return create_model(
+            'data_analysis',
+            bucket_name=(
+                Optional[str],
+                Field(
+                    default=None,
+                    title="Bucket name",
+                    description="Bucket where files are stored (auto-injected from conversation)"
+                )
+            ),
+            selected_tools=(
+                List[Literal[tuple(selected_tools)]],
+                Field(
+                    default=[],
+                    json_schema_extra={'args_schemas': selected_tools}
+                )
+            ),
+            __config__=ConfigDict(json_schema_extra={
+                'metadata': {
+                    "label": "Data Analysis",
+                    "icon_url": "data-analysis.svg",
+                    "hidden": True,  # Hidden from regular toolkit menu
+                    "categories": ["internal_tool"],
+                    "extra_categories": ["data analysis", "pandas", "dataframes", "data science"],
+                }
+            })
+        )
+
+    @classmethod
+    def get_toolkit(
+        cls,
+        alita_client=None,
+        llm=None,
+        bucket_name: str = None,
+        toolkit_name: Optional[str] = None,
+        selected_tools: Optional[List[str]] = None,
+        **kwargs
+    ):
+        """
+        Get toolkit with data analysis tools.
+
+        Args:
+            alita_client: Alita client instance (required)
+            llm: LLM for code generation (optional, uses alita_client.llm if not provided)
+            bucket_name: Conversation attachment bucket (required)
+            toolkit_name: Optional name prefix for tools
+            selected_tools: Optional list of tool names to include (default: all)
+            **kwargs: Additional arguments
+
+        Returns:
+            DataAnalysisToolkit instance with configured tools
+
+        Raises:
+            ValueError: If alita_client or bucket_name is not provided
+        """
+        if not alita_client:
+            raise ValueError("Alita client is required for data analysis")
+
+        if not bucket_name:
+            raise ValueError("bucket_name is required for data analysis (should be conversation attachment bucket)")
+
+        # Import the PandasWrapper from existing toolkit
+        from alita_sdk.tools.pandas.api_wrapper import PandasWrapper
+        from alita_sdk.tools.base.tool import BaseAction
+
+        # Create wrapper with conversation bucket
+        wrapper = PandasWrapper(
+            alita=alita_client,
+            llm=llm,
+            bucket_name=bucket_name
+        )
+
+        # Get tools from wrapper
+        available_tools = wrapper.get_available_tools()
+        tools = []
+
+        for tool in available_tools:
+            # Filter by selected_tools if provided
+            if selected_tools and tool["name"] not in selected_tools:
+                continue
+
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
+
+            tools.append(BaseAction(
+                api_wrapper=wrapper,
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": name} if toolkit_name else {}
+            ))
+
+        return cls(tools=tools)
+
+    def get_tools(self):
+        return self.tools

alita_sdk/runtime/tools/llm.py

@@ -81,22 +81,41 @@ class LLMNode(BaseTool):
         """
         Prepare structured output parameters from structured_output_dict.
 
+        Expected self.structured_output_dict formats:
+          - {"field": "str"} / {"field": "list"} / {"field": "list[str]"} / {"field": "any"} ...
+          - OR {"field": {"type": "...", "description": "...", "default": ...}}  (optional)
+
         Returns:
-            Dictionary with parameter definitions for creating Pydantic model
+            Dict[str, Dict] suitable for create_pydantic_model(...)
         """
-        struct_params = {
-            key: {
-                "type": 'list[str]' if 'list' in value else value,
-                "description": ""
-            }
-            for key, value in (self.structured_output_dict or {}).items()
-        }
+        struct_params: dict[str, dict] = {}
+
+        for key, value in (self.structured_output_dict or {}).items():
+            # Allow either a plain type string or a dict with details
+            if isinstance(value, dict):
+                type_str = (value.get("type") or "any")
+                desc = value.get("description", "") or ""
+                entry: dict = {"type": type_str, "description": desc}
+                if "default" in value:
+                    entry["default"] = value["default"]
+            else:
+                type_str = (value or "any") if isinstance(value, str) else "any"
+                entry = {"type": type_str, "description": ""}
+
+            # Normalize: only convert the *exact* "list" into "list[str]"
+            # (avoid the old bug where "if 'list' in value" also hits "blacklist", etc.)
+            if isinstance(entry.get("type"), str) and entry["type"].strip().lower() == "list":
+                entry["type"] = "list[str]"
+
+            struct_params[key] = entry
+
         # Add default output field for proper response to user
         struct_params[ELITEA_RS] = {
-            'description': 'final output to user (summarized output from LLM)',
-            'type': 'str',
-            "default": None
+            "description": "final output to user (summarized output from LLM)",
+            "type": "str",
+            "default": None,
         }
+
         return struct_params
 
     def _invoke_with_structured_output(self, llm_client: Any, messages: List, struct_model: Any, config: RunnableConfig):

alita_sdk/runtime/tools/mcp_server_tool.py

@@ -1,9 +1,12 @@
 import uuid
 from logging import getLogger
-from typing import Any, Type, Literal, Optional, Union, List
+from typing import Any, Type, Literal, Optional, Union, List, Annotated
 
 from langchain_core.tools import BaseTool
-from pydantic import BaseModel, Field, create_model, EmailStr, constr, ConfigDict
+from pydantic import BaseModel, Field, create_model, ConfigDict, StringConstraints
+
+# EmailStr moved to pydantic_extra_types in pydantic v2, use str for simplicity
+EmailStr = str
 
 logger = getLogger(__name__)
 
@@ -59,7 +62,7 @@ class McpServerTool(BaseTool):
                 if field.get("format") == "email":
                     return EmailStr
                 if "pattern" in field:
-                    return constr(regex=field["pattern"])
+                    return Annotated[str, StringConstraints(pattern=field["pattern"])]
                 return str
             if t == "integer":
                 return int

alita_sdk/runtime/tools/router.py

@@ -27,10 +27,8 @@ class RouterNode(BaseTool):
         if result in [clean_string(formatted_result) for formatted_result in self.routes]:
             # If the result is one of the routes, return it
             return {"router_output": result}
-        elif result == self.default_output:
-            # If the result is the default output, return it
-            return {"router_output": clean_string(self.default_output)}
-        return {"router_output": 'END'}
+        # For any unmatched condition (including empty string), use the configured default_output
+        return {"router_output": clean_string(self.default_output)}
 
     def _run(self, *args, **kwargs):
         return self.invoke(**kwargs)

alita_sdk/runtime/tools/sandbox.py

@@ -326,12 +326,15 @@ class SandboxToolkit(BaseToolkit):
 
     @staticmethod
     def toolkit_config_schema() -> Type[BaseModel]:
-        # Create sample tools to get their schemas
-        sample_tools = [
-            PyodideSandboxTool(),
-            StatefulPyodideSandboxTool()
-        ]
-        selected_tools = {x.name: x.args_schema.model_json_schema() for x in sample_tools}
+        # Get tool schemas without instantiating the tools (avoids Deno requirement)
+        try:
+            selected_tools = {
+                "pyodide_sandbox": sandbox_tool_input.model_json_schema(),
+                "stateful_pyodide_sandbox": sandbox_tool_input.model_json_schema(),
+            }
+        except Exception as e:
+            logger.warning(f"Could not generate sandbox tool schemas: {e}")
+            selected_tools = {}
 
         return create_model(
             'sandbox',

alita_sdk/runtime/utils/constants.py

@@ -436,4 +436,8 @@ STYLES = r"""
             filter: hue-rotate(180deg) brightness(1.2);
         }
         </style>
-        """
+        """
+
+TOOLKIT_NAME_META = "toolkit_name"
+TOOL_NAME_META = "tool_name"
+TOOLKIT_TYPE_META = "toolkit_type"

alita_sdk/runtime/utils/mcp_client.py

@@ -192,7 +192,7 @@ class McpClient:
                     "sampling": {}
                 },
                 "clientInfo": {
-                    "name": "Alita MCP Client",
+                    "name": "ELITEA MCP Client",
                     "version": "1.0.0"
                 }
             }

alita_sdk/runtime/utils/mcp_sse_client.py

@@ -374,7 +374,7 @@ class McpSseClient:
                     "sampling": {}
                 },
                 "clientInfo": {
-                    "name": "Alita MCP Client",
+                    "name": "ELITEA MCP Client",
                     "version": "1.0.0"
                 }
             }

alita_sdk/runtime/utils/toolkit_utils.py

@@ -59,10 +59,12 @@ def instantiate_toolkit_with_client(toolkit_config: Dict[str, Any],
 
         # Create a tool configuration dict with required fields
         # Note: MCP toolkit always requires toolkit_name, other toolkits respect use_prefix flag
+        # Note: 'name' is always set for provider-based toolkits (used by provider_worker.utils.tools)
         tool_config = {
             'id': toolkit_config.get('id', random.randint(1, 1000000)),
             'type': toolkit_config.get('type', toolkit_type),
             'settings': settings,
+            'name': toolkit_name,  # Always pass name for provider toolkits
             'toolkit_name': toolkit_name if (use_prefix or toolkit_type == 'mcp') else None
         }
         

alita_sdk/tools/__init__.py

@@ -102,7 +102,7 @@ _safe_import_tool('k8s', 'cloud.k8s', None, 'KubernetesToolkit')
 _safe_import_tool('elastic', 'elastic', None, 'ElasticToolkit')
 _safe_import_tool('keycloak', 'keycloak', None, 'KeycloakToolkit')
 _safe_import_tool('localgit', 'localgit', None, 'AlitaLocalGitToolkit')
-_safe_import_tool('pandas', 'pandas', 'get_tools', 'PandasToolkit')
+# pandas toolkit removed - use Data Analysis internal tool instead
 _safe_import_tool('azure_search', 'azure_ai.search', 'get_tools', 'AzureSearchToolkit')
 _safe_import_tool('figma', 'figma', 'get_tools', 'FigmaToolkit')
 _safe_import_tool('salesforce', 'salesforce', 'get_tools', 'SalesforceToolkit')
@@ -186,7 +186,9 @@ def get_tools(tools_list, alita, llm, store: Optional[BaseStore] = None, *args,
                 toolkit = tkitclass.get_toolkit(**get_toolkit_params)
                 toolkit_tools.extend(toolkit.get_tools())
             except Exception as e:
+                import traceback
                 logger.error(f"Error in getting custom toolkit: {e}")
+                logger.error(f"Traceback:\n{traceback.format_exc()}")
         else:
             if tool_type in FAILED_IMPORTS:
                 logger.warning(f"Tool '{tool_type}' is not available: {FAILED_IMPORTS[tool_type]}")

alita_sdk/tools/ado/repos/__init__.py

@@ -11,6 +11,7 @@ from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
 from .repos_wrapper import ReposApiWrapper
 from ...utils import clean_string, get_max_toolkit_length, check_connection_response
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "ado_repos"
 
@@ -52,13 +53,30 @@ class AzureDevOpsReposToolkit(BaseToolkit):
             embedding_model=(Optional[str], Field(default=None, description="Embedding configuration.", json_schema_extra={'configuration_model': 'embedding'})),
 
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
-            __config__={'json_schema_extra': {'metadata':
-                {
-                    "label": "ADO repos",
-                    "icon_url": "ado-repos-icon.svg",
-                    "categories": ["code repositories"],
-                    "extra_categories": ["code", "repository", "version control"],
-                }}}
+            __config__={
+                'json_schema_extra': {
+                    'metadata': {
+                        "label": "ADO repos",
+                        "icon_url": "ado-repos-icon.svg",
+                        "categories": ["code repositories"],
+                        "extra_categories": ["code", "repository", "version control"],
+                        "sections": {
+                            "auth": {
+                                "required": True,
+                                "subsections": [
+                                    {
+                                        "name": "Token",
+                                        "fields": ["token"]
+                                    }
+                                ]
+                            }
+                        },
+                        "configuration_group": {
+                            "name": "ado",
+                        }
+                    }
+                }
+            }
         )
 
         @check_connection_response
@@ -107,7 +125,7 @@ class AzureDevOpsReposToolkit(BaseToolkit):
                     name=tool["name"],
                     description=description,
                     args_schema=tool["args_schema"],
-                    metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                    metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
                 )
             )
         return cls(tools=tools)