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

alita_sdk/tools/figma/__init__.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel, ConfigDict, Field, create_model
 from ..base.tool import BaseAction
 from .api_wrapper import FigmaApiWrapper, GLOBAL_LIMIT
 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.figma import FigmaConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -36,7 +36,6 @@ def get_tools(tool):
 
 class FigmaToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
@@ -44,7 +43,6 @@ class FigmaToolkit(BaseToolkit):
             x["name"]: x["args_schema"].schema()
             for x in FigmaApiWrapper.model_construct().get_available_tools()
         }
-        FigmaToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             global_limit=(Optional[int], Field(description="Global limit", default=GLOBAL_LIMIT)),
@@ -66,7 +64,6 @@ class FigmaToolkit(BaseToolkit):
                      "metadata": {
                          "label": "Figma",
                          "icon_url": "figma-icon.svg",
-                         "max_length": FigmaToolkit.toolkit_max_length,
                          "categories": ["other"],
                          "extra_categories": ["figma", "design", "ui/ux", "prototyping", "collaboration"],
                      }
@@ -85,18 +82,21 @@ class FigmaToolkit(BaseToolkit):
             **(kwargs.get('pgvector_configuration') or {}),
         }
         figma_api_wrapper = FigmaApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = figma_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[:1000]
             tools.append(
                 BaseAction(
                     api_wrapper=figma_api_wrapper,
-                    name=prefix + tool["name"],
-                    description=tool["description"],
+                    name=tool["name"],
+                    description=description,
                     args_schema=tool["args_schema"],
                 )
             )

alita_sdk/tools/figma/api_wrapper.py

@@ -345,7 +345,8 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
                             text_nodes[node['id']] = self.get_texts_recursive(node)
         # process image nodes
         if image_nodes:
-            images = self._client.get_file_images(file_key, image_nodes).images or {}
+            file_images = self._client.get_file_images(file_key, image_nodes)
+            images = self._client.get_file_images(file_key, image_nodes).images or {} if file_images else {}
             total_images = len(images)
             if total_images == 0:
                 logging.info(f"No images found for file {file_key}.")

alita_sdk/tools/github/__init__.py

@@ -7,7 +7,7 @@ from .api_wrapper import AlitaGitHubAPIWrapper
 from .tool import GitHubAction
 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.github import GithubConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -39,13 +39,11 @@ def get_tools(tool):
 
 class AlitaGitHubToolkit(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
                           AlitaGitHubAPIWrapper.model_construct().get_available_tools()}
-        AlitaGitHubToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             __config__=ConfigDict(
@@ -62,8 +60,7 @@ class AlitaGitHubToolkit(BaseToolkit):
                                                              json_schema_extra={'configuration_types': ['github']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector configuration", default=None,
                                                                      json_schema_extra={'configuration_types': ['pgvector']})),
-            repository=(str, Field(description="Github repository", json_schema_extra={'toolkit_name': True,
-                                                                                       'max_toolkit_length': AlitaGitHubToolkit.toolkit_max_length})),
+            repository=(str, Field(description="Github repository")),
             active_branch=(Optional[str], Field(description="Active branch", default="main")),
             base_branch=(Optional[str], Field(description="Github Base branch", default="main")),
             # embedder settings
@@ -87,17 +84,20 @@ class AlitaGitHubToolkit(BaseToolkit):
         github_api_wrapper = AlitaGitHubAPIWrapper(**wrapper_payload)
         available_tools: List[Dict] = github_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, AlitaGitHubToolkit.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         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"Repository: {github_api_wrapper.github_repository}\n{description}"
