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

alita_sdk/runtime/utils/mcp_sse_client.py

@@ -0,0 +1,405 @@
+"""
+MCP SSE (Server-Sent Events) Client
+Handles persistent SSE connections for MCP servers like Atlassian
+"""
+import asyncio
+import json
+import logging
+from typing import Dict, Any, Optional, AsyncIterator
+import aiohttp
+
+logger = logging.getLogger(__name__)
+
+
+class McpSseClient:
+    """
+    Client for MCP servers using SSE (Server-Sent Events) transport.
+    
+    For Atlassian-style SSE (dual-connection model):
+    - GET request opens persistent SSE stream for receiving events
+    - POST requests send commands (return 202 Accepted immediately)
+    - Responses come via the GET stream
+    
+    This client handles:
+    - Opening persistent SSE connection via GET
+    - Sending JSON-RPC requests via POST
+    - Reading SSE event streams
+    - Matching responses to requests by ID
+    """
+    
+    def __init__(self, url: str, session_id: str, headers: Optional[Dict[str, str]] = None, timeout: int = 300):
+        """
+        Initialize SSE client.
+        
+        Args:
+            url: Base URL of the MCP SSE server
+            session_id: Client-generated UUID for session
+            headers: Additional headers (e.g., Authorization)
+            timeout: Request timeout in seconds
+        """
+        self.url = url
+        self.session_id = session_id
+        self.headers = headers or {}
+        self.timeout = timeout
+        self.url_with_session = f"{url}?sessionId={session_id}"
+        self._stream_task = None
+        self._pending_requests = {}  # request_id -> asyncio.Future
+        self._stream_session = None
+        self._stream_response = None
+        self._endpoint_ready = asyncio.Event()  # Signal when endpoint is received
+        
+        logger.info(f"[MCP SSE Client] Initialized for {url} with session {session_id}")
+    
+    async def _ensure_stream_connected(self):
+        """Ensure the GET stream is connected and reading events."""
+        if self._stream_task is None or self._stream_task.done():
+            logger.info(f"[MCP SSE Client] Opening persistent SSE stream...")
+            self._stream_session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=None))
+            
+            headers = {
+                "Accept": "text/event-stream",
+                **self.headers
+            }
+            
+            self._stream_response = await self._stream_session.get(self.url_with_session, headers=headers)
+            
+            logger.info(f"[MCP SSE Client] Stream opened: status={self._stream_response.status}")
+            
+            # Handle 401 Unauthorized - need OAuth
+            if self._stream_response.status == 401:
+                from ..utils.mcp_oauth import (
+                    McpAuthorizationRequired,
+                    canonical_resource,
+                    extract_resource_metadata_url,
+                    fetch_resource_metadata_async,
+                    infer_authorization_servers_from_realm,
+                    fetch_oauth_authorization_server_metadata
+                )
+                
+                auth_header = self._stream_response.headers.get('WWW-Authenticate', '')
+                resource_metadata_url = extract_resource_metadata_url(auth_header, self.url)
+                
+                metadata = None
+                if resource_metadata_url:
+                    metadata = await fetch_resource_metadata_async(
+                        resource_metadata_url,
+                        session=self._stream_session,
+                        timeout=30
+                    )
+                
+                # Infer authorization servers if not in metadata
+                if not metadata or not metadata.get('authorization_servers'):
+                    inferred_servers = infer_authorization_servers_from_realm(auth_header, self.url)
+                    if inferred_servers:
+                        if not metadata:
+                            metadata = {}
+                        metadata['authorization_servers'] = inferred_servers
+                        logger.info(f"[MCP SSE Client] Inferred authorization servers: {inferred_servers}")
+                        
+                        # Fetch OAuth metadata
+                        auth_server_metadata = fetch_oauth_authorization_server_metadata(inferred_servers[0], timeout=30)
+                        if auth_server_metadata:
+                            metadata['oauth_authorization_server'] = auth_server_metadata
+                            logger.info(f"[MCP SSE Client] Fetched OAuth metadata")
+                
+                raise McpAuthorizationRequired(
+                    message=f"MCP server {self.url} requires OAuth authorization",
+                    server_url=canonical_resource(self.url),
+                    resource_metadata_url=resource_metadata_url,
+                    www_authenticate=auth_header,
+                    resource_metadata=metadata,
+                    status=self._stream_response.status,
+                    tool_name=self.url,
+                )
+            
+            if self._stream_response.status != 200:
+                error_text = await self._stream_response.text()
+                raise Exception(f"Failed to open SSE stream: HTTP {self._stream_response.status}: {error_text}")
+            
+            # Start background task to read stream
+            self._stream_task = asyncio.create_task(self._read_stream())
+    
+    async def _read_stream(self):
+        """Background task that continuously reads the SSE stream."""
+        logger.info(f"[MCP SSE Client] Starting stream reader...")
+        
+        try:
+            buffer = ""
+            current_event = {}
+            
+            async for chunk in self._stream_response.content.iter_chunked(1024):
+                chunk_str = chunk.decode('utf-8')
+                buffer += chunk_str
+                
+                # Process complete lines
+                while '\n' in buffer:
+                    line, buffer = buffer.split('\n', 1)
+                    line_str = line.strip()
+                    
+                    # Empty line indicates end of event
+                    if not line_str:
+                        if current_event and 'data' in current_event:
+                            self._process_event(current_event)
+                            current_event = {}
+                        continue
+                    
+                    # Parse SSE fields
+                    if line_str.startswith('event:'):
+                        current_event['event'] = line_str[6:].strip()
+                    elif line_str.startswith('data:'):
+                        data_str = line_str[5:].strip()
+                        current_event['data'] = data_str
+                    elif line_str.startswith('id:'):
+                        current_event['id'] = line_str[3:].strip()
+                    
+        except Exception as e:
+            logger.error(f"[MCP SSE Client] Stream reader error: {e}")
+            # Fail all pending requests
+            for future in self._pending_requests.values():
+                if not future.done():
+                    future.set_exception(e)
+        finally:
+            logger.info(f"[MCP SSE Client] Stream reader stopped")
+    
+    def _process_event(self, event: Dict[str, str]):
+        """Process a complete SSE event."""
+        event_type = event.get('event', 'message')
+        data_str = event.get('data', '')
+        
+        # Handle 'endpoint' event - server provides the actual session URL to use
+        if event_type == 'endpoint':
+            # Extract session ID from endpoint URL
+            # Format: /v1/sse?sessionId=<uuid>
+            if 'sessionId=' in data_str:
+                new_session_id = data_str.split('sessionId=')[1].split('&')[0]
+                logger.info(f"[MCP SSE Client] Server provided session ID: {new_session_id}")
+                self.session_id = new_session_id
+                self.url_with_session = f"{self.url}?sessionId={new_session_id}"
+                self._endpoint_ready.set()  # Signal that we can now send requests
+            return
+        
+        # Skip other non-message events
+        if event_type != 'message' and not data_str.startswith('{'):
+            return
+        
+        if not data_str:
+            return
+        
+        try:
+            data = json.loads(data_str)
+            request_id = data.get('id')
+            
+            logger.debug(f"[MCP SSE Client] Received response for request {request_id}")
+            
+            # Resolve pending request
+            if request_id and request_id in self._pending_requests:
+                future = self._pending_requests.pop(request_id)
+                if not future.done():
+                    future.set_result(data)
+                
+        except json.JSONDecodeError as e:
+            logger.warning(f"[MCP SSE Client] Failed to parse SSE data: {e}, data: {repr(data_str)[:200]}")
+                            
+        except Exception as e:
+            logger.error(f"[MCP SSE Client] Stream reader error: {e}")
+            # Fail all pending requests
+            for future in self._pending_requests.values():
+                if not future.done():
+                    future.set_exception(e)
+        finally:
+            logger.info(f"[MCP SSE Client] Stream reader stopped")
+    
+    async def send_request(self, method: str, params: Optional[Dict[str, Any]] = None, request_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Send a JSON-RPC request and wait for response via SSE stream.
+        
+        Uses dual-connection model:
+        1. GET stream is kept open to receive responses
+        2. POST request sends the command (returns 202 immediately)
+        3. Response comes via the GET stream
+        
+        Args:
+            method: JSON-RPC method name (e.g., "tools/list", "tools/call")
+            params: Method parameters
+            request_id: Optional request ID (auto-generated if not provided)
+            
+        Returns:
+            Parsed JSON-RPC response
+            
+        Raises:
+            Exception: If request fails or times out
+        """
+        import time
+        if request_id is None:
+            request_id = f"{method.replace('/', '_')}_{int(time.time() * 1000)}"
+        
+        request = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+            "params": params or {}
+        }
+        
+        logger.debug(f"[MCP SSE Client] Sending request: {method} (id={request_id})")
+        
+        # Ensure stream is connected
+        await self._ensure_stream_connected()
+        
+        # Wait for endpoint event (server provides the actual session ID to use)
+        await asyncio.wait_for(self._endpoint_ready.wait(), timeout=10)
+        
+        # Create future for this request
+        future = asyncio.Future()
+        self._pending_requests[request_id] = future
+        
+        # Send POST request
+        headers = {
+            "Content-Type": "application/json",
+            **self.headers
+        }
+        
+        timeout = aiohttp.ClientTimeout(total=30)
+        
+        try:
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.post(self.url_with_session, json=request, headers=headers) as response:
+                    if response.status == 404:
+                        error_text = await response.text()
+                        raise Exception(f"HTTP 404: {error_text}")
+                    
+                    # 202 is expected - response will come via stream
+                    if response.status not in [200, 202]:
+                        error_text = await response.text()
+                        raise Exception(f"HTTP {response.status}: {error_text}")
+            
+            # Wait for response from stream (with timeout)
+            result = await asyncio.wait_for(future, timeout=self.timeout)
+            
+            # Check for JSON-RPC error
+            if 'error' in result:
+                error = result['error']
+                raise Exception(f"MCP Error: {error.get('message', str(error))}")
+            
+            return result
+                    
+        except asyncio.TimeoutError:
+            self._pending_requests.pop(request_id, None)
+            logger.error(f"[MCP SSE Client] Request timeout after {self.timeout}s")
+            raise Exception(f"SSE request timeout after {self.timeout}s")
+        except Exception as e:
+            self._pending_requests.pop(request_id, None)
+            logger.error(f"[MCP SSE Client] Request failed: {e}")
+            raise
+    
+    async def close(self):
+        """Close the persistent SSE stream."""
+        logger.info(f"[MCP SSE Client] Closing connection...")
+        
+        # Cancel background stream reader task
+        if self._stream_task and not self._stream_task.done():
+            self._stream_task.cancel()
+            try:
+                await self._stream_task
+            except (asyncio.CancelledError, Exception) as e:
+                logger.debug(f"[MCP SSE Client] Stream task cleanup: {e}")
+        
+        # Close response stream
+        if self._stream_response and not self._stream_response.closed:
+            try:
+                self._stream_response.close()
+            except Exception as e:
+                logger.debug(f"[MCP SSE Client] Response close error: {e}")
+        
+        # Close session
+        if self._stream_session and not self._stream_session.closed:
+            try:
+                await self._stream_session.close()
+                # Give aiohttp time to cleanup
+                await asyncio.sleep(0.1)
+            except Exception as e:
+                logger.debug(f"[MCP SSE Client] Session close error: {e}")
+        
+        logger.info(f"[MCP SSE Client] Connection closed")
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+    
+    async def initialize(self) -> Dict[str, Any]:
+        """
+        Send initialize request to establish MCP protocol session.
+        
+        Returns:
+            Server capabilities and info
+        """
+        response = await self.send_request(
+            method="initialize",
+            params={
+                "protocolVersion": "2024-11-05",
+                "capabilities": {
+                    "roots": {"listChanged": True},
+                    "sampling": {}
+                },
+                "clientInfo": {
+                    "name": "Alita MCP Client",
+                    "version": "1.0.0"
+                }
+            }
+        )
+        
+        logger.info(f"[MCP SSE Client] MCP session initialized")
+        return response.get('result', {})
+    
+    async def list_tools(self) -> list:
+        """
+        Discover available tools from the MCP server.
+        
+        Returns:
+            List of tool definitions
+        """
+        response = await self.send_request(method="tools/list")
+        result = response.get('result', {})
+        tools = result.get('tools', [])
+        
+        logger.info(f"[MCP SSE Client] Discovered {len(tools)} tools")
+        return tools
+    
+    async def list_prompts(self) -> list:
+        """
+        Discover available prompts from the MCP server.
+        
+        Returns:
+            List of prompt definitions
+        """
+        response = await self.send_request(method="prompts/list")
+        result = response.get('result', {})
+        prompts = result.get('prompts', [])
+        
+        logger.debug(f"[MCP SSE Client] Discovered {len(prompts)} prompts")
+        return prompts
+    
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+        """
+        Execute a tool on the MCP server.
+        
+        Args:
+            tool_name: Name of the tool to call
+            arguments: Tool arguments
+            
+        Returns:
+            Tool execution result
+        """
+        response = await self.send_request(
+            method="tools/call",
+            params={
+                "name": tool_name,
+                "arguments": arguments
+            }
+        )
+        
+        result = response.get('result', {})
+        return result

alita_sdk/runtime/utils/streamlit.py

@@ -868,10 +868,24 @@ def run_streamlit(st, ai_icon=None, user_icon=None):
                                 label = f"{'🔒 ' if is_secret else ''}{'*' if is_required else ''}{field_name.replace('_', ' ').title()}"
                                 
                                 if field_type == 'string':
-                                    if is_secret:
+                                    # Check if this is an enum field
+                                    if field_schema.get('enum'):
+                                        # Dropdown for enum values
+                                        options = field_schema['enum']
+                                        default_index = 0
+                                        if default_value and str(default_value) in options:
+                                            default_index = options.index(str(default_value))
+                                        toolkit_config_values[field_name] = st.selectbox(
+                                            label,
+                                            options=options,
+                                            index=default_index,
+                                            help=field_description,
+                                            key=f"config_{field_name}_{selected_toolkit_idx}"
+                                        )
+                                    elif is_secret:
                                         toolkit_config_values[field_name] = st.text_input(
                                             label,
-                                            value=str(default_value) if default_value else '', 
+                                            value=str(default_value) if default_value else '',
                                             help=field_description,
                                             type="password",
                                             key=f"config_{field_name}_{selected_toolkit_idx}"
@@ -879,7 +893,7 @@ def run_streamlit(st, ai_icon=None, user_icon=None):
                                     else:
                                         toolkit_config_values[field_name] = st.text_input(
                                             label,
-                                            value=str(default_value) if default_value else '', 
+                                            value=str(default_value) if default_value else '',
                                             help=field_description,
                                             key=f"config_{field_name}_{selected_toolkit_idx}"
                                         )
@@ -971,6 +985,23 @@ def run_streamlit(st, ai_icon=None, user_icon=None):
                                                 key=f"config_{field_name}_{selected_toolkit_idx}"
                                             )
                                         toolkit_config_values[field_name] = [line.strip() for line in array_input.split('\n') if line.strip()]
+                                elif field_type == 'object':
+                                    # Handle object/dict types (like headers)
+                                    obj_input = st.text_area(
+                                        f"{label} (JSON object)",
+                                        value=json.dumps(default_value) if isinstance(default_value, dict) else str(default_value) if default_value else '',
+                                        help=f"{field_description} - Enter as JSON object, e.g. {{\"Authorization\": \"Bearer token\"}}",
+                                        placeholder='{"key": "value"}',
+                                        key=f"config_{field_name}_{selected_toolkit_idx}"
+                                    )
+                                    try:
+                                        if obj_input.strip():
+                                            toolkit_config_values[field_name] = json.loads(obj_input)
+                                        else:
+                                            toolkit_config_values[field_name] = None
+                                    except json.JSONDecodeError as e:
+                                        st.error(f"Invalid JSON format for {field_name}: {e}")
+                                        toolkit_config_values[field_name] = None
                         else:
                             st.info("This toolkit doesn't require additional configuration.")
                         

alita_sdk/runtime/utils/toolkit_utils.py

@@ -29,13 +29,14 @@ def instantiate_toolkit_with_client(toolkit_config: Dict[str, Any],
         
     Raises:
         ValueError: If required configuration or client is missing
+        McpAuthorizationRequired: If MCP server requires OAuth authorization
         Exception: If toolkit instantiation fails
     """
+    toolkit_name = toolkit_config.get('toolkit_name', 'unknown')
     try:
         from ..toolkits.tools import get_tools
         
-        toolkit_name = toolkit_config.get('toolkit_name')
-        if not toolkit_name:
+        if not toolkit_name or toolkit_name == 'unknown':
             raise ValueError("toolkit_name is required in configuration")
         
         if not llm_client:
@@ -46,11 +47,14 @@ def instantiate_toolkit_with_client(toolkit_config: Dict[str, Any],
         # Log the configuration being used
         logger.info(f"Instantiating toolkit {toolkit_name} with LLM client")
         logger.debug(f"Toolkit {toolkit_name} configuration: {toolkit_config}")
-        
+
+        # Use toolkit type from config, or fall back to lowercase toolkit name
+        toolkit_type = toolkit_config.get('type', toolkit_name.lower())
+
         # Create a tool configuration dict with required fields
         tool_config = {
             'id': toolkit_config.get('id', random.randint(1, 1000000)),
-            'type': toolkit_config.get('type', toolkit_name.lower()),
+            'type': toolkit_config.get('type', toolkit_type),
             'settings': settings,
             'toolkit_name': toolkit_name
         }
@@ -67,6 +71,12 @@ def instantiate_toolkit_with_client(toolkit_config: Dict[str, Any],
         return tools
             
     except Exception as e:
+        # Re-raise McpAuthorizationRequired without logging as error
+        from ..utils.mcp_oauth import McpAuthorizationRequired
+        if isinstance(e, McpAuthorizationRequired):
+            logger.info(f"Toolkit {toolkit_name} requires MCP OAuth authorization")
+            raise
+        # Log and re-raise other errors
         logger.error(f"Error instantiating toolkit {toolkit_name} with client: {str(e)}")
         raise
 

alita_sdk/tools/__init__.py

@@ -90,64 +90,79 @@ available_count = len(AVAILABLE_TOOLS)
 total_attempted = len(AVAILABLE_TOOLS) + len(FAILED_IMPORTS)
 logger.info(f"Tool imports completed: {available_count}/{total_attempted} successful")
 
+
 def get_tools(tools_list, alita, llm, store: Optional[BaseStore] = None, *args, **kwargs):
     tools = []
+
     for tool in tools_list:
-        # validate tool name syntax - it cannot be started with _
-        for tool_name in tool.get('settings', {}).get('selected_tools', []):
-            if isinstance(tool_name, str) and tool_name.startswith('_'):
-                raise ValueError(f"Tool name '{tool_name}' from toolkit '{tool.get('type', '')}' cannot start with '_'")
-        if not tool.get('settings'):
+        settings = tool.get('settings')
+
+        # Skip tools without settings early
+        if not settings:
             logger.warning(f"Tool '{tool.get('type', '')}' has no settings, skipping...")
             continue
-        tool['settings']['alita'] = alita
-        tool['settings']['llm'] = llm
-        tool['settings']['store'] = store
+
+        # Validate tool names once
+        selected_tools = settings.get('selected_tools', [])
+        invalid_tools = [name for name in selected_tools if isinstance(name, str) and name.startswith('_')]
+        if invalid_tools:
+            raise ValueError(f"Tool names {invalid_tools} from toolkit '{tool.get('type', '')}' cannot start with '_'")
+
+        # Cache tool type and add common settings
         tool_type = tool['type']
+        settings['alita'] = alita
+        settings['llm'] = llm
+        settings['store'] = store
 
-        # Handle special cases for ADO tools
+        # Set pgvector collection schema if present
+        if settings.get('pgvector_configuration'):
+            settings['pgvector_configuration']['collection_schema'] = str(tool['id'])
+
+        # Handle ADO special cases
         if tool_type in ['ado_boards', 'ado_wiki', 'ado_plans']:
             tools.extend(AVAILABLE_TOOLS['ado']['get_tools'](tool_type, tool))
+            continue
 
-        # Check if tool is available and has get_tools function
-        elif tool_type in AVAILABLE_TOOLS and 'get_tools' in AVAILABLE_TOOLS[tool_type]:
+        # Handle ADO repos aliases
+        if tool_type in ['ado_repos', 'azure_devops_repos'] and 'ado_repos' in AVAILABLE_TOOLS:
             try:
-                get_tools_func = AVAILABLE_TOOLS[tool_type]['get_tools']
-                tools.extend(get_tools_func(tool))
-
+                tools.extend(AVAILABLE_TOOLS['ado_repos']['get_tools'](tool))
             except Exception as e:
-                logger.error(f"Error getting tools for {tool_type}: {e}")
-                raise ToolException(f"Error getting tools for {tool_type}: {e}")
+                logger.error(f"Error getting ADO repos tools: {e}")
+            continue
 
-        # Handle ADO repos special case (it might be requested as azure_devops_repos)
-        elif tool_type in ['ado_repos', 'azure_devops_repos'] and 'ado_repos' in AVAILABLE_TOOLS:
+        # Skip MCP toolkit - it's handled by runtime/toolkits/tools.py to avoid duplicate loading
+        if tool_type == 'mcp':
+            logger.debug(f"Skipping MCP toolkit '{tool.get('toolkit_name')}' - handled by runtime toolkit system")
+            continue
+
+        # Handle standard tools
+        if tool_type in AVAILABLE_TOOLS and 'get_tools' in AVAILABLE_TOOLS[tool_type]:
             try:
-                get_tools_func = AVAILABLE_TOOLS['ado_repos']['get_tools']
-                tools.extend(get_tools_func(tool))
+                tools.extend(AVAILABLE_TOOLS[tool_type]['get_tools'](tool))
             except Exception as e:
-                logger.error(f"Error getting ADO repos tools: {e}")
+                logger.error(f"Error getting tools for {tool_type}: {e}")
+                raise ToolException(f"Error getting tools for {tool_type}: {e}")
+            continue
 
         # Handle custom modules
-        elif tool.get("settings", {}).get("module"):
+        if settings.get("module"):
             try:
-                settings = tool.get("settings", {})
                 mod = import_module(settings.pop("module"))
                 tkitclass = getattr(mod, settings.pop("class"))
-                #
-                get_toolkit_params = tool["settings"].copy()
+                get_toolkit_params = settings.copy()
                 get_toolkit_params["name"] = tool.get("name")
-                #
                 toolkit = tkitclass.get_toolkit(**get_toolkit_params)
                 tools.extend(toolkit.get_tools())
             except Exception as e:
                 logger.error(f"Error in getting custom toolkit: {e}")
+            continue
 
+        # Tool not available
+        if tool_type in FAILED_IMPORTS:
+            logger.warning(f"Tool '{tool_type}' is not available: {FAILED_IMPORTS[tool_type]}")
         else:
-            # Tool not available or not found
-            if tool_type in FAILED_IMPORTS:
-                logger.warning(f"Tool '{tool_type}' is not available: {FAILED_IMPORTS[tool_type]}")
-            else:
-                logger.warning(f"Unknown tool type: {tool_type}")
+            logger.warning(f"Unknown tool type: {tool_type}")
 
     return tools
 

alita_sdk/tools/ado/repos/__init__.py

@@ -63,6 +63,7 @@ class AzureDevOpsReposToolkit(BaseToolkit):
                     "icon_url": "ado-repos-icon.svg",
                     "categories": ["code repositories"],
                     "extra_categories": ["code", "repository", "version control"],
+                    "max_length": AzureDevOpsReposToolkit.toolkit_max_length
                 }}}
         )
 

