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

alita_sdk/tools/advanced_jira_mining/__init__.py

@@ -6,7 +6,7 @@ from pydantic import create_model, BaseModel, Field, SecretStr
 from .data_mining_wrapper import AdvancedJiraMiningWrapper
 from ..base.tool import BaseAction
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 
 name = "advanced_jira_mining"
 
@@ -28,15 +28,13 @@ def get_tools(tool):
 
 class AdvancedJiraMiningToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AdvancedJiraMiningWrapper.model_construct().get_available_tools()}
-        AdvancedJiraMiningToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            jira_base_url=(str, Field(default="", title="Jira URL", description="Jira URL", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AdvancedJiraMiningToolkit.toolkit_max_length})),
+            jira_base_url=(str, Field(default="", title="Jira URL", description="Jira URL", json_schema_extra={'toolkit_name': True})),
             confluence_base_url=(str, Field(default="", title="Confluence URL", description="Confluence URL")),
             model_type=(str, Field(default="", title="Model type", description="Model type")),
             summarization_prompt=(Optional[str], Field(default=None, title="Summarization prompt", description="Summarization prompt")),
@@ -66,17 +64,21 @@ class AdvancedJiraMiningToolkit(BaseToolkit):
             selected_tools = []
         jira_mining_wrapper = AdvancedJiraMiningWrapper(**kwargs)
         available_tools = jira_mining_wrapper.get_available_tools()
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if 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=jira_mining_wrapper,
-                name=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/tools/aws/delta_lake/__init__.py

@@ -6,7 +6,7 @@ from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import BaseModel, Field, computed_field, field_validator
 
 from alita_sdk.configurations.delta_lake import DeltaLakeConfiguration
-from ...utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length
+from ...utils import clean_string, get_max_toolkit_length
 from .api_wrapper import DeltaLakeApiWrapper
 from .tool import DeltaLakeAction
 
@@ -21,10 +21,6 @@ def get_available_tools() -> dict[str, dict]:
     }
     return available_tools
 
-toolkit_max_length = lru_cache(maxsize=1)(
-    lambda: get_max_toolkit_length(get_available_tools())
-)
-
 class DeltaLakeToolkitConfig(BaseModel):
     class Config:
         title = name
@@ -87,9 +83,10 @@ class DeltaLakeToolkit(BaseToolkit):
 
     @computed_field
     @property
-    def tool_prefix(self) -> str:
+    def toolkit_context(self) -> str:
+        """Returns toolkit context for descriptions (max 1000 chars)."""
         return (
-            clean_string(self.toolkit_name, toolkit_max_length()) + TOOLKIT_SPLITTER
+            f" [Toolkit: {clean_string(self.toolkit_name, 0)}]"
             if self.toolkit_name
             else ""
         )
@@ -118,12 +115,18 @@ class DeltaLakeToolkit(BaseToolkit):
             selected_tools = set(selected_tools)
             for t in instance.available_tools:
                 if t["name"] in selected_tools:
+                    description = t["description"]
+                    if toolkit_name:
+                        description = f"Toolkit: {toolkit_name}\n{description}"
+                    description = f"S3 Path: {getattr(instance.api_wrapper, 's3_path', '')} Table Path: {getattr(instance.api_wrapper, 'table_path', '')}\n{description}"
+                    description = description[:1000]
                     instance.tools.append(
                         DeltaLakeAction(
                             api_wrapper=instance.api_wrapper,
-                            name=instance.tool_prefix + t["name"],
-                            description=f"S3 Path: {getattr(instance.api_wrapper, 's3_path', '')} Table Path: {getattr(instance.api_wrapper, 'table_path', '')}\n" + t["description"],
+                            name=t["name"],
+                            description=description,
                             args_schema=t["args_schema"],
+                            metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
                         )
                     )
         return instance

alita_sdk/tools/aws/delta_lake/tool.py

@@ -29,7 +29,11 @@ class DeltaLakeAction(BaseTool):
     ) -> str:
         """Use the Delta Lake API to run an operation."""
         try:
