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

alita_sdk/tools/salesforce/__init__.py

@@ -5,8 +5,9 @@ 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
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "salesforce"
 
@@ -19,11 +20,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 +30,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 +46,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_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
 
         return cls(tools=tools)

alita_sdk/tools/servicenow/__init__.py

@@ -7,35 +7,33 @@ 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 ...configurations.service_now import ServiceNowConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 
 name = "service_now"
 
 def get_tools(tool):
+    settings = tool.get('settings') or {}
+
     return ServiceNowToolkit().get_toolkit(
-        selected_tools=tool['settings'].get('selected_tools', []),
-        instance_alias=tool['settings'].get('instance_alias', None),
-        base_url=tool['settings']['base_url'],
-        servicenow_configuration=tool['settings']['servicenow_configuration'],
-        response_fields=tool['settings'].get('response_fields', None),
+        selected_tools=settings.get('selected_tools', []),
+        instance_alias=settings.get('instance_alias', None),
+        servicenow_configuration=settings.get('servicenow_configuration', None),
+        response_fields=settings.get('response_fields', None),
         toolkit_name=tool.get('toolkit_name')
     ).get_tools()
 
 
 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")),
             response_fields=(Optional[str], Field(description="Response fields", default=None)),
             servicenow_configuration=(ServiceNowConfiguration, Field(description="ServiceNow Configuration",
                                                                                json_schema_extra={
@@ -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,24 @@ 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
+            base_url = getattr(servicenow_api_wrapper, "base_url", "") or ""
+            description = tool.get("description", "") if isinstance(tool, dict) else ""
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = f"ServiceNow: {base_url}\n{description}".strip()
+            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_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/servicenow/api_wrapper.py

@@ -58,7 +58,7 @@ class ServiceNowAPIWrapper(BaseToolApiWrapper):
         password = SecretStr(values['password'])
         username = values['username']
         cls.fields = values.get('fields', ['sys_id', 'number', 'state', 'short_description', 'description', 'priority', 'category', 'urgency', 'impact', 'creation_date'])
-        cls.client = ServiceNowClient(base_url, (username, password.get_secret_value()))
+        cls.client = ServiceNowClient(instance=base_url, auth=(username, password.get_secret_value()))
         return values
 
     def get_incidents(self, data: Optional[Dict[str, Any]] = None) -> ToolException | str:

alita_sdk/tools/sharepoint/__init__.py

@@ -5,9 +5,10 @@ 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
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "sharepoint"
 
@@ -29,12 +30,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 +47,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 +63,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_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/sharepoint/api_wrapper.py

@@ -20,7 +20,7 @@ NoInput = create_model(
 ReadList = create_model(
     "ReadList",
     list_title=(str, Field(description="Name of a Sharepoint list to be read.")),
-    limit=(Optional[int], Field(description="Limit (maximum number) of list items to be returned", default=1000))
+    limit=(Optional[int], Field(description="Limit (maximum number) of list items to be returned", default=1000, gt=0))
 )
 
 GetFiles = create_model(
@@ -30,7 +30,7 @@ GetFiles = create_model(
                                                   "Can be called with synonyms, such as First, Top, etc., "
                                                   "or can be reflected just by a number for example 'Top 10 files'. "
                                                   "Use default value if not specified in a query WITH NO EXTRA "
-                                                  "CONFIRMATION FROM A USER", default=100)),
+                                                  "CONFIRMATION FROM A USER", default=100, gt=0)),
 )
 
 ReadDocument = create_model(
@@ -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,9 +12,10 @@ 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
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "slack"
 
@@ -28,12 +29,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 +58,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 +77,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
-            tools.append(BaseAction(                
+            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_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/slack/api_wrapper.py

@@ -17,8 +17,8 @@ SendMessageModel = create_model(
 
 ReadMessagesModel = create_model(
                     "ReadMessagesModel",
-                    channel_id=(Optional[str], Field(default=None,description="Channel ID, user ID, or conversation ID to read messages from. (like C12345678 for public channels, D12345678 for DMs)")),                    
-                    limit=(int, Field(default=10, description="The number of messages to fetch (default is 10)."))
+                    channel_id=(Optional[str], Field(default=None,description="Channel ID, user ID, or conversation ID to read messages from. (like C12345678 for public channels, D12345678 for DMs)")),
+                    limit=(int, Field(default=10, description="The number of messages to fetch (default is 10).", gt=0))
                     )
 
 CreateChannelModel = create_model(

alita_sdk/tools/sql/__init__.py

@@ -7,8 +7,9 @@ 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
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "sql"
 
@@ -24,16 +25,14 @@ 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,
-            dialect=(Literal[tuple(supported_dialects)], Field(description="Database dialect (mysql or postgres)")),
+            dialect=(Literal[tuple(supported_dialects)], Field(default=SQLDialect.POSTGRES.value, description="Database dialect (mysql or postgres)")),
             database_name=(str, Field(description="Database name")),
             sql_configuration=(SqlConfiguration, Field(description="SQL Configuration", json_schema_extra={'configuration_types': ['sql']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
@@ -42,7 +41,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 +55,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_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/testio/__init__.py

@@ -6,8 +6,9 @@ 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
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "testio"
 
@@ -19,8 +20,6 @@ def get_tools(tool):
     ).get_tools()
 
 
-TOOLKIT_MAX_LENGTH = 25
-
 class TestIOToolkit(BaseToolkit):
     tools: list[BaseTool] = []
     
@@ -33,7 +32,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 +46,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_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/testrail/__init__.py

@@ -7,9 +7,10 @@ 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
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "testrail"
 
@@ -31,12 +32,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 +46,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 +75,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_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/testrail/api_wrapper.py

@@ -697,7 +697,7 @@ class TestrailAPIWrapper(NonCodeIndexerToolkit):
                 'id': str(case.get('id', '')),
                 IndexerKeywords.UPDATED_ON.value: case.get('updated_on') or -1,
                 'labels': [lbl['title'] for lbl in case.get('labels', [])],
-                'type': case.get('type_id') or -1,
+                'type': "testrail_test_case",
                 'priority': case.get('priority_id') or -1,
                 'milestone': case.get('milestone_id') or -1,
                 'estimate': case.get('estimate') or '',

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]:

alita_sdk/tools/utils/content_parser.py

@@ -109,7 +109,15 @@ def parse_file_content(file_name=None, file_content=None, is_capture_image: bool
                                     loader_extra_config=loader_kwargs,
                                     llm=llm)
     except Exception as e:
-        return ToolException(f"Error reading file ({file_name or file_path}) content. Make sure these types are supported: {str(e)}")
+        # Surface full underlying error message (including nested causes) so that
+        # JSONDecodeError or other specific issues are not hidden behind
+        # generic RuntimeError messages from loaders.
+        root_msg = str(e)
+        if getattr(e, "__cause__", None):
+            root_msg = f"{root_msg} | Cause: {e.__cause__}"
+        return ToolException(
+            f"Error reading file ({file_name or file_path}) content. Make sure these types are supported: {root_msg}"
+        )
 
 def load_file_docs(file_name=None, file_content=None, is_capture_image: bool = False, page_number: int = None,
                        sheet_name: str = None, llm=None, file_path: str = None, excel_by_sheets: bool = False) -> List[Document] | ToolException:
@@ -130,7 +138,38 @@ def load_file_docs(file_name=None, file_content=None, is_capture_image: bool = F
 
 def get_loader_kwargs(loader_object, file_name=None, file_content=None, is_capture_image: bool = False, page_number: int = None,
                     sheet_name: str = None, llm=None, file_path: str = None, excel_by_sheets: bool = False, prompt=None):
-    loader_kwargs = deepcopy(loader_object['kwargs'])
+    """Build loader kwargs safely without deepcopying non-picklable objects like LLMs.
+
+    We avoid copying keys that are going to be overridden by this function anyway
+    (file_path, file_content, file_name, extract_images, llm, page_number,
+    sheet_name, excel_by_sheets, prompt, row_content, json_documents) to
+    prevent errors such as `cannot pickle '_thread.RLock' object` when an LLM
+    or client with internal locks is stored in the original kwargs.
+    """
+    if not loader_object:
+        raise ToolException("Loader configuration is missing.")
+
+    original_kwargs = loader_object.get("kwargs", {}) or {}
+
+    # Keys that will be overwritten below – skip them when copying
+    overridden_keys = {
+        "file_path",
+        "file_content",
+        "file_name",
+        "extract_images",
+        "llm",
+        "page_number",
+        "sheet_name",
+        "excel_by_sheets",
+        "prompt",
+        "row_content",
+        "json_documents",
+    }
+
+    # Build a safe shallow copy without overridden keys to avoid deepcopy
+    # of potentially non-picklable objects (e.g., llm with internal RLock).
+    loader_kwargs = {k: v for k, v in original_kwargs.items() if k not in overridden_keys}
+
     loader_kwargs.update({
         "file_path": file_path,
         "file_content": file_content,
@@ -212,6 +251,41 @@ def load_content_from_bytes(file_content: bytes, extension: str = None, loader_e
         if temp_file_path and os.path.exists(temp_file_path):
             os.remove(temp_file_path)
 
+
+def _load_content_from_bytes_with_prompt(file_content: bytes, extension: str = None, loader_extra_config: dict = None, llm = None, prompt: str = image_processing_prompt) -> str:
+    """Internal helper that behaves like load_content_from_bytes but also propagates prompt.
+
+    This keeps the public load_content_from_bytes API unchanged while allowing newer
+    code paths to pass an explicit prompt through to the loader.
+    """
+    temp_file_path = None
+    try:
+        with tempfile.NamedTemporaryFile(mode='w+b', delete=False, suffix=extension or '') as temp_file:
+            temp_file.write(file_content)
+            temp_file.flush()
+            temp_file_path = temp_file.name
+
+        # Use prepare_loader so that prompt and other kwargs are handled consistently
+        loader = prepare_loader(
+            file_name=None,
+            file_content=None,
+            is_capture_image=loader_extra_config.get('extract_images') if loader_extra_config else False,
+            page_number=loader_extra_config.get('page_number') if loader_extra_config else None,
+            sheet_name=loader_extra_config.get('sheet_name') if loader_extra_config else None,
+            llm=llm or (loader_extra_config.get('llm') if loader_extra_config else None),
+            file_path=temp_file_path,
+            excel_by_sheets=loader_extra_config.get('excel_by_sheets') if loader_extra_config else False,
+            prompt=prompt or (loader_extra_config.get('prompt') if loader_extra_config else image_processing_prompt),
+        )
+
+        documents = loader.load()
+        page_contents = [doc.page_content for doc in documents]
+        return "\n".join(page_contents)
+    finally:
+        if temp_file_path and os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+
 def process_document_by_type(content, extension_source: str, document: Document = None, llm = None, chunking_config=None) \
         -> Generator[Document, None, None]:
     """Process the content of a file based on its type using a configured loader cosidering the origin document."""
@@ -338,4 +412,4 @@ def file_extension_by_chunker(chunker_name: str) -> str | None:
         return ".xml"
     if name == "csv":
         return ".csv"
-    return None
+    return None