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

alita_sdk/runtime/toolkits/mcp.py

@@ -15,7 +15,6 @@ from pydantic import BaseModel, ConfigDict, Field, SecretStr
 from ..tools.mcp_server_tool import McpServerTool
 from ..tools.mcp_remote_tool import McpRemoteTool
 from ..tools.mcp_inspect_tool import McpInspectTool
-from ...tools.utils import TOOLKIT_SPLITTER, clean_string
 from ..models.mcp_models import McpConnectionConfig
 from ..utils.mcp_client import McpClient
 from ..utils.mcp_oauth import (
@@ -40,110 +39,6 @@ def safe_int(value, default):
         logger.warning(f"Invalid integer value '{value}', using default {default}")
         return default
 
-def optimize_tool_name(prefix: str, tool_name: str, max_total_length: int = 64) -> str:
-    """
-    Optimize tool name to fit within max_total_length while preserving meaning.
-    
-    Args:
-        prefix: The toolkit prefix (already cleaned)
-        tool_name: The original tool name
-        max_total_length: Maximum total length for the full tool name (default: 64)
-    
-    Returns:
-        Optimized full tool name in format: prefix___tool_name
-    """
-    splitter = TOOLKIT_SPLITTER
-    splitter_len = len(splitter)
-    prefix_len = len(prefix)
-    
-    # Calculate available space for tool name
-    available_space = max_total_length - prefix_len - splitter_len
-    
-    if available_space <= 0:
-        logger.error(f"Prefix '{prefix}' is too long ({prefix_len} chars), cannot create valid tool name")
-        # Fallback: truncate prefix itself
-        prefix = prefix[:max_total_length - splitter_len - 10]  # Leave 10 chars for tool name
-        available_space = max_total_length - len(prefix) - splitter_len
-    
-    # If tool name fits, use it as-is
-    if len(tool_name) <= available_space:
-        return f'{prefix}{splitter}{tool_name}'
-    
-    # Tool name is too long, need to optimize
-    logger.debug(f"Tool name '{tool_name}' is too long ({len(tool_name)} chars), optimizing to fit {available_space} chars")
-    
-    # Split tool name into parts (handle camelCase, snake_case, and mixed)
-    # First, split by underscores and hyphens
-    parts = re.split(r'[_-]', tool_name)
-    
-    # Further split camelCase within each part
-    all_parts = []
-    for part in parts:
-        # Insert underscore before uppercase letters (camelCase to snake_case)
-        snake_case_part = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', part)
-        all_parts.extend(snake_case_part.split('_'))
-    
-    # Filter out empty parts
-    all_parts = [p for p in all_parts if p]
-    
-    # Remove redundant prefix words (case-insensitive comparison)
-    # Only remove if prefix is meaningful (>= 3 chars) to avoid over-filtering
-    prefix_lower = prefix.lower()
-    filtered_parts = []
-    for part in all_parts:
-        part_lower = part.lower()
-        # Skip if this part contains the prefix or the prefix contains this part
-        # But only if both are meaningful (>= 3 chars)
-        should_remove = False
-        if len(prefix_lower) >= 3 and len(part_lower) >= 3:
-            if part_lower in prefix_lower or prefix_lower in part_lower:
-                should_remove = True
-                logger.debug(f"Removing redundant part '{part}' (matches prefix '{prefix}')")
-        
-        if not should_remove:
-            filtered_parts.append(part)
-    
-    # If we removed all parts, keep the original parts
-    if not filtered_parts:
-        filtered_parts = all_parts
-    
-    # Reconstruct tool name with filtered parts
-    optimized_name = '_'.join(filtered_parts)
-    
-    # If still too long, truncate intelligently
-    if len(optimized_name) > available_space:
-        # Strategy: Keep beginning and end, as they often contain the most important info
-        # For example: "projectalita_github_io_list_branches" -> "projectalita_list_branches"
-        
-        # Try removing middle parts first
-        if len(filtered_parts) > 2:
-            # Keep first and last parts, remove middle
-            kept_parts = [filtered_parts[0], filtered_parts[-1]]
-            optimized_name = '_'.join(kept_parts)
-            
-            # If still too long, add parts from the end until we run out of space
-            if len(optimized_name) <= available_space and len(filtered_parts) > 2:
-                for i in range(len(filtered_parts) - 2, 0, -1):
-                    candidate = '_'.join([filtered_parts[0]] + filtered_parts[i:])
-                    if len(candidate) <= available_space:
-                        optimized_name = candidate
-                        break
-        
-        # If still too long, just truncate
-        if len(optimized_name) > available_space:
-            # Try to truncate at word boundary
-            truncated = optimized_name[:available_space]
-            last_underscore = truncated.rfind('_')
-            if last_underscore > available_space * 0.7:  # Keep if we're not losing too much
-                optimized_name = truncated[:last_underscore]
-            else:
-                optimized_name = truncated
-    
-    full_name = f'{prefix}{splitter}{optimized_name}'
-    logger.info(f"Optimized tool name: '{tool_name}' ({len(tool_name)} chars) -> '{optimized_name}' ({len(optimized_name)} chars), full: '{full_name}' ({len(full_name)} chars)")
-    
-    return full_name
-
 class McpToolkit(BaseToolkit):
     """
     MCP Toolkit for connecting to a single remote MCP server and exposing its tools.
@@ -153,9 +48,6 @@ class McpToolkit(BaseToolkit):
     tools: List[BaseTool] = []
     toolkit_name: Optional[str] = None
 
-    # Class variable (not Pydantic field) for tool name length limit
-    toolkit_max_length: ClassVar[int] = 0  # No limit for MCP tool names
-
     def __getstate__(self):
         """Custom serialization for pickle compatibility."""
         state = self.__dict__.copy()
@@ -595,28 +487,23 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create a BaseTool from a tool/prompt dictionary (from direct HTTP discovery)."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
-
-            # Clean toolkit name for prefixing
-            clean_prefix = clean_string(toolkit_name, max_length_value)
-
-            # Optimize tool name to fit within 64 character limit
-            full_tool_name = optimize_tool_name(clean_prefix, tool_dict.get("name", "unknown"))
+            # Use original tool name directly
+            tool_name = tool_dict.get("name", "unknown")
             
             # Check if this is a prompt (converted to tool)
             is_prompt = tool_dict.get("_mcp_type") == "prompt"
             item_type = "prompt" if is_prompt else "tool"
 
-            # Build description and ensure it doesn't exceed 1000 characters
-            description = f"MCP {item_type} '{tool_dict.get('name')}' from toolkit '{toolkit_name}': {tool_dict.get('description', '')}"
+            # Build description with toolkit context and ensure it doesn't exceed 1000 characters
+            base_description = tool_dict.get('description', '')
+            description = f"{base_description}\nToolkit: {toolkit_name} ({connection_config.url})"
             if len(description) > 1000:
                 description = description[:997] + "..."
-                logger.debug(f"Trimmed description for tool '{tool_dict.get('name')}' from {len(description)} to 1000 chars")
+                logger.debug(f"Trimmed description for tool '{tool_name}' to 1000 chars")
 
             # Use McpRemoteTool for remote MCP servers (HTTP/SSE)
             return McpRemoteTool(
-                name=full_tool_name,
+                name=tool_name,
                 description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(
                     tool_dict.get("inputSchema", {})
@@ -628,11 +515,11 @@ class McpToolkit(BaseToolkit):
                 tool_timeout_sec=timeout,
                 is_prompt=is_prompt,
                 prompt_name=tool_dict.get("_mcp_prompt_name") if is_prompt else None,
-                original_tool_name=tool_dict.get('name'),  # Store original name for MCP server invocation
+                original_tool_name=tool_name,  # Store original name for MCP server invocation
                 session_id=session_id  # Pass session ID for stateful SSE servers
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{tool_dict.get('name')}' from toolkit '{toolkit_name}': {e}")
+            logger.error(f"Failed to create MCP tool '{tool_name}' from toolkit '{toolkit_name}': {e}")
             return None
 
     @classmethod
@@ -691,7 +578,7 @@ class McpToolkit(BaseToolkit):
             # We don't have full connection config in static mode, so create a basic one
             # The inspection tool will work as long as the server is accessible
             inspection_tool = McpInspectTool(
-                name=f"{clean_string(toolkit_name, 50)}{TOOLKIT_SPLITTER}mcp_inspect",
+                name="mcp_inspect",
                 server_name=toolkit_name,
                 server_url="",  # Will be populated by the client if available
                 description=f"Inspect available tools, prompts, and resources from MCP toolkit '{toolkit_name}'"
@@ -713,22 +600,17 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create a BaseTool from discovered metadata."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
+            # Use original tool name directly
+            tool_name = tool_metadata.name
 
-            # Clean server name for prefixing (use tool_metadata.server instead of toolkit_name)
-            clean_prefix = clean_string(tool_metadata.server, max_length_value)
-            # Optimize tool name to fit within 64 character limit
-            full_tool_name = optimize_tool_name(clean_prefix, tool_metadata.name)
-
-            # Build description and ensure it doesn't exceed 1000 characters
-            description = f"MCP tool '{tool_metadata.name}' from server '{tool_metadata.server}': {tool_metadata.description}"
+            # Build description with toolkit context and ensure it doesn't exceed 1000 characters
+            description = f"{tool_metadata.description}\nToolkit: {toolkit_name}"
             if len(description) > 1000:
                 description = description[:997] + "..."
-                logger.debug(f"Trimmed description for tool '{tool_metadata.name}' from {len(description)} to 1000 chars")
+                logger.debug(f"Trimmed description for tool '{tool_name}' to 1000 chars")
 
             return McpServerTool(
-                name=full_tool_name,
+                name=tool_name,
                 description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(tool_metadata.input_schema),
                 client=client,
@@ -736,7 +618,7 @@ class McpToolkit(BaseToolkit):
                 tool_timeout_sec=timeout
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{tool_metadata.name}' from server '{tool_metadata.server}': {e}")
+            logger.error(f"Failed to create MCP tool '{tool_name}' from server '{tool_metadata.server}': {e}")
             return None
 
     @classmethod
@@ -749,23 +631,18 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create a single MCP tool."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
-
-            # Clean toolkit name for prefixing
-            clean_prefix = clean_string(toolkit_name, max_length_value)
+            # Use original tool name directly
+            tool_name = available_tool["name"]
 
-            # Optimize tool name to fit within 64 character limit
-            full_tool_name = optimize_tool_name(clean_prefix, available_tool["name"])
-
-            # Build description and ensure it doesn't exceed 1000 characters
-            description = f"MCP tool '{available_tool['name']}' from toolkit '{toolkit_name}': {available_tool.get('description', '')}"
+            # Build description with toolkit context and ensure it doesn't exceed 1000 characters
+            base_description = available_tool.get('description', '')
+            description = f"{base_description}\nToolkit: {toolkit_name}"
             if len(description) > 1000:
                 description = description[:997] + "..."
-                logger.debug(f"Trimmed description for tool '{available_tool['name']}' from {len(description)} to 1000 chars")
+                logger.debug(f"Trimmed description for tool '{tool_name}' to 1000 chars")
 
             return McpServerTool(
-                name=full_tool_name,
+                name=tool_name,
                 description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(
                     available_tool.get("inputSchema", {})
@@ -775,7 +652,7 @@ class McpToolkit(BaseToolkit):
                 tool_timeout_sec=timeout
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{available_tool.get('name')}' from toolkit '{toolkit_name}': {e}")
+            logger.error(f"Failed to create MCP tool '{tool_name}' from toolkit '{toolkit_name}': {e}")
             return None
 
     @classmethod
@@ -786,16 +663,8 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create the inspection tool for the MCP toolkit."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
-
-            # Clean toolkit name for prefixing
-            clean_prefix = clean_string(toolkit_name, max_length_value)
-
-            full_tool_name = f'{clean_prefix}{TOOLKIT_SPLITTER}mcp_inspect'
-
             return McpInspectTool(
-                name=full_tool_name,
+                name="mcp_inspect",
                 server_name=toolkit_name,
                 server_url=connection_config.url,
                 server_headers=connection_config.headers,

alita_sdk/runtime/toolkits/planning.py

@@ -16,7 +16,7 @@ from pydantic.fields import FieldInfo
 
 from ..tools.planning import PlanningWrapper
 from ...tools.base.tool import BaseAction
-from ...tools.utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...tools.utils import clean_string, get_max_toolkit_length
 
 
 class PlanningToolkit(BaseToolkit):
@@ -150,8 +150,8 @@ class PlanningToolkit(BaseToolkit):
             plan_callback=plan_callback,
         )
         
-        # Build tool name prefix
-        prefix = clean_string(toolkit_name, cls._toolkit_max_length) + 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, 0)}]" if toolkit_name else ''
         
         # Create tools from wrapper
         available_tools = wrapper.get_available_tools()
@@ -159,10 +159,15 @@ class PlanningToolkit(BaseToolkit):
             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=wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         

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