alita-sdk 0.3.497__py3-none-any.whl → 0.3.516__py3-none-any.whl

alita_sdk/tools/localgit/local_git.py

@@ -8,7 +8,8 @@ from git import Repo
 from pydantic import BaseModel, Field, create_model, model_validator
 from langchain_core.tools import ToolException
 
-from ..elitea_base import BaseToolApiWrapper
+from ..elitea_base import BaseToolApiWrapper, extend_with_file_operations, BaseCodeToolApiWrapper
+from ..utils.text_operations import parse_old_new_markers
 
 logger = logging.getLogger(__name__)
 CREATE_FILE_PROMPT = """Create new file in your local repository."""
@@ -110,6 +111,12 @@ class LocalGit(BaseToolApiWrapper):
     repo_url: str = None
     commit_sha: str = None
     path_pattern: str = '**/*.py'
+    
+    # Import file operation methods from BaseCodeToolApiWrapper
+    read_file_chunk = BaseCodeToolApiWrapper.read_file_chunk
+    read_multiple_files = BaseCodeToolApiWrapper.read_multiple_files
+    search_file = BaseCodeToolApiWrapper.search_file
+    edit_file = BaseCodeToolApiWrapper.edit_file
 
     @model_validator(mode='before')
     @classmethod
@@ -128,58 +135,6 @@ class LocalGit(BaseToolApiWrapper):
             repo.head.reset(commit=commit_sha, working_tree=True)
         return values
 
-    def extract_old_new_pairs(self, file_query):
-        # Split the file content by lines
-        code_lines = file_query.split("\n")
-
-        # Initialize lists to hold the contents of OLD and NEW sections
-        old_contents = []
-        new_contents = []
-
-        # Initialize variables to track whether the current line is within an OLD or NEW section
-        in_old_section = False
-        in_new_section = False
-
-        # Temporary storage for the current section's content
-        current_section_content = []
-
-        # Iterate through each line in the file content
-        for line in code_lines:
-            # Check for OLD section start
-            if "OLD <<<" in line:
-                in_old_section = True
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for OLD section end
-            if ">>>> OLD" in line:
-                in_old_section = False
-                old_contents.append("\n".join(current_section_content).strip())  # Add the captured content
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for NEW section start
-            if "NEW <<<" in line:
-                in_new_section = True
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for NEW section end
-            if ">>>> NEW" in line:
-                in_new_section = False
-                new_contents.append("\n".join(current_section_content).strip())  # Add the captured content
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # If currently in an OLD or NEW section, add the line to the current section content
-            if in_old_section or in_new_section:
-                current_section_content.append(line)
-
-        # Pair the OLD and NEW contents
-        paired_contents = list(zip(old_contents, new_contents))
-
-        return paired_contents
-
     def checkout_commit(self, commit_sha: str) -> str:
         """ Checkout specific commit from repository """
         try:
@@ -233,6 +188,58 @@ class LocalGit(BaseToolApiWrapper):
                 return f.read()
         else:
             return "File '{}' cannot be read because it is not existed".format(file_path)
+    
+    def _read_file(self, file_path: str, branch: str = None, **kwargs) -> str:
+        """
+        Read a file from the repository with optional partial read support.
+        
+        Parameters:
+            file_path: the file path (relative to repo root)
+            branch: branch name (not used for local git, always reads from working dir)
+            **kwargs: Additional parameters (offset, limit, head, tail) - currently ignored,
+                     partial read handled client-side by base class methods
+        
+        Returns:
+            File content as string
+        """
+        return self.read_file(file_path)
+    
+    def _write_file(
+        self,
+        file_path: str,
+        content: str,
+        branch: str = None,
+        commit_message: str = None
+    ) -> str:
+        """
+        Write content to a file (create or update).
+        
+        Parameters:
+            file_path: Path to the file (relative to repo root)
+            content: New file content
+            branch: Branch name (not used for local git)
+            commit_message: Commit message (not used - files are written without commit)
+            
+        Returns:
+            Success message
+        """
+        try:
+            full_path = os.path.normpath(os.path.join(self.repo.working_dir, file_path))
+            
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            
+            # Write the file
+            with open(full_path, 'w') as f:
+                f.write(content)
+            
+            # Determine if file was created or updated
+            if os.path.exists(full_path):
+                return f"Updated file {file_path}"
+            else:
+                return f"Created file {file_path}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
     def update_file_content_by_lines(self, file_path: str, start_line_index: int, end_line_index: int,
                                      new_content: str) -> str:
@@ -314,7 +321,7 @@ class LocalGit(BaseToolApiWrapper):
             file_path = os.path.normpath(os.path.join(self.repo.working_dir, file_path))
             file_content = self.read_file(file_path)
             updated_file_content = file_content
-            for old, new in self.extract_old_new_pairs(file_query):
+            for old, new in parse_old_new_markers(file_query):  # Use shared utility
                 if not old.strip():
                     continue
                 updated_file_content = updated_file_content.replace(old, new)
@@ -332,6 +339,7 @@ class LocalGit(BaseToolApiWrapper):
         except Exception as e:
             return "Unable to update file due to error:\n" + str(e)
 
+    @extend_with_file_operations
     def get_available_tools(self):
         return [
             {

alita_sdk/tools/localgit/tool.py

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

alita_sdk/tools/memory/__init__.py

@@ -80,13 +80,14 @@ class MemoryToolkit(BaseToolkit):
         )
 
     @classmethod
-    def get_toolkit(cls, namespace: str, store=None, **kwargs):
+    def get_toolkit(cls, namespace: str, store=None, toolkit_name: str = None, **kwargs):
         """
         Get toolkit with memory tools.
         
         Args:
             namespace: Memory namespace
             store: PostgresStore instance (imported dynamically)
+            toolkit_name: Optional toolkit name for metadata
             **kwargs: Additional arguments
         """
         try:
@@ -109,10 +110,17 @@ class MemoryToolkit(BaseToolkit):
         if store is not None and not isinstance(store, PostgresStore):
             raise TypeError(f"Expected PostgresStore, got {type(store)}")
         
-        return cls(tools=[
+        tools = [
             create_manage_memory_tool(namespace=namespace, store=store),
             create_search_memory_tool(namespace=namespace, store=store)
-        ])
+        ]
+        
+        # Add metadata to tools if toolkit_name is provided
+        if toolkit_name:
+            for tool in tools:
+                tool.metadata = {"toolkit_name": toolkit_name}
+        
+        return cls(tools=tools)
 
     def get_tools(self):
         return self.tools

alita_sdk/tools/ocr/__init__.py

@@ -5,7 +5,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from .api_wrapper import OCRApiWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 
 name = "ocr"
 
@@ -23,15 +23,13 @@ def get_tools(tool):
 
 class OCRToolkit(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 OCRApiWrapper.model_construct().get_available_tools()}
-        OCRToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            artifacts_folder=(str, Field(description="Folder path containing artifacts to process", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': OCRToolkit.toolkit_max_length})),
+            artifacts_folder=(str, Field(description="Folder path containing artifacts to process", json_schema_extra={'toolkit_name': True})),
             tesseract_settings=(dict, Field(description="Settings for Tesseract OCR processing", default={})),
             structured_output=(bool, Field(description="Whether to return structured JSON output", default=False)),
             expected_fields=(dict, Field(description="Expected fields for structured output", default={})),
@@ -47,17 +45,21 @@ class OCRToolkit(BaseToolkit):
         if selected_tools is None:
             selected_tools = []
         ocr_api_wrapper = OCRApiWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = ocr_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=ocr_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/openapi/__init__.py

@@ -96,7 +96,8 @@ class AlitaOpenAPIToolkit(BaseToolkit):
     @classmethod
     def get_toolkit(cls, openapi_spec: str | dict,
                     selected_tools: list[dict] | None = None,
-                    headers: Optional[Dict[str, str]] = None):
+                    headers: Optional[Dict[str, str]] = None,
+                    toolkit_name: Optional[str] = None):
         if selected_tools is not None:
             tools_set = set([i if not isinstance(i, dict) else i.get('name') for i in selected_tools])
         else:
@@ -124,7 +125,10 @@ class AlitaOpenAPIToolkit(BaseToolkit):
                 tool = c.operations[i]
                 if not isinstance(tool, Operation):
                     raise ToolException(f"Operation {i} is not an instance of Operation class.")
-                tools.append(create_api_tool(i, tool))
+                api_tool = create_api_tool(i, tool)
+                if toolkit_name:
+                    api_tool.metadata = {"toolkit_name": toolkit_name}
+                tools.append(api_tool)
             except ToolException:
                 raise
             except Exception as e:

alita_sdk/tools/pandas/__init__.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel, ConfigDict, create_model, Field
 
 from .api_wrapper import PandasWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 
 name = "pandas"
 
@@ -21,12 +21,10 @@ def get_tools(tool):
 
 class PandasToolkit(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 PandasWrapper.model_construct().get_available_tools()}
-        PandasToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             bucket_name=(str, Field(default=None, title="Bucket name", description="Bucket where the content file is stored")),
@@ -41,17 +39,21 @@ class PandasToolkit(BaseToolkit):
         if selected_tools is None:
             selected_tools = []
         csv_tool_api_wrapper = PandasWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = csv_tool_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=csv_tool_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/postman/__init__.py

@@ -6,7 +6,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, field_validator
 from ..base.tool import BaseAction
 
 from .api_wrapper import PostmanApiWrapper
-from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER, check_connection_response
+from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from ...configurations.postman import PostmanConfiguration
 
 name = "postman"
@@ -43,14 +43,11 @@ def get_tools(tool):
 
 class PostmanToolkit(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 PostmanApiWrapper.model_construct().get_available_tools()}
-        PostmanToolkit.toolkit_max_length = get_max_toolkit_length(
-            selected_tools)
         m = create_model(
             name,
             postman_configuration=(Optional[PostmanConfiguration], Field(description="Postman Configuration",
@@ -62,8 +59,7 @@ class PostmanToolkit(BaseToolkit):
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(
                 default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {
-                                  "label": "Postman", "icon_url": "postman.svg",
-                "max_length": PostmanToolkit.toolkit_max_length,}})
+                                  "label": "Postman", "icon_url": "postman.svg"}})
         )
 
         @check_connection_response
