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

alita_sdk/runtime/tools/llm.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 from traceback import format_exc
-from typing import Any, Optional, List, Union
+from typing import Any, Optional, List, Union, Literal
 
 from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
 from langchain_core.runnables import RunnableConfig
@@ -174,26 +174,36 @@ class LLMNode(BaseTool):
                     for key, value in (self.structured_output_dict or {}).items()
                 }
                 # Add default output field for proper response to user
-                struct_params['elitea_response'] = {'description': 'final output to user', 'type': 'str'}
+                struct_params['elitea_response'] = {
+                    'description': 'final output to user (summarized output from LLM)', 'type': 'str',
+                    "default": None}
                 struct_model = create_pydantic_model(f"LLMOutput", struct_params)
-                completion = llm_client.invoke(messages, config=config)
-                if hasattr(completion, 'tool_calls') and completion.tool_calls:
+                initial_completion = llm_client.invoke(messages, config=config)
+                if hasattr(initial_completion, 'tool_calls') and initial_completion.tool_calls:
                     new_messages, _ = self._run_async_in_sync_context(
-                        self.__perform_tool_calling(completion, messages, llm_client, config)
+                        self.__perform_tool_calling(initial_completion, messages, llm_client, config)
                     )
                     llm = self.__get_struct_output_model(llm_client, struct_model)
                     completion = llm.invoke(new_messages, config=config)
                     result = completion.model_dump()
                 else:
-                    llm = self.__get_struct_output_model(llm_client, struct_model)
-                    completion = llm.invoke(messages, config=config)
+                    try:
+                        llm = self.__get_struct_output_model(llm_client, struct_model)
+                        completion = llm.invoke(messages, config=config)
+                    except ValueError as e:
+                        logger.error(f"Error invoking structured output model: {format_exc()}")
+                        logger.info("Attemping to fall back to json mode")
+                        # Fallback to regular LLM with JSON extraction
+                        completion = self.__get_struct_output_model(llm_client, struct_model,
+                                                                    method="json_mode").invoke(messages, config=config)
                     result = completion.model_dump()
 
                 # Ensure messages are properly formatted
                 if result.get('messages') and isinstance(result['messages'], list):
                     result['messages'] = [{'role': 'assistant', 'content': '\n'.join(result['messages'])}]
                 else:
-                    result['messages'] = messages + [AIMessage(content=result.get(ELITEA_RS, ''))]
+                    result['messages'] = messages + [
+                        AIMessage(content=result.get(ELITEA_RS, '') or initial_completion.content)]
 
                 return result
             else:
@@ -650,5 +660,5 @@ class LLMNode(BaseTool):
 
         return new_messages, current_completion
 
-    def __get_struct_output_model(self, llm_client, pydantic_model):
-        return llm_client.with_structured_output(pydantic_model)
+    def __get_struct_output_model(self, llm_client, pydantic_model, method: Literal["function_calling", "json_mode", "json_schema"] = "json_schema"):
+        return llm_client.with_structured_output(pydantic_model, method=method)

alita_sdk/runtime/tools/mcp_remote_tool.py

@@ -99,7 +99,6 @@ class McpRemoteTool(McpServerTool):
 
     async def _execute_remote_tool(self, kwargs: Dict[str, Any]) -> str:
         """Execute the actual remote MCP tool call using SSE client."""
-        from ...tools.utils import TOOLKIT_SPLITTER
         
         # Check for session_id requirement
         if not self.session_id:
@@ -109,8 +108,8 @@ class McpRemoteTool(McpServerTool):
         # Use the original tool name from discovery for MCP server invocation
         tool_name_for_server = self.original_tool_name
         if not tool_name_for_server:
-            tool_name_for_server = self.name.rsplit(TOOLKIT_SPLITTER, 1)[-1] if TOOLKIT_SPLITTER in self.name else self.name
-            logger.warning(f"original_tool_name not set for '{self.name}', using extracted: {tool_name_for_server}")
+            tool_name_for_server = self.name
+            logger.warning(f"original_tool_name not set for '{self.name}', using: {tool_name_for_server}")
         
         logger.info(f"[MCP] Executing tool '{tool_name_for_server}' with session {self.session_id}")
         

alita_sdk/runtime/tools/mcp_server_tool.py

@@ -5,8 +5,6 @@ from typing import Any, Type, Literal, Optional, Union, List
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel, Field, create_model, EmailStr, constr, ConfigDict
 
-from ...tools.utils import TOOLKIT_SPLITTER
-
 logger = getLogger(__name__)
 
 
@@ -91,13 +89,13 @@ class McpServerTool(BaseTool):
         return create_model(model_name, **fields)
 
     def _run(self, *args, **kwargs):
