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

alita_sdk/runtime/toolkits/subgraph.py

@@ -1,4 +1,6 @@
-from typing import List, Any
+from typing import List, Any,  Optional
+import logging
+import yaml
 
 from langchain_core.tools import BaseTool
 from langgraph.checkpoint.memory import MemorySaver
@@ -8,7 +10,238 @@ from ..langchain.langraph_agent import create_graph, SUBGRAPH_REGISTRY
 from ..tools.graph import GraphTool
 from ..utils.utils import clean_string
 
+logger = logging.getLogger(__name__)
 
+
+def _resolve_bypass_chain(target: str, bypass_mapping: dict, all_printer_related: set, max_depth: int = 100) -> str:
+    """
+    Recursively follow bypass mapping chain to find the first non-printer target.
+
+    Args:
+        target: Starting target node ID
+        bypass_mapping: Mapping of printer_id -> successor_id
+        all_printer_related: Set of all printer and reset node IDs
+        max_depth: Maximum chain depth to prevent infinite loops
+
+    Returns:
+        Final non-printer target node ID
+    """
+    visited = set()
+    depth = 0
+
+    while target in all_printer_related or target in bypass_mapping:
+        if depth >= max_depth:
+            logger.error(f"Maximum bypass chain depth ({max_depth}) exceeded for target '{target}'")
+            break
+
+        if target in visited:
+            logger.error(f"Circular reference detected in bypass chain starting from '{target}'")
+            break
+
+        visited.add(target)
+
+        if target in bypass_mapping:
+            target = bypass_mapping[target]
+            depth += 1
+            logger.debug(f"Following bypass chain: depth={depth}, target={target}")
+        else:
+            # Target is in all_printer_related but not in bypass mapping
+            logger.warning(f"Target '{target}' is a printer node without bypass mapping")
+            break
+
+    return target
+
+
+def _filter_printer_nodes_from_yaml(yaml_schema: str) -> str:
+    """
+    Filter out PrinterNodes and their reset nodes from a YAML schema.
+
+    This function removes:
+    1. Nodes with type='printer'
+    2. Reset nodes (pattern: {node_id}_reset)
+    3. Rewires transitions to bypass removed printer nodes
+    4. Removes printer nodes from interrupt configurations
+
+    Args:
+        yaml_schema: Original YAML schema string
+
+    Returns:
+        Filtered YAML schema string without PrinterNodes
+    """
+    try:
+        schema_dict = yaml.safe_load(yaml_schema)
+
+        if not schema_dict or 'nodes' not in schema_dict:
+            return yaml_schema
+
+        nodes = schema_dict.get('nodes', [])
+
+        # Step 1: Identify printer nodes and build bypass mapping
+        printer_nodes = set()
+        printer_reset_nodes = set()
+        printer_bypass_mapping = {}  # printer_node_id -> actual_successor_id
+
+        # First pass: Identify all printer nodes and reset nodes
+        for node in nodes:
+            node_id = node.get('id')
+            node_type = node.get('type')
+
+            if not node_id:
+                continue
+
+            # Identify reset nodes by naming pattern
+            if node_id.endswith('_reset'):
+                printer_reset_nodes.add(node_id)
+                continue
+
+            # Identify main printer nodes
+            if node_type == 'printer':
+                printer_nodes.add(node_id)
+
+        # Second pass: Build bypass mapping for printer nodes
+        for node in nodes:
+            node_id = node.get('id')
+            node_type = node.get('type')
+
+            if not node_id or node_type != 'printer':
+                continue
+
+            # Try standard pattern first: Printer -> Printer_reset -> NextNode
+            reset_node_id = f"{node_id}_reset"
+            reset_node = next((n for n in nodes if n.get('id') == reset_node_id), None)
+
+            if reset_node:
+                # Standard pattern with reset node
+                actual_successor = reset_node.get('transition')
+                if actual_successor:
+                    printer_bypass_mapping[node_id] = actual_successor
+                    logger.debug(f"Printer bypass mapping (standard): {node_id} -> {actual_successor}")
+            else:
+                # Direct transition pattern: Printer -> NextNode (no reset node)
+                # Get the direct transition from the printer node
+                direct_transition = node.get('transition')
+                if direct_transition:
+                    printer_bypass_mapping[node_id] = direct_transition
+                    logger.debug(f"Printer bypass mapping (direct): {node_id} -> {direct_transition}")
+
+        # Create the set of all printer-related nodes early so it can be used in rewiring
+        all_printer_related = printer_nodes | printer_reset_nodes
+
+        # Step 2: Filter out printer nodes and reset nodes
+        filtered_nodes = []
+        for node in nodes:
+            node_id = node.get('id')
+            node_type = node.get('type')
+
+            # Skip printer nodes
+            if node_type == 'printer':
+                logger.debug(f"Filtering out printer node: {node_id}")
+                continue
+
+            # Skip reset nodes
+            if node_id in printer_reset_nodes:
+                logger.debug(f"Filtering out printer reset node: {node_id}")
+                continue
+
+            # Step 3: Rewire transitions in remaining nodes to bypass printer nodes
+            # Use recursive resolution to handle chains of printers
+            if 'transition' in node:
+                transition = node['transition']
+                if transition in printer_bypass_mapping or transition in all_printer_related:
+                    new_transition = _resolve_bypass_chain(transition, printer_bypass_mapping, all_printer_related)
+                    if new_transition != transition:
+                        node['transition'] = new_transition
+                        logger.debug(f"Rewired transition in node '{node_id}': {transition} -> {new_transition}")
+
+            # Handle conditional outputs
+            if 'condition' in node:
+                condition = node['condition']
+                if 'conditional_outputs' in condition:
+                    new_outputs = []
+                    for output in condition['conditional_outputs']:
+                        if output in printer_bypass_mapping or output in all_printer_related:
+                            resolved_output = _resolve_bypass_chain(output, printer_bypass_mapping, all_printer_related)
+                            new_outputs.append(resolved_output)
+                        else:
+                            new_outputs.append(output)
+                    condition['conditional_outputs'] = new_outputs
+
+                if 'default_output' in condition:
+                    default = condition['default_output']
+                    if default in printer_bypass_mapping or default in all_printer_related:
+                        condition['default_output'] = _resolve_bypass_chain(default, printer_bypass_mapping, all_printer_related)
+
+            # Handle decision nodes
+            if 'decision' in node:
+                decision = node['decision']
+                if 'nodes' in decision:
+                    new_nodes = []
+                    for decision_node in decision['nodes']:
+                        if decision_node in printer_bypass_mapping or decision_node in all_printer_related:
+                            resolved_node = _resolve_bypass_chain(decision_node, printer_bypass_mapping, all_printer_related)
+                            new_nodes.append(resolved_node)
+                        else:
+                            new_nodes.append(decision_node)
+                    decision['nodes'] = new_nodes
+
+            # Handle routes (for router nodes)
+            if 'routes' in node:
+                routes = node['routes']
+                if isinstance(routes, list):
+                    new_routes = []
+                    for route in routes:
+                        if isinstance(route, dict) and 'target' in route:
+                            target = route['target']
+                            if target in printer_bypass_mapping or target in all_printer_related:
+                                route['target'] = _resolve_bypass_chain(target, printer_bypass_mapping, all_printer_related)
+                        new_routes.append(route)
+                    node['routes'] = new_routes
+
+            filtered_nodes.append(node)
+
+        # Update the nodes in schema
+        schema_dict['nodes'] = filtered_nodes
+
+        # Step 4: Filter printer nodes from interrupt configurations
+        if 'interrupt_before' in schema_dict:
+            schema_dict['interrupt_before'] = [
+                i for i in schema_dict['interrupt_before']
+                if i not in all_printer_related
+            ]
+
+        if 'interrupt_after' in schema_dict:
+            schema_dict['interrupt_after'] = [
+                i for i in schema_dict['interrupt_after']
+                if i not in all_printer_related
+            ]
+
+        # Update entry point if it points to a printer node
+        # Use helper function to recursively resolve the chain
+        if 'entry_point' in schema_dict:
+            entry_point = schema_dict['entry_point']
+            original_entry = entry_point
+
+            # Check if entry point is a printer node (directly or in bypass mapping)
+            if entry_point in all_printer_related or entry_point in printer_bypass_mapping:
+                # Use helper function to resolve the chain
+                resolved_entry = _resolve_bypass_chain(entry_point, printer_bypass_mapping, all_printer_related)
+
+                if resolved_entry != original_entry:
+                    schema_dict['entry_point'] = resolved_entry
+                    logger.info(f"Updated entry point: {original_entry} -> {resolved_entry}")
+
+
+        # Convert back to YAML
+        filtered_yaml = yaml.dump(schema_dict, default_flow_style=False, sort_keys=False)
+        return filtered_yaml
+
+    except Exception as e:
+        logger.error(f"Error filtering PrinterNodes from YAML: {e}", exc_info=True)
+        # Return original YAML if filtering fails
+        return yaml_schema
+
+
+# TODO: deprecate next release (1/15/2026)
 class SubgraphToolkit:
 
     @staticmethod
@@ -18,21 +251,33 @@ class SubgraphToolkit:
         application_version_id: int,
         llm,
         app_api_key: str,
-        selected_tools: list[str] = []
+        selected_tools: list[str] = [],
+        is_subgraph: bool = True,
+        mcp_tokens: Optional[dict] = None,
+        ignored_mcp_servers: Optional[list] = None
     ) -> List[BaseTool]:
         from .tools import get_tools
         # from langgraph.checkpoint.memory import MemorySaver
 
         app_details = client.get_app_details(application_id)
         version_details = client.get_app_version_details(application_id, application_version_id)
-        tools = get_tools(version_details['tools'], alita_client=client, llm=llm)
+        tools = get_tools(version_details['tools'], alita_client=client, llm=llm,
+                          mcp_tokens=mcp_tokens, ignored_mcp_servers=ignored_mcp_servers)
 
         # Get the subgraph name
         subgraph_name = app_details.get("name")
         
+        # Get the original YAML
+        yaml_schema = version_details['instructions']
+
+        # Filter PrinterNodes from YAML if this is a subgraph
+        if is_subgraph:
+            yaml_schema = _filter_printer_nodes_from_yaml(yaml_schema)
+            logger.info(f"Filtered PrinterNodes from subgraph pipeline '{subgraph_name}'")
+
         # Populate the registry for flattening approach
         SUBGRAPH_REGISTRY[subgraph_name] = {
-            'yaml': version_details['instructions'],
+            'yaml': yaml_schema,  # Use filtered YAML
             'tools': tools,
             'flattened': False
         }
@@ -43,11 +288,11 @@ class SubgraphToolkit:
         graph = create_graph(
             client=llm,
             tools=tools,
-            yaml_schema=version_details['instructions'],
+            yaml_schema=yaml_schema,  # Use filtered YAML
             debug=False,
             store=None,
             memory=MemorySaver(),
-            # for_subgraph=True,  # compile as raw subgraph
+            for_subgraph=is_subgraph,  # Pass flag to create_graph
         )
 
         cleaned_subgraph_name = clean_string(subgraph_name)

alita_sdk/runtime/toolkits/tools.py

@@ -9,18 +9,23 @@ from alita_sdk.tools import get_tools as alita_tools
 from .application import ApplicationToolkit
 from .artifact import ArtifactToolkit
 from .datasource import DatasourcesToolkit
+from .planning import PlanningToolkit
 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
 from ..utils.mcp_oauth import canonical_resource, McpAuthorizationRequired
-from ...tools.utils import TOOLKIT_SPLITTER
+from ...tools.utils import clean_string
+from alita_sdk.tools import _inject_toolkit_id
 
 logger = logging.getLogger(__name__)
 
@@ -29,22 +34,59 @@ def get_toolkits():
     core_toolkits = [
         ArtifactToolkit.toolkit_config_schema(),
         MemoryToolkit.toolkit_config_schema(),
+        PlanningToolkit.toolkit_config_schema(),
         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
 
-def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = None, debug_mode: Optional[bool] = False, mcp_tokens: Optional[dict] = None) -> list:
     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'])],
@@ -52,24 +94,35 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                     toolkit_name=tool.get('toolkit_name', '') or tool.get('name', '')
                 ).get_tools())
             elif tool['type'] == 'application':
+                tool_handled = True
+                # Check if this is a pipeline to enable PrinterNode filtering
+                is_pipeline_subgraph = tool.get('agent_type', '') == 'pipeline'
+
                 tools.extend(ApplicationToolkit.get_toolkit(
                     alita_client,
                     application_id=int(tool['settings']['application_id']),
                     application_version_id=int(tool['settings']['application_version_id']),
-                    selected_tools=[]
+                    selected_tools=[],
+                    ignored_mcp_servers=ignored_mcp_servers,
+                    is_subgraph=is_pipeline_subgraph,  # Pass is_subgraph for pipelines
+                    mcp_tokens=mcp_tokens
                 ).get_tools())
-                # backward compatibility for pipeline application type as subgraph node
-                if tool.get('agent_type', '') == 'pipeline':
-                    # static get_toolkit returns a list of CompiledStateGraph stubs
-                    tools.extend(SubgraphToolkit.get_toolkit(
-                        alita_client,
-                        application_id=int(tool['settings']['application_id']),
-                        application_version_id=int(tool['settings']['application_version_id']),
-                        app_api_key=alita_client.auth_token,
-                        selected_tools=[],
-                        llm=llm
-                    ))
+                # TODO: deprecate next release (1/15/2026)
+                # if is_pipeline_subgraph:
+                #     # static get_toolkit returns a list of CompiledStateGraph stubs
+                #     # Pass is_subgraph=True to enable PrinterNode filtering
+                #     logger.info(f"Processing pipeline as subgraph, will filter PrinterNodes")
+                #     tools.extend(SubgraphToolkit.get_toolkit(
+                #         alita_client,
+                #         application_id=int(tool['settings']['application_id']),
+                #         application_version_id=int(tool['settings']['application_version_id']),
+                #         app_api_key=alita_client.auth_token,
+                #         selected_tools=[],
+                #         llm=llm,
+                #         is_subgraph=True  # Enable PrinterNode filtering for pipelines used as subgraphs
+                #     ))
             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', {}),