@@ -90,20 +86,23 @@ class PostmanToolkit(BaseToolkit):
             **kwargs['postman_configuration'],
         }
         postman_api_wrapper = PostmanApiWrapper(**wrapper_payload)
-        prefix = clean_string(str(toolkit_name), cls.toolkit_max_length) + \
-            TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = postman_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = f"{tool['description']}\nAPI URL: {postman_api_wrapper.base_url}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(PostmanAction(
                 api_wrapper=postman_api_wrapper,
-                name=prefix + tool["name"],
+                name=tool["name"],
                 mode=tool["mode"],
-                description=f"{tool['description']}\nAPI URL: {postman_api_wrapper.base_url}",
-                args_schema=tool["args_schema"]
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/pptx/__init__.py

@@ -7,7 +7,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 from .pptx_wrapper import PPTXWrapper
 
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 
 logger = logging.getLogger(__name__)
 
@@ -27,8 +27,6 @@ def get_tools(tool):
     ).get_tools()
 
 
-TOOLKIT_MAX_LENGTH = 25
-
 class PPTXToolkit(BaseToolkit):
     """
     PowerPoint (PPTX) manipulation toolkit for Alita.
@@ -51,7 +49,6 @@ class PPTXToolkit(BaseToolkit):
                 'metadata': {
                     "label": "PPTX",
                     "icon_url": "pptx.svg",
-                    "max_length": TOOLKIT_MAX_LENGTH,
                     "categories": ["office"],
                     "extra_categories": ["presentation", "office automation", "document"]
                 }
@@ -75,19 +72,22 @@ class PPTXToolkit(BaseToolkit):
             selected_tools = []
             
         pptx_api_wrapper = PPTXWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, TOOLKIT_MAX_LENGTH) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = pptx_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=pptx_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
             
         return cls(tools=tools)

alita_sdk/tools/qtest/__init__.py

@@ -7,7 +7,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 from .api_wrapper import QtestApiWrapper
 from .tool import QtestAction
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER, check_connection_response
+from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from ...configurations.qtest import QtestConfiguration
 
 name = "qtest"
@@ -27,12 +27,10 @@ def get_tools(tool):
 
 class QtestToolkit(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 QtestApiWrapper.model_construct().get_available_tools()}
-        QtestToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
             qtest_configuration=(QtestConfiguration, Field(description="QTest API token", json_schema_extra={
@@ -44,7 +42,6 @@ class QtestToolkit(BaseToolkit):
         selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "QTest", "icon_url": "qtest.svg",
-                                                                  "max_length": QtestToolkit.toolkit_max_length,
                                                                   "categories": ["test management"],
                                                                   "extra_categories": ["quality assurance",
                                                                                        "test case management",
@@ -76,19 +73,23 @@ class QtestToolkit(BaseToolkit):
             **kwargs['qtest_configuration'],
         }
         qtest_api_wrapper = QtestApiWrapper(**wrapper_payload)
-        prefix = clean_string(str(toolkit_name), cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = qtest_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = f"{tool['description']}\nUrl: {qtest_api_wrapper.base_url}. Project id: {qtest_api_wrapper.qtest_project_id}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(QtestAction(
                 api_wrapper=qtest_api_wrapper,
-                name=prefix + tool["name"],
+                name=tool["name"],
                 mode=tool["mode"],
-                description=f"{tool['description']}\nUrl: {qtest_api_wrapper.base_url}. Project id: {qtest_api_wrapper.qtest_project_id}",
-                args_schema=tool["args_schema"]
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/rally/__init__.py

@@ -5,7 +5,7 @@ from .api_wrapper import RallyApiWrapper
 from langchain_core.tools import BaseTool
 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.rally import RallyConfiguration
 
 name = "rally"
@@ -21,12 +21,10 @@ def get_tools(tool):
 
 class RallyToolkit(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 RallyApiWrapper.model_construct().get_available_tools()}
-        RallyToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             rally_configuration=(RallyConfiguration, Field(description="Rally configuration", json_schema_extra={'configuration_types': ['rally']})),
@@ -37,7 +35,6 @@ class RallyToolkit(BaseToolkit):
                 'metadata': {
                     "label": "Rally",
                     "icon_url": "rally.svg",
-                    "max_length": RallyToolkit.toolkit_max_length,
                     "categories": ["project management"],
                     "extra_categories": ["agile management", "test management", "scrum", "kanban"]
                 }
@@ -54,18 +51,22 @@ class RallyToolkit(BaseToolkit):
             **kwargs.get('rally_configuration'),
         }
         rally_api_wrapper = RallyApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = rally_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = f"{tool['description']}\nWorkspace: {rally_api_wrapper.workspace}. Project: {rally_api_wrapper.project}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=rally_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"{tool['description']}\nWorkspace: {rally_api_wrapper.workspace}. Project: {rally_api_wrapper.project}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/report_portal/__init__.py

@@ -7,7 +7,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 from .api_wrapper import ReportPortalApiWrapper
 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.report_portal import ReportPortalConfiguration
 
 name = "report_portal"
@@ -21,19 +21,16 @@ def get_tools(tool):
 
 
 class ReportPortalToolkit(BaseToolkit):
-    tools: list[BaseTool] = []
-    toolkit_max_length: int = 0
+    tools: List[BaseTool] = []
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in ReportPortalApiWrapper.model_construct().get_available_tools()}
-        ReportPortalToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             report_portal_configuration=(ReportPortalConfiguration, Field(description="Report Portal Configuration", json_schema_extra={'configuration_types': ['report_portal']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Report Portal", "icon_url": "reportportal-icon.svg",
-                                                                  "max_length": ReportPortalToolkit.toolkit_max_length,
                                                                   "categories": ["testing"],
                                                                   "extra_categories": ["test reporting", "test automation"]}})
         )
@@ -48,17 +45,22 @@ class ReportPortalToolkit(BaseToolkit):
             **kwargs.get('report_portal_configuration', {}),
         }
         report_portal_api_wrapper = ReportPortalApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = report_portal_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 = f"{description}\nReport portal configuration: 'url - {report_portal_api_wrapper.endpoint}, project - {report_portal_api_wrapper.project}'"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=report_portal_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"{tool['description']}\nReport portal configuration: 'url - {report_portal_api_wrapper.endpoint}, project - {report_portal_api_wrapper.project}'",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)