+            description = description[:1000]
             tools.append(GitHubAction(
                 api_wrapper=github_api_wrapper,
-                name=prefix + tool["name"],
+                name=tool["name"],
                 mode=tool["mode"],
-                # set unique description for declared tools to differentiate the same methods for different toolkits
-                description=f"Repository: {github_api_wrapper.github_repository}\n" + tool["description"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/tools/github/api_wrapper.py

@@ -1,9 +1,7 @@
-from typing import Any, Dict, List, Optional, Union, Tuple
 import logging
-import traceback
-import json
-import re
-from pydantic import BaseModel, model_validator, Field, SecretStr
+from typing import Any, Dict, Optional
+
+from pydantic import model_validator, Field, SecretStr
 
 from .github_client import GitHubClient
 from .graphql_client_wrapper import GraphQLClientWrapper
@@ -11,28 +9,17 @@ from .schemas import (
     GitHubAuthConfig,
     GitHubRepoConfig
 )
-
-from ..elitea_base import BaseCodeToolApiWrapper
-
-from langchain_core.callbacks import dispatch_custom_event
+from ..code_indexer_toolkit import CodeIndexerToolkit
+from ..utils.available_tools_decorator import extend_with_parent_available_tools
 
 logger = logging.getLogger(__name__)
 
 # Import prompts for tools
-from .tool_prompts import (
-    UPDATE_FILE_PROMPT,
-    CREATE_ISSUE_PROMPT,
-    UPDATE_ISSUE_PROMPT,
-    CREATE_ISSUE_ON_PROJECT_PROMPT,
-    UPDATE_ISSUE_ON_PROJECT_PROMPT
-)
 
 # Create schema models for the new indexing functionality
-from pydantic import create_model
-from typing import Literal
 
 
-class AlitaGitHubAPIWrapper(BaseCodeToolApiWrapper):
+class AlitaGitHubAPIWrapper(CodeIndexerToolkit):
     """
     Wrapper for GitHub API that integrates both REST and GraphQL functionality.
     """
@@ -117,7 +104,7 @@ class AlitaGitHubAPIWrapper(BaseCodeToolApiWrapper):
         if "llm" not in values:
             values["llm"] = None
 
-        return values
+        return super().validate_toolkit(values)
 
     # Expose GitHub REST client methods directly via property
     @property
@@ -131,7 +118,7 @@ class AlitaGitHubAPIWrapper(BaseCodeToolApiWrapper):
         """Access to GitHub GraphQL client methods"""
         return self.graphql_client_instance
 
-
+    @extend_with_parent_available_tools
     def get_available_tools(self):
         # this is horrible, I need to think on something better
         if not self.github_client_instance:
@@ -142,12 +129,8 @@ class AlitaGitHubAPIWrapper(BaseCodeToolApiWrapper):
             graphql_tools = GraphQLClientWrapper.model_construct().get_available_tools()
         else:
             graphql_tools = self.graphql_client_instance.get_available_tools()
-            
-        # Add vector search tools from base class (includes index_data + search tools)
-        vector_search_tools = self._get_vector_search_tools()
         
-        tools = github_tools + graphql_tools + vector_search_tools
-        return tools
+        return github_tools + graphql_tools
 
     def _get_files(self, path: str = "", branch: str = None):
         """Get list of files from GitHub repository."""

alita_sdk/tools/github/github_client.py

@@ -11,6 +11,7 @@ from github import Auth, Github, GithubIntegration, Repository
 from github.Consts import DEFAULT_BASE_URL
 from langchain_core.tools import ToolException
 
+from ..elitea_base import extend_with_file_operations
 from .schemas import (
     GitHubAuthConfig,
     GitHubRepoConfig,
@@ -1414,13 +1415,16 @@ class GitHubClient(BaseModel):
         except Exception as e:
             return f"File not found `{file_path}` on branch `{branch}`. Error: {str(e)}"
 
-    def _read_file(self, file_path: str, branch: str, repo_name: Optional[str] = None) -> str:
+    def _read_file(self, file_path: str, branch: str, repo_name: Optional[str] = None, **kwargs) -> str:
         """
-        Read a file from specified branch
+        Read a file from specified branch with optional partial read support.
+        
         Parameters:
             file_path(str): the file path
             branch(str): the branch to read the file from
             repo_name (Optional[str]): Name of the repository in format 'owner/repo'
+            **kwargs: Additional parameters (offset, limit, head, tail) - currently ignored,
+                     partial read handled client-side by base class methods
 
         Returns:
             str: The file decoded as a string, or an error message if not found
@@ -1445,6 +1449,61 @@ class GitHubClient(BaseModel):
             str: The file contents as a string
         """
         return self._read_file(file_path, branch if branch else self.active_branch, repo_name)
+    
+    def _write_file(
+        self,
+        file_path: str,
+        content: str,
+        branch: str = None,
+        commit_message: str = None,
+        repo_name: Optional[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
+            repo_name: Name of the repository in format 'owner/repo'
+            
+        Returns:
+            Success message
+        """
+        try:
+            repo = self.github_api.get_repo(repo_name) if repo_name else self.github_repo_instance
+            branch = branch or self.active_branch
+            
+            if branch == self.github_base_branch:
+                raise ToolException(
+                    f"Cannot commit directly to the {self.github_base_branch} branch. "
+                    "Please create a new branch and try again."
+                )
+            
+            # Check if file exists
+            try:
+                existing_file = repo.get_contents(file_path, ref=branch)
+                # File exists, update it
+                repo.update_file(
+                    path=file_path,
+                    message=commit_message or f"Update {file_path}",
+                    content=content,
+                    branch=branch,
+                    sha=existing_file.sha,
+                )
+                return f"Updated file {file_path}"
+            except:
+                # File doesn't exist, create it
+                repo.create_file(
+                    path=file_path,
+                    message=commit_message or f"Create {file_path}",
+                    content=content,
+                    branch=branch,
+                )
+                return f"Created file {file_path}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
     def loader(self,
                branch: Optional[str] = None,
@@ -1877,6 +1936,7 @@ class GitHubClient(BaseModel):
             import traceback
             return f"API call failed: {traceback.format_exc()}"
 
+    @extend_with_file_operations
     def get_available_tools(self) -> List[Dict[str, Any]]:
         return [
              {

alita_sdk/tools/gitlab/__init__.py

@@ -8,7 +8,7 @@ from pydantic.fields import Field
 
 from .api_wrapper import GitLabAPIWrapper
 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.gitlab import GitlabConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -34,16 +34,14 @@ def get_tools(tool):
 
 class AlitaGitlabToolkit(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
                           GitLabAPIWrapper.model_construct().get_available_tools()}
-        AlitaGitlabToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            repository=(str, Field(description="GitLab repository", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AlitaGitlabToolkit.toolkit_max_length})),
+            repository=(str, Field(description="GitLab repository")),
             gitlab_configuration=(GitlabConfiguration, Field(description="GitLab configuration", json_schema_extra={'configuration_types': ['gitlab']})),
             branch=(str, Field(description="Main branch", default="main")),
             # indexer settings
@@ -76,18 +74,20 @@ class AlitaGitlabToolkit(BaseToolkit):
             **(kwargs.get('embedding_configuration') or {}),
         }
         gitlab_api_wrapper = GitLabAPIWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools: List[Dict] = gitlab_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"] +  f"\nrepo: {gitlab_api_wrapper.repository}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=gitlab_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] +  f"\nrepo: {gitlab_api_wrapper.repository}",
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/tools/gitlab/api_wrapper.py

@@ -1,9 +1,15 @@
 # api_wrapper.py
-from typing import Any, Dict, List, Optional
 import fnmatch
-from ...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,18 +103,26 @@ 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()
 
+    @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
         except ImportError:
@@ -116,22 +130,34 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
                 "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]:
@@ -146,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)]
@@ -173,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):
@@ -185,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,
@@ -218,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 = (
@@ -229,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:
@@ -255,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,
@@ -272,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:
@@ -281,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 = {
@@ -290,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:
@@ -335,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)
@@ -365,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)
@@ -375,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"
@@ -405,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,
@@ -417,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 [
             {
@@ -521,4 +623,4 @@ class GitLabAPIWrapper(BaseCodeToolApiWrapper):
                 "description": "Retrieve a list of commits from the repository.",
                 "args_schema": GetCommitsModel,
             }
-        ] + self._get_vector_search_tools()
+        ]