-        # Extract the actual tool/prompt name (remove toolkit prefix)
+        # Use the tool name directly (no prefix extraction needed)
         call_data = {
             "server": self.server,
             "tool_timeout_sec": self.tool_timeout_sec,
             "tool_call_id": str(uuid.uuid4()),
             "params": {
-                "name": self.name.rsplit(TOOLKIT_SPLITTER)[1] if TOOLKIT_SPLITTER in self.name else self.name,
+                "name": self.name,
                 "arguments": kwargs
             }
         }

alita_sdk/runtime/utils/AlitaCallback.py

@@ -128,10 +128,39 @@ class AlitaStreamlitCallback(BaseCallbackHandler):
 
         tool_name = args[0].get("name")
         tool_run_id = str(run_id)
+        
+        # Extract metadata from tool if available (from BaseAction.metadata)
+        # Try multiple sources for metadata with toolkit_name
+        tool_meta = args[0].copy()
+        
+        # Source 1: kwargs['serialized']['metadata'] - LangChain's full tool serialization
+        if 'serialized' in kwargs and 'metadata' in kwargs['serialized']:
+            tool_meta['metadata'] = kwargs['serialized']['metadata']
+            log.info(f"[METADATA] Extracted from serialized: {kwargs['serialized']['metadata']}")
+        # Source 2: Check if metadata is directly in args[0] (some LangChain versions)
+        elif 'metadata' in args[0]:
+            tool_meta['metadata'] = args[0]['metadata']
+            log.info(f"[METADATA] Extracted from args[0]: {args[0]['metadata']}")
+        else:
+            log.info(f"[METADATA] No metadata found. args[0] keys: {list(args[0].keys())}, kwargs keys: {list(kwargs.keys())}")
+            # Fallback: Try to extract toolkit_name from description
+            description = args[0].get('description', '')
+            if description:
+                import re
+                # Try pattern 1: [Toolkit: name]
+                match = re.search(r'\[Toolkit:\s*([^\]]+)\]', description)
+                if not match:
+                    # Try pattern 2: Toolkit: name at start or end
+                    match = re.search(r'(?:^|\n)Toolkit:\s*([^\n]+)', description)
+                if match:
+                    toolkit_name = match.group(1).strip()
+                    tool_meta['metadata'] = {'toolkit_name': toolkit_name}
+                    log.info(f"[METADATA] Extracted toolkit_name from description: {toolkit_name}")
+        
         payload = {
             "tool_name": tool_name,
             "tool_run_id": tool_run_id,
-            "tool_meta": args[0],
+            "tool_meta": tool_meta,
             "tool_inputs": kwargs.get('inputs')
         }
         payload = json.loads(json.dumps(payload, ensure_ascii=False, default=lambda o: str(o)))

alita_sdk/runtime/utils/mcp_client.py

@@ -360,6 +360,7 @@ class McpClient:
         from .mcp_oauth import (
             canonical_resource,
             extract_resource_metadata_url,
+            extract_authorization_uri,
             fetch_resource_metadata_async,
             infer_authorization_servers_from_realm,
             fetch_oauth_authorization_server_metadata
@@ -368,13 +369,39 @@ class McpClient:
         auth_header = 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._http_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
+                }
+        
+        # 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._http_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
         
         # Infer authorization servers if not in metadata
         if not metadata or not metadata.get('authorization_servers'):

alita_sdk/runtime/utils/mcp_oauth.py

@@ -43,6 +43,23 @@ class McpAuthorizationRequired(ToolException):
         }
 
 
+def extract_authorization_uri(www_authenticate: Optional[str]) -> Optional[str]:
+    """
+    Extract authorization_uri from WWW-Authenticate header.
+    This points directly to the OAuth authorization server metadata URL.
+    Should be used before falling back to resource_metadata.
+    """
+    if not www_authenticate:
+        return None
+    
+    # Look for authorization_uri="<url>" in the header
+    match = re.search(r'authorization_uri\s*=\s*\"?([^\", ]+)\"?', www_authenticate)
+    if match:
+        return match.group(1)
+    
+    return None
+
+
 def extract_resource_metadata_url(www_authenticate: Optional[str], server_url: Optional[str] = None) -> Optional[str]:
     """
     Pull the resource_metadata URL from a WWW-Authenticate header if present.
@@ -62,15 +79,33 @@ def extract_resource_metadata_url(www_authenticate: Optional[str], server_url: O
     # or using well-known OAuth discovery endpoints directly
     return None
 
-
-def fetch_oauth_authorization_server_metadata(base_url: str, timeout: int = 10) -> Optional[Dict[str, Any]]:
+def fetch_oauth_authorization_server_metadata(url: str, timeout: int = 10) -> Optional[Dict[str, Any]]:
     """
     Fetch OAuth authorization server metadata from well-known endpoints.
