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

alita_sdk/runtime/toolkits/tools.py

@@ -21,7 +21,7 @@ from ..tools.image_generation import ImageGenerationToolkit
 from ...community import get_toolkits as community_toolkits, get_tools as community_tools
 from ...tools.memory import MemoryToolkit
 from ..utils.mcp_oauth import canonical_resource, McpAuthorizationRequired
-from ...tools.utils import TOOLKIT_SPLITTER
+from ...tools.utils import clean_string
 from alita_sdk.tools import _inject_toolkit_id
 
 logger = logging.getLogger(__name__)
@@ -41,7 +41,7 @@ def get_toolkits():
     return core_toolkits + community_toolkits() + alita_toolkits()
 
 
-def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseStore = None, debug_mode: Optional[bool] = False, mcp_tokens: Optional[dict] = None, conversation_id: Optional[str] = None) -> list:
+def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseStore = None, debug_mode: Optional[bool] = False, mcp_tokens: Optional[dict] = None, conversation_id: Optional[str] = None, ignored_mcp_servers: Optional[list] = None) -> list:
     prompts = []
     tools = []
 
@@ -110,10 +110,11 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                     pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
                     embedding_model=tool['settings'].get('embedding_model'),
                     collection_name=f"{tool.get('toolkit_name')}",
-                    collection_schema=str(tool['id']),
+                    collection_schema=str(tool['settings'].get('id', tool.get('id', ''))),
                 ).get_tools()
                 # Inject toolkit_id for artifact tools as well
-                _inject_toolkit_id(tool, toolkit_tools)
+                # Pass settings as the tool config since that's where the id field is
+                _inject_toolkit_id(tool['settings'], toolkit_tools)
                 tools.extend(toolkit_tools)
 
             elif tool['type'] == 'vectorstore':
@@ -164,6 +165,14 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                 # remote mcp tool initialization with token injection
                 settings = dict(tool['settings'])
                 url = settings.get('url')
+                
+                # Check if this MCP server should be ignored (user chose to continue without auth)
+                if ignored_mcp_servers and url:
+                    canonical_url = canonical_resource(url)
+                    if canonical_url in ignored_mcp_servers or url in ignored_mcp_servers:
+                        logger.info(f"[MCP Auth] Skipping ignored MCP server: {url}")
+                        continue
+                
                 headers = settings.get('headers')
                 token_data = None
                 session_id = None
@@ -319,11 +328,18 @@ def _mcp_tools(tools_list, alita):
 
 def _init_single_mcp_tool(server_toolkit_name, toolkit_name, available_tool, alita, toolkit_settings):
     try:
-
-        tool_name = f'{toolkit_name}{TOOLKIT_SPLITTER}{available_tool["name"]}'
+        # Use clean tool name without prefix
+        tool_name = available_tool["name"]
+        # Add toolkit context to description (max 1000 chars)
+        toolkit_context = f" [Toolkit: {clean_string(toolkit_name)}]" if toolkit_name else ''
+        base_description = f"MCP for a tool '{tool_name}': {available_tool.get('description', '')}"
+        description = base_description
+        if toolkit_context and len(base_description + toolkit_context) <= 1000:
+            description = base_description + toolkit_context
+        
         return McpServerTool(
             name=tool_name,
-            description=f"MCP for a tool '{tool_name}': {available_tool.get('description', '')}",
+            description=description,
             args_schema=McpServerTool.create_pydantic_model_from_schema(
                 available_tool.get("inputSchema", {})
             ),

alita_sdk/runtime/toolkits/vectorstore.py

@@ -1,7 +1,7 @@
 from logging import getLogger
 from typing import Any, List, Literal, Optional
 
-from alita_sdk.tools.utils import clean_string, TOOLKIT_SPLITTER
+from alita_sdk.tools.utils import clean_string
 from pydantic import BaseModel, create_model, Field, ConfigDict
 from langchain_core.tools import BaseToolkit, BaseTool
 from alita_sdk.tools.base.tool import BaseAction
@@ -31,7 +31,8 @@ class VectorStoreToolkit(BaseToolkit):
                     toolkit_name: Optional[str] = None,
                     selected_tools: list[str] = []):
         logger.info("Selected tools: %s", selected_tools)
-        prefix = clean_string(toolkit_name) + TOOLKIT_SPLITTER if toolkit_name else ''
+        # Use clean toolkit name for context (max 1000 chars in description)
+        toolkit_context = f" [Toolkit: {clean_string(toolkit_name)}]" if toolkit_name else ''
         if selected_tools is None:
             selected_tools = []
         tools = []
