alita-sdk 0.3.486__py3-none-any.whl → 0.3.515__py3-none-any.whl

alita_sdk/runtime/utils/mcp_sse_client.py

@@ -71,6 +71,7 @@ class McpSseClient:
                     McpAuthorizationRequired,
                     canonical_resource,
                     extract_resource_metadata_url,
+                    extract_authorization_uri,
                     fetch_resource_metadata_async,
                     infer_authorization_servers_from_realm,
                     fetch_oauth_authorization_server_metadata
@@ -79,13 +80,41 @@ class McpSseClient:
                 auth_header = self._stream_response.headers.get('WWW-Authenticate', '')
                 resource_metadata_url = extract_resource_metadata_url(auth_header, self.url)
                 
+                # First, try authorization_uri from WWW-Authenticate header (preferred)
+                authorization_uri = extract_authorization_uri(auth_header)
+                
                 metadata = None
-                if resource_metadata_url:
-                    metadata = await fetch_resource_metadata_async(
-                        resource_metadata_url,
-                        session=self._stream_session,
-                        timeout=30
-                    )
+                if authorization_uri:
+                    # Fetch OAuth metadata directly from authorization_uri
+                    auth_server_metadata = fetch_oauth_authorization_server_metadata(authorization_uri, timeout=30)
+                    if auth_server_metadata:
+                        # Extract base authorization server URL from the issuer or the well-known URL
+                        base_auth_server = auth_server_metadata.get('issuer')
+                        if not base_auth_server and '/.well-known/' in authorization_uri:
+                            base_auth_server = authorization_uri.split('/.well-known/')[0]
+                        
+                        metadata = {
+                            'authorization_servers': [base_auth_server] if base_auth_server else [authorization_uri],
+                            'oauth_authorization_server': auth_server_metadata
+                        }
+                        logger.info(f"[MCP SSE Client] Using authorization_uri: {authorization_uri}, base: {base_auth_server}")
+                
+                # Fall back to resource_metadata if authorization_uri didn't work
+                if not metadata:
+                    if resource_metadata_url:
+                        metadata = await fetch_resource_metadata_async(
+                            resource_metadata_url,
+                            session=self._stream_session,
+                            timeout=30
+                        )
+                        # If we got resource_metadata, also fetch oauth_authorization_server
+                        if metadata and metadata.get('authorization_servers'):
+                            auth_server_metadata = fetch_oauth_authorization_server_metadata(
+                                metadata['authorization_servers'][0], timeout=30
+                            )
+                            if auth_server_metadata:
+                                metadata['oauth_authorization_server'] = auth_server_metadata
+                                logger.info(f"[MCP SSE Client] Fetched OAuth metadata from resource_metadata")
                 
                 # Infer authorization servers if not in metadata
                 if not metadata or not metadata.get('authorization_servers'):

alita_sdk/runtime/utils/mcp_tools_discovery.py

