alita-sdk 0.3.351__py3-none-any.whl → 0.3.499__py3-none-any.whl

alita_sdk/tools/sharepoint/authorization_helper.py

@@ -1,7 +1,10 @@
 from datetime import datetime, timezone
+from urllib.parse import unquote, urlparse, quote
 
 import jwt
 import requests
+from botocore.response import get_response
+
 
 class SharepointAuthorizationHelper:
 
@@ -54,4 +57,191 @@ class SharepointAuthorizationHelper:
         except jwt.ExpiredSignatureError:
             return False
         except jwt.InvalidTokenError:
-            return False
+            return False
+
+    def _validate_response(self, response, required_field, error_prefix=None):
+        if response.status_code != 200:
+            raise RuntimeError(f"{error_prefix or 'Request'} failed: {response.status_code} {response.text}")
+        json_data = response.json()
+        if required_field not in json_data:
+            raise KeyError(f"'{required_field}' missing in response")
+        return json_data[required_field]
+
+    def generate_token_and_site_id(self, site_url: str) -> tuple[str, str]:
+        try:
+            parsed = urlparse(site_url)
+            domain = parsed.hostname
+            site_path = parsed.path.strip('/')
+            if not domain or not site_path:
+                raise ValueError(f"site_url missing domain or site path: {site_url}")
+            app_name = domain.split('.')[0]
+            openid_config_url = f"https://login.microsoftonline.com/{app_name}.onmicrosoft.com/v2.0/.well-known/openid-configuration"
+            response = requests.get(openid_config_url)
+            token_url = self._validate_response(response, required_field="token_endpoint", error_prefix="OpenID config")
+            token_data = {
+                "grant_type": "client_credentials",
+                "client_id": self.client_id,
+                "client_secret": self.client_secret,
+                "scope": "https://graph.microsoft.com/.default"
+            }
+            token_response = requests.post(token_url, data=token_data)
+            access_token = self._validate_response(token_response, required_field="access_token", error_prefix="Token request")
+            graph_site_url = f"https://graph.microsoft.com/v1.0/sites/{domain}:/{site_path}"
+            headers = {"Authorization": f"Bearer {access_token}"}
+            site_response = requests.get(graph_site_url, headers=headers)
+            site_id = self._validate_response(site_response, required_field="id", error_prefix="Site info")
+            return access_token, site_id
+        except Exception as e:
+            raise RuntimeError(f"Error while obtaining access_token and site_id: {e}")
+
+    def get_files_list(self, site_url: str, folder_name: str = None, limit_files: int = 100):
+        if not site_url or not site_url.startswith("https://"):
+            raise ValueError(f"Invalid site_url format: {site_url}")
+        if limit_files is not None and (not isinstance(limit_files, int) or limit_files <= 0):
+            raise ValueError(f"limit_files must be a positive integer, got: {limit_files}")
+        try:
+            access_token, site_id = self.generate_token_and_site_id(site_url)
+            headers = {"Authorization": f"Bearer {access_token}"}
+            drives_url = f"https://graph.microsoft.com/v1.0/sites/{site_id}/drives"
+            drives_response = requests.get(drives_url, headers=headers)
+            drives = self._validate_response(drives_response, required_field="value", error_prefix="Drives request")
+            result = []
+            def _recurse_drive(drive_id, drive_path, parent_folder, limit_files):
+                # Escape folder_name for URL safety if present
+                if parent_folder:
+                    safe_folder_name = quote(parent_folder.strip('/'), safe="/")
+                    url = f"https://graph.microsoft.com/v1.0/sites/{site_id}/drives/{drive_id}/root:/{safe_folder_name}:/children?$top={limit_files}"
+                else:
+                    url = f"https://graph.microsoft.com/v1.0/sites/{site_id}/drives/{drive_id}/root/children?$top={limit_files}"
+                response = requests.get(url, headers=headers)
+                if response.status_code != 200:
+                    return []
+                files_json = response.json()
+                if "value" not in files_json:
+                    return []
+                files = []
+                for file in files_json["value"]:
+                    file_name = file.get('name', '')
+                    # Build full path reflecting nested folders
+                    if parent_folder:
+                        full_path = '/' + '/'.join([drive_path.strip('/'), parent_folder.strip('/'), file_name.strip('/')])
+                    else:
+                        full_path = '/' + '/'.join([drive_path.strip('/'), file_name.strip('/')])
+                    temp_props = {
+                        'Name': file_name,
+                        'Path': full_path,
+                        'Created': file.get('createdDateTime'),
+                        'Modified': file.get('lastModifiedDateTime'),
+                        'Link': file.get('webUrl'),
+                        'id': file.get('id')
+                    }
+                    if not all([temp_props['Name'], temp_props['Path'], temp_props['id']]):
+                        continue  # skip files with missing required fields
+                    if 'folder' in file:
+                        # Recursively extract files from this folder
+                        inner_folder = parent_folder + '/' + file_name if parent_folder else file_name
+                        inner_files = _recurse_drive(drive_id, drive_path, inner_folder, limit_files)
+                        files.extend(inner_files)
+                    else:
+                        files.append(temp_props)
+                    if limit_files is not None and len(result) + len(files) >= limit_files:
+                        return files[:limit_files - len(result)]
+                return files
+            #
+            site_segments = [seg for seg in site_url.strip('/').split('/') if seg][-2:]
+            full_path_prefix = '/'.join(site_segments)
+            #
+            for drive in drives:
+                drive_id = drive.get("id")
+                drive_path = unquote(urlparse(drive.get("webUrl")).path) if drive.get("webUrl") else ""
+                if not drive_id:
+                    continue  # skip drives without id
+                #
+                sub_folder = folder_name
+                if folder_name:
+                    folder_path = folder_name.strip('/')
+                    expected_prefix = drive_path.strip('/')#f'{full_path_prefix}/{library_type}'
+                    if folder_path.startswith(full_path_prefix):
+                        if folder_path.startswith(expected_prefix):
+                            sub_folder = folder_path.removeprefix(f'{expected_prefix}').strip('/')#target_folder_url = folder_path.removeprefix(f'{full_path_prefix}/')
+                        else:
+                            # ignore full path folder which is not targeted to current drive
+                            continue
+                #
+                files = _recurse_drive(drive_id, drive_path, sub_folder, limit_files)
+                result.extend(files)
+                if limit_files is not None and len(result) >= limit_files:
+                    return result[:limit_files]
+            return result
+        except Exception as e:
+            raise RuntimeError(f"Error in get_files_list: {e}")
+
+    def get_file_content(self, site_url: str, path: str):
+        try:
+            access_token, site_id = self.generate_token_and_site_id(site_url)
+            headers = {"Authorization": f"Bearer {access_token}"}
+            drives_url = f"https://graph.microsoft.com/v1.0/sites/{site_id}/drives"
+            drives_response = requests.get(drives_url, headers=headers)
+            drives = self._validate_response(drives_response, required_field="value", error_prefix="Drives request")
+            path = path.strip('/')
+            #
+            for drive in drives:
+                drive_path = unquote(urlparse(drive.get("webUrl")).path).strip('/')
+                if not drive_path or not path.startswith(drive_path):
+                    continue
+                drive_id = drive.get("id")
+                if not drive_id:
+                    continue
+                path = path.replace(drive_path, '').strip('/')
+                safe_path = quote(path, safe="")
+                url = f"https://graph.microsoft.com/v1.0/drives/{drive_id}/root:/{safe_path}:/content"
+                response = requests.get(url, headers=headers)
+                if response.status_code == 200:
+                    return response.content
+            raise RuntimeError(f"File '{path}' not found in any private or shared documents.")
+        except Exception as e:
+            raise RuntimeError(f"Error in get_file_content: {e}")
+
+    def get_list_items(self, site_url: str, list_title: str, limit: int = 1000):
+        """Fallback Graph API method to read SharePoint list items by list title.
+
+        Returns a list of dictionaries representing list item fields.
+        """
+        if not site_url or not site_url.startswith("https://"):
+            raise ValueError(f"Invalid site_url format: {site_url}")
+        try:
+            access_token, site_id = self.generate_token_and_site_id(site_url)
+            headers = {"Authorization": f"Bearer {access_token}"}
+            lists_url = f"https://graph.microsoft.com/v1.0/sites/{site_id}/lists"
+            response = requests.get(lists_url, headers=headers)
+            if response.status_code != 200:
+                raise RuntimeError(f"Lists request failed: {response.status_code} {response.text}")
+            lists_json = response.json()
+            lists = lists_json.get("value", [])
+            target_list = None
+            normalized_title = list_title.strip().lower()
+            for lst in lists:
+                # displayName is the user-visible title. name can differ (internal name)
+                display_name = (lst.get("displayName") or lst.get("name") or '').strip().lower()
+                if display_name == normalized_title:
+                    target_list = lst
+                    break
+            if not target_list:
+                raise RuntimeError(f"List '{list_title}' not found via Graph API.")
+            list_id = target_list.get('id')
+            if not list_id:
+                raise RuntimeError(f"List '{list_title}' missing id field.")
+            items_url = f"https://graph.microsoft.com/v1.0/sites/{site_id}/lists/{list_id}/items?expand=fields&$top={limit}"
+            items_response = requests.get(items_url, headers=headers)
+            if items_response.status_code != 200:
+                raise RuntimeError(f"List items request failed: {items_response.status_code} {items_response.text}")
+            items_json = items_response.json()
+            values = items_json.get('value', [])
+            result = []
+            for item in values:
+                fields = item.get('fields', {})
+                if fields:
+                    result.append(fields)
+            return result
+        except Exception as e:
+            raise RuntimeError(f"Error in get_list_items: {e}")