+            # Strip numeric suffix added for deduplication (_2, _3, etc.)
+            # to get the original tool name that exists in the wrapper
+            import re
+            tool_name = re.sub(r'_\d+$', '', self.name)
             # Use the tool name to dispatch to the correct API wrapper method
-            return self.api_wrapper.run(self.name, *args, **kwargs)
+            return self.api_wrapper.run(tool_name, *args, **kwargs)
         except Exception as e:
             return f"Error: {format_exc()}"

alita_sdk/tools/azure_ai/search/__init__.py

@@ -6,7 +6,7 @@ from langchain_core.tools import BaseToolkit, BaseTool
 from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from ...elitea_base import filter_missconfigured_index_tools
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import clean_string, get_max_toolkit_length, check_connection_response
 from ....configurations.azure_search import AzureSearchConfiguration
 import requests
 
@@ -31,12 +31,10 @@ def get_toolkit():
 
 class AzureSearchToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AzureSearchApiWrapper.model_construct().get_available_tools()}
-        AzureSearchToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
             index_name=(str, Field(description="Azure Search index name")),
@@ -79,17 +77,21 @@ class AzureSearchToolkit(BaseToolkit):
         }
         azure_search_api_wrapper = AzureSearchApiWrapper(**wrapper_payload)
         available_tools = azure_search_api_wrapper.get_available_tools()
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if 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=azure_search_api_wrapper,
-                name=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/tools/base/tool.py

@@ -23,6 +23,10 @@ class BaseAction(BaseTool):
     ) -> ToolException | str:
         """Use the Confluence API to run an operation."""
         try:
-            return self.api_wrapper.run(self.name, *args, **kwargs)
+            # Strip numeric suffix added for deduplication (_2, _3, etc.)
+            # to get the original tool name that exists in the wrapper
+            import re
+            tool_name = re.sub(r'_\d+$', '', self.name)
+            return self.api_wrapper.run(tool_name, *args, **kwargs)
         except Exception as e:
             return ToolException(f"An exception occurred: {e}")

alita_sdk/tools/base_indexer_toolkit.py

@@ -386,7 +386,8 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
 
     def remove_index(self, index_name: str = ""):
         """Cleans the indexed data in the collection."""
-        super()._clean_collection(index_name=index_name)
+        super()._clean_collection(index_name=index_name, including_index_meta=True)
+        self._emit_index_data_removed_event(index_name)
         return (f"Collection '{index_name}' has been removed from the vector store.\n"
                 f"Available collections: {self.list_collections()}") if index_name \
             else "All collections have been removed from the vector store." 
@@ -641,6 +642,30 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
         except Exception as e:
             logger.warning(f"Failed to emit index_data_status event: {e}")
 
