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

alita_sdk/runtime/tools/artifact.py

@@ -1,23 +1,33 @@
+import base64
 import hashlib
+import io
 import json
 import logging
+import re
 from typing import Any, Optional, Generator, List
 
+from langchain_core.callbacks import dispatch_custom_event
 from langchain_core.documents import Document
 from langchain_core.tools import ToolException
+from openpyxl.workbook.workbook import Workbook
 from pydantic import create_model, Field, model_validator
 
-from alita_sdk.tools.elitea_base import BaseVectorStoreToolApiWrapper, extend_with_vector_tools
+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, resolve_image_from_cache
 
-try:
-    from alita_sdk.runtime.langchain.interfaces.llm_processor import get_embeddings
-except ImportError:
-    from alita_sdk.langchain.interfaces.llm_processor import get_embeddings
 
-class ArtifactWrapper(BaseVectorStoreToolApiWrapper):
+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):
@@ -26,13 +36,152 @@ class ArtifactWrapper(BaseVectorStoreToolApiWrapper):
         if not values.get('bucket'):
             raise ValueError("Bucket is required.")
         values["artifact"] = values['alita'].artifact(values['bucket'])
-        return values
+        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):
-        return self.artifact.create(filename, filedata, bucket_name)
+        # 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(sanitized_filename, filedata, bucket_name)
+        
+        # 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",
+                "toolkit": "artifact",
+                "operation_type": "create",
+                "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:
+            workbook = Workbook()
+
+            first_sheet = True
+            for sheet_name, sheet_data in data.items():
+                if first_sheet:
+                    sheet = workbook.active
+                    sheet.title = sheet_name
+                    first_sheet = False
+                else:
+                    sheet = workbook.create_sheet(title=sheet_name)
+
+                for row in sheet_data:
+                    sheet.append(row)
+
+            file_buffer = io.BytesIO()
+            workbook.save(file_buffer)
+            file_buffer.seek(0)
+
+            return file_buffer.read()
+
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON format for .xlsx file data.")
+        except Exception as e:
+            raise ValueError(f"Error processing .xlsx file data: {e}")
+
 
     def read_file(self,
                   filename: str,
@@ -48,31 +197,187 @@ class ArtifactWrapper(BaseVectorStoreToolApiWrapper):
                                   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)
 
     def append_data(self, filename: str, filedata: str, bucket_name = None):
-        return self.artifact.append(filename, filedata, bucket_name)
+        result = self.artifact.append(filename, filedata, bucket_name)
+        
+        # Dispatch custom event for file append
+        dispatch_custom_event("file_modified", {
+            "message": f"Data appended to file '{filename}' successfully",
+            "filename": filename,
+            "tool_name": "appendData",
+            "toolkit": "artifact",
+            "operation_type": "modify",
+            "meta": {
+                "bucket": bucket_name or self.bucket
+            }
+        })
+        
+        return result
 
     def overwrite_data(self, filename: str, filedata: str, bucket_name = None):
-        return self.artifact.overwrite(filename, filedata, bucket_name)
+        result = self.artifact.overwrite(filename, filedata, bucket_name)
+        
+        # Dispatch custom event for file overwrite
+        dispatch_custom_event("file_modified", {
+            "message": f"File '{filename}' overwritten successfully",
+            "filename": filename,
+            "tool_name": "overwriteData",
+            "toolkit": "artifact",
+            "operation_type": "modify",
+            "meta": {
+                "bucket": bucket_name or self.bucket
+            }
+        })
+        
+        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 {
+            'include_extensions': (Optional[List[str]], Field(
+                description="List of file extensions to include when processing: i.e. ['*.png', '*.jpg']. "
+                            "If empty, all files will be processed (except skip_extensions).",
+                default=[])),
+            'skip_extensions': (Optional[List[str]], Field(
+                description="List of file extensions to skip when processing: i.e. ['*.png', '*.jpg']",
+                default=[])),
+        }
 
     def _base_loader(self, **kwargs) -> Generator[Document, None, None]:
+        self._log_tool_event(message=f"Loading the files from artifact's bucket. {kwargs=}", tool_name="loader")
         try:
-            all_files = self.list_files(self.bucket, False)
+            all_files = self.list_files(self.bucket, False)['rows']
         except Exception as e:
             raise ToolException(f"Unable to extract files: {e}")
 