alita_sdk/tools/ado/test_plan/__init__.py

@@ -27,7 +27,6 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
         AzureDevOpsPlansToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name_alias,
-            name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsPlansToolkit.toolkit_max_length})),
             ado_configuration=(AdoConfiguration, Field(description="Ado configuration", json_schema_extra={'configuration_types': ['ado']})),
             limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),
             # indexer settings
@@ -40,6 +39,7 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
                 {
                     "label": "ADO plans",
                     "icon_url": "ado-plans.svg",
+                    "max_length": AzureDevOpsPlansToolkit.toolkit_max_length,
                     "categories": ["test management"],
                     "extra_categories": ["test case management", "qa"],
                     "sections": {

alita_sdk/tools/ado/wiki/__init__.py

@@ -24,11 +24,6 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
         AzureDevOpsWikiToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name_alias,
-            name=(str, Field(description="Toolkit name",
-                             json_schema_extra={
-                                 'toolkit_name': True,
-                                 'max_toolkit_length': AzureDevOpsWikiToolkit.toolkit_max_length})
-                  ),
             ado_configuration=(AdoConfiguration, Field(description="Ado configuration", json_schema_extra={'configuration_types': ['ado']})),
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None,
@@ -42,6 +37,7 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
                     'metadata': {
                         "label": "ADO wiki",
                         "icon_url": "ado-wiki-icon.svg",
+                        "max_length": AzureDevOpsWikiToolkit.toolkit_max_length,
                         "categories": ["documentation"],
                         "extra_categories": ["knowledge base", "documentation management", "wiki"],
                         "sections": {