alita_sdk/tools/sharepoint/utils.py

@@ -1,5 +1,7 @@
-from docx import Document
+import re
 from io import BytesIO
+from docx import Document
+
 
 def read_docx_from_bytes(file_content):
     """Read and return content from a .docx file using a byte stream."""
@@ -11,4 +13,8 @@ def read_docx_from_bytes(file_content):
         return '\n'.join(text)
     except Exception as e:
         print(f"Error reading .docx from bytes: {e}")
-        return ""
+        return ""
+
+
+def decode_sharepoint_string(s):
+    return re.sub(r'_x([0-9A-Fa-f]{4})_', lambda m: chr(int(m.group(1), 16)), s)

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):
@@ -78,16 +76,19 @@ 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"],
             ))
         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,17 +24,15 @@ 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)")),
-            database_name=(str, Field(description="Database name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': SQLToolkit.toolkit_max_length})),
+            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})),
             __config__=ConfigDict(json_schema_extra=
@@ -56,16 +54,19 @@ 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}",
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/tools/sql/api_wrapper.py

@@ -1,8 +1,9 @@
 import logging
-from typing import Optional, Any
+from typing import Optional
 
-from pydantic import BaseModel, create_model, model_validator, Field, SecretStr
-from pydantic.fields import PrivateAttr
+from langchain_core.tools import ToolException
+from pydantic import create_model, SecretStr, model_validator
+from pydantic.fields import PrivateAttr, Field
 from sqlalchemy import create_engine, text, inspect, Engine
 from sqlalchemy.orm import sessionmaker
 