@@ -77,6 +130,7 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                 ).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,
@@ -91,8 +145,28 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                     else:
                         logger.warning("Image generation internal tool requested "
                                        "but no image generation model configured")
+                elif tool['name'] == 'planner':
+                    tools += PlanningToolkit.get_toolkit(
+                        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':
-                tools.extend(ArtifactToolkit.get_toolkit(
+                tool_handled = True
+                toolkit_tools = ArtifactToolkit.get_toolkit(
                     client=alita_client,
                     bucket=tool['settings']['bucket'],
                     toolkit_name=tool.get('toolkit_name', ''),
@@ -102,17 +176,72 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                     pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
                     embedding_model=tool['settings'].get('embedding_model'),
                     collection_name=f"{tool.get('toolkit_name')}",
-                    collection_schema = str(tool['id'])
-                ).get_tools())
+                    collection_schema=str(tool['settings'].get('id', tool.get('id', ''))),
+                ).get_tools()
+                # Inject toolkit_id for artifact tools as well
+                # Pass settings as the tool config since that's where the id field is
+                _inject_toolkit_id(tool['settings'], toolkit_tools)
+                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', {})
+                
+                # Check if local mode is enabled (uses filesystem storage, ignores pgvector)
+                use_local = settings.get('local', False)
+                
+                if use_local:
+                    # Local mode - use filesystem storage
+                    logger.info("Planning toolkit using local filesystem storage (local=true)")
+                    pgvector_config = {}
+                else:
+                    # Check if explicit connection_string is provided in pgvector_configuration
+                    explicit_pgvector_config = settings.get('pgvector_configuration', {})
+                    explicit_connstr = explicit_pgvector_config.get('connection_string') if explicit_pgvector_config else None
+                    
+                    if explicit_connstr:
+                        # Use explicitly provided connection string (overrides project secrets)
+                        logger.info("Using explicit connection_string for planning toolkit")
+                        pgvector_config = explicit_pgvector_config
+                    else:
+                        # Try to fetch pgvector_project_connstr from project secrets
+                        pgvector_connstr = None
+                        if alita_client:
+                            try:
+                                pgvector_connstr = alita_client.unsecret('pgvector_project_connstr')
+                                if pgvector_connstr:
+                                    logger.info("Using pgvector_project_connstr for planning toolkit")
+                            except Exception as e:
+                                logger.debug(f"pgvector_project_connstr not available: {e}")
+                        
+                        pgvector_config = {'connection_string': pgvector_connstr} if pgvector_connstr else {}
+                
+                tools.extend(PlanningToolkit.get_toolkit(
+                    toolkit_name=tool.get('toolkit_name', ''),
+                    selected_tools=settings.get('selected_tools', []),
+                    pgvector_configuration=pgvector_config,
+                    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')
+                
+                # Check if this MCP server should be ignored (user chose to continue without auth)
+                if ignored_mcp_servers and url:
+                    canonical_url = canonical_resource(url)
+                    if canonical_url in ignored_mcp_servers or url in ignored_mcp_servers:
+                        logger.info(f"[MCP Auth] Skipping ignored MCP server: {url}")
+                        continue
+                
                 headers = settings.get('headers')
                 token_data = None
                 session_id = None
@@ -153,26 +282,96 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                     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
         except Exception as e:
-            if isinstance(e, McpAuthorizationRequired):
-                raise
             logger.error(f"Error initializing toolkit for tool '{tool.get('name', 'unknown')}': {e}", exc_info=True)
             if debug_mode:
                 logger.info("Skipping tool initialization error due to debug mode.")
                 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)
@@ -267,11 +466,18 @@ def _mcp_tools(tools_list, alita):
 
 def _init_single_mcp_tool(server_toolkit_name, toolkit_name, available_tool, alita, toolkit_settings):
     try:
-
-        tool_name = f'{toolkit_name}{TOOLKIT_SPLITTER}{available_tool["name"]}'
+        # Use clean tool name without prefix
+        tool_name = available_tool["name"]
+        # Add toolkit context to description (max 1000 chars)
+        toolkit_context = f" [Toolkit: {clean_string(toolkit_name)}]" if toolkit_name else ''
+        base_description = f"MCP for a tool '{tool_name}': {available_tool.get('description', '')}"
+        description = base_description
+        if toolkit_context and len(base_description + toolkit_context) <= 1000:
+            description = base_description + toolkit_context
+        
         return McpServerTool(
             name=tool_name,
-            description=f"MCP for a tool '{tool_name}': {available_tool.get("description", "")}",
+            description=description,
             args_schema=McpServerTool.create_pydantic_model_from_schema(
                 available_tool.get("inputSchema", {})
             ),