+    def _emit_index_data_removed_event(self, index_name: str):
+        """
+        Emit custom event for index data removing.
+
+        Args:
+            index_name: The name of the index
+            toolkit_id: The toolkit identifier
+        """
+        # Build event message
+        event_data = {
+            "index_name": index_name,
+            "toolkit_id": self.toolkit_id,
+            "project_id": self.alita.project_id,
+        }
+        # Emit the event
+        try:
+            dispatch_custom_event("index_data_removed", event_data)
+            logger.debug(
+                f"Emitted index_data_removed event for index "
+                f"'{index_name}': {event_data}"
+            )
+        except Exception as e:
+            logger.warning(f"Failed to emit index_data_removed event: {e}")
+
     def get_available_tools(self):
         """
         Returns the standardized vector search tools (search operations only).

alita_sdk/tools/bitbucket/__init__.py

@@ -9,7 +9,7 @@ from pydantic import BaseModel, Field, ConfigDict, create_model
 
 from ..base.tool import BaseAction
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from ...configurations.bitbucket import BitbucketConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 import requests
@@ -18,7 +18,7 @@ import requests
 name = "bitbucket"
 
 
-def get_tools(tool):
+def get_toolkit(tool):
     return AlitaBitbucketToolkit.get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
         project=tool['settings']['project'],
@@ -33,18 +33,19 @@ def get_tools(tool):
         doctype='code',
         embedding_model=tool['settings'].get('embedding_model'),
         toolkit_name=tool.get('toolkit_name')
-    ).get_tools()
+    )
+
+def get_tools(tool):
+    return get_toolkit(tool).get_tools()
 
 
 class AlitaBitbucketToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in
                           BitbucketAPIWrapper.model_construct().get_available_tools()}
-        AlitaBitbucketToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
             project=(str, Field(description="Project/Workspace")),
@@ -61,7 +62,6 @@ class AlitaBitbucketToolkit(BaseToolkit):
                 'metadata':
                     {
                         "label": "Bitbucket", "icon_url": "bitbucket-icon.svg",
-                        "max_length": AlitaBitbucketToolkit.toolkit_max_length,
                         "categories": ["code repositories"],
                         "extra_categories": ["bitbucket", "git", "repository", "code", "version control"],
                     }
@@ -100,17 +100,21 @@ class AlitaBitbucketToolkit(BaseToolkit):
         }
         bitbucket_api_wrapper = BitbucketAPIWrapper(**wrapper_payload)
         available_tools: List[Dict] = bitbucket_api_wrapper.get_available_tools()
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool['name'] not in selected_tools:
                     continue
+            description = tool["description"] + f"\nrepo: {bitbucket_api_wrapper.repository}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=bitbucket_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + f"\nrepo: {bitbucket_api_wrapper.repository}",
-                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/tools/bitbucket/api_wrapper.py

@@ -13,6 +13,7 @@ from pydantic.fields import PrivateAttr
 
 from ..code_indexer_toolkit import CodeIndexerToolkit
 from ..utils.available_tools_decorator import extend_with_parent_available_tools
+from ..elitea_base import extend_with_file_operations, BaseCodeToolApiWrapper
 
 logger = logging.getLogger(__name__)
 
@@ -123,6 +124,12 @@ class BitbucketAPIWrapper(CodeIndexerToolkit):
 
     _bitbucket: Any = PrivateAttr()
     _active_branch: Any = PrivateAttr()
+    
+    # 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
     url: str = ''
     project: str = ''
     """The key of the project this repo belongs to"""
@@ -360,12 +367,15 @@ class BitbucketAPIWrapper(CodeIndexerToolkit):
     #     except Exception as e:
     #         raise ToolException(f"Can't extract file commit hash (`{file_path}`) due to error:\n{str(e)}")
 
-    def _read_file(self, file_path: str, branch: str) -> str:
+    def _read_file(self, file_path: str, branch: str, **kwargs) -> str:
         """
-        Reads a file from the gitlab repo
+        Reads a file from the bitbucket repo with optional partial read support.
+        
         Parameters:
             file_path(str): the file path
             branch(str): branch name (by default: active_branch)