@@ -27,7 +28,7 @@ class SQLApiWrapper(BaseToolApiWrapper):
     username: str
     password: SecretStr
     database_name: str
-    _client: Optional[Engine] = PrivateAttr()
+    _client: Optional[Engine] = PrivateAttr(default=None)
 
     @model_validator(mode='before')
     @classmethod
@@ -35,27 +36,73 @@ class SQLApiWrapper(BaseToolApiWrapper):
         for field in SQLConfig.model_fields:
             if field not in values or not values[field]:
                 raise ValueError(f"{field} is a required field and must be provided.")
-
-        dialect = values['dialect']
-        host = values['host']
-        username = values['username']
-        password = values['password']
-        database_name = values['database_name']
-        port = values['port']
-
-        if dialect == SQLDialect.POSTGRES:
-            connection_string = f'postgresql+psycopg2://{username}:{password}@{host}:{port}/{database_name}'
-        elif dialect == SQLDialect.MYSQL:
-            connection_string = f'mysql+pymysql://{username}:{password}@{host}:{port}/{database_name}'
-        else:
-            raise ValueError(f"Unsupported database type. Supported types are: {[e.value for e in SQLDialect]}")
-
-        cls._client = create_engine(connection_string)
         return values
 
+    def _mask_password_in_error(self, error_message: str) -> str:
+        """Mask password in error messages, showing only last 4 characters."""
+        password_str = self.password.get_secret_value()
+        if len(password_str) <= 4:
+            masked_password = "****"
+        else:
+            masked_password = "****" + password_str[-4:]
+
+        # Replace all occurrences of the password, and any substring of the password that may appear in the error message
+        for part in [password_str, password_str.replace('@', ''), password_str.split('@')[-1]]:
+            if part and part in error_message:
+                error_message = error_message.replace(part, masked_password)
+        return error_message
+
+    @property
+    def client(self) -> Engine:
+        """Lazy property to create and return database engine with error handling."""
+        if self._client is None:
+            try:
+                dialect = self.dialect
+                host = self.host
+                username = self.username
+                password = self.password.get_secret_value()
+                database_name = self.database_name
+                port = self.port
+
+                if dialect == SQLDialect.POSTGRES:
+                    connection_string = f'postgresql+psycopg2://{username}:{password}@{host}:{port}/{database_name}'
+                elif dialect == SQLDialect.MYSQL:
+                    connection_string = f'mysql+pymysql://{username}:{password}@{host}:{port}/{database_name}'
+                else:
+                    raise ValueError(f"Unsupported database type. Supported types are: {[e.value for e in SQLDialect]}")
+
+                self._client = create_engine(connection_string)
+
+                # Test the connection
+                with self._client.connect() as conn:
+                    conn.execute(text("SELECT 1"))
+
+            except Exception as e:
+                error_message = str(e)
+                masked_error = self._mask_password_in_error(error_message)
+                logger.error(f"Database connection failed: {masked_error}")
+                raise ValueError(f"Database connection failed: {masked_error}")
+
+        return self._client
+
+    def _handle_database_errors(func):
+        """Decorator to catch exceptions and mask passwords in error messages."""
+
+        def wrapper(self, *args, **kwargs):
+            try:
+                return func(self, *args, **kwargs)
+            except Exception as e:
+                error_message = str(e)
+                masked_error = self._mask_password_in_error(error_message)
+                logger.error(f"Database operation failed in {func.__name__}: {masked_error}")
+                raise ToolException(masked_error)
+
+        return wrapper
+
+    @_handle_database_errors
     def execute_sql(self, sql_query: str):
         """Executes the provided SQL query on the configured database."""