-    Tries both oauth-authorization-server and openid-configuration discovery endpoints.
+    
+    Args:
+        url: Either a full well-known URL (e.g., https://api.figma.com/.well-known/oauth-authorization-server)
+             or a base URL (e.g., https://api.figma.com) where we'll try discovery endpoints.
+        timeout: Request timeout in seconds.
+    
+    Returns:
+        OAuth authorization server metadata dict, or None if not found.
     """
+    # If the URL is already a .well-known endpoint, try it directly first
+    if '/.well-known/' in url:
+        try:
+            resp = requests.get(url, timeout=timeout)
+            if resp.status_code == 200:
+                return resp.json()
+        except Exception as exc:
+            logger.debug(f"Failed to fetch OAuth metadata from {url}: {exc}")
+        # If direct fetch failed, don't try other endpoints
+        return None
+    
+    # Otherwise, try standard discovery endpoints
     discovery_endpoints = [
-        f"{base_url}/.well-known/oauth-authorization-server",
-        f"{base_url}/.well-known/openid-configuration",
+        f"{url}/.well-known/oauth-authorization-server",
+        f"{url}/.well-known/openid-configuration",
     ]
     
     for endpoint in discovery_endpoints:
@@ -168,7 +203,7 @@ def exchange_oauth_token(
     token_endpoint: str,
     code: str,
     redirect_uri: str,
-    client_id: str,
+    client_id: Optional[str] = None,
     client_secret: Optional[str] = None,
     code_verifier: Optional[str] = None,
     scope: Optional[str] = None,
@@ -184,7 +219,7 @@ def exchange_oauth_token(
         token_endpoint: OAuth token endpoint URL
         code: Authorization code from OAuth provider
         redirect_uri: Redirect URI used in authorization request
-        client_id: OAuth client ID
+        client_id: OAuth client ID (optional for DCR/public clients)
         client_secret: OAuth client secret (optional for public clients)
         code_verifier: PKCE code verifier (optional)
         scope: OAuth scope (optional)
@@ -196,15 +231,22 @@ def exchange_oauth_token(
     Raises:
         requests.RequestException: If the HTTP request fails
         ValueError: If the token exchange fails
+    
+    Note:
+        client_id may be optional for:
+        - Dynamic Client Registration (DCR): client_id may be in the code
+        - OIDC public clients: some providers don't require it
+        - Some MCP servers handle auth differently
     """
     # Build the token request body
     token_body = {
         "grant_type": "authorization_code",
         "code": code,
         "redirect_uri": redirect_uri,
-        "client_id": client_id,
     }
     
+    if client_id:
+        token_body["client_id"] = client_id
     if client_secret:
         token_body["client_secret"] = client_secret
     if code_verifier:
@@ -242,3 +284,78 @@ def exchange_oauth_token(
         logger.error(f"MCP OAuth: token exchange failed - {response.status_code}: {error_msg}")
         raise ValueError(f"Token exchange failed: {error_msg}")
 
+
+def refresh_oauth_token(
+    token_endpoint: str,
+    refresh_token: str,
+    client_id: Optional[str] = None,
+    client_secret: Optional[str] = None,
+    scope: Optional[str] = None,
+    timeout: int = 30,
+) -> Dict[str, Any]:
+    """
+    Refresh an OAuth access token using a refresh token.
+    
+    Args:
+        token_endpoint: OAuth token endpoint URL
+        refresh_token: Refresh token from previous authorization
+        client_id: OAuth client ID (optional for DCR/public clients)
+        client_secret: OAuth client secret (optional for public clients)
+        scope: OAuth scope (optional)
+        timeout: Request timeout in seconds
+        
+    Returns:
+        Token response from OAuth provider containing access_token, etc.
+        May also include a new refresh_token depending on the provider.
+        
+    Raises:
+        requests.RequestException: If the HTTP request fails
+        ValueError: If the token refresh fails
+    
+    Note:
+        client_id may be optional for:
+        - Dynamic Client Registration (DCR): client_id embedded in refresh_token
+        - OIDC public clients: some providers don't require it
+        - Some MCP servers handle auth differently
+    """
+    token_body = {
+        "grant_type": "refresh_token",
+        "refresh_token": refresh_token,
+    }
+    
+    if client_id:
+        token_body["client_id"] = client_id
+    if client_secret:
+        token_body["client_secret"] = client_secret
+    if scope:
+        token_body["scope"] = scope
+
+    logger.info(f"MCP OAuth: refreshing token at {token_endpoint}")
+    
+    response = requests.post(
+        token_endpoint,
+        data=token_body,
+        headers={
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json",
+        },
+        timeout=timeout
+    )
+    
+    # Try to parse as JSON
+    try:
+        token_data = response.json()
+    except Exception:
+        # Some providers return URL-encoded response
+        from urllib.parse import parse_qs
+        token_data = {k: v[0] if len(v) == 1 else v 
+                     for k, v in parse_qs(response.text).items()}
+    
+    if response.ok:
+        logger.info("MCP OAuth: token refresh successful")
+        return token_data
+    else:
+        error_msg = token_data.get("error_description") or token_data.get("error") or response.text
+        logger.error(f"MCP OAuth: token refresh failed - {response.status_code}: {error_msg}")
+        raise ValueError(f"Token refresh failed: {error_msg}")
+

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