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

alita_sdk/tools/sharepoint/api_wrapper.py

@@ -1,5 +1,6 @@
 import logging
-from typing import Optional, Generator
+import re
+from typing import Optional, Generator, List
 
 from langchain_core.documents import Document
 from langchain_core.tools import ToolException
@@ -7,8 +8,10 @@ from office365.runtime.auth.client_credential import ClientCredential
 from office365.sharepoint.client_context import ClientContext
 from pydantic import Field, PrivateAttr, create_model, model_validator, SecretStr
 
+from .utils import decode_sharepoint_string
 from ..non_code_indexer_toolkit import NonCodeIndexerToolkit
 from ..utils.content_parser import parse_file_content
+from ...runtime.utils.utils import IndexerKeywords
 
 NoInput = create_model(
     "NoInput"
@@ -23,7 +26,11 @@ ReadList = create_model(
 GetFiles = create_model(
     "GetFiles",
     folder_name=(Optional[str], Field(description="Folder name to get list of the files.", default=None)),
-    limit_files=(Optional[int], Field(description="Limit (maximum number) of files to be returned. 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)),
+    limit_files=(Optional[int], Field(description="Limit (maximum number) of files to be returned."
+                                                  "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)),
 )
 
 ReadDocument = create_model(
@@ -85,43 +92,100 @@ class SharepointApiWrapper(NonCodeIndexerToolkit):
             target_list = self._client.web.lists.get_by_title(list_title)
             self._client.load(target_list)
             self._client.execute_query()
-            items = target_list.items.get().top(limit).execute_query()
-            logging.info("{0} items from sharepoint loaded successfully.".format(len(items)))
+            items = target_list.items.top(limit).get().execute_query()
+            logging.info("{0} items from sharepoint loaded successfully via SharePoint REST API.".format(len(items)))
             result = []
             for item in items:
                 result.append(item.properties)
             return result
-        except Exception as e:
-            logging.error(f"Failed to load items from sharepoint: {e}")
-            return ToolException("Can not list items. Please, double check List name and read permissions.")
+        except Exception as base_e:
+            logging.warning(f"Primary SharePoint REST list read failed: {base_e}. Attempting Graph API fallback.")
+            # Attempt Graph API fallback
+            try:
+                from .authorization_helper import SharepointAuthorizationHelper
+                auth_helper = SharepointAuthorizationHelper(
+                    client_id=self.client_id,
+                    client_secret=self.client_secret.get_secret_value() if self.client_secret else None,
+                    tenant="",  # optional for graph api (derived inside helper)
+                    scope="",  # optional for graph api
+                    token_json="",  # not needed for client credentials flow here
+                )
+                graph_items = auth_helper.get_list_items(self.site_url, list_title, limit)
+                if graph_items:
+                    logging.info(f"{len(graph_items)} items from sharepoint loaded successfully via Graph API fallback.")
+                    return graph_items
+                else:
+                    return ToolException("List appears empty or inaccessible via both REST and Graph APIs.")
+            except Exception as graph_e:
+                logging.error(f"Graph API fallback failed: {graph_e}")
+                return ToolException(f"Cannot read list '{list_title}'. Check list name and permissions: {base_e} | {graph_e}")
 
 
     def get_files_list(self, folder_name: str = None, limit_files: int = 100):
         """ If folder name is specified, lists all files in this folder under Shared Documents path. If folder name is empty, lists all files under root catalog (Shared Documents). Number of files is limited by limit_files (default is 100)."""
         try:
+            # exclude default system libraries like 'Form Templates', 'Site Assets', 'Style Library'
+            all_libraries = self._client.web.lists.filter("BaseTemplate eq 101 and Title ne 'Form Templates' and Title ne 'Site Assets' and Title ne 'Style Library'").get().execute_query()
             result = []
-
-            target_folder_url = f"Shared Documents/{folder_name}" if folder_name else "Shared Documents"
-            files = (self._client.web.get_folder_by_server_relative_path(target_folder_url)
-                     .get_files(True)
-                     .execute_query())
-
-            for file in files:
-                if len(result) >= limit_files:
-                    break
-                temp_props = {
-                    'Name': file.properties['Name'],
-                    'Path': file.properties['ServerRelativeUrl'],
-                    'Created': file.properties['TimeCreated'],
-                    'Modified': file.properties['TimeLastModified'],
-                    'Link': file.properties['LinkingUrl'],
-                    'id': file.properties['UniqueId']
-                }
-                result.append(temp_props)
+            if not limit_files:
+                limit_files = 100
+            #
+            site_segments = [seg for seg in self.site_url.strip('/').split('/') if seg][-2:]
+            full_path_prefix = '/'.join(site_segments)
+            #
+            for lib in all_libraries:
+                library_type = decode_sharepoint_string(lib.properties["EntityTypeName"])
+                target_folder_url = library_type
+                if folder_name:
+                    folder_path = folder_name.strip('/')
+                    expected_prefix = f'{full_path_prefix}/{library_type}'
+                    if folder_path.startswith(full_path_prefix):
+                        if folder_path.startswith(expected_prefix):
+                            target_folder_url = folder_path.removeprefix(f'{full_path_prefix}/')
+                        else:
+                            # ignore full path folder which is not targeted to current library
+                            continue
+                    else:
+                        target_folder_url = f"{library_type}/{folder_name}"
+                #
+                files = (self._client.web.get_folder_by_server_relative_path(target_folder_url)
+                         .get_files(True)
+                         .execute_query())
+                #
+                for file in files:
+                    if f"{library_type}/Forms" in file.properties['ServerRelativeUrl']:
+                        # skip files from system folder "Forms"
+                        continue
+                    if len(result) >= limit_files:
+                        break
+                    temp_props = {
+                        'Name': file.properties['Name'],
+                        'Path': file.properties['ServerRelativeUrl'],
+                        'Created': file.properties['TimeCreated'],
+                        'Modified': file.properties['TimeLastModified'],
+                        'Link': file.properties['LinkingUrl'],
+                        'id': file.properties['UniqueId']
+                    }
+                    result.append(temp_props)
             return result if result else ToolException("Can not get files or folder is empty. Please, double check folder name and read permissions.")
         except Exception as e:
-            logging.error(f"Failed to load files from sharepoint: {e}")
-            return ToolException("Can not get files. Please, double check folder name and read permissions.")
+            # attempt to get via graph api
+            try:
+                # attempt to get files via graph api
+                from .authorization_helper import SharepointAuthorizationHelper
+                auth_helper = SharepointAuthorizationHelper(
+                    client_id=self.client_id,
+                    client_secret=self.client_secret.get_secret_value(),
+                    tenant="", # optional for graph api
+                    scope="", # optional for graph api
+                    token_json="", # optional for graph api
+                )
+                files = auth_helper.get_files_list(self.site_url, folder_name, limit_files)
+                return files
+            except Exception as graph_e:
+                logging.error(f"Failed to load files from sharepoint via base api: {e}")
+                logging.error(f"Failed to load files from sharepoint via graph api: {graph_e}")
+                return ToolException(f"Can not get files. Please, double check folder name and read permissions: {e} and {graph_e}")
 
     def read_file(self, path,
                   is_capture_image: bool = False,
@@ -134,11 +198,28 @@ class SharepointApiWrapper(NonCodeIndexerToolkit):
             self._client.load(file).execute_query()
 
             file_content = file.read()
+            file_name = file.name
             self._client.execute_query()
         except Exception as e:
-            logging.error(f"Failed to load file from SharePoint: {e}. Path: {path}. Please, double check file name and path.")
-            return ToolException("File not found. Please, check file name and path.")
-        return parse_file_content(file_name=file.name,
+            # attempt to get via graph api
+            try:
+                # attempt to get files via graph api
+                from .authorization_helper import SharepointAuthorizationHelper
+                auth_helper = SharepointAuthorizationHelper(
+                    client_id=self.client_id,
+                    client_secret=self.client_secret.get_secret_value(),
+                    tenant="",  # optional for graph api
+                    scope="",  # optional for graph api
+                    token_json="",  # optional for graph api
+                )
+                file_content = auth_helper.get_file_content(self.site_url, path)
+                file_name = path.split('/')[-1]
+            except Exception as graph_e:
+                logging.error(f"Failed to load file from SharePoint via base api: {e}. Path: {path}. Please, double check file name and path.")
+                logging.error(f"Failed to load file from SharePoint via graph api: {graph_e}. Path: {path}. Please, double check file name and path.")
+                return ToolException(f"File not found. Please, check file name and path: {e} and {graph_e}")
+        #
+        return parse_file_content(file_name=file_name,
                                   file_content=file_content,
                                   is_capture_image=is_capture_image,
                                   page_number=page_number,
@@ -146,13 +227,60 @@ class SharepointApiWrapper(NonCodeIndexerToolkit):
                                   excel_by_sheets=excel_by_sheets,
                                   llm=self.llm)
 
+    def _index_tool_params(self):
+        return {
+            'limit_files': (Optional[int], Field(
+                description="Limit (maximum number) of files to be returned. 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=1000, ge=0)),
+            'include_extensions': (Optional[List[str]], Field(
+                description="List of file extensions to include when processing: i.e. ['*.png', '*.jpg']. "
+                            "If empty, all files will be processed (except skip_extensions).",
+                default=[])),
+            'skip_extensions': (Optional[List[str]], Field(
+                description="List of file extensions to skip when processing: i.e. ['*.png', '*.jpg']",
+                default=[])),
+            'path': (Optional[str], Field(
+                description="Folder path. "
+                            "Accepts either a full server-relative path (e.g., '/sites/SiteName/...') or a relative path. "
+                            "If a relative path is provided, the search will be performed recursively under 'Shared Documents' and other private libraries.",
+                default=None)),
+        }
+
     def _base_loader(self, **kwargs) -> Generator[Document, None, None]:
+
+        self._log_tool_event(message="Starting SharePoint files extraction", tool_name="loader")
         try:
-            all_files = self.get_files_list()
+            all_files = self.get_files_list(kwargs.get('path'), kwargs.get('limit_files', 10000))
+            self._log_tool_event(message="List of the files has been extracted", tool_name="loader")
         except Exception as e:
             raise ToolException(f"Unable to extract files: {e}")
 
+        include_extensions = kwargs.get('include_extensions', [])
+        skip_extensions = kwargs.get('skip_extensions', [])
+        self._log_tool_event(message=f"Files filtering started. Include extensions: {include_extensions}. "
+                                     f"Skip extensions: {skip_extensions}", tool_name="loader")
+        # show the progress of filtering
+        total_files = len(all_files) if isinstance(all_files, list) else 0
+        filtered_files_count = 0
         for file in all_files:
+            filtered_files_count += 1
+            if filtered_files_count % 10 == 0 or filtered_files_count == total_files:
+                self._log_tool_event(message=f"Files filtering progress: {filtered_files_count}/{total_files}", tool_name="loader")
+            file_name = file.get('Name', '')
+
+            # Check if file should be skipped based on skip_extensions
+            if any(re.match(re.escape(pattern).replace(r'\*', '.*') + '$', file_name, re.IGNORECASE)
+                   for pattern in skip_extensions):
+                continue
+
+            # Check if file should be included based on include_extensions
+            # If include_extensions is empty, process all files (that weren't skipped)
+            if include_extensions and not (any(re.match(re.escape(pattern).replace(r'\*', '.*') + '$', file_name, re.IGNORECASE)
+                        for pattern in include_extensions)):
+                continue
+
             metadata = {
                 ("updated_on" if k == "Modified" else k): str(v)
                 for k, v in file.items()
@@ -162,20 +290,32 @@ class SharepointApiWrapper(NonCodeIndexerToolkit):
     def _extend_data(self, documents: Generator[Document, None, None]):
         for document in documents:
             try:
-                document.metadata['loader_content'] = self._load_file_content_in_bytes(document.metadata['Path'])
-                document.metadata['loader_content_type'] = document.metadata['Name']
+                document.metadata[IndexerKeywords.CONTENT_IN_BYTES.value] = self._load_file_content_in_bytes(document.metadata['Path'])
+                document.metadata[IndexerKeywords.CONTENT_FILE_NAME.value] = document.metadata['Name']
                 yield document
             except Exception as e:
                 logging.error(f"Failed while parsing the file '{document.metadata['Path']}': {e}")
                 yield document
 
     def _load_file_content_in_bytes(self, path):
-        file = self._client.web.get_file_by_server_relative_path(path)
-        self._client.load(file).execute_query()
-        file_content = file.read()
-        self._client.execute_query()
-        #
-        return file_content
+        try:
+            file = self._client.web.get_file_by_server_relative_path(path)
+            self._client.load(file).execute_query()
+            file_content = file.read()
+            self._client.execute_query()
+            #
+            return file_content
+        except Exception as e:
+            # attempt to get via graph api
+            from .authorization_helper import SharepointAuthorizationHelper
+            auth_helper = SharepointAuthorizationHelper(
+                client_id=self.client_id,
+                client_secret=self.client_secret.get_secret_value(),
+                tenant="",  # optional for graph api
+                scope="",  # optional for graph api
+                token_json="",  # optional for graph api
+            )
+            return auth_helper.get_file_content(self.site_url, path)
 
     def get_available_tools(self):
         return super().get_available_tools() + [

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

@@ -2,6 +2,7 @@ from typing import List, Optional, Literal
 
 import logging
 
+from ..elitea_base import filter_missconfigured_index_tools
 from ...configurations.slack import SlackConfiguration
 
 logger = logging.getLogger(__name__)
@@ -11,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
 
@@ -27,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):
@@ -50,7 +49,7 @@ class SlackToolkit(BaseToolkit):
 
          model = create_model(
              name,
-             slack_configuration=(Optional[SlackConfiguration], Field(default=None, description="Slack configuration",
+             slack_configuration=(SlackConfiguration, Field(default=None, description="Slack configuration",
                                                              json_schema_extra={'configuration_types': ['slack']})),
              selected_tools=(List[Literal[tuple(selected_tools)]],
                              Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
@@ -67,6 +66,7 @@ class SlackToolkit(BaseToolkit):
          return model
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: Optional[List[str]] = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -76,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)