alita-sdk 0.3.379__py3-none-any.whl → 0.3.627__py3-none-any.whl

alita_sdk/runtime/tools/artifact.py

@@ -1,3 +1,4 @@
+import base64
 import hashlib
 import io
 import json
@@ -13,13 +14,262 @@ 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 ...runtime.utils.utils import IndexerKeywords
+from ...tools.elitea_base import extend_with_file_operations, BaseCodeToolApiWrapper
+from ...runtime.utils.utils import IndexerKeywords, resolve_image_from_cache
 
 
 class ArtifactWrapper(NonCodeIndexerToolkit):
     bucket: str
     artifact: Optional[Any] = None
-    
+
+    # Override file operation methods to support bucket_name parameter
+    # (instead of importing from BaseCodeToolApiWrapper which uses 'branch')
+
+    def read_file_chunk(
+        self,
+        file_path: str,
+        start_line: int,
+        end_line: Optional[int] = None,
+        bucket_name: str = None
+    ) -> str:
+        """
+        Read a specific range of lines from a file in an artifact bucket.
+
+        Args:
+            file_path: Path to the file to read
+            start_line: Starting line number (1-indexed, inclusive)
+            end_line: Ending line number (1-indexed, inclusive). If None, reads to end.
+            bucket_name: Bucket name. If not provided, uses toolkit-configured default bucket.
+
+        Returns:
+            File content for the specified line range
+        """
+        from ...tools.utils.text_operations import apply_line_slice
+
+        # Calculate offset and limit from start_line and end_line
+        offset = start_line
+        limit = (end_line - start_line + 1) if end_line is not None else None
+
+        # Read the file with bucket_name support
+        content = self._read_file(file_path, branch=None, bucket_name=bucket_name, offset=offset, limit=limit)
+
+        # Apply client-side slicing if toolkit doesn't support partial reads
+        return apply_line_slice(content, offset=offset, limit=limit)
+
+    def read_multiple_files(
+        self,
+        file_paths: List[str],
+        bucket_name: str = None,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None
+    ) -> dict:
+        """
+        Read multiple files in batch from an artifact bucket.
+
+        Args:
+            file_paths: List of file paths to read
+            bucket_name: Bucket name. If not provided, uses toolkit-configured default bucket.
+            offset: Starting line number for all files (1-indexed)
+            limit: Number of lines to read from offset for all files
+
+        Returns:
+            Dict mapping file paths to their content
+        """
+        from ...tools.utils.text_operations import apply_line_slice
+
+        results = {}
+        for path in file_paths:
+            try:
+                content = self._read_file(path, branch=None, bucket_name=bucket_name, offset=offset, limit=limit)
+                results[path] = apply_line_slice(content, offset=offset, limit=limit)
+            except Exception as e:
+                results[path] = f"Error reading file: {str(e)}"
+        return results
+
+    def search_file(
+        self,
+        file_path: str,
+        pattern: str,
+        bucket_name: str = None,
+        is_regex: bool = True,
+        context_lines: int = 2
+    ) -> str:
+        """
+        Search for a pattern in a file from an artifact bucket.
+
+        Args:
+            file_path: Path to the file to search
+            pattern: Search pattern. Treated as regex by default unless is_regex=False.
+            bucket_name: Bucket name. If not provided, uses toolkit-configured default bucket.
+            is_regex: Whether pattern is a regex. Default is True for flexible matching.
+            context_lines: Number of lines before/after match to include for context
+
+        Returns:
+            Formatted string with match results and context
+        """
+        from ...tools.utils.text_operations import search_in_content
+
+        content = self._read_file(file_path, branch=None, bucket_name=bucket_name)
+        matches = search_in_content(content, pattern, is_regex=is_regex, context_lines=context_lines)
+
+        if not matches:
+            return f"No matches found for pattern '{pattern}' in {file_path}"
+
+        # Format results
+        results = [f"Found {len(matches)} match(es) in {file_path}:\n"]
+        for match in matches:
+            results.append(f"\n--- Line {match['line_number']} ---")
+            if match['context_before']:
+                results.append("\n".join(f"  {l}" for l in match['context_before']))
+            results.append(f"> {match['line_content']}")
+            if match['context_after']:
+                results.append("\n".join(f"  {l}" for l in match['context_after']))
+
+        return "\n".join(results)
+
+    def edit_file(
+        self,
+        file_path: str,
+        file_query: str,
+        bucket_name: str = None,
+        commit_message: str = None
+    ) -> str:
+        """
+        Edit a file in an artifact bucket using OLD/NEW markers.
+
+        Args:
+            file_path: Path to the file to edit. Must be a text file.
+            file_query: Edit instructions with OLD/NEW markers.
+            bucket_name: Bucket name. If not provided, uses toolkit-configured default bucket.
+            commit_message: Not used for artifacts (kept for API consistency)
+
+        Returns:
+            Success message or error description
+        """
+        from ...tools.utils.text_operations import parse_old_new_markers, is_text_editable, try_apply_edit
+        from langchain_core.tools import ToolException
+
+        # Validate file type
+        if not is_text_editable(file_path):
+            raise ToolException(f"File '{file_path}' is not a text-editable file type")
+
+        # Read current content
+        content = self._read_file(file_path, branch=None, bucket_name=bucket_name)
+
+        # Parse edit instructions
+        edits = parse_old_new_markers(file_query)
+        if not edits:
+            raise ToolException("No valid OLD/NEW marker pairs found in edit instructions")
+
+        # Apply edits
+        updated_content = content
+        applied_count = 0
+        for old_text, new_text in edits:
+            updated_content, used_fallback = try_apply_edit(updated_content, old_text, new_text, file_path)
+            if updated_content != content or used_fallback:
+                applied_count += 1
+                content = updated_content
+
+        if applied_count == 0:
+            return f"No edits were applied to {file_path}. The OLD blocks may not match the file content."
+
+        # Write updated content
+        self._write_file(file_path, updated_content, branch=None, commit_message=commit_message, bucket_name=bucket_name)
+
+        return f"Successfully applied {applied_count} edit(s) to {file_path}"
+
+    def _get_file_operation_schemas(self):
+        """
+        Returns custom schemas for file operations that use bucket_name instead of branch.
+
+        This method is called by the @extend_with_file_operations decorator to get
+        toolkit-specific schemas for file operation tools.
+        """
+        # Artifact-specific schemas with bucket_name instead of branch
+        ArtifactReadFileChunkInput = create_model(
+            "ArtifactReadFileChunkInput",
+            file_path=(str, Field(description="Path to the file to read")),
+            bucket_name=(Optional[str], Field(
+                description="Bucket name. If not provided, uses toolkit-configured default bucket.",
+                default=None
+            )),
+            start_line=(int, Field(description="Starting line number (1-indexed, inclusive)", ge=1)),
+            end_line=(Optional[int], Field(
+                description="Ending line number (1-indexed, inclusive). If None, reads to end.",
+                default=None,
+                ge=1
+            )),
+        )
+
+        ArtifactReadMultipleFilesInput = create_model(
+            "ArtifactReadMultipleFilesInput",
+            file_paths=(List[str], Field(description="List of file paths to read", min_length=1)),
+            bucket_name=(Optional[str], Field(
+                description="Bucket name. If not provided, uses toolkit-configured default bucket.",
+                default=None
+            )),
+            offset=(Optional[int], Field(
+                description="Starting line number for all files (1-indexed)",
+                default=None,
+                ge=1
+            )),
+            limit=(Optional[int], Field(
+                description="Number of lines to read from offset for all files",
+                default=None,
+                ge=1
+            )),
+        )
+
+        ArtifactSearchFileInput = create_model(
+            "ArtifactSearchFileInput",
+            file_path=(str, Field(description="Path to the file to search")),
+            pattern=(str, Field(description="Search pattern. Treated as regex by default unless is_regex=False.")),
+            bucket_name=(Optional[str], Field(
+                description="Bucket name. If not provided, uses toolkit-configured default bucket.",
+                default=None
+            )),
+            is_regex=(bool, Field(
+                description="Whether pattern is a regex. Default is True for flexible matching.",
+                default=True
+            )),
+            context_lines=(int, Field(
+                description="Number of lines before/after match to include for context",
+                default=2,
+                ge=0
+            )),
+        )
+
+        ArtifactEditFileInput = create_model(
+            "ArtifactEditFileInput",
+            file_path=(str, Field(
+                description="Path to the file to edit. Must be a text file (markdown, txt, csv, json, xml, html, yaml, etc.)"
+            )),
+            file_query=(str, Field(description="""Edit instructions with OLD/NEW markers. Format:
+OLD <<<<
+old content to replace
+>>>> OLD
+NEW <<<<
+new content
+>>>> NEW
+
+Multiple OLD/NEW pairs can be provided for multiple edits.""")),
+            bucket_name=(Optional[str], Field(
+                description="Bucket name. If not provided, uses toolkit-configured default bucket.",
+                default=None
+            )),
+            commit_message=(Optional[str], Field(
+                description="Not used for artifacts (kept for API consistency)",
+                default=None
+            )),
+        )
+
+        return {
+            "read_file_chunk": ArtifactReadFileChunkInput,
+            "read_multiple_files": ArtifactReadMultipleFilesInput,
+            "search_file": ArtifactSearchFileInput,
+            "edit_file": ArtifactEditFileInput,
+        }
+
     @model_validator(mode='before')
     @classmethod
     def validate_toolkit(cls, values):
