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

alita_sdk/tools/salesforce/__init__.py

@@ -5,7 +5,7 @@ from ..base.tool import BaseAction
 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
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.salesforce import SalesforceConfiguration
 
 name = "salesforce"
@@ -19,11 +19,9 @@ def get_tools(tool):
 
 class SalesforceToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         available_tools = {x['name']: x['args_schema'].schema() for x in SalesforceApiWrapper.model_construct().get_available_tools()}
-        SalesforceToolkit.toolkit_max_length = get_max_toolkit_length(available_tools)
         return create_model(
             name,
             api_version=(str, Field(description="Salesforce API Version", default='v59.0')),
@@ -31,7 +29,6 @@ class SalesforceToolkit(BaseToolkit):
             selected_tools=(List[Literal[tuple(available_tools)]], Field(default=[], json_schema_extra={'args_schemas': available_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {
                 "label": "Salesforce", "icon_url": "salesforce-icon.svg",
-                "max_length": SalesforceToolkit.toolkit_max_length,
                 "categories": ["other"],
                 "extra_categories": ["customer relationship management", "cloud computing", "marketing automation", "salesforce"]
                                                                   }})
@@ -48,18 +45,21 @@ class SalesforceToolkit(BaseToolkit):
             **kwargs.get('salesforce_configuration', {}),
         }
         api_wrapper = SalesforceApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         tools = []
 
         for tool in api_wrapper.get_available_tools():
             if selected_tools and tool["name"] not in selected_tools:
                 continue
-
+            description = f"Salesforce Tool: {tool['description']}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=api_wrapper,
-                name=prefix + tool["name"],
-                description=f"Salesforce Tool: {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/servicenow/__init__.py

@@ -7,7 +7,7 @@ from ..base.tool import BaseAction
 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
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.service_now import ServiceNowConfiguration
 
 
@@ -26,13 +26,11 @@ def get_tools(tool):
 
 class ServiceNowToolkit(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
                           ServiceNowAPIWrapper.model_construct().get_available_tools()}
-        ServiceNowToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             name=(str, Field(description="Toolkit name")),
@@ -47,7 +45,6 @@ class ServiceNowToolkit(BaseToolkit):
                 'metadata': {
                     "label": "ServiceNow",
                     "icon_url": "service-now.svg",
-                    "max_length": ServiceNowToolkit.toolkit_max_length,
                     "hidden": False,
                     "sections": {
                         "auth": {
@@ -79,18 +76,23 @@ class ServiceNowToolkit(BaseToolkit):
             **kwargs['servicenow_configuration'],
         }
         servicenow_api_wrapper = ServiceNowAPIWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = servicenow_api_wrapper.get_available_tools()
         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 = f"ServiceNow: {servicenow_api_wrapper.base_url}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=servicenow_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"ServiceNow: {servicenow_api_wrapper.base_url} " + 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/sharepoint/__init__.py

@@ -5,7 +5,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 from .api_wrapper import SharepointApiWrapper
 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
 from ...configurations.pgvector import PgVectorConfiguration
 from ...configurations.sharepoint import SharepointConfiguration
 
@@ -29,12 +29,10 @@ def get_tools(tool):
 
 class SharepointToolkit(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 SharepointApiWrapper.model_construct().get_available_tools()}
-        SharepointToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             sharepoint_configuration=(SharepointConfiguration, Field(description="SharePoint Configuration", json_schema_extra={'configuration_types': ['sharepoint']})),
@@ -48,7 +46,6 @@ class SharepointToolkit(BaseToolkit):
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {
                     "label": "Sharepoint", "icon_url": "sharepoint.svg",
-                    "max_length": SharepointToolkit.toolkit_max_length,
                     "categories": ["office"],
                     "extra_categories": ["microsoft", "cloud storage", "team collaboration", "content management"]
         }})
@@ -65,18 +62,22 @@ class SharepointToolkit(BaseToolkit):
             **(kwargs.get('pgvector_configuration') or {}),
         }
         sharepoint_api_wrapper = SharepointApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = sharepoint_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = f"Sharepoint {sharepoint_api_wrapper.site_url}\n{tool['description']}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=sharepoint_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"Sharepoint {sharepoint_api_wrapper.site_url}\n{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/sharepoint/api_wrapper.py

@@ -271,13 +271,13 @@ class SharepointApiWrapper(NonCodeIndexerToolkit):
             file_name = file.get('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
 

alita_sdk/tools/slack/__init__.py

@@ -12,7 +12,7 @@ from pydantic import create_model, BaseModel, Field
 from ..base.tool import BaseAction
 
 from .api_wrapper import SlackApiWrapper
-from ..utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length, check_connection_response
+from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from slack_sdk.errors import SlackApiError
 from slack_sdk import WebClient
 
@@ -28,12 +28,10 @@ def get_tools(tool):
 
 class SlackToolkit(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 SlackApiWrapper.model_construct().get_available_tools()}
-         SlackToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
 
          @check_connection_response
          def check_connection(self):
@@ -59,7 +57,6 @@ class SlackToolkit(BaseToolkit):
                 'metadata': {
                     "label": "Slack",
                     "icon_url": "slack-icon.svg",
-                    "max_length": SlackToolkit.toolkit_max_length,
                     "categories": ["communication"],
                     "extra_categories": ["slack", "chat", "messaging", "collaboration"],
                 }
@@ -79,17 +76,21 @@ class SlackToolkit(BaseToolkit):
             **kwargs['slack_configuration'],
         }
         slack_api_wrapper = SlackApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = slack_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = f"Slack Tool: {tool['description']}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(                
                 api_wrapper=slack_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"Slack Tool: {tool['description']}",
+                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/sql/__init__.py

@@ -7,7 +7,7 @@ from .api_wrapper import SQLApiWrapper
 from ..base.tool import BaseAction
 from .models import SQLDialect
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.sql import SqlConfiguration
 
 name = "sql"
@@ -24,12 +24,10 @@ def get_tools(tool):
 
 class SQLToolkit(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 SQLApiWrapper.model_construct().get_available_tools()}
-        SQLToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         supported_dialects = (d.value for d in SQLDialect)
         return create_model(
             name,
@@ -42,7 +40,6 @@ class SQLToolkit(BaseToolkit):
                                       'metadata':
                                           {
                                               "label": "SQL", "icon_url": "sql-icon.svg",
-                                              "max_length": SQLToolkit.toolkit_max_length,
                                               "categories": ["development"],
                                               "extra_categories": ["sql", "data management", "data analysis"]}})
         )
