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

alita_sdk/configurations/report_portal.py

@@ -1,3 +1,6 @@
+from urllib.parse import quote, urlparse, urlunparse
+
+import requests
 from pydantic import BaseModel, ConfigDict, Field, SecretStr
 
 
@@ -17,3 +20,96 @@ class ReportPortalConfiguration(BaseModel):
     project: str = Field(description="Report Portal Project Name")
     endpoint: str = Field(description="Report Portal Endpoint URL")
     api_key: SecretStr = Field(description="Report Portal API Key")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """Check the connection to ReportPortal.
+
+        Validates:
+        - endpoint URL format and reachability
+        - API key (token) via an auth-required endpoint
+        - project access (because most ReportPortal APIs are scoped to a project)
+
+        Returns:
+            None if connection successful, error message string otherwise
+        """
+        endpoint_in = settings.get("endpoint")
+        endpoint = endpoint_in.strip() if isinstance(endpoint_in, str) else ""
+        if not endpoint:
+            return "Endpoint is required"
+
+        if not endpoint.startswith(("http://", "https://")):
+            return "Endpoint must start with http:// or https://"
+
+        # Normalize: remove query/fragment and trailing slash.
+        parsed = urlparse(endpoint)
+        endpoint = urlunparse(parsed._replace(query="", fragment="")).rstrip("/")
+
+        # If user pasted an API URL, normalize back to base endpoint.
+        # Common pastes: .../api/v1 or .../api/v1/<project>
+        # lowered = endpoint.lower()
+        # for suffix in ("/api/v1", "/api"):
+        #     if lowered.endswith(suffix):
+        #         endpoint = endpoint[: -len(suffix)].rstrip("/")
+        #         lowered = endpoint.lower()
+        #         break
+
+        project_in = settings.get("project")
+        project = project_in.strip() if isinstance(project_in, str) else ""
+        if not project:
+            return "Project is required"
+
+        api_key = settings.get("api_key")
+        if api_key is None:
+            return "API key is required"
+        api_key_value = api_key.get_secret_value() if hasattr(api_key, "get_secret_value") else str(api_key)
+        if not api_key_value or not api_key_value.strip():
+            return "API key cannot be empty"
+
+        # Auth-required endpoint for verification.
+        # /user endpoint validates the token and project context.
+        project_encoded = quote(project, safe="")
+        test_url = f"{endpoint}/api/v1/project/{project_encoded}"
+
+        try:
+            resp = requests.get(
+                test_url,
+                headers={"Authorization": f"Bearer {api_key_value}"},
+                timeout=10,
+            )
+
+            if resp.status_code == 200:
+                return None
+            if resp.status_code == 401:
+                return "Invalid API key"
+            if resp.status_code == 403:
+                return "Access forbidden - API key has no access to this project"
+            if resp.status_code == 404:
+                return "API endpoint not found (404) - verify endpoint URL and project name"
+            if resp.status_code == 429:
+                return "Rate limited (429) - please try again later"
+            if 500 <= resp.status_code <= 599:
+                return f"ReportPortal service error (HTTP {resp.status_code})"
+            return f"Connection failed (HTTP {resp.status_code})"
+
+        except requests.exceptions.Timeout:
+            return "Connection timeout - ReportPortal did not respond within 10 seconds"
+        except requests.exceptions.SSLError as e:
+            if "Hostname mismatch" in str(e):
+                return "API endpoint not found - verify endpoint URL and project name"
+            return "SSL error - certificate verification failed"
+        except requests.exceptions.ConnectionError:
+            return "Connection error - unable to reach ReportPortal. Check endpoint URL and network."
+        except requests.exceptions.RequestException as e:
+            return f"Request failed: {str(e)}"
+        except Exception:
+            return "Unexpected error during ReportPortal connection check"
+
+if __name__ == '__main__':
+    settings = {
+        "endpoint": "https://reportportal.epam.com",
+        "project": "epm-alta",
+        "api_key": "my-api-key_U1kF0zFvToqcweG3x552cI8pnYkMqszgtht_LHGZhpxwrxDl5nXlmrSf_JLEE8jy",
+    }
+
+    print(ReportPortalConfiguration.check_connection(settings))

alita_sdk/configurations/sharepoint.py

@@ -1,3 +1,5 @@
+import requests
+from office365.onedrive.sharepoint_settings import SharepointSettings
 from pydantic import BaseModel, ConfigDict, Field, SecretStr
 
 
@@ -17,3 +19,149 @@ class SharepointConfiguration(BaseModel):
     client_id: str = Field(description="SharePoint Client ID")
     client_secret: SecretStr = Field(description="SharePoint Client Secret")
     site_url: str = Field(description="SharePoint Site URL")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Test the connection to SharePoint API using OAuth2 client credentials.
+
+        Args:
+            settings: Dictionary containing 'client_id', 'client_secret', and 'site_url' (all required)
+
+        Returns:
+            None if connection is successful, error message string otherwise
+        """
+        # Validate client_id
+        client_id = settings.get("client_id")
+        if client_id is None or client_id == "":
+            if client_id == "":
+                return "Client ID cannot be empty"
+            return "Client ID is required"
+
+        if not isinstance(client_id, str):
+            return "Client ID must be a string"
+
+        client_id = client_id.strip()
+        if not client_id:
+            return "Client ID cannot be empty"
+
+        # Validate client_secret
+        client_secret = settings.get("client_secret")
+        if client_secret is None:
+            return "Client secret is required"
+
+        # 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 client_secret.strip():
+            return "Client secret cannot be empty"
+
+        # Validate site_url
+        site_url = settings.get("site_url")
+        if site_url is None or site_url == "":
+            if site_url == "":
+                return "Site URL cannot be empty"
+            return "Site URL is required"
+
+        if not isinstance(site_url, str):
+            return "Site URL must be a string"
+
+        site_url = site_url.strip()
+        if not site_url:
+            return "Site URL cannot be empty"
+
+        if not site_url.startswith(("http://", "https://")):
+            return "Site URL must start with http:// or https://"
+
+        # Remove trailing slash for consistency
+        site_url = site_url.rstrip("/")
+
+        # Extract tenant and resource from site URL
+        # Expected format: https://<tenant>.sharepoint.com/sites/<site>
+        try:
+            if ".sharepoint.com" not in site_url:
+                return "Site URL must be a valid SharePoint URL (*.sharepoint.com)"
+
+            # Extract tenant (e.g., "contoso" from "contoso.sharepoint.com")
+            parts = site_url.split("//")[1].split(".")
+            if len(parts) < 3:
+                return "Invalid SharePoint URL format"
+            tenant = parts[0]
+
+            # Build token endpoint
+            token_url = f"https://accounts.accesscontrol.windows.net/{tenant}.onmicrosoft.com/tokens/OAuth/2"
+
+            # Build resource (the site URL with /_api appended)
+            resource = f"{site_url.split('/sites/')[0]}@{site_url.split('//')[1].split('/')[0].split('.')[0]}"
+
+        except Exception:
+            return "Failed to parse SharePoint URL - ensure it's in format: https://<tenant>.sharepoint.com/sites/<site>"
+
+        try:
+            # Step 1: Get OAuth2 access token using client credentials
+            token_response = requests.post(
+                token_url,
+                data={
+                    "grant_type": "client_credentials",
+                    "client_id": f"{client_id}@{tenant}.onmicrosoft.com",
+                    "client_secret": client_secret,
+                    "resource": f"00000003-0000-0ff1-ce00-000000000000/{site_url.split('//')[1].split('/')[0]}@{tenant}.onmicrosoft.com"
+                },
+                timeout=10,
+            )
+
+            if token_response.status_code == 400:
+                try:
+                    error_data = token_response.json()
+                    error_desc = error_data.get("error_description", "")
+                    if "not found in the directory" in error_desc.lower():
+                        return "Invalid client ID. Please check if you provide a correct client ID and try again."
+                    elif "client_secret" in error_desc.lower():
+                        return "Invalid client secret"
+                    else:
+                        return f"OAuth2 authentication failed: {error_desc}"
+                except Exception:
+                    return "Invalid client credentials"
+
+            elif token_response.status_code == 401:
+                return "Invalid client secret provided. Please check if you provide a correct client secret and try again."
+            elif token_response.status_code != 200:
+                return f"Failed to obtain access token (status {token_response.status_code})"
+
+            # Extract access token
+            try:
+                token_data = token_response.json()
+                access_token = token_data.get("access_token")
+                if not access_token:
+                    return "No access token received from SharePoint"
+            except Exception:
+                return "Failed to parse token response"
+
+            # Step 2: Test the access token by calling SharePoint API
+            api_url = f"{site_url}/_api/web"
+            api_response = requests.get(
+                api_url,
+                headers={"Authorization": f"Bearer {access_token}"},
+                timeout=10,
+            )
+
+            if api_response.status_code == 200:
+                return None  # Connection successful
+            elif api_response.status_code == 401:
+                return "Access token is invalid or expired"
+            elif api_response.status_code == 403:
+                return "Access forbidden - client may lack required permissions for this site"
+            elif api_response.status_code == 404:
+                return f"Site not found or not accessible: {site_url}"
+            else:
+                return f"SharePoint API request failed with status {api_response.status_code}"
+
+        except requests.exceptions.Timeout:
+            return "Connection timeout - SharePoint is not responding"
+        except requests.exceptions.ConnectionError:
+            return "Connection error - unable to reach SharePoint"
+        except requests.exceptions.RequestException as e:
+            return f"Request failed: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/testio.py

@@ -1,3 +1,4 @@
+import requests
 from pydantic import BaseModel, ConfigDict, Field, SecretStr
 
 
@@ -16,3 +17,85 @@ class TestIOConfiguration(BaseModel):
     )
     endpoint: str = Field(description="TestIO endpoint")
     api_key: SecretStr = Field(description="TestIO API Key")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Test the connection to TestIO API.
+
+        Args:
+            settings: Dictionary containing 'endpoint' and 'api_key' (both required)
+
+        Returns:
+            None if connection is successful, error message string otherwise
+        """
+        endpoint = settings.get("endpoint")
+        if endpoint is None or endpoint == "":
+            if endpoint == "":
+                return "Endpoint cannot be empty"
+            return "Endpoint is required"
+
+        # Validate endpoint format
+        if not isinstance(endpoint, str):
+            return "Endpoint must be a string"
+        
+        endpoint = endpoint.strip()
+        if not endpoint:
+            return "Endpoint cannot be empty"
+        if not endpoint.startswith(("http://", "https://")):
+            return "Endpoint must start with http:// or https://"
+
+        # Remove trailing slash for consistency
+        endpoint = endpoint.rstrip("/")
+
+        api_key = settings.get("api_key")
+        if api_key is None:
+            return "API key is required"
+
+        # Extract secret value if it's a SecretStr
+        if hasattr(api_key, "get_secret_value"):
+            api_key = api_key.get_secret_value()
+
+        # Validate API key is not empty
+        if not api_key or not api_key.strip():
+            return "API key cannot be empty"
+
+        # Verification strategy:
+        # Use an auth-required endpoint and a single, explicit auth scheme:
+        #   Authorization: Token <token>
+        url = f"{endpoint}/customer/v2/products"
+
+        try:
+            resp = TestIOConfiguration._get_with_token(url, api_key)
+
+            if resp.status_code == 200:
+                return None  # Connection successful
+            if resp.status_code == 401:
+                return "Invalid token"
+            if resp.status_code == 403:
+                return "Access forbidden - token has no access to /customer/v2/products"
+            if resp.status_code == 404:
+                return "Invalid endpoint. Verify TestIO base endpoint."
+            if resp.status_code == 429:
+                return "Rate limited - please try again later"
+            if 500 <= resp.status_code <= 599:
+                return f"TestIO service error (HTTP {resp.status_code})"
+            return f"Connection failed (HTTP {resp.status_code})"
+
+        except requests.exceptions.Timeout:
+            return "Connection timeout - TestIO did not respond within 10 seconds"
+        except requests.exceptions.ConnectionError:
+            return "Connection error - unable to reach TestIO. Check endpoint URL and network."
+        except requests.exceptions.RequestException as e:
+            return f"Request failed: {str(e)}"
+        except Exception:
+            return "Unexpected error during TestIO connection check"
+
+    @staticmethod
+    def _get_with_token(url: str, token: str) -> requests.Response:
+        """Perform an authenticated GET using `Authorization: Token <token>`."""
+        return requests.get(
+            url,
+            headers={"Authorization": f"Token {token}"},
+            timeout=10,
+        )