@@ -31,20 +281,46 @@ 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):
-        if filename.endswith(".xlsx"):
+        # Sanitize filename to prevent regex errors during indexing
+        sanitized_filename, was_modified = self._sanitize_filename(filename)
+        if was_modified:
+            logging.warning(f"Filename sanitized: '{filename}' -> '{sanitized_filename}'")
+        
+        # Auto-detect and extract base64 from image_url structures (from image_generation tool)
+        # Returns tuple: (processed_data, is_from_image_generation)
+        filedata, is_from_image_generation = self._extract_base64_if_needed(filedata)
+        
+        if sanitized_filename.endswith(".xlsx"):
             data = json.loads(filedata)
             filedata = self.create_xlsx_filedata(data)
 
-        result = self.artifact.create(filename, filedata, bucket_name)
+        result = self.artifact.create(sanitized_filename, filedata, bucket_name)
         
-        # Dispatch custom event for file creation
-        self._log_tool_event(
-            tool_name="file_modified",
-            message="""
-            {
+        # Skip file_modified event for images from image_generation tool
+        # These are already tracked in the tool output and don't need duplicate events
+        if not is_from_image_generation:
+            # Dispatch custom event for file creation
+            dispatch_custom_event("file_modified", {
                 "message": f"File '{filename}' created successfully",
                 "filename": filename,
                 "tool_name": "createFile",
@@ -53,9 +329,73 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                 "meta": {
                     "bucket": bucket_name or self.bucket
                 }
-            }""")
+            })
 
         return result