-        for file in all_files['rows']:
+        include_extensions = kwargs.get('include_extensions', [])
+        skip_extensions = kwargs.get('skip_extensions', [])
+        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
+        total_files = len(all_files) if isinstance(all_files, list) else 0
+        filtered_files_count = 0
+        for file in all_files:
+            filtered_files_count += 1
+            if filtered_files_count % 10 == 0 or filtered_files_count == total_files:
+                self._log_tool_event(message=f"Files filtering progress: {filtered_files_count}/{total_files}",
+                                     tool_name="loader")
+            file_name = file['name']
+
+            # Check if file should be skipped based on skip_extensions
+            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(re.escape(pattern).replace(r'\*', '.*') + '$', file_name, re.IGNORECASE)
+                                               for pattern in include_extensions)):
+                continue
+
             metadata = {
                 ("updated_on" if k == "modified" else k): str(v)
                 for k, v in file.items()
             }
-            metadata['id'] = self.get_hash_from_bucket_and_file_name(self.bucket, file['name'])
+            metadata['id'] = self.get_hash_from_bucket_and_file_name(self.bucket, file_name)
             yield Document(page_content="", metadata=metadata)
 
     def get_hash_from_bucket_and_file_name(self, bucket, file_name):
@@ -81,27 +386,28 @@ class ArtifactWrapper(BaseVectorStoreToolApiWrapper):
         hasher.update(file_name.encode('utf-8'))
         return hasher.hexdigest()
 