alita_sdk/runtime/clients/artifact.py

@@ -38,8 +38,8 @@ class Artifact:
         if len(data) == 0:
             # empty file might be created
             return ""
-        if isinstance(data, dict) and data['error']:
-            return f"{data['error']}. {data['content'] if data['content'] else ''}"
+        if isinstance(data, dict) and data.get('error'):
+            return f"{data['error']}. {data.get('content', '')}"
         detected = chardet.detect(data)
         if detected['encoding'] is not None:
             try:

alita_sdk/runtime/clients/client.py

@@ -20,8 +20,8 @@ from .prompt import AlitaPrompt
 from .datasource import AlitaDataSource
 from .artifact import Artifact
 from ..langchain.chat_message_template import Jinja2TemplatedChatMessagesTemplate
-from ..utils.utils import TOOLKIT_SPLITTER
-from ...tools import get_available_toolkit_models
+from ..utils.mcp_oauth import McpAuthorizationRequired
+from ...tools import get_available_toolkit_models, instantiate_toolkit
 from ...tools.base_indexer_toolkit import IndexTools
 
 logger = logging.getLogger(__name__)
@@ -145,6 +145,19 @@ class AlitaClient:
         data = requests.get(url, headers=self.headers, verify=False).json()
         return data
 
+    def toolkit(self, toolkit_id: int):
+        url = f"{self.base_url}{self.api_path}/tool/prompt_lib/{self.project_id}/{toolkit_id}"
+        response = requests.get(url, headers=self.headers, verify=False)
+        if not response.ok:
+            raise ValueError(f"Failed to fetch toolkit {toolkit_id}: {response.text}")
+        
+        tool_data = response.json()
+        if 'settings' not in tool_data:
+            tool_data['settings'] = {}
+        tool_data['settings']['alita'] = self
+        
+        return instantiate_toolkit(tool_data)
+
     def get_list_of_apps(self):
         apps = []
         limit = 10
@@ -347,7 +360,7 @@ class AlitaClient:
                     application_variables: Optional[dict] = None,
                     version_details: Optional[dict] = None, store: Optional[BaseStore] = None,
                     llm: Optional[ChatOpenAI] = None, mcp_tokens: Optional[dict] = None,
-                    conversation_id: Optional[str] = None):
+                    conversation_id: Optional[str] = None, ignored_mcp_servers: Optional[list] = None):
         if tools is None:
             tools = []
         if chat_history is None:
@@ -396,12 +409,12 @@ class AlitaClient:
         if runtime == 'nonrunnable':
             return LangChainAssistant(self, data, llm, chat_history, app_type,
                                       tools=tools, memory=memory, store=store, mcp_tokens=mcp_tokens,
-                                      conversation_id=conversation_id)
+                                      conversation_id=conversation_id, ignored_mcp_servers=ignored_mcp_servers)
         if runtime == 'langchain':
             return LangChainAssistant(self, data, llm,
                                       chat_history, app_type,
                                       tools=tools, memory=memory, store=store, mcp_tokens=mcp_tokens,
-                                      conversation_id=conversation_id).runnable()
+                                      conversation_id=conversation_id, ignored_mcp_servers=ignored_mcp_servers).runnable()
         elif runtime == 'llama':
             raise NotImplementedError("LLama runtime is not supported")
 