+    
+    @staticmethod
+    def _sanitize_filename(filename: str) -> tuple:
+        """Sanitize filename for safe storage and regex pattern matching."""
+        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 _extract_base64_if_needed(self, filedata: str) -> tuple[str | bytes, bool]:
+        """
+        Resolve cached_image_id references from cache and decode to binary data.
+        
+        Requires JSON format with cached_image_id field: {"cached_image_id": "img_xxx"}
+        LLM must extract specific cached_image_id from generate_image response.
+        
+        Returns:
+            tuple: (processed_data, is_from_image_generation)
+                - processed_data: Original filedata or resolved binary image data
+                - is_from_image_generation: True if data came from image_generation cache
+        """
+        if not filedata or not isinstance(filedata, str):
+            return filedata, False
+        
+        # Require JSON format - fail fast if not JSON
+        if '{' not in filedata:
+            return filedata, False
+        
+        try:
+            data = json.loads(filedata)
+        except json.JSONDecodeError:
+            # Not valid JSON, return as-is (regular file content)
+            return filedata, False
+        
+        if not isinstance(data, dict):
+            return filedata, False
+        
+        # Only accept direct cached_image_id format: {"cached_image_id": "img_xxx"}
+        # LLM must parse generate_image response and extract specific cached_image_id
+        if 'cached_image_id' in data:
+            binary_data = resolve_image_from_cache(self.alita, data['cached_image_id'])
+            return binary_data, True  # Mark as from image_generation
+        
+        # If JSON doesn't have cached_image_id, treat as regular file content
+        return filedata, False
 
     def create_xlsx_filedata(self, data: dict[str, list[list]]) -> bytes:
         try:
@@ -99,9 +439,112 @@ 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)
+        # Check if file exists before attempting deletion
+        # S3/MinIO delete is idempotent and won't fail for non-existing files
+        try:
+            files = self.list_files(bucket_name, return_as_string=False)
+            file_names = [f['name'] for f in files.get('rows', [])]
+            if filename not in file_names:
+                raise ToolException(f'Error (deleteFile): ENOENT: no such file or directory: \'{filename}\'')
+        except ToolException:
+            raise
+        except Exception as e:
+            raise ToolException(f'Error (deleteFile): Unable to verify file existence for \'{filename}\': {str(e)}')
+
+        result = self.artifact.delete(filename, bucket_name)
+        if result and isinstance(result, dict) and result.get('error'):
+            raise ToolException(f'Error (deleteFile): {result.get("error")} for file \'{filename}\'')
+        return f'File "{filename}" deleted successfully.'
 
     def append_data(self, filename: str, filedata: str, bucket_name = None):
         result = self.artifact.append(filename, filedata, bucket_name)
@@ -138,7 +581,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 {
@@ -160,6 +607,21 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
 
         include_extensions = kwargs.get('include_extensions', [])
         skip_extensions = kwargs.get('skip_extensions', [])
+        chunking_config = kwargs.get('chunking_config', {})
+        
+        # Auto-include extensions from chunking_config if include_extensions is specified
+        # This allows chunking config to work without manually adding extensions to include_extensions
+        if chunking_config and include_extensions:
+            for ext_pattern in chunking_config.keys():
+                # Normalize extension pattern (both ".cbl" and "*.cbl" should work)
+                normalized = ext_pattern if ext_pattern.startswith('*') else f'*{ext_pattern}'
+                if normalized not in include_extensions:
+                    include_extensions.append(normalized)
+                    self._log_tool_event(
+                        message=f"Auto-included extension '{normalized}' from chunking_config",
+                        tool_name="loader"
+                    )
+        
         self._log_tool_event(message=f"Files filtering started. Include extensions: {include_extensions}. "
                                      f"Skip extensions: {skip_extensions}", tool_name="loader")
         # show the progress of filtering
@@ -173,13 +635,13 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
             file_name = file['name']
 
             # Check if file should be skipped based on skip_extensions
-            if any(re.match(pattern.replace('*', '.*') + '$', file_name, re.IGNORECASE)
+            if any(re.match(re.escape(pattern).replace(r'\*', '.*') + '$', file_name, re.IGNORECASE)
                    for pattern in skip_extensions):
                 continue
 
             # Check if file should be included based on include_extensions
             # If include_extensions is empty, process all files (that weren't skipped)
-            if include_extensions and not (any(re.match(pattern.replace('*', '.*') + '$', file_name, re.IGNORECASE)
+            if include_extensions and not (any(re.match(re.escape(pattern).replace(r'\*', '.*') + '$', file_name, re.IGNORECASE)
                                                for pattern in include_extensions)):
                 continue
 
@@ -207,14 +669,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",
@@ -229,15 +694,19 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                     "createFile", 
                     filename=(str, Field(description="Filename")),
                     filedata=(str, Field(description="""Stringified content of the file.
-                    Example for .xlsx filedata format:
-                    {
-                        "Sheet1":[
-                            ["Name", "Age", "City"],
-                            ["Alice", 25, "New York"],
-                            ["Bob", 30, "San Francisco"],
-                            ["Charlie", 35, "Los Angeles"]
-                        ]
-                    }
+                    
+                    Supports three input formats:
+                    
+                    1. CACHED IMAGE REFERENCE (for generated/cached images):
+                       Pass JSON with cached_image_id field: {"cached_image_id": "img_xxx"}
+                       The tool will automatically resolve and decode the image from cache.
+                       This is typically used when another tool returns an image reference.
+                    
+                    2. EXCEL FILES (.xlsx extension):
+                       Pass JSON with sheet structure: {"Sheet1": [["Name", "Age"], ["Alice", 25], ["Bob", 30]]}
+                    
+                    3. TEXT/OTHER FILES:
+                       Pass the plain text string directly.
                     """)),
                     bucket_name=bucket_name
                 )
@@ -299,11 +768,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