-        engine = self._client
+        engine = self.client
         maker_session = sessionmaker(bind=engine)
         session = maker_session()
         try:
@@ -76,9 +123,10 @@ class SQLApiWrapper(BaseToolApiWrapper):
         finally:
             session.close()
 
+    @_handle_database_errors
     def list_tables_and_columns(self):
         """Lists all tables and their columns in the configured database."""
-        inspector = inspect(self._client)
+        inspector = inspect(self.client)
         data = {}
         tables = inspector.get_table_names()
         for table in tables:
@@ -109,4 +157,4 @@ class SQLApiWrapper(BaseToolApiWrapper):
                 "description": self.list_tables_and_columns.__doc__,
                 "args_schema": SQLNoInput,
             }
-        ]
+        ]

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] = []
     
@@ -47,16 +45,19 @@ 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"],
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         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,17 +31,12 @@ 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,
-            name=(str, Field(description="Toolkit name", json_schema_extra={
-                'toolkit_name': True,
-                "max_length": TestrailToolkit.toolkit_max_length})),
             testrail_configuration=(Optional[TestRailConfiguration], Field(description="TestRail Configuration", json_schema_extra={'configuration_types': ['testrail']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default = None,
                                                                            description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
@@ -79,17 +74,21 @@ 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,
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         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]:
@@ -97,3 +102,20 @@ def check_connection_response(check_fun):
         else:
             return f"Service Unreachable: return code {response.status_code}"
     return _wrapper
+
+
+def make_json_serializable(obj):
+    if isinstance(obj, BaseModel):
+        return obj.model_dump()
+    if isinstance(obj, dict):
+        return {k: make_json_serializable(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [make_json_serializable(i) for i in obj]
+    if isinstance(obj, bool):
+        return bool(obj)
+    if isinstance(obj, (str, int, float)) or obj is None:
+        return obj
+    # Fallback: handle objects that look like booleans but were not caught above
+    if str(obj) in ("True", "False"):
+        return str(obj) == "True"
+    return str(obj)