@@ -0,0 +1,124 @@
+"""
+MCP Tools Discovery Utility.
+Provides a standalone function to discover tools from remote MCP servers.
+Supports both SSE (Server-Sent Events) and Streamable HTTP transports with auto-detection.
+"""
+
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional
+
+from .mcp_oauth import McpAuthorizationRequired
+from .mcp_client import McpClient
+
+logger = logging.getLogger(__name__)
+
+
+def discover_mcp_tools(
+    url: str,
+    headers: Optional[Dict[str, str]] = None,
+    timeout: int = 60,
+    session_id: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Discover available tools from a remote MCP server.
+    
+    This function connects to a remote MCP server and retrieves the list of 
+    available tools using the MCP protocol. Automatically detects and uses
+    the appropriate transport (SSE or Streamable HTTP).
+    
+    Args:
+        url: MCP server HTTP URL (http:// or https://)
+        headers: Optional HTTP headers for authentication
+        timeout: Request timeout in seconds (default: 60)
+        session_id: Optional session ID for stateful connections
+        
+    Returns:
+        List of tool definitions, each containing:
+        - name: Tool name
+        - description: Tool description
+        - inputSchema: JSON schema for tool input parameters
+        
+    Raises:
+        McpAuthorizationRequired: If the server requires OAuth authorization (401)
+        Exception: For other connection or protocol errors
+        
+    Example:
+        >>> tools = discover_mcp_tools(
+        ...     url="https://mcp.example.com/sse",
+        ...     headers={"Authorization": "Bearer token123"}
+        ... )
+        >>> print(f"Found {len(tools)} tools")
+    """
+    logger.info(f"[MCP Discovery] Starting tool discovery from {url}")
+    
+    try:
+        # Run the async discovery in a new event loop
+        tools_list = asyncio.run(
+            _discover_tools_async(url, headers, timeout, session_id)
+        )
+        logger.info(f"[MCP Discovery] Successfully discovered {len(tools_list)} tools from {url}")
+        return tools_list
+        
+    except McpAuthorizationRequired:
+        # Re-raise auth exceptions directly
+        logger.info(f"[MCP Discovery] Authorization required for {url}")
+        raise
+        
+    except Exception as e:
+        logger.error(f"[MCP Discovery] Failed to discover tools from {url}: {e}")
+        raise
+
+
+async def _discover_tools_async(
+    url: str,
+    headers: Optional[Dict[str, str]],
+    timeout: int,
+    session_id: Optional[str],
+) -> List[Dict[str, Any]]:
+    """
+    Async implementation of tool discovery using unified MCP client.
+    """
+    all_tools = []
+    
+    # Create unified MCP client (auto-detects transport)
+    client = McpClient(
+        url=url,
+        session_id=session_id,
+        headers=headers,
+        timeout=timeout
+    )
+    
+    async with client:
+        # Initialize MCP session
+        await client.initialize()
+        logger.debug(f"[MCP Discovery] Session initialized (transport={client.detected_transport})")
+        
+        # Get tools list
+        tools = await client.list_tools()
+        logger.debug(f"[MCP Discovery] Received {len(tools)} tools")
+        
+        # Convert tools to standard format
+        for tool in tools:
+            tool_def = {
+                'name': tool.get('name'),
+                'description': tool.get('description', ''),
+                'inputSchema': tool.get('inputSchema', {}),
+            }
+            all_tools.append(tool_def)
+    
+    return all_tools
+
+
+async def discover_mcp_tools_async(
+    url: str,
+    headers: Optional[Dict[str, str]] = None,
+    timeout: int = 60,
+    session_id: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Async version of discover_mcp_tools.
+    
+    See discover_mcp_tools for full documentation.
+    """
+    return await _discover_tools_async(url, headers, timeout, session_id)

alita_sdk/runtime/utils/toolkit_utils.py

@@ -13,7 +13,8 @@ logger = logging.getLogger(__name__)
 def instantiate_toolkit_with_client(toolkit_config: Dict[str, Any], 
                                    llm_client: Any, 
                                    alita_client: Optional[Any] = None,
-                                   mcp_tokens: Optional[Dict[str, Any]] = None) -> List[Any]:
+                                   mcp_tokens: Optional[Dict[str, Any]] = None,
+                                   use_prefix: bool = False) -> List[Any]:
     """
     Instantiate a toolkit with LLM client support.
     
@@ -25,6 +26,9 @@ def instantiate_toolkit_with_client(toolkit_config: Dict[str, Any],
         llm_client: LLM client instance for tools that need LLM capabilities
         alita_client: Optional additional client instance
         mcp_tokens: Optional dictionary of MCP OAuth tokens by server URL
+        use_prefix: If True, tools get prefixed with toolkit_name to prevent collisions
+                   (for agent use). If False, tools use base names only (for testing interface).
+                   Default False for backward compatibility with testing.
     
     Returns:
         List of instantiated tools from the toolkit
@@ -54,11 +58,12 @@ def instantiate_toolkit_with_client(toolkit_config: Dict[str, Any],
         toolkit_type = toolkit_config.get('type', toolkit_name.lower())
 
         # Create a tool configuration dict with required fields
+        # Note: MCP toolkit always requires toolkit_name, other toolkits respect use_prefix flag
         tool_config = {
             'id': toolkit_config.get('id', random.randint(1, 1000000)),
             'type': toolkit_config.get('type', toolkit_type),
             'settings': settings,
-            'toolkit_name': toolkit_name
+            'toolkit_name': toolkit_name if (use_prefix or toolkit_type == 'mcp') else None
         }
         
         # Get tools using the toolkit configuration with clients
@@ -76,21 +81,10 @@ def instantiate_toolkit_with_client(toolkit_config: Dict[str, Any],
         # Re-raise McpAuthorizationRequired without logging as error
         from ..utils.mcp_oauth import McpAuthorizationRequired
         
-        # Check if it's McpAuthorizationRequired directly
         if isinstance(e, McpAuthorizationRequired):
             logger.info(f"Toolkit {toolkit_name} requires MCP OAuth authorization")
             raise
         
-        # Also check for wrapped exceptions
-        if hasattr(e, '__cause__') and isinstance(e.__cause__, McpAuthorizationRequired):
-            logger.info(f"Toolkit {toolkit_name} requires MCP OAuth authorization (wrapped)")
-            raise e.__cause__
-        
-        # Check exception class name as fallback
-        if e.__class__.__name__ == 'McpAuthorizationRequired':
-            logger.info(f"Toolkit {toolkit_name} requires MCP OAuth authorization (by name)")
-            raise
-        
         # Log and re-raise other errors
         logger.error(f"Error instantiating toolkit {toolkit_name} with client: {str(e)}")
         raise

alita_sdk/runtime/utils/utils.py

@@ -1,6 +1,8 @@
 import re
 from enum import Enum
 
+# DEPRECATED: Tool names no longer use prefixes
+# Kept for backward compatibility only
 TOOLKIT_SPLITTER = "___"
 
 class IndexerKeywords(Enum):

alita_sdk/tools/__init__.py

@@ -45,6 +45,9 @@ def _safe_import_tool(tool_name, module_path, get_tools_name=None, toolkit_class
         imported = {}
         if get_tools_name and hasattr(module, get_tools_name):
             imported['get_tools'] = getattr(module, get_tools_name)
+        
+        if hasattr(module, 'get_toolkit'):
+            imported['get_toolkit'] = getattr(module, 'get_toolkit')
 
         if toolkit_class_name and hasattr(module, toolkit_class_name):
             imported['toolkit_class'] = getattr(module, toolkit_class_name)
@@ -209,6 +212,18 @@ def get_toolkits():
     logger.info(f"Successfully loaded {len(toolkit_configs)} toolkit configurations")
     return toolkit_configs
 
+def instantiate_toolkit(tool_config):
+    """Instantiate a toolkit from its configuration."""
+    tool_type = tool_config.get('type')
+    
+    if tool_type in AVAILABLE_TOOLS:
+        tool_module = AVAILABLE_TOOLS[tool_type]
+        
+        if 'get_toolkit' in tool_module:
+             return tool_module['get_toolkit'](tool_config)
+             
+    raise ValueError(f"Toolkit type '{tool_type}' does not support direct instantiation or is not available.")
+
 def get_available_tools():
     """Return list of available tool types."""
     return list(AVAILABLE_TOOLS.keys())

alita_sdk/tools/ado/repos/__init__.py

@@ -10,12 +10,12 @@ from ....configurations.ado import AdoReposConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
 from .repos_wrapper import ReposApiWrapper
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import clean_string, get_max_toolkit_length, check_connection_response
 
 name = "ado_repos"
 
 
-def _get_toolkit(tool) -> BaseToolkit:
+def get_toolkit(tool) -> BaseToolkit:
     return AzureDevOpsReposToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
         ado_repos_configuration=tool['settings']['ado_repos_configuration'],
@@ -30,20 +30,15 @@ def _get_toolkit(tool) -> BaseToolkit:
         llm=tool['settings'].get('llm', None),
     )
 
-def get_toolkit():
-    return AzureDevOpsReposToolkit.toolkit_config_schema()
-
 def get_tools(tool):
-    return _get_toolkit(tool).get_tools()
+    return get_toolkit(tool).get_tools()
 
 class AzureDevOpsReposToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in ReposApiWrapper.model_construct().get_available_tools()}
-        AzureDevOpsReposToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
             ado_repos_configuration=(AdoReposConfiguration, Field(description="Ado Repos configuration", default=None,
@@ -63,7 +58,6 @@ class AzureDevOpsReposToolkit(BaseToolkit):
                     "icon_url": "ado-repos-icon.svg",
                     "categories": ["code repositories"],
                     "extra_categories": ["code", "repository", "version control"],
-                    "max_length": AzureDevOpsReposToolkit.toolkit_max_length
                 }}}
         )
 
@@ -99,17 +93,21 @@ class AzureDevOpsReposToolkit(BaseToolkit):
         azure_devops_repos_wrapper = ReposApiWrapper(**wrapper_payload)
         available_tools = azure_devops_repos_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"] + f"\nADO instance: {azure_devops_repos_wrapper.organization_url}/{azure_devops_repos_wrapper.project}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(
                 BaseAction(
                     api_wrapper=azure_devops_repos_wrapper,
-                    name=prefix + tool["name"],
-                    description=tool["description"] + f"\nADO instance: {azure_devops_repos_wrapper.organization_url}/{azure_devops_repos_wrapper.project}",
+                    name=tool["name"],
+                    description=description,
                     args_schema=tool["args_schema"],
+                    metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
                 )
             )
         return cls(tools=tools)

alita_sdk/tools/ado/test_plan/__init__.py

@@ -10,21 +10,33 @@ from ....configurations.ado import AdoConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from .test_plan_wrapper import TestPlanApiWrapper
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import clean_string, get_max_toolkit_length, check_connection_response
 
 
 name = "azure_devops_plans"
 name_alias = "ado_plans"
 
+def get_toolkit(tool):
+    return AzureDevOpsPlansToolkit().get_toolkit(
+        selected_tools=tool['settings'].get('selected_tools', []),
+        ado_configuration=tool['settings']['ado_configuration'],
+        limit=tool['settings'].get('limit', 5),
+        toolkit_name=tool.get('toolkit_name', ''),
+        alita=tool['settings'].get('alita', None),
+        llm=tool['settings'].get('llm', None),
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
+        collection_name=tool['toolkit_name'],
+        doctype='doc',
+        embedding_model=tool['settings'].get('embedding_model'),
+        vectorstore_type="PGVector"
+    )
 
 class AzureDevOpsPlansToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in TestPlanApiWrapper.model_construct().get_available_tools()}
-        AzureDevOpsPlansToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name_alias,
             ado_configuration=(AdoConfiguration, Field(description="Ado configuration", json_schema_extra={'configuration_types': ['ado']})),
@@ -39,7 +51,6 @@ 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": {
@@ -97,17 +108,21 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
         azure_devops_api_wrapper = TestPlanApiWrapper(**wrapper_payload)
         available_tools = azure_devops_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
             print(tool)
+            description = tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=azure_devops_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/ado/wiki/__init__.py

@@ -9,19 +9,32 @@ from ...elitea_base import filter_missconfigured_index_tools
 from ....configurations.ado import AdoConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import clean_string, get_max_toolkit_length, check_connection_response
 
 name = "azure_devops_wiki"
 name_alias = 'ado_wiki'
 
+def get_toolkit(tool):
+    return AzureDevOpsWikiToolkit().get_toolkit(
+        selected_tools=tool['settings'].get('selected_tools', []),
+        ado_configuration=tool['settings']['ado_configuration'],
+        limit=tool['settings'].get('limit', 5),
+        toolkit_name=tool.get('toolkit_name', ''),
+        alita=tool['settings'].get('alita', None),
+        llm=tool['settings'].get('llm', None),
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
+        collection_name=tool['toolkit_name'],
+        doctype='doc',
+        embedding_model=tool['settings'].get('embedding_model'),
+        vectorstore_type="PGVector"
+    )
+
 class AzureDevOpsWikiToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AzureDevOpsApiWrapper.model_construct().get_available_tools()}
-        AzureDevOpsWikiToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name_alias,
             ado_configuration=(AdoConfiguration, Field(description="Ado configuration", json_schema_extra={'configuration_types': ['ado']})),
@@ -37,7 +50,6 @@ 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": {
@@ -91,16 +103,20 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
         azure_devops_api_wrapper = AzureDevOpsApiWrapper(**wrapper_payload)
         available_tools = azure_devops_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}/{azure_devops_api_wrapper.project}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=azure_devops_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}/{azure_devops_api_wrapper.project}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/ado/wiki/ado_wrapper.py

@@ -52,8 +52,9 @@ ModifyPageInput = create_model(
     wiki_identified=(str, Field(description="Wiki ID or wiki name")),
     page_name=(str, Field(description="Wiki page name")),
     page_content=(str, Field(description="Wiki page content")),
-    version_identifier=(str, Field(description="Version string identifier (name of tag/branch, SHA1 of commit)")),
-    version_type=(Optional[str], Field(description="Version type (branch, tag, or commit). Determines how Id is interpreted", default="branch"))
+    version_identifier=(str, Field(description="Version string identifier (name of tag/branch, SHA1 of commit). Usually for wiki the branch is 'wikiMaster'")),
+    version_type=(Optional[str], Field(description="Version type (branch, tag, or commit). Determines how Id is interpreted", default="branch")),
+    expanded=(Optional[bool], Field(description="Whether to return the full page object or just its simplified version.", default=False))
 )
 
 RenamePageInput = create_model(
@@ -66,6 +67,19 @@ RenamePageInput = create_model(
 )
 
 
+def _format_wiki_page_response(wiki_page_response, expanded: bool = False):
+    """Format wiki page response."""
+    try:
+        return {
+            'eTag': wiki_page_response.eTag,
+            'page': wiki_page_response.page.__dict__ if wiki_page_response.page else None
+        } if expanded else {"eTag": wiki_page_response.eTag, "id": wiki_page_response.page.id,
+                            "page": wiki_page_response.page.url}
+    except:
+        logger.error(f"Unable to format wiki page response: {wiki_page_response}")
+        return wiki_page_response
+
+
 class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
     # TODO use ado_configuration instead of organization_url, project and token
     organization_url: str
@@ -226,7 +240,7 @@ class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
             logger.error(f"Unable to rename wiki page: {str(e)}")
             return ToolException(f"Unable to rename wiki page: {str(e)}")
 
-    def modify_wiki_page(self, wiki_identified: str, page_name: str, page_content: str, version_identifier: str, version_type: str = "branch"):
+    def modify_wiki_page(self, wiki_identified: str, page_name: str, page_content: str, version_identifier: str, version_type: str = "branch", expanded: Optional[bool] = False):
         """Create or Update ADO wiki page content."""
         try:
             all_wikis = [wiki.name for wiki in self._client.get_all_wikis(project=self.project)]
@@ -257,24 +271,24 @@ class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
                     return ToolException(f"Unable to extract page by path {page_name}: {str(get_page_e)}")
 
             try:
-                return self._client.create_or_update_page(
+                return _format_wiki_page_response(self._client.create_or_update_page(
                     project=self.project,
                     wiki_identifier=wiki_identified,
                     path=page_name,
                     parameters=WikiPageCreateOrUpdateParameters(content=page_content),
                     version=version,
                     version_descriptor=GitVersionDescriptor(version=version_identifier, version_type=version_type)
-                )
+                ), expanded=expanded)
             except AzureDevOpsServiceError as e:
                 if "The version '{0}' either is invalid or does not exist." in str(e):
                     # Retry the request without version_descriptor
-                    return self._client.create_or_update_page(
+                    return _format_wiki_page_response(wiki_page_response=self._client.create_or_update_page(
                         project=self.project,
                         wiki_identifier=wiki_identified,
                         path=page_name,
                         parameters=WikiPageCreateOrUpdateParameters(content=page_content),
                         version=version
-                    )
+                    ), expanded=expanded)
                 else:
                     raise
         except Exception as e:

alita_sdk/tools/ado/work_item/__init__.py

@@ -9,18 +9,31 @@ from ...elitea_base import filter_missconfigured_index_tools
 from ....configurations.ado import AdoConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import clean_string, get_max_toolkit_length, check_connection_response
 
 name = "ado_boards"
 
+def get_toolkit(tool):
+    return AzureDevOpsWorkItemsToolkit().get_toolkit(
+        selected_tools=tool['settings'].get('selected_tools', []),
+        ado_configuration=tool['settings']['ado_configuration'],
+        limit=tool['settings'].get('limit', 5),
+        toolkit_name=tool.get('toolkit_name', ''),
+        alita=tool['settings'].get('alita', None),
+        llm=tool['settings'].get('llm', None),
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
+        collection_name=tool['toolkit_name'],
+        doctype='doc',
+        embedding_model=tool['settings'].get('embedding_model'),
+        vectorstore_type="PGVector"
+    )
+
 class AzureDevOpsWorkItemsToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AzureDevOpsApiWrapper.model_construct().get_available_tools()}
-        AzureDevOpsWorkItemsToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
             ado_configuration=(AdoConfiguration, Field(description="Ado Work Item configuration", json_schema_extra={'configuration_types': ['ado']})),
@@ -37,7 +50,6 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
                     'metadata': {
                         "label": "ADO boards",
                         "icon_url": "ado-boards-icon.svg",
-                        "max_length": AzureDevOpsWorkItemsToolkit.toolkit_max_length,
                         "categories": ["project management"],
                         "extra_categories": ["work item management", "issue tracking", "agile boards"],
                         "sections": {
@@ -92,16 +104,20 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
         azure_devops_api_wrapper = AzureDevOpsApiWrapper(**wrapper_payload)
         available_tools = azure_devops_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}/{azure_devops_api_wrapper.project}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=azure_devops_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}/{azure_devops_api_wrapper.project}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)