+            **kwargs: Additional parameters (offset, limit, head, tail) - currently ignored,
+                     partial read handled client-side by base class methods
         Returns:
             str: The file decoded as a string
         """
@@ -399,8 +409,46 @@ class BitbucketAPIWrapper(CodeIndexerToolkit):
             return self._read_file(file_path, branch)
         except Exception as e:
             return f"Failed to read file {file_path}: {str(e)}"
+    
+    def _write_file(
+        self,
+        file_path: str,
+        content: str,
+        branch: str = None,
+        commit_message: str = None
+    ) -> str:
+        """
+        Write content to a file (create or update).
+        
+        Parameters:
+            file_path: Path to the file
+            content: New file content
+            branch: Branch name (uses active branch if None)
+            commit_message: Commit message (not used by Bitbucket API)
+            
+        Returns:
+            Success message
+        """
+        try:
+            branch = branch or self._active_branch
+            
+            # Check if file exists by attempting to read it
+            try:
+                self._read_file(file_path, branch)
+                # File exists, update it using OLD/NEW format
+                old_content = self._read_file(file_path, branch)
+                update_query = f"OLD <<<<\n{old_content}\n>>>> OLD\nNEW <<<<\n{content}\n>>>> NEW"
+                self._bitbucket.update_file(file_path=file_path, update_query=update_query, branch=branch)
+                return f"Updated file {file_path}"
+            except:
+                # File doesn't exist, create it
+                self._bitbucket.create_file(file_path=file_path, file_contents=content, branch=branch)
+                return f"Created file {file_path}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
     @extend_with_parent_available_tools
+    @extend_with_file_operations
     def get_available_tools(self):
         return [
             {

alita_sdk/tools/browser/__init__.py

@@ -8,7 +8,7 @@ from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
 from .google_search_rag import GoogleSearchResults
 from .crawler import SingleURLCrawler, MultiURLCrawler, GetHTMLContent, GetPDFContent
 from .wiki import WikipediaQueryRun
-from ..utils import get_max_toolkit_length, clean_string, TOOLKIT_SPLITTER
+from ..utils import get_max_toolkit_length, clean_string
 from ...configurations.browser import BrowserConfiguration
 from logging import getLogger
 
@@ -42,7 +42,6 @@ class BrowserToolkit(BaseToolkit):
             'google': GoogleSearchResults.__pydantic_fields__['args_schema'].default.schema(),
             'wiki': WikipediaQueryRun.__pydantic_fields__['args_schema'].default.schema()
         }
-        BrowserToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
 
         def validate_google_fields(cls, values):
             if 'google' in values.get('selected_tools', []):
@@ -90,7 +89,6 @@ class BrowserToolkit(BaseToolkit):
         }
 
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         if not selected_tools:
             selected_tools = [
                 'single_url_crawler',
@@ -127,7 +125,10 @@ class BrowserToolkit(BaseToolkit):
 
             # Only add the tool if it was successfully created
             if tool_entry is not None:
-                tool_entry.name = f"{prefix}{tool_entry.name}"
+                if toolkit_name:
+                    tool_entry.description = f"{tool_entry.description}\nToolkit: {toolkit_name}"
+                    tool_entry.description = tool_entry.description[:1000]
+                    tool_entry.metadata = {"toolkit_name": toolkit_name}
                 tools.append(tool_entry)
         return cls(tools=tools)
 

alita_sdk/tools/carrier/__init__.py

@@ -7,7 +7,7 @@ from functools import lru_cache
 from .api_wrapper import CarrierAPIWrapper
 from .tools import __all__
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.carrier import CarrierConfiguration
 
 logger = logging.getLogger(__name__)
@@ -17,7 +17,6 @@ name = 'carrier'
 
 class AlitaCarrierToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 100
 
     @classmethod
     @lru_cache(maxsize=32)
@@ -26,7 +25,6 @@ class AlitaCarrierToolkit(BaseToolkit):
         for t in __all__:
             default = t['tool'].__pydantic_fields__['args_schema'].default
             selected_tools[t['name']] = default.schema() if default else default
-        cls.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             project_id=(Optional[str], Field(None, description="Optional project ID for scoped operations")),
@@ -70,15 +68,16 @@ class AlitaCarrierToolkit(BaseToolkit):
             logger.exception(f"[AlitaCarrierToolkit] Error initializing CarrierAPIWrapper: {e}")
             raise ValueError(f"CarrierAPIWrapper initialization error: {e}")
 
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
-
         tools = []
         for tool_def in __all__:
             if selected_tools and tool_def['name'] not in selected_tools:
                 continue
             try:
                 tool_instance = tool_def['tool'](api_wrapper=carrier_api_wrapper)
-                tool_instance.name = prefix + tool_instance.name
+                if toolkit_name:
+                    tool_instance.description = f"{tool_instance.description}\nToolkit: {toolkit_name}"
+                    tool_instance.description = tool_instance.description[:1000]
+                    tool_instance.metadata = {"toolkit_name": toolkit_name}
                 tools.append(tool_instance)
                 logger.info(f"[AlitaCarrierToolkit] Successfully initialized tool '{tool_instance.name}'")
             except Exception as e:

alita_sdk/tools/chunkers/sematic/json_chunker.py

@@ -17,6 +17,7 @@ def json_chunker(file_content_generator: Generator[Document, None, None], config
             for chunk in chunks:
                 metadata = doc.metadata.copy()
                 metadata['chunk_id'] = chunk_id
+                metadata['method_name'] = 'json'
                 chunk_id += 1
                 yield Document(page_content=json.dumps(chunk), metadata=metadata)
         except Exception as e:

alita_sdk/tools/chunkers/sematic/markdown_chunker.py

@@ -60,6 +60,7 @@ def markdown_chunker(file_content_generator: Generator[Document, None, None], co
                     docmeta.update({"headers": "; ".join(headers_meta)})
                     docmeta['chunk_id'] = chunk_id
                     docmeta['chunk_type'] = "document"
+                    docmeta['method_name'] = 'markdown'
                     yield Document(
                         page_content=subchunk,
                         metadata=docmeta
@@ -71,6 +72,7 @@ def markdown_chunker(file_content_generator: Generator[Document, None, None], co
                 docmeta.update({"headers": "; ".join(headers_meta)})
                 docmeta['chunk_id'] = chunk_id
                 docmeta['chunk_type'] = "document"
+                docmeta['method_name'] = 'text'
                 yield Document(
                     page_content=chunk.page_content,
                     metadata=docmeta

alita_sdk/tools/chunkers/universal_chunker.py

@@ -86,6 +86,7 @@ def _default_text_chunker(
         for idx, chunk in enumerate(chunks, 1):
             chunk.metadata['chunk_id'] = idx
             chunk.metadata['chunk_type'] = 'text'
+            chunk.metadata['method_name'] = 'text'
             yield chunk
 
 

alita_sdk/tools/cloud/aws/__init__.py

@@ -6,7 +6,7 @@ from langchain_core.tools import BaseToolkit, BaseTool
 from .api_wrapper import AWSToolConfig
 from ...base.tool import BaseAction
 from ...elitea_base import filter_missconfigured_index_tools
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...utils import clean_string, get_max_toolkit_length
 
 name = "aws"
 
@@ -22,12 +22,10 @@ def get_tools(tool):
 
 class AWSToolkit(BaseToolkit):
     tools: list[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AWSToolConfig.model_construct().get_available_tools()}
-        AWSToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             region=(str, Field(default="", title="Region", description="AWS region")),
@@ -54,15 +52,19 @@ class AWSToolkit(BaseToolkit):
         aws_tool_config = AWSToolConfig(**kwargs)
         available_tools = aws_tool_config.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             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=aws_tool_config,
-                name=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/tools/cloud/azure/__init__.py

@@ -6,7 +6,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 from .api_wrapper import AzureApiWrapper
 from ...base.tool import BaseAction
 from ...elitea_base import filter_missconfigured_index_tools
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...utils import clean_string, get_max_toolkit_length
 
 name = "azure"
 
@@ -23,12 +23,10 @@ def get_tools(tool):
 
 class AzureToolkit(BaseToolkit):
     tools: list[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AzureApiWrapper.model_construct().get_available_tools()}
-        AzureToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             subscription_id=(str, Field(default="", title="Subscription ID", description="Azure subscription ID")),
@@ -47,15 +45,19 @@ class AzureToolkit(BaseToolkit):
         azure_api_wrapper = AzureApiWrapper(**kwargs)
         available_tools = azure_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             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=azure_api_wrapper,
-                name=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/tools/cloud/gcp/__init__.py

@@ -6,7 +6,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 from .api_wrapper import GCPApiWrapper
 from ...base.tool import BaseAction
 from ...elitea_base import filter_missconfigured_index_tools
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...utils import clean_string, get_max_toolkit_length
 
 name = "gcp"
 
@@ -20,12 +20,10 @@ def get_tools(tool):
 
 class GCPToolkit(BaseToolkit):
     tools: list[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in GCPApiWrapper.model_construct().get_available_tools()}
-        GCPToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             api_key=(SecretStr, Field(default="", title="API key", description="GCP API key", json_schema_extra={'secret': True})),
@@ -41,15 +39,19 @@ class GCPToolkit(BaseToolkit):
         gcp_api_wrapper = GCPApiWrapper(**kwargs)
         available_tools = gcp_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             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=gcp_api_wrapper,
-                name=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)