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

alita_sdk/tools/gitlab/api_wrapper.py

@@ -1,9 +1,15 @@
 # api_wrapper.py
-from typing import Any, Dict, List, Optional
 import fnmatch
-from alita_sdk.tools.elitea_base import BaseCodeToolApiWrapper
+from typing import Any, Dict, List, Optional
+
+from langchain_core.tools import ToolException
 from pydantic import create_model, Field, model_validator, SecretStr, PrivateAttr
 
+from ..code_indexer_toolkit import CodeIndexerToolkit
+from ..utils.available_tools_decorator import extend_with_parent_available_tools
+from ..elitea_base import extend_with_file_operations
+from ..utils.content_parser import parse_file_content
+
 AppendFileModel = create_model(
     "AppendFileModel",
     file_path=(str, Field(description="The path of the file")),
@@ -97,53 +103,61 @@ GetCommitsModel = create_model(
     author=(Optional[str], Field(description="Author name", default=None)),
 )
 
-class GitLabAPIWrapper(BaseCodeToolApiWrapper):
+class GitLabAPIWrapper(CodeIndexerToolkit):
     url: str
     repository: str
     private_token: SecretStr
     branch: Optional[str] = 'main'
     _git: Any = PrivateAttr()
-    _repo_instance: Any = PrivateAttr()
     _active_branch: Any = PrivateAttr()
 
-    llm: Optional[Any] = None
-    # Alita instance
-    alita: Optional[Any] = None
-
-    # Vector store configuration
-    connection_string: Optional[SecretStr] = None
-    collection_name: Optional[str] = None
-    doctype: Optional[str] = 'code'
-    embedding_model: Optional[str] = "HuggingFaceEmbeddings"
-    embedding_model_params: Optional[Dict[str, Any]] = {"model_name": "sentence-transformers/all-MiniLM-L6-v2"}
-    vectorstore_type: Optional[str] = "PGVector"
+    @staticmethod
+    def _sanitize_url(url: str) -> str:
+        """Remove trailing slash from URL if present."""
+        return url.rstrip('/') if url else url
 
     @model_validator(mode='before')
     @classmethod
-    def validate_toolkit(cls, values: Dict) -> Dict:
+    def validate_toolkit_before(cls, values: Dict) -> Dict:
+        return super().validate_toolkit(values)
+
+    @model_validator(mode='after')
+    def validate_toolkit(self):
         try:
-            import gitlab
+           import gitlab
         except ImportError:
             raise ImportError(
                 "python-gitlab is not installed. "
                 "Please install it with `pip install python-gitlab`"
             )
-
+        self.repository = self._sanitize_url(self.repository)
         g = gitlab.Gitlab(
-            url=values['url'],
-            private_token=values['private_token'],
+            url=self._sanitize_url(self.url),
+            private_token=self.private_token.get_secret_value(),
             keep_base_url=True,
         )
 
         g.auth()
-        cls._repo_instance = g.projects.get(values.get('repository'))
-        cls._git = g
-        cls._active_branch = values.get('branch')
-        return values
+        self._git = g
+        self._active_branch = self.branch
+        return self
+
+    @property
+    def repo_instance(self):
+        if not hasattr(self, "_repo_instance") or self._repo_instance is None:
+            try:
+                if self._git and self.repository:
+                    self._repo_instance = self._git.projects.get(self.repository)
+                else:
+                    self._repo_instance = None
+            except Exception as e:
+                # Only raise when accessed, not during initialization
+                raise ToolException(e)
+        return self._repo_instance
 
     def set_active_branch(self, branch_name: str) -> str:
         self._active_branch = branch_name
-        self._repo_instance.default_branch = branch_name
+        self.repo_instance.default_branch = branch_name
         return f"Active branch set to {branch_name}"
 
     def list_branches_in_repo(self, limit: Optional[int] = 20, branch_wildcard: Optional[str] = None) -> List[str]:
@@ -158,7 +172,7 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
             List[str]: List containing names of branches
         """
         try:
-            branches = self._repo_instance.branches.list(get_all=True)
+            branches = self.repo_instance.branches.list(get_all=True)
             
             if branch_wildcard:
                 branches = [branch for branch in branches if fnmatch.fnmatch(branch.name, branch_wildcard)]
@@ -185,7 +199,7 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
 
     def _get_all_files(self, path: str = None, recursive: bool = True, branch: str = None):
         branch = branch if branch else self._active_branch
-        return self._repo_instance.repository_tree(path=path, ref=branch, recursive=recursive, all=True)
+        return self.repo_instance.repository_tree(path=path, ref=branch, recursive=recursive, all=True)
 
     # overrided for indexer
     def _get_files(self, path: str = None, recursive: bool = True, branch: str = None):
@@ -197,17 +211,29 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
         Get the commit hash of a file in a specific branch.
         """
         try:
-            file = self._repo_instance.files.get(file_path, branch)
+            file = self.repo_instance.files.get(file_path, branch)
             return file.commit_id
         except Exception as e:
             return f"Unable to get commit hash for {file_path} due to error:\n{e}"
 
-    def _read_file(self, file_path: str, branch: str):
+    def _read_file(self, file_path: str, branch: str, **kwargs):
+        """
+        Read a file from specified branch with optional partial read support.
+        
+        Parameters:
+            file_path: the file path
+            branch: the branch to read the file from
+            **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, branch)
 
     def create_branch(self, branch_name: str) -> str:
         try:
-            self._repo_instance.branches.create(
+            self.repo_instance.branches.create(
                 {
                     'branch': branch_name,
                     'ref': self._active_branch,
@@ -230,7 +256,7 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
         return parsed
 
     def get_issues(self) -> str:
-        issues = self._repo_instance.issues.list(state="opened")
+        issues = self.repo_instance.issues.list(state="opened")
         if len(issues) > 0:
             parsed_issues = self.parse_issues(issues)
             parsed_issues_str = (
@@ -241,7 +267,7 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
             return "No open issues available"
 
     def get_issue(self, issue_number: int) -> Dict[str, Any]:
-        issue = self._repo_instance.issues.get(issue_number)
+        issue = self.repo_instance.issues.get(issue_number)
         page = 0
         comments: List[dict] = []
         while len(comments) <= 10:
@@ -267,7 +293,7 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
             commits are already in the {self.branch} branch"""
         else:
             try:
-                pr = self._repo_instance.mergerequests.create(
+                pr = self.repo_instance.mergerequests.create(
                     {
                         "source_branch": branch,
                         "target_branch": self.branch,
@@ -284,7 +310,7 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
         issue_number = int(comment_query.split("\n\n")[0])
         comment = comment_query[len(str(issue_number)) + 2 :]
         try:
-            issue = self._repo_instance.issues.get(issue_number)
+            issue = self.repo_instance.issues.get(issue_number)
             issue.notes.create({"body": comment})
             return "Commented on issue " + str(issue_number)
         except Exception as e:
@@ -293,7 +319,7 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
     def create_file(self, file_path: str, file_contents: str, branch: str) -> str:
         try:
             self.set_active_branch(branch)
-            self._repo_instance.files.get(file_path, branch)
+            self.repo_instance.files.get(file_path, branch)
             return f"File already exists at {file_path}. Use update_file instead"
         except Exception:
             data = {
@@ -302,14 +328,76 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
                 "file_path": file_path,
                 "content": file_contents,
             }
-            self._repo_instance.files.create(data)
+            self.repo_instance.files.create(data)
 
             return "Created file " + file_path
 
     def read_file(self, file_path: str, branch: str) -> str:
         self.set_active_branch(branch)
-        file = self._repo_instance.files.get(file_path, branch)
-        return file.decode().decode("utf-8")
+        file = self.repo_instance.files.get(file_path, branch)
+        return parse_file_content(file_name=file_path,
+                                  file_content=file.decode(),
+                                  llm=self.llm)
+    
+    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
+            content: New file content
+            branch: Branch name (uses active branch if None)
+            commit_message: Commit message
+            
+        Returns:
+            Success message
+        """
+        try:
+            branch = branch or self._active_branch
+            
+            if branch == self.branch:
+                raise ToolException(
+                    f"Cannot commit directly to the {self.branch} branch. "
+                    "Please create a new branch and try again."
+                )
+            
+            self.set_active_branch(branch)
+            
+            # Check if file exists
+            try:
+                self.repo_instance.files.get(file_path, branch)
+                # File exists, update it
+                commit = {
+                    "branch": branch,
+                    "commit_message": commit_message or f"Update {file_path}",
+                    "actions": [
+                        {
+                            "action": "update",
+                            "file_path": file_path,
+                            "content": content,
+                        }
+                    ],
+                }
+                self.repo_instance.commits.create(commit)
+                return f"Updated file {file_path}"
+            except:
+                # File doesn't exist, create it
+                data = {
+                    "branch": branch,
+                    "commit_message": commit_message or f"Create {file_path}",
+                    "file_path": file_path,
+                    "content": content,
+                }
+                self.repo_instance.files.create(data)
+                return f"Created file {file_path}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
     def update_file(self, file_query: str, branch: str) -> str:
         if branch == self.branch:
@@ -347,7 +435,7 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
                 ],
             }
 
-            self._repo_instance.commits.create(commit)
+            self.repo_instance.commits.create(commit)
             return "Updated file " + file_path
         except Exception as e:
             return "Unable to update file due to error:\n" + str(e)
@@ -377,7 +465,7 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
                 ],
             }
 
-            self._repo_instance.commits.create(commit)
+            self.repo_instance.commits.create(commit)
             return "Updated file " + file_path
         except Exception as e:
             return "Unable to update file due to error:\n" + str(e)
@@ -387,20 +475,20 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
             self.set_active_branch(branch)
             if not commit_message:
                 commit_message = f"Delete {file_path}"
-            self._repo_instance.files.delete(file_path, branch, commit_message)
+            self.repo_instance.files.delete(file_path, branch, commit_message)
             return f"Deleted file {file_path}"
         except Exception as e:
             return f"Unable to delete file due to error:\n{e}"
 
     def get_pr_changes(self, pr_number: int) -> str:
-        mr = self._repo_instance.mergerequests.get(pr_number)
+        mr = self.repo_instance.mergerequests.get(pr_number)
         res = f"title: {mr.title}\ndescription: {mr.description}\n\n"
         for change in mr.changes()["changes"]:
             res += f"diff --git a/{change['old_path']} b/{change['new_path']}\n{change['diff']}\n"
         return res
 
     def create_pr_change_comment(self, pr_number: int, file_path: str, line_number: int, comment: str) -> str:
-        mr = self._repo_instance.mergerequests.get(pr_number)
+        mr = self.repo_instance.mergerequests.get(pr_number)
         position = {"position_type": "text", "new_path": file_path, "new_line": line_number}
         mr.discussions.create({"body": comment, "position": position})
         return "Comment added"
@@ -417,7 +505,7 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
             params["until"] = until
         if author:
             params["author"] = author
-        commits = self._repo_instance.commits.list(**params)
+        commits = self.repo_instance.commits.list(**params)
         return [
             {
                 "sha": commit.id,
@@ -429,6 +517,8 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
             for commit in commits
         ]
 
+    @extend_with_parent_available_tools
+    @extend_with_file_operations
     def get_available_tools(self):
         return [
             {
@@ -533,4 +623,4 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
                 "description": "Retrieve a list of commits from the repository.",
                 "args_schema": GetCommitsModel,
             }
-        ] + self._get_vector_search_tools()
+        ]

alita_sdk/tools/gitlab_org/__init__.py

@@ -4,7 +4,9 @@ from langchain_core.tools import BaseToolkit
 from langchain_core.tools import BaseTool
 from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.gitlab import GitlabConfiguration
 
 name = "gitlab_org"
@@ -20,17 +22,13 @@ def get_tools(tool):
 
 class AlitaGitlabSpaceToolkit(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 GitLabWorkspaceAPIWrapper.model_construct().get_available_tools()}
-        AlitaGitlabSpaceToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True,
-                                                                            'max_toolkit_length': AlitaGitlabSpaceToolkit.toolkit_max_length})),
-            gitlab_configuration=(Optional[GitlabConfiguration], Field(description="GitLab configuration",
+            gitlab_configuration=(GitlabConfiguration, Field(description="GitLab configuration",
                                                                        json_schema_extra={
                                                                            'configuration_types': ['gitlab']})),
             repositories=(str, Field(
@@ -51,6 +49,7 @@ class AlitaGitlabSpaceToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -60,17 +59,20 @@ class AlitaGitlabSpaceToolkit(BaseToolkit):
             **kwargs['gitlab_configuration'],
         }
         gitlab_wrapper = GitLabWorkspaceAPIWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, AlitaGitlabSpaceToolkit.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = gitlab_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[:1000]
             tools.append(BaseAction(
                 api_wrapper=gitlab_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/google/bigquery/__init__.py

@@ -5,7 +5,7 @@ from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import BaseModel, Field, computed_field, field_validator
 
 from ....configurations.bigquery import BigQueryConfiguration
-from ...utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length
+from ...utils import clean_string, get_max_toolkit_length
 from .api_wrapper import BigQueryApiWrapper
 from .tool import BigQueryAction
 
@@ -22,11 +22,6 @@ def get_available_tools() -> dict[str, dict]:
     return available_tools
 
 
-toolkit_max_length = lru_cache(maxsize=1)(
-    lambda: get_max_toolkit_length(get_available_tools())
-)
-
-
 class BigQueryToolkitConfig(BaseModel):
     class Config:
         title = name
@@ -46,7 +41,7 @@ class BigQueryToolkitConfig(BaseModel):
             }
         }
 
-    bigquery_configuration: Optional[BigQueryConfiguration] = Field(
+    bigquery_configuration: BigQueryConfiguration = Field(
         description="BigQuery configuration", json_schema_extra={"configuration_types": ["bigquery"]}
     )
     selected_tools: List[str] = Field(
@@ -86,9 +81,10 @@ class BigQueryToolkit(BaseToolkit):
 
     @computed_field
     @property
-    def tool_prefix(self) -> str:
+    def toolkit_context(self) -> str:
+        """Returns toolkit context for descriptions (max 1000 chars)."""
         return (
-            clean_string(self.toolkit_name, toolkit_max_length()) + TOOLKIT_SPLITTER
+            f" [Toolkit: {clean_string(self.toolkit_name, 0)}]"
             if self.toolkit_name
             else ""
         )
@@ -122,13 +118,16 @@ class BigQueryToolkit(BaseToolkit):
             selected_tools = set(selected_tools)
             for t in instance.available_tools:
                 if t["name"] in selected_tools:
+                    description = t["description"]
+                    if toolkit_name:
+                        description = f"Toolkit: {toolkit_name}\n{description}"
+                    description = f"Project: {getattr(instance.api_wrapper, 'project', '')}\n{description}"
+                    description = description[:1000]
                     instance.tools.append(
                         BigQueryAction(
                             api_wrapper=instance.api_wrapper,
-                            name=instance.tool_prefix + t["name"],
-                            # set unique description for declared tools to differentiate the same methods for different toolkits
-                            description=f"Project: {getattr(instance.api_wrapper, 'project', '')}\n"
-                            + t["description"],
+                            name=t["name"],
+                            description=description,
                             args_schema=t["args_schema"],
                         )
                     )

alita_sdk/tools/google_places/__init__.py

@@ -1,35 +1,35 @@
 from typing import List, Literal, Optional
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict
 from pydantic.fields import Field
 
 from .api_wrapper import GooglePlacesAPIWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
+from ...configurations.google_places import GooglePlacesConfiguration
 
 name = "google_places"
 
 def get_tools(tool):
     return GooglePlacesToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        api_key=tool['settings']['api_key'],
         results_count=tool['settings'].get('results_count'),
+        google_places_configuration=tool['settings']['google_places_configuration'],
         toolkit_name=tool.get('toolkit_name')
     ).get_tools()
 
 
 class GooglePlacesToolkit(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 GooglePlacesAPIWrapper.model_construct().get_available_tools()}
-        GooglePlacesToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            api_key=(SecretStr, Field(description="Google Places API key", json_schema_extra={'secret': True, 'max_toolkit_length': GooglePlacesToolkit.toolkit_max_length})),
             results_count=(Optional[int], Field(description="Results number to show", default=None)),
+            google_places_configuration=(GooglePlacesConfiguration, Field(description="Google Places Configuration", json_schema_extra={'configuration_types': ['google_places']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra=
                                   {
@@ -44,20 +44,28 @@ class GooglePlacesToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        google_places_api_wrapper = GooglePlacesAPIWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, GooglePlacesToolkit.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('google_places_configuration', {}),
+        }
+        google_places_api_wrapper = GooglePlacesAPIWrapper(**wrapper_payload)
         available_tools = google_places_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=google_places_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/jira/__init__.py

@@ -5,7 +5,8 @@ from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field
 import requests
 
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list, check_connection_response
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length, parse_list, check_connection_response
 from ...configurations.jira import JiraConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -16,6 +17,7 @@ def get_tools(tool):
         selected_tools=tool['settings'].get('selected_tools', []),
         base_url=tool['settings'].get('base_url'),
         cloud=tool['settings'].get('cloud', True),
+        api_version=tool['settings'].get('api_version', '2'),
         jira_configuration=tool['settings']['jira_configuration'],
         limit=tool['settings'].get('limit', 5),
         labels=parse_list(tool['settings'].get('labels', [])),
@@ -35,12 +37,10 @@ def get_tools(tool):
 
 class JiraToolkit(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 JiraApiWrapper.model_construct().get_available_tools()}
-        JiraToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
 
         @check_connection_response
         def check_connection(self):
@@ -66,16 +66,17 @@ class JiraToolkit(BaseToolkit):
             name,
             cloud=(bool, Field(description="Hosting Option", json_schema_extra={'configuration': True})),
             limit=(int, Field(description="Limit issues. Default is 5", gt=0, default=5)),
+            api_version=(Literal['2', '3'], Field(description="Rest API version: optional. Default is 2", default="3")),
             labels=(Optional[str], Field(
                 description="List of comma separated labels used for labeling of agent's created or updated entities",
                 default=None,
                 examples="alita,elitea;another-label"
             )),
             # optional field for custom headers as dictionary
-            custom_headers=(Optional[dict], Field(description="Custom headers for API requests", default=None)),
+            custom_headers=(Optional[dict], Field(description="Custom headers for API requests", default={})),
             verify_ssl=(bool, Field(description="Verify SSL", default=True)),
             additional_fields=(Optional[str], Field(description="Additional fields", default="")),
-            jira_configuration=(Optional[JiraConfiguration], Field(description="Jira Configuration", json_schema_extra={'configuration_types': ['jira']})),
+            jira_configuration=(JiraConfiguration, Field(description="Jira Configuration", json_schema_extra={'configuration_types': ['jira']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None,
                                                                            description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
@@ -95,6 +96,7 @@ class JiraToolkit(BaseToolkit):
         return model
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -105,17 +107,21 @@ class JiraToolkit(BaseToolkit):
             **(kwargs.get('pgvector_configuration') or {}),
         }
         jira_api_wrapper = JiraApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = jira_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = f"Jira instance: {jira_api_wrapper.url}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=jira_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"Tool for Jira: '{jira_api_wrapper.base_url}'\n{tool['description']}",
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)