@@ -57,17 +54,21 @@ class SQLToolkit(BaseToolkit):
             **kwargs.get('sql_configuration', {}),
         }
         sql_api_wrapper = SQLApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = sql_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = f"{tool['description']}\nDatabase: {sql_api_wrapper.database_name}. Host: {sql_api_wrapper.host}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=sql_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"{tool['description']}\nDatabase: {sql_api_wrapper.database_name}. Host: {sql_api_wrapper.host}",
-                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/testio/__init__.py

@@ -6,7 +6,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 from .api_wrapper import TestIOApiWrapper
 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
 from ...configurations.testio import TestIOConfiguration
 
 name = "testio"
@@ -19,8 +19,6 @@ def get_tools(tool):
     ).get_tools()
 
 
-TOOLKIT_MAX_LENGTH = 25
-
 class TestIOToolkit(BaseToolkit):
     tools: list[BaseTool] = []
     
@@ -33,7 +31,6 @@ class TestIOToolkit(BaseToolkit):
             testio_configuration=(TestIOConfiguration, Field(description="TestIO Configuration", json_schema_extra={'configuration_types': ['testio']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "TestIO", "icon_url": "testio-icon.svg",
-                                                                  "max_length": TOOLKIT_MAX_LENGTH,
                                                                   "categories": ["testing"],
                                                                   "extra_categories": ["test automation", "test case management", "test planning"]}})
         )
@@ -48,17 +45,21 @@ class TestIOToolkit(BaseToolkit):
             **kwargs.get('testio_configuration', {}),
         }
         testio_api_wrapper = TestIOApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, TOOLKIT_MAX_LENGTH) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = testio_api_wrapper.get_available_tools()
         tools = []
         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=testio_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/testrail/__init__.py

@@ -7,7 +7,7 @@ import requests
 from .api_wrapper import TestrailAPIWrapper
 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.testrail import TestRailConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -31,12 +31,10 @@ def get_tools(tool):
 
 class TestrailToolkit(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 TestrailAPIWrapper.model_construct().get_available_tools()}
-        TestrailToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
             testrail_configuration=(Optional[TestRailConfiguration], Field(description="TestRail Configuration", json_schema_extra={'configuration_types': ['testrail']})),
@@ -47,7 +45,6 @@ class TestrailToolkit(BaseToolkit):
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata':
                                                          {"label": "Testrail", "icon_url": "testrail-icon.svg",
-                                                          "max_length": TestrailToolkit.toolkit_max_length,
                                                           "categories": ["test management"],
                                                           "extra_categories": ["quality assurance", "test case management", "test planning"]
                                                           }})
@@ -77,18 +74,23 @@ class TestrailToolkit(BaseToolkit):
             **(kwargs.get('pgvector_configuration') or {}),
         }
         testrail_api_wrapper = TestrailAPIWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = testrail_api_wrapper.get_available_tools()
         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 + "\nTestrail instance: " + testrail_api_wrapper.url
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=testrail_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + "\nTestrail instance: " + testrail_api_wrapper.url,
-                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/utils/__init__.py

@@ -7,6 +7,8 @@ import requests
 from pydantic import create_model, Field
 
 
+# DEPRECATED: Tool names no longer use prefixes
+# Kept for backward compatibility only
 TOOLKIT_SPLITTER = "___"
 TOOL_NAME_LIMIT = 64
 
@@ -22,10 +24,13 @@ def clean_string(s: str, max_length: int = 0):
 
 
 def get_max_toolkit_length(selected_tools: Any):
-    """Calculates the maximum length of the toolkit name based on the selected tools per toolkit."""
-
-    longest_tool_name_length = max(len(tool_name) for tool_name in selected_tools.keys())
-    return TOOL_NAME_LIMIT - longest_tool_name_length - len(TOOLKIT_SPLITTER)
+    """DEPRECATED: Calculates the maximum length of the toolkit name.
+    
+    This function is deprecated as tool names no longer use prefixes.
+    Returns a fixed value for backward compatibility.
+    """
+    # Return a reasonable default since we no longer use prefixes
+    return 50
 
 
 def parse_list(list_str: str = None) -> List[str]: