alita-sdk 0.3.562__py3-none-any.whl → 0.3.584__py3-none-any.whl

alita_sdk/configurations/openapi.py

@@ -1,8 +1,23 @@
 from typing import Any, Literal, Optional
 from pydantic import BaseModel, ConfigDict, Field, SecretStr, model_validator
 
+import base64
+import requests
+
 
 class OpenApiConfiguration(BaseModel):
+    """
+    OpenAPI configuration for authentication.
+    
+    Supports three authentication modes:
+    - Anonymous: No authentication (all fields empty)
+    - API Key: Static key sent via header (Bearer, Basic, or Custom)
+    - OAuth2 Client Credentials: Machine-to-machine authentication flow
+    
+    Note: Only OAuth2 Client Credentials flow is supported. Authorization Code flow
+    is not supported as it requires user interaction and pre-registered redirect URLs.
+    """
+    
     model_config = ConfigDict(
         extra='allow',
         json_schema_extra={
@@ -25,7 +40,6 @@ class OpenApiConfiguration(BaseModel):
                                 "fields": [
                                     "client_id",
                                     "client_secret",
-                                    "auth_url",
                                     "token_url",
                                     "scope",
                                     "method",
@@ -39,6 +53,10 @@ class OpenApiConfiguration(BaseModel):
         }
     )
 
+    # =========================================================================
+    # API Key Authentication Fields
+    # =========================================================================
+    
     api_key: Optional[SecretStr] = Field(
         default=None,
         description=(
@@ -60,15 +78,44 @@ class OpenApiConfiguration(BaseModel):
         json_schema_extra={'visible_when': {'field': 'auth_type', 'value': 'custom'}},
     )
 
-    client_id: Optional[str] = Field(default=None, description='OAuth client ID')
-    client_secret: Optional[SecretStr] = Field(default=None, description='OAuth client secret (stored as a secret)')
-    auth_url: Optional[str] = Field(default=None, description='OAuth authorization URL')
-    token_url: Optional[str] = Field(default=None, description='OAuth token URL')
-    scope: Optional[str] = Field(default=None, description='OAuth scope(s)')
+    # =========================================================================
+    # OAuth2 Client Credentials Flow Fields
+    # =========================================================================
+    
+    client_id: Optional[str] = Field(
+        default=None, 
+        description='OAuth2 client ID (also known as Application ID or App ID)'
+    )
+    client_secret: Optional[SecretStr] = Field(
+        default=None, 
+        description='OAuth2 client secret (stored securely)'
+    )
+    token_url: Optional[str] = Field(
+        default=None, 
+        description=(
+            'OAuth2 token endpoint URL for obtaining access tokens. '
+            'Examples: '
+            'Azure AD: https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token, '
+            'Google: https://oauth2.googleapis.com/token, '
+            'Auth0: https://{domain}/oauth/token, '
+            'Spotify: https://accounts.spotify.com/api/token'
+        )
+    )
+    scope: Optional[str] = Field(
+        default=None, 
+        description=(
+            'OAuth2 scope(s), space-separated if multiple (per OAuth2 RFC 6749). '
+            'Examples: "user-read-private user-read-email" (Spotify), '
+            '"api://app-id/.default" (Azure), '
+            '"https://www.googleapis.com/auth/cloud-platform" (Google)'
+        )
+    )
     method: Optional[Literal['default', 'Basic']] = Field(
         default='default',
         description=(
-            "Token exchange method. 'default' uses standard POST body; 'Basic' uses a Basic authorization header."
+            "Token exchange method for client credentials flow. "
+            "'default': Sends client_id and client_secret in POST body (Azure AD, Auth0, most providers). "
+            "'Basic': Sends credentials via HTTP Basic auth header - required by Spotify, some AWS services, and certain OAuth providers."
         ),
     )
 
@@ -78,9 +125,9 @@ class OpenApiConfiguration(BaseModel):
         if not isinstance(values, dict):
             return values
 
-        # OAuth: if any OAuth field is provided, require the key ones.
+        # OAuth: if any OAuth field is provided, require the essential ones
         has_any_oauth = any(
-            (values.get('client_id'), values.get('client_secret'), values.get('auth_url'), values.get('token_url'))
+            (values.get('client_id'), values.get('client_secret'), values.get('token_url'))
         )
         if has_any_oauth:
             missing = []
@@ -93,7 +140,7 @@ class OpenApiConfiguration(BaseModel):
             if missing:
                 raise ValueError(f"OAuth is misconfigured; missing: {', '.join(missing)}")
 
-        # API key: if auth_type is custom, custom_header_name must be present.
+        # API key: if auth_type is custom, custom_header_name must be present
         auth_type = values.get('auth_type')
         if isinstance(auth_type, str) and auth_type.strip().lower() == 'custom' and values.get('api_key'):
             if not values.get('custom_header_name'):
@@ -103,9 +150,174 @@ class OpenApiConfiguration(BaseModel):
 
     @staticmethod
     def check_connection(settings: dict) -> str | None:
-        """Best-effort validation for OpenAPI credentials.
-
-        This model is intended to store reusable credentials only.
-        Spec/base_url validation happens at toolkit configuration level.
         """
-        return None
+        Validate the OpenAPI configuration by testing connectivity where possible.
+        
+        Validation behavior by authentication type:
+        
+        1. ANONYMOUS (no auth fields configured):
+           - Cannot validate without making actual API calls
+           - Returns None (success) - validation skipped
+           
+        2. API KEY (api_key field configured):
+           - Cannot validate without knowing which endpoint to call
+           - The OpenAPI spec is not available at configuration time
+           - Returns None (success) - validation skipped
+           
+        3. OAUTH2 CLIENT CREDENTIALS (client_id, client_secret, token_url configured):
+           - CAN validate by attempting token exchange with the OAuth provider
+           - Makes a real HTTP request to token_url
+           - Returns None on success, error message on failure
+        
+        Args:
+            settings: Dictionary containing OpenAPI configuration fields
+        
+        Returns:
+            None: Configuration is valid (or cannot be validated for this auth type)
+            str: Error message describing the validation failure
+        """
+        
+        # =====================================================================
+        # Determine authentication type from configured fields
+        # =====================================================================
+        
+        client_id = settings.get('client_id')
+        client_secret = settings.get('client_secret')
+        token_url = settings.get('token_url')
+        
+        has_oauth_fields = client_id or client_secret or token_url
+        
+        # =====================================================================
+        # ANONYMOUS or API KEY: Cannot validate, return success
+        # =====================================================================
+        
+        if not has_oauth_fields:
+            # No OAuth fields configured - this is either:
+            # - Anonymous authentication (no auth at all)
+            # - API Key authentication (api_key field may be set)
+            # 
+            # Neither can be validated without making actual API calls to the
+            # target service, and we don't have the OpenAPI spec available here.
+            return None
+        
+        # =====================================================================
+        # OAUTH2: Validate by attempting token exchange
+        # =====================================================================
+        
+        # Check for required OAuth fields
+        if not client_id:
+            return "OAuth client_id is required when using OAuth authentication"
+        if not client_secret:
+            return "OAuth client_secret is required when using OAuth authentication"
+        if not token_url:
+            return "OAuth token_url is required when using OAuth authentication"
+        
+        # Extract secret value if it's a SecretStr
+        if hasattr(client_secret, 'get_secret_value'):
+            client_secret = client_secret.get_secret_value()
+        
+        if not client_secret or not str(client_secret).strip():
+            return "OAuth client_secret cannot be empty"
+        
+        # Validate token_url format
+        token_url = token_url.strip()
+        if not token_url.startswith(('http://', 'https://')):
+            return "OAuth token_url must start with http:// or https://"
+        
+        # Get optional OAuth settings
+        scope = settings.get('scope')
+        method = settings.get('method', 'default') or 'default'
+        
+        # ---------------------------------------------------------------------
+        # Attempt OAuth2 Client Credentials token exchange
+        # ---------------------------------------------------------------------
+        
+        try:
+            headers = {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json',
+            }
+            
+            data = {
+                'grant_type': 'client_credentials',
+            }
+            
+            # Apply credentials based on method
+            if method == 'Basic':
+                # Basic method: credentials in Authorization header (Spotify, some AWS)
+                credentials = f"{client_id}:{client_secret}"
+                encoded = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')
+                headers['Authorization'] = f'Basic {encoded}'
+            else:
+                # Default method: credentials in POST body (Azure AD, Auth0, most providers)
+                data['client_id'] = client_id
+                data['client_secret'] = str(client_secret)
+            
+            if scope:
+                data['scope'] = scope
+            
+            response = requests.post(
+                token_url,
+                headers=headers,
+                data=data,
+                timeout=30,
+            )
+            
+            # ---------------------------------------------------------------------
+            # Handle response
+            # ---------------------------------------------------------------------
+            
+            if response.status_code == 200:
+                try:
+                    token_data = response.json()
+                    if 'access_token' in token_data:
+                        return None  # Success - token obtained
+                    return "OAuth response did not contain 'access_token'"
+                except Exception:
+                    return "Failed to parse OAuth token response"
+            
+            # Handle common error status codes with helpful messages
+            if response.status_code == 400:
+                try:
+                    error_data = response.json()
+                    error = error_data.get('error', 'bad_request')
+                    error_desc = error_data.get('error_description', '')
+                    if error_desc:
+                        return f"OAuth error: {error} - {error_desc}"
+                    return f"OAuth error: {error}"
+                except Exception:
+                    return "OAuth request failed: bad request (400)"
+            
+            if response.status_code == 401:
+                return "OAuth authentication failed: invalid client_id or client_secret"
+            
+            if response.status_code == 403:
+                return "OAuth access forbidden: client may lack required permissions"
+            
+            if response.status_code == 404:
+                return f"OAuth token endpoint not found: {token_url}"
+            
+            return f"OAuth token request failed with status {response.status_code}"
+            
+        except requests.exceptions.SSLError as e:
+            error_str = str(e).lower()
+            if 'hostname mismatch' in error_str:
+                return "OAuth token_url hostname does not match SSL certificate - verify the URL is correct"
+            if 'certificate verify failed' in error_str:
+                return "SSL certificate verification failed for OAuth endpoint - the server may have an invalid or self-signed certificate"
+            if 'certificate has expired' in error_str:
+                return "SSL certificate has expired for OAuth endpoint"
+            return "SSL error connecting to OAuth endpoint - verify the token_url is correct"
+        except requests.exceptions.ConnectionError as e:
+            error_str = str(e).lower()
+            if 'name or service not known' in error_str or 'nodename nor servname provided' in error_str:
+                return "OAuth token_url hostname could not be resolved - verify the URL is correct"
+            if 'connection refused' in error_str:
+                return "Connection refused by OAuth endpoint - verify the token_url and port are correct"
+            return "Cannot connect to OAuth token endpoint - verify the token_url is correct"
+        except requests.exceptions.Timeout:
+            return "OAuth token request timed out - the endpoint may be unreachable"
+        except requests.exceptions.RequestException:
+            return "OAuth request failed - verify the token_url is correct and accessible"
+        except Exception:
+            return "Unexpected error during OAuth configuration validation"

alita_sdk/runtime/langchain/langraph_agent.py

@@ -23,6 +23,7 @@ from langgraph.store.base import BaseStore
 from .constants import PRINTER_NODE_RS, PRINTER, PRINTER_COMPLETED_STATE
 from .mixedAgentRenderes import convert_message_to_json
 from .utils import create_state, propagate_the_input_mapping, safe_format
+from ..utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META
 from ..tools.function import FunctionTool
 from ..tools.indexer_tool import IndexerNode
 from ..tools.llm import LLMNode
@@ -188,7 +189,7 @@ Answer only with step name, no need to add descrip in case none of the steps are
                 decision_input = state.get('messages', [])[:]
             else:
                 if len(additional_info) == 0:
-                    additional_info = """### Additoinal info: """
+                    additional_info = """### Additional info: """
                 additional_info += "{field}: {value}\n".format(field=field, value=state.get(field, ""))
         decision_input.append(HumanMessage(
             self.prompt.format(steps=self.steps, description=safe_format(self.description, state), additional_info=additional_info)))
@@ -447,6 +448,50 @@ def prepare_output_schema(lg_builder, memory, store, debug=False, interrupt_befo
     return compiled
 
 
+def find_tool_by_name_or_metadata(tools: list, tool_name: str, toolkit_name: Optional[str] = None) -> Optional[BaseTool]:
+    """
+    Find a tool by name or by matching metadata (toolkit_name + tool_name).
+
+    For toolkit nodes with toolkit_name specified, this function checks:
+    1. Metadata match first (toolkit_name + tool_name) - PRIORITY when toolkit_name is provided
+    2. Direct tool name match (backward compatibility fallback)
+
+    For toolkit nodes without toolkit_name, or other node types:
+    1. Direct tool name match
+
+    Args:
+        tools: List of available tools
+        tool_name: The tool name to search for
+        toolkit_name: Optional toolkit name for metadata matching
+
+    Returns:
+        The matching tool or None if not found
+    """
+    # When toolkit_name is specified, prioritize metadata matching
+    if toolkit_name:
+        for tool in tools:
+            # Check metadata match first
+            if hasattr(tool, 'metadata') and tool.metadata:
+                metadata_toolkit_name = tool.metadata.get(TOOLKIT_NAME_META)
+                metadata_tool_name = tool.metadata.get(TOOL_NAME_META)
+
+                # Match if both toolkit_name and tool_name in metadata match
+                if metadata_toolkit_name == toolkit_name and metadata_tool_name == tool_name:
+                    return tool
+
+        # Fallback to direct name match for backward compatibility
+        for tool in tools:
+            if tool.name == tool_name:
+                return tool
+    else:
+        # No toolkit_name specified, use direct name match only
+        for tool in tools:
+            if tool.name == tool_name:
+                return tool
+
+    return None
+
+
 def create_graph(
         client: Any,
         yaml_schema: str,
@@ -482,19 +527,37 @@ def create_graph(
             node_type = node.get('type', 'function')
             node_id = clean_string(node['id'])
             toolkit_name = node.get('toolkit_name')
-            tool_name = clean_string(node.get('tool', node_id))
+            tool_name = clean_string(node.get('tool', ''))
             # Tool names are now clean (no prefix needed)
             logger.info(f"Node: {node_id} : {node_type} - {tool_name}")
             if node_type in ['function', 'toolkit', 'mcp', 'tool', 'loop', 'loop_from_tool', 'indexer', 'subgraph', 'pipeline', 'agent']:
-                if node_type == 'mcp' and tool_name not in [tool.name for tool in tools]:
-                    # MCP is not connected and node cannot be added
-                    raise ToolException(f"MCP tool '{tool_name}' not found in the provided tools. "
-                                        f"Make sure it is connected properly. Available tools: {[tool.name for tool in tools]}")
-                for tool in tools:
-                    if tool.name == tool_name:
+                if node_type in ['mcp', 'toolkit', 'agent'] and not tool_name:
+                    # tool is not specified
+                    raise ToolException(f"Tool name is required for {node_type} node with id '{node_id}'")
+
+                # Unified validation and tool finding for toolkit, mcp, and agent node types
+                matching_tool = None
+                if node_type in ['toolkit', 'mcp', 'agent']:
+                    # Use enhanced validation that checks both direct name and metadata
+                    matching_tool = find_tool_by_name_or_metadata(tools, tool_name, toolkit_name)
+                    if not matching_tool:
+                        # tool is not found in the provided tools
+                        error_msg = f"Node `{node_id}` with type `{node_type}` has tool '{tool_name}'"
+                        if toolkit_name:
+                            error_msg += f" (toolkit: '{toolkit_name}')"
+                        error_msg += f" which is not found in the provided tools. Make sure it is connected properly. Available tools: {format_tools(tools)}"
+                        raise ToolException(error_msg)
+                else:
+                    # For other node types, find tool by direct name match
+                    for tool in tools:
+                        if tool.name == tool_name:
+                            matching_tool = tool
+                            break
+
+                if matching_tool:
                         if node_type in ['function', 'toolkit', 'mcp']:
                             lg_builder.add_node(node_id, FunctionTool(
-                                tool=tool, name=node_id, return_type='dict',
+                                tool=matching_tool, name=node_id, return_type='dict',
                                 output_variables=node.get('output', []),
                                 input_mapping=node.get('input_mapping',
                                                        {'messages': {'type': 'variable', 'value': 'messages'}}),
@@ -505,7 +568,7 @@ def create_graph(
                                                      {'messages': {'type': 'variable', 'value': 'messages'}})
                             output_vars = node.get('output', [])
                             lg_builder.add_node(node_id, FunctionTool(
-                                client=client, tool=tool,
+                                client=client, tool=matching_tool,
                                 name=node_id, return_type='str',
                                 output_variables=output_vars + ['messages'] if 'messages' not in output_vars else output_vars,
                                 input_variables=input_params,
@@ -513,15 +576,15 @@ def create_graph(
                             ))
                         elif node_type == 'subgraph' or node_type == 'pipeline':
                             # assign parent memory/store
-                            # tool.checkpointer = memory
-                            # tool.store = store
+                            # matching_tool.checkpointer = memory
+                            # matching_tool.store = store
                             # wrap with mappings
                             pipeline_name = node.get('tool', None)
                             if not pipeline_name:
                                 raise ValueError(
                                     "Subgraph must have a 'tool' node: add required tool to the subgraph node")
                             node_fn = SubgraphRunnable(
-                                inner=tool.graph,
+                                inner=matching_tool.graph,
                                 name=pipeline_name,
                                 input_mapping=node.get('input_mapping', {}),
                                 output_mapping=node.get('output_mapping', {}),
@@ -530,7 +593,7 @@ def create_graph(
                             break  # skip legacy handling
                         elif node_type == 'tool':
                             lg_builder.add_node(node_id, ToolNode(
-                                client=client, tool=tool,
+                                client=client, tool=matching_tool,
                                 name=node_id, return_type='dict',
                                 output_variables=node.get('output', []),
                                 input_variables=node.get('input', ['messages']),
@@ -539,7 +602,7 @@ def create_graph(
                             ))
                         elif node_type == 'loop':
                             lg_builder.add_node(node_id, LoopNode(
-                                client=client, tool=tool,
+                                client=client, tool=matching_tool,
                                 name=node_id, return_type='dict',
                                 output_variables=node.get('output', []),
                                 input_variables=node.get('input', ['messages']),
@@ -557,7 +620,7 @@ def create_graph(
                                         lg_builder.add_node(node_id, LoopToolNode(
                                             client=client,
                                             name=node_id, return_type='dict',
-                                            tool=tool, loop_tool=t,
+                                            tool=matching_tool, loop_tool=t,
                                             variables_mapping=node.get('variables_mapping', {}),
                                             output_variables=node.get('output', []),
                                             input_variables=node.get('input', ['messages']),
@@ -573,7 +636,7 @@ def create_graph(
                                     indexer_tool = t
                             logger.info(f"Indexer tool: {indexer_tool}")
                             lg_builder.add_node(node_id, IndexerNode(
-                                client=client, tool=tool,
+                                client=client, tool=matching_tool,
                                 index_tool=indexer_tool,
                                 input_mapping=node.get('input_mapping', {}),
                                 name=node_id, return_type='dict',
@@ -582,7 +645,6 @@ def create_graph(
                                 output_variables=node.get('output', []),
                                 input_variables=node.get('input', ['messages']),
                                 structured_output=node.get('structured_output', False)))
-                        break
             elif node_type == 'code':
                 from ..tools.sandbox import create_sandbox_tool
                 sandbox_tool = create_sandbox_tool(stateful=False, allow_net=True,
@@ -651,10 +713,13 @@ def create_graph(
                     ))
                 elif node_type == 'decision':
                     logger.info(f'Adding decision: {node["nodes"]}')
+                    # fallback to old-style decision node
+                    decisional_inputs = node.get('decisional_inputs')
+                    decisional_inputs = node.get('input', ['messages']) if not decisional_inputs else decisional_inputs
                     lg_builder.add_node(node_id, DecisionEdge(
                         client, node['nodes'],
                         node.get('description', ""),
-                        decisional_inputs=node.get('decisional_inputs', ['messages']),
+                        decisional_inputs=decisional_inputs,
                         default_output=node.get('default_output', 'END'),
                         is_node=True
                     ))
@@ -750,7 +815,7 @@ def create_graph(
         )
     except ValueError as e:
         raise ValueError(
-            f"Validation of the schema failed. {e}\n\nDEBUG INFO:**Schema Nodes:**\n\n{lg_builder.nodes}\n\n**Schema Enges:**\n\n{lg_builder.edges}\n\n**Tools Available:**\n\n{tools}")
+            f"Validation of the schema failed. {e}\n\nDEBUG INFO:**Schema Nodes:**\n\n*{'\n*'.join(lg_builder.nodes.keys())}\n\n**Schema Edges:**\n\n{lg_builder.edges}\n\n**Tools Available:**\n\n{format_tools(tools)}")
     # If building a nested subgraph, return the raw CompiledStateGraph
     if for_subgraph:
         return graph
@@ -764,6 +829,14 @@ def create_graph(
     )
     return compiled.validate()
 
+def format_tools(tools_list: list) -> str:
+    """Format a list of tool names into a comma-separated string."""
+    try:
+        return ', '.join([tool.name for tool in tools_list])
+    except Exception as e:
+        logger.warning(f"Failed to format tools list: {e}")
+        return str(tools_list)
+
 def set_defaults(d):
     """Set default values for dictionary entries based on their type."""
     type_defaults = {

alita_sdk/runtime/langchain/utils.py

@@ -2,7 +2,7 @@ import builtins
 import json
 import logging
 import re
-from pydantic import create_model, Field, Json
+from pydantic import create_model, Field, JsonValue
 from typing import Tuple, TypedDict, Any, Optional, Annotated
 from langchain_core.messages import AnyMessage
 from langgraph.graph import add_messages
@@ -263,17 +263,33 @@ def create_pydantic_model(model_name: str, variables: dict[str, dict]):
     return create_model(model_name, **fields)
 
 def parse_pydantic_type(type_name: str):
-    """
-    Helper function to parse type names into Python types.
-    Extend this function to handle custom types like 'dict' -> Json[Any].
-    """
-    type_mapping = {
-        'str': str,
-        'int': int,
-        'float': float,
-        'bool': bool,
-        'dict': Json[Any],  # Map 'dict' to Pydantic's Json type
-        'list': list,
-        'any': Any
+    t = (type_name or "any").strip().lower()
+
+    base = {
+        "str": str,
+        "int": int,
+        "float": float,
+        "bool": bool,
+        # "dict" means JSON object
+        "dict": dict[str, JsonValue],
+        # "list" means array of JSON values (or pick str if you want)
+        "list": list[JsonValue],
+        # IMPORTANT: don't return bare Any -> it produces {} schema
+        "any": JsonValue,
     }
-    return type_mapping.get(type_name, Any)
+    if t in base:
+        return base[t]
+
+    m = re.fullmatch(r"list\[(.+)\]", t)
+    if m:
+        return list[parse_pydantic_type(m.group(1))]
+
+    m = re.fullmatch(r"dict\[(.+?),(.+)\]", t)
+    if m:
+        k = parse_pydantic_type(m.group(1))
+        v = parse_pydantic_type(m.group(2))
+        # restrict keys to str for JSON objects
+        return dict[str, v] if k is not str else dict[str, v]
+
+    # fallback: avoid Any
+    return JsonValue

alita_sdk/runtime/toolkits/artifact.py

@@ -7,6 +7,7 @@ from langchain_core.tools import BaseTool
 from pydantic import create_model, BaseModel, ConfigDict, Field
 from pydantic.fields import FieldInfo
 from ..tools.artifact import ArtifactWrapper
+from ..utils.constants import TOOLKIT_NAME_META, TOOLKIT_TYPE_META, TOOL_NAME_META
 from ...tools.base.tool import BaseAction
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -68,7 +69,7 @@ class ArtifactToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: "artifact", TOOL_NAME_META: tool['name']} if toolkit_name else {}
             ))
         return cls(tools=tools)
     

alita_sdk/runtime/toolkits/mcp.py

@@ -615,7 +615,8 @@ class McpToolkit(BaseToolkit):
                 args_schema=McpServerTool.create_pydantic_model_from_schema(tool_metadata.input_schema),
                 client=client,
                 server=tool_metadata.server,
-                tool_timeout_sec=timeout
+                tool_timeout_sec=timeout,
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": name}
             )
         except Exception as e:
             logger.error(f"Failed to create MCP tool '{tool_name}' from server '{tool_metadata.server}': {e}")
@@ -649,7 +650,8 @@ class McpToolkit(BaseToolkit):
                 ),
                 client=client,
                 server=toolkit_name,
-                tool_timeout_sec=timeout
+                tool_timeout_sec=timeout,
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": name}
             )
         except Exception as e:
             logger.error(f"Failed to create MCP tool '{tool_name}' from toolkit '{toolkit_name}': {e}")

alita_sdk/runtime/toolkits/skill_router.py

@@ -147,7 +147,7 @@ class SkillRouterToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": "skill_router"} if toolkit_name else {}
             ))
 
         return cls(tools=tools)

alita_sdk/runtime/toolkits/vectorstore.py

@@ -56,7 +56,7 @@ class VectorStoreToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": "vectorstore"} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/runtime/tools/data_analysis.py

@@ -174,7 +174,7 @@ class DataAnalysisToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": name} if toolkit_name else {}
             ))
 
         return cls(tools=tools)