@@ -46,11 +47,16 @@ class VectorStoreToolkit(BaseToolkit):
             # if selected_tools:
             #     if tool["name"] not in selected_tools:
             #         continue
+            # Add toolkit context to description with character limit
+            description = tool["description"]
+            if toolkit_context and len(description + toolkit_context) <= 1000:
+                description = description + toolkit_context
             tools.append(BaseAction(
                 api_wrapper=vectorstore_wrapper,
-                name=f'{prefix}{tool["name"]}',
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/runtime/tools/artifact.py

@@ -13,6 +13,7 @@ from pydantic import create_model, Field, model_validator
 
 from ...tools.non_code_indexer_toolkit import NonCodeIndexerToolkit
 from ...tools.utils.available_tools_decorator import extend_with_parent_available_tools
+from ...tools.elitea_base import extend_with_file_operations, BaseCodeToolApiWrapper
 from ...runtime.utils.utils import IndexerKeywords
 
 
@@ -20,6 +21,12 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
     bucket: str
     artifact: Optional[Any] = None
     
+    # Import file operation methods from BaseCodeToolApiWrapper
+    read_file_chunk = BaseCodeToolApiWrapper.read_file_chunk
+    read_multiple_files = BaseCodeToolApiWrapper.read_multiple_files
+    search_file = BaseCodeToolApiWrapper.search_file
+    edit_file = BaseCodeToolApiWrapper.edit_file
+    
     @model_validator(mode='before')
     @classmethod
     def validate_toolkit(cls, values):
@@ -31,7 +38,24 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         return super().validate_toolkit(values)
 
     def list_files(self, bucket_name = None, return_as_string = True):
-        return self.artifact.list(bucket_name, return_as_string)
+        """List all files in the artifact bucket with API download links."""
+        result = self.artifact.list(bucket_name, return_as_string=False)
+        
+        # Add API download link to each file
+        if isinstance(result, dict) and 'rows' in result:
+            bucket = bucket_name or self.bucket
+            
+            # Get base_url and project_id from alita client
+            base_url = getattr(self.alita, 'base_url', '').rstrip('/')
+            project_id = getattr(self.alita, 'project_id', '')
+            
+            for file_info in result['rows']:
+                if 'name' in file_info:
+                    # Generate API download link
+                    file_name = file_info['name']
+                    file_info['link'] = f"{base_url}/api/v2/artifacts/artifact/default/{project_id}/{bucket}/{file_name}"
+        
+        return str(result) if return_as_string else result
 
     def create_file(self, filename: str, filedata: str, bucket_name = None):
         # Sanitize filename to prevent regex errors during indexing
@@ -128,6 +152,94 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                                   sheet_name=sheet_name,
                                   excel_by_sheets=excel_by_sheets,
                                   llm=self.llm)
+    
+    def _read_file(
+        self,
+        file_path: str,
+        branch: str = None,
+        bucket_name: str = None,
+        **kwargs
+    ) -> str:
+        """
+        Read a file from artifact bucket with optional partial read support.
+        
+        Parameters:
+            file_path: Name of the file in the bucket
+            branch: Not used for artifacts (kept for API consistency)
+            bucket_name: Name of the bucket (uses default if None)
+            **kwargs: Additional parameters (offset, limit, head, tail) - currently ignored,
+                     partial read handled client-side by base class methods
+        
+        Returns:
+            File content as string
+        """
+        return self.read_file(filename=file_path, bucket_name=bucket_name)
+    
+    def _write_file(
+        self,
+        file_path: str,
+        content: str,
+        branch: str = None,
+        commit_message: str = None,
+        bucket_name: str = None
+    ) -> str:
+        """
+        Write content to a file (create or overwrite).
+        
+        Parameters:
+            file_path: Name of the file in the bucket
+            content: New file content
+            branch: Not used for artifacts (kept for API consistency)
+            commit_message: Not used for artifacts (kept for API consistency)
+            bucket_name: Name of the bucket (uses default if None)
+            
+        Returns:
+            Success message
+        """
+        try:
+            # Sanitize filename
+            sanitized_filename, was_modified = self._sanitize_filename(file_path)
+            if was_modified:
+                logging.warning(f"Filename sanitized: '{file_path}' -> '{sanitized_filename}'")
+            
+            # Check if file exists
+            try:
+                self.artifact.get(artifact_name=sanitized_filename, bucket_name=bucket_name, llm=self.llm)
+                # File exists, overwrite it
+                result = self.artifact.overwrite(sanitized_filename, content, bucket_name)
+                
+                # Dispatch custom event
+                dispatch_custom_event("file_modified", {
+                    "message": f"File '{sanitized_filename}' updated successfully",
+                    "filename": sanitized_filename,
+                    "tool_name": "edit_file",
+                    "toolkit": "artifact",
+                    "operation_type": "modify",
+                    "meta": {
+                        "bucket": bucket_name or self.bucket
+                    }
+                })
+                
+                return f"Updated file {sanitized_filename}"
+            except:
+                # File doesn't exist, create it
+                result = self.artifact.create(sanitized_filename, content, bucket_name)
+                
+                # Dispatch custom event
+                dispatch_custom_event("file_modified", {
+                    "message": f"File '{sanitized_filename}' created successfully",
+                    "filename": sanitized_filename,
+                    "tool_name": "edit_file",
+                    "toolkit": "artifact",
+                    "operation_type": "create",
+                    "meta": {
+                        "bucket": bucket_name or self.bucket
+                    }
+                })
+                
+                return f"Created file {sanitized_filename}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
     def delete_file(self, filename: str, bucket_name = None):
         return self.artifact.delete(filename, bucket_name)
@@ -167,7 +279,11 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         return result
 
     def create_new_bucket(self, bucket_name: str, expiration_measure = "weeks", expiration_value = 1):
-        return self.artifact.client.create_bucket(bucket_name, expiration_measure, expiration_value)
+        # Sanitize bucket name: replace underscores with hyphens and ensure lowercase
+        sanitized_name = bucket_name.replace('_', '-').lower()
+        if sanitized_name != bucket_name:
+            logging.warning(f"Bucket name '{bucket_name}' was sanitized to '{sanitized_name}' (underscores replaced with hyphens, converted to lowercase)")
+        return self.artifact.client.create_bucket(sanitized_name, expiration_measure, expiration_value)
 
     def _index_tool_params(self):
         return {
@@ -236,14 +352,17 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                 logging.error(f"Failed while parsing the file '{document.metadata['name']}': {e}")
                 yield document
 
-    @extend_with_parent_available_tools
+    @extend_with_file_operations
     def get_available_tools(self):
+        """Get available tools. Returns all tools for schema; filtering happens at toolkit level."""
         bucket_name = (Optional[str], Field(description="Name of the bucket to work with."
                                                         "If bucket is not specified by user directly, the name should be taken from chat history."
                                                         "If bucket never mentioned in chat, the name will be taken from tool configuration."
                                                         " ***IMPORTANT*** Underscore `_` is prohibited in bucket name and should be replaced by `-`",
                                             default=None))
-        return [
+        
+        # Basic artifact tools (always available)
+        basic_tools = [
             {
                 "ref": self.list_files,
                 "name": "listFiles",
@@ -328,11 +447,25 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                 "description": "Creates new bucket specified by user.",
                 "args_schema": create_model(
                     "createNewBucket",
-                    bucket_name=(str, Field(description="Bucket name to create. ***IMPORTANT*** Underscore `_` is prohibited in bucket name and should be replaced by `-`.")),
+                    bucket_name=(str, Field(
+                        description="Bucket name to create. Must start with lowercase letter and contain only lowercase letters, numbers, and hyphens. Underscores will be automatically converted to hyphens.",
+                        pattern=r'^[a-z][a-z0-9_-]*$'  # Allow underscores in input, will be sanitized
+                    )),
                     expiration_measure=(Optional[str], Field(description="Measure of expiration time for bucket configuration."
                                                                          "Possible values: `days`, `weeks`, `months`, `years`.",
                                                              default="weeks")),
                     expiration_value=(Optional[int], Field(description="Expiration time values.", default=1))
                 )
             }
-        ]
+        ]
+        
+        # Always include indexing tools in available tools list
+        # Filtering based on vector store config happens at toolkit level via decorator
+        try:
+            # Get indexing tools from parent class
+            indexing_tools = super(ArtifactWrapper, self).get_available_tools()
+            return indexing_tools + basic_tools
+        except Exception as e:
+            # If getting parent tools fails, log warning and return basic tools only
+            logging.warning(f"Failed to load indexing tools: {e}. Only basic artifact tools will be available.")
+            return basic_tools

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'):