@@ -469,11 +482,44 @@ class AlitaClient:
         return self._process_requst(data)
 
     def create_artifact(self, bucket_name, artifact_name, artifact_data):
+        # Sanitize filename to prevent regex errors during indexing
+        sanitized_name, was_modified = self._sanitize_artifact_name(artifact_name)
+        if was_modified:
+            logger.warning(f"Artifact filename sanitized: '{artifact_name}' -> '{sanitized_name}'")
+        
         url = f'{self.artifacts_url}/{bucket_name.lower()}'
         data = requests.post(url, headers=self.headers, files={
-            'file': (artifact_name, artifact_data)
+            'file': (sanitized_name, artifact_data)
         }, verify=False)
         return self._process_requst(data)
+    
+    @staticmethod
+    def _sanitize_artifact_name(filename: str) -> tuple:
+        """Sanitize filename for safe storage and regex pattern matching."""
+        import re
+        from pathlib import Path
+        
+        if not filename or not filename.strip():
+            return "unnamed_file", True
+        
+        original = filename
+        path_obj = Path(filename)
+        name = path_obj.stem
+        extension = path_obj.suffix
+        
+        # Whitelist: alphanumeric, underscore, hyphen, space, Unicode letters/digits
+        sanitized_name = re.sub(r'[^\w\s-]', '', name, flags=re.UNICODE)
+        sanitized_name = re.sub(r'[-\s]+', '-', sanitized_name)
+        sanitized_name = sanitized_name.strip('-').strip()
+        
+        if not sanitized_name:
+            sanitized_name = "file"
+        
+        if extension:
+            extension = re.sub(r'[^\w.-]', '', extension, flags=re.UNICODE)
+        
+        sanitized = sanitized_name + extension
+        return sanitized, (sanitized != original)
 
     def download_artifact(self, bucket_name, artifact_name):
         url = f'{self.artifact_url}/{bucket_name.lower()}/{artifact_name}'
@@ -622,7 +668,8 @@ class AlitaClient:
                       tools: Optional[list] = None, chat_history: Optional[List[Any]] = None,
                       memory=None, runtime='langchain', variables: Optional[list] = None,
                       store: Optional[BaseStore] = None, debug_mode: Optional[bool] = False,