-    def _process_document(self, document: Document) -> Generator[Document, None, None]:
-        try:
-            page_content = self.read_file(document.metadata['name'], is_capture_image=True, excel_by_sheets=True)
-        except Exception as e:
-            logging.error(f"Failed while parsing the file 'document.metadata['Path']': {e}")
-        if isinstance(page_content, dict):
-            for key, value in page_content.items():
-                metadata = document.metadata
-                metadata['page'] = key
-                yield Document(page_content=str(value), metadata=metadata)
-        else:
-            document.page_content = json.dumps(str(page_content))
-
-    @extend_with_vector_tools
+    def _extend_data(self, documents: Generator[Document, None, None]):
+        for document in documents:
+            try:
+                page_content = self.artifact.get_content_bytes(artifact_name=document.metadata['name'])
+                document.metadata[IndexerKeywords.CONTENT_IN_BYTES.value] = page_content
+                document.metadata[IndexerKeywords.CONTENT_FILE_NAME.value] = document.metadata['name']
+                yield document
+            except Exception as e:
+                logging.error(f"Failed while parsing the file '{document.metadata['name']}': {e}")
+                yield document
+
+    @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",
@@ -115,7 +421,21 @@ class ArtifactWrapper(BaseVectorStoreToolApiWrapper):
                 "args_schema": create_model(
                     "createFile", 
                     filename=(str, Field(description="Filename")),
-                    filedata=(str, Field(description="Stringified content of the file")),
+                    filedata=(str, Field(description="""Stringified content of the file.
+                    
+                    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
                 )
             },
@@ -176,11 +496,25 @@ class ArtifactWrapper(BaseVectorStoreToolApiWrapper):
                 "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/data_analysis.py

@@ -0,0 +1,183 @@
+"""
+Data Analysis internal tool for Alita SDK.
+
+This tool provides Pandas-based data analysis capabilities as an internal tool,
+accessible through the "Enable internal tools" dropdown menu.
+
+It uses the conversation attachment bucket for file storage, providing seamless
+integration with drag-and-drop file uploads in chat.
+"""
+import logging
+from typing import Any, List, Literal, Optional, Type
+
+from langchain_core.tools import BaseTool, BaseToolkit
+from pydantic import BaseModel, ConfigDict, create_model, Field
+
+logger = logging.getLogger(__name__)
+
+name = "data_analysis"
+
+
+def get_tools(tools_list: list, alita_client=None, llm=None, memory_store=None):
+    """
+    Get data analysis tools for the provided tool configurations.
+
+    Args:
+        tools_list: List of tool configurations
+        alita_client: Alita client instance (required for data analysis)
+        llm: LLM client instance (required for code generation)
+        memory_store: Optional memory store instance (unused)
+
+    Returns:
+        List of data analysis tools
+    """
+    all_tools = []
+
+    for tool in tools_list:
+        if (tool.get('type') == 'data_analysis' or
+                tool.get('toolkit_name') == 'data_analysis'):
+            try:
+                if not alita_client:
+                    logger.error("Alita client is required for data analysis tools")
+                    continue
+
+                settings = tool.get('settings', {})
+                bucket_name = settings.get('bucket_name')
+
+                if not bucket_name:
+                    logger.error("bucket_name is required for data analysis tools")
+                    continue
+
+                toolkit_instance = DataAnalysisToolkit.get_toolkit(
+                    alita_client=alita_client,
+                    llm=llm,
+                    bucket_name=bucket_name,
+                    toolkit_name=tool.get('toolkit_name', '')
+                )
+                all_tools.extend(toolkit_instance.get_tools())
+            except Exception as e:
+                logger.error(f"Error in data analysis toolkit get_tools: {e}")
+                logger.error(f"Tool config: {tool}")
+                raise
+
+    return all_tools
+
+
+class DataAnalysisToolkit(BaseToolkit):
+    """
+    Data Analysis toolkit providing Pandas-based data analysis capabilities.
+
+    This is an internal tool that uses the conversation attachment bucket
+    for file storage, enabling seamless integration with chat file uploads.
+    """
+    tools: List[BaseTool] = []
+
+    @staticmethod
+    def toolkit_config_schema() -> Type[BaseModel]:
+        """Get the configuration schema for the data analysis toolkit."""
+        # Import PandasWrapper to get available tools schema
+        from alita_sdk.tools.pandas.api_wrapper import PandasWrapper
+
+        selected_tools = {
+            x['name']: x['args_schema'].model_json_schema()
+            for x in PandasWrapper.model_construct().get_available_tools()
+        }
+
+        return create_model(
+            'data_analysis',
+            bucket_name=(
+                Optional[str],
+                Field(
+                    default=None,
+                    title="Bucket name",
+                    description="Bucket where files are stored (auto-injected from conversation)"
+                )
+            ),
+            selected_tools=(
+                List[Literal[tuple(selected_tools)]],
+                Field(
+                    default=[],
+                    json_schema_extra={'args_schemas': selected_tools}
+                )
+            ),
+            __config__=ConfigDict(json_schema_extra={
+                'metadata': {
+                    "label": "Data Analysis",
+                    "icon_url": "data-analysis.svg",
+                    "hidden": True,  # Hidden from regular toolkit menu
+                    "categories": ["internal_tool"],
+                    "extra_categories": ["data analysis", "pandas", "dataframes", "data science"],
+                }
+            })
+        )
+
+    @classmethod
+    def get_toolkit(
+        cls,
+        alita_client=None,
+        llm=None,
+        bucket_name: str = None,
+        toolkit_name: Optional[str] = None,
+        selected_tools: Optional[List[str]] = None,
+        **kwargs
+    ):
+        """
+        Get toolkit with data analysis tools.
+
+        Args:
+            alita_client: Alita client instance (required)
+            llm: LLM for code generation (optional, uses alita_client.llm if not provided)
+            bucket_name: Conversation attachment bucket (required)
+            toolkit_name: Optional name prefix for tools
+            selected_tools: Optional list of tool names to include (default: all)
+            **kwargs: Additional arguments
+
+        Returns:
+            DataAnalysisToolkit instance with configured tools
+
+        Raises:
+            ValueError: If alita_client or bucket_name is not provided
+        """
+        if not alita_client:
+            raise ValueError("Alita client is required for data analysis")
+
+        if not bucket_name:
+            raise ValueError("bucket_name is required for data analysis (should be conversation attachment bucket)")
+
+        # Import the PandasWrapper from existing toolkit
+        from alita_sdk.tools.pandas.api_wrapper import PandasWrapper
+        from alita_sdk.tools.base.tool import BaseAction
+
+        # Create wrapper with conversation bucket
+        wrapper = PandasWrapper(
+            alita=alita_client,
+            llm=llm,
+            bucket_name=bucket_name
+        )
+
+        # Get tools from wrapper
+        available_tools = wrapper.get_available_tools()
+        tools = []
+
+        for tool in available_tools:
+            # Filter by selected_tools if provided
+            if selected_tools and tool["name"] not in selected_tools:
+                continue
+
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
+
+            tools.append(BaseAction(
+                api_wrapper=wrapper,
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": name} if toolkit_name else {}
+            ))
+
+        return cls(tools=tools)
+
+    def get_tools(self):
+        return self.tools