-                      mcp_tokens: Optional[dict] = None, conversation_id: Optional[str] = None):
+                      mcp_tokens: Optional[dict] = None, conversation_id: Optional[str] = None,
+                      ignored_mcp_servers: Optional[list] = None):
         """
         Create a predict-type agent with minimal configuration.
 
@@ -638,6 +685,7 @@ class AlitaClient:
             variables: Optional list of variables for the agent
             store: Optional store for memory
             debug_mode: Enable debug mode for cases when assistant can be initialized without tools
+            ignored_mcp_servers: Optional list of MCP server URLs to ignore (user chose to continue without auth)
 
         Returns:
             Runnable agent ready for execution
@@ -671,7 +719,8 @@ class AlitaClient:
             store=store,
             debug_mode=debug_mode,
             mcp_tokens=mcp_tokens,
-            conversation_id=conversation_id
+            conversation_id=conversation_id,
+            ignored_mcp_servers=ignored_mcp_servers
         ).runnable()
 
     def test_toolkit_tool(self, toolkit_config: dict, tool_name: str, tool_params: dict = None,
@@ -814,26 +863,12 @@ class AlitaClient:
 
             # Instantiate the toolkit with client and LLM support
             try:
-                tools = instantiate_toolkit_with_client(toolkit_config, llm, self, mcp_tokens=mcp_tokens)
-            except Exception as toolkit_error:
+                tools = instantiate_toolkit_with_client(toolkit_config, llm, self, mcp_tokens=mcp_tokens, use_prefix=False)
+            except McpAuthorizationRequired:
                 # Re-raise McpAuthorizationRequired to allow proper handling upstream
-                from ..utils.mcp_oauth import McpAuthorizationRequired
-                
-                # Check if it's McpAuthorizationRequired directly
-                if isinstance(toolkit_error, McpAuthorizationRequired):
-                    logger.info(f"McpAuthorizationRequired detected, re-raising")
-                    raise
-                
-                # Also check for wrapped exceptions (e.g., from asyncio)
-                if hasattr(toolkit_error, '__cause__') and isinstance(toolkit_error.__cause__, McpAuthorizationRequired):
-                    logger.info(f"Wrapped McpAuthorizationRequired detected, re-raising cause")
-                    raise toolkit_error.__cause__
-                
-                # Check exception class name as fallback (in case of module reload issues)
-                if toolkit_error.__class__.__name__ == 'McpAuthorizationRequired':
-                    logger.info(f"McpAuthorizationRequired detected by name, re-raising")
-                    raise
-                
+                logger.info(f"McpAuthorizationRequired detected, re-raising")
+                raise
+            except Exception as toolkit_error:
                 # For other errors, return error response
                 return {
                     "success": False,
@@ -919,7 +954,6 @@ class AlitaClient:
             if target_tool is None:
                 available_tools = []
                 base_available_tools = []
-                full_available_tools = []
 
                 for tool in tools:
                     tool_name_attr = None
@@ -936,10 +970,6 @@ class AlitaClient:
                         if base_name not in base_available_tools:
                             base_available_tools.append(base_name)
 
-                        # Track full names separately
-                        if TOOLKIT_SPLITTER in tool_name_attr:
-                            full_available_tools.append(tool_name_attr)
-
                 # Create comprehensive error message
                 error_msg = f"Tool '{tool_name}' not found in toolkit '{toolkit_config.get('toolkit_name')}'.\n"
 
@@ -947,9 +977,7 @@ class AlitaClient:
                 if toolkit_name in [tool.value for tool in IndexTools]:
                     error_msg += f" Please make sure proper PGVector configuration and embedding model are set in the platform.\n"
 
-                if base_available_tools and full_available_tools:
-                    error_msg += f" Available tools: {base_available_tools} (base names) or {full_available_tools} (full names)"
-                elif base_available_tools:
+                if base_available_tools:
                     error_msg += f" Available tools: {base_available_tools}"
                 elif available_tools:
                     error_msg += f" Available tools: {available_tools}"
@@ -958,10 +986,7 @@ class AlitaClient:
 
                 # Add helpful hint about naming conventions
                 if '___' in tool_name:
-                    error_msg += f" Note: You provided a full name '{tool_name}'. Try using just the base name '{extract_base_tool_name(tool_name)}'."
-                elif full_available_tools:
-                    possible_full_name = create_full_tool_name(tool_name, toolkit_name)
-                    error_msg += f" Note: You provided a base name '{tool_name}'. The full name might be '{possible_full_name}'."
+                    error_msg += f" Note: Tool names no longer use '___' prefixes. Try using just the base name '{extract_base_tool_name(tool_name)}'."
 
                 return {
                     "success": False,
@@ -1068,7 +1093,6 @@ class AlitaClient:
 
         except Exception as e:
             # Re-raise McpAuthorizationRequired to allow proper handling upstream
-            from ..utils.mcp_oauth import McpAuthorizationRequired
             if isinstance(e, McpAuthorizationRequired):
                 raise
             logger = logging.getLogger(__name__)

alita_sdk/runtime/clients/sandbox_client.py

@@ -6,6 +6,7 @@ import requests
 from typing import Any
 from json import dumps
 import chardet
+from ...tools import instantiate_toolkit
 
 logger = logging.getLogger(__name__)
 
@@ -184,6 +185,19 @@ class SandboxClient:
         data = requests.get(url, headers=self.headers, verify=False).json()
         return data
 
+    def toolkit(self, toolkit_id: int):
+        url = f"{self.base_url}{self.api_path}/tool/prompt_lib/{self.project_id}/{toolkit_id}"
+        response = requests.get(url, headers=self.headers, verify=False)
+        if not response.ok:
+            raise ValueError(f"Failed to fetch toolkit {toolkit_id}: {response.text}")
+        
+        tool_data = response.json()
+        if 'settings' not in tool_data:
+            tool_data['settings'] = {}
+        tool_data['settings']['alita'] = self
+        
+        return instantiate_toolkit(tool_data)
+
     def get_list_of_apps(self):
         apps = []
         limit = 10

alita_sdk/runtime/langchain/assistant.py

@@ -33,7 +33,8 @@ class Assistant:
                  store: Optional[BaseStore] = None,
                  debug_mode: Optional[bool] = False,
                  mcp_tokens: Optional[dict] = None,
-                 conversation_id: Optional[str] = None):
+                 conversation_id: Optional[str] = None,
+                 ignored_mcp_servers: Optional[list] = None):
 
         self.app_type = app_type
         self.memory = memory
@@ -98,10 +99,55 @@ class Assistant:
             memory_store=self.store,
             debug_mode=debug_mode,
             mcp_tokens=mcp_tokens,
-            conversation_id=conversation_id
+            conversation_id=conversation_id,
+            ignored_mcp_servers=ignored_mcp_servers
         )
         if tools:
             self.tools += tools
+        
+        # Create ToolRegistry to track tool metadata and handle name collisions
+        self.tool_registry = {}
+        tool_name_counts = {}  # Track how many times each base name appears
+        
+        for tool in self.tools:
+            if hasattr(tool, 'name'):
+                original_name = tool.name
+                base_name = original_name
+                
+                # Extract toolkit metadata from tool configuration
+                toolkit_name = ""
+                toolkit_type = ""
+                
+                # Find matching tool config to extract metadata
+                for tool_config in version_tools:
+                    # Try to match by toolkit_name or name field
+                    config_toolkit_name = tool_config.get('toolkit_name', tool_config.get('name', ''))
+                    # Simple heuristic: toolkit info should be accessible from tool config
+                    # For now, use toolkit_name and type from config
+                    toolkit_name = config_toolkit_name
+                    toolkit_type = tool_config.get('type', '')
+                    break  # Use first match for now; will refine with better matching
+                
+                # Handle duplicate tool names by appending numeric suffix
+                if base_name in tool_name_counts:
+                    tool_name_counts[base_name] += 1
+                    # Append suffix to make unique
+                    new_name = f"{base_name}_{tool_name_counts[base_name]}"
+                    tool.name = new_name
+                    logger.info(f"Tool name collision detected: '{base_name}' -> '{new_name}'")
+                else:
+                    tool_name_counts[base_name] = 0
+                    new_name = base_name
+                
+                # Store in registry
+                self.tool_registry[tool.name] = {
+                    'toolkit_name': toolkit_name,
+                    'toolkit_type': toolkit_type,
+                    'original_tool_name': base_name
+                }
+                
+        logger.info(f"ToolRegistry initialized with {len(self.tool_registry)} tools")
+        
         # Handle prompt setup
         if app_type in ["pipeline", "predict", "react"]:
             self.prompt = data['instructions']

alita_sdk/runtime/langchain/constants.py

@@ -84,4 +84,6 @@ DEFAULT_MULTIMODAL_PROMPT = """
 ELITEA_RS = "elitea_response"
 PRINTER = "printer"
 PRINTER_NODE_RS = "printer_output"
-PRINTER_COMPLETED_STATE = "PRINTER_COMPLETED"
+PRINTER_COMPLETED_STATE = "PRINTER_COMPLETED"
+
+LOADER_MAX_TOKENS_DEFAULT = 512