alita-sdk 0.3.379__py3-none-any.whl → 0.3.627__py3-none-any.whl

alita_sdk/tools/google/bigquery/__init__.py

@@ -5,9 +5,10 @@ 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
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "bigquery"
 
@@ -22,11 +23,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
@@ -86,9 +82,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,14 +119,18 @@ 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"],
+                            metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: t["name"]} if toolkit_name else {TOOL_NAME_META: t["name"]}
                         )
                     )
         return instance

alita_sdk/tools/google/bigquery/tool.py

@@ -29,6 +29,10 @@ class BigQueryAction(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/google_places/__init__.py

@@ -6,8 +6,9 @@ from pydantic.fields import Field
 from .api_wrapper import GooglePlacesAPIWrapper
 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.google_places import GooglePlacesConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "google_places"
 
@@ -22,15 +23,13 @@ def get_tools(tool):
 
 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,
-            results_count=(Optional[int], Field(description="Results number to show", default=None, json_schema_extra={'toolkit_name': 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=
@@ -55,17 +54,21 @@ class GooglePlacesToolkit(BaseToolkit):
             **kwargs.get('google_places_configuration', {}),
         }
         google_places_api_wrapper = GooglePlacesAPIWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, GooglePlacesToolkit.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         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"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/google_places/api_wrapper.py

@@ -104,7 +104,7 @@ class GooglePlacesAPIWrapper(BaseToolApiWrapper):
                     "GooglePlacesFindNearSchema",
                     current_location_query=(
                     str, Field(description="Detailed user query of current user location or where to start from")),
-                    target=(str, Field(description="The target location or query which user wants to find", default=None)),
+                    target=(Optional[str], Field(description="The target location or query which user wants to find", default=None)),
                     radius=(Optional[int], Field(description="The radius of the search. This is optional field", default=3000))
                 ),
             }

alita_sdk/tools/jira/__init__.py

@@ -6,13 +6,14 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 import requests
 
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list, check_connection_response
+from ..utils import clean_string, get_max_toolkit_length, parse_list, check_connection_response
 from ...configurations.jira import JiraConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOLKIT_TYPE_META, TOOL_NAME_META
 
 name = "jira"
 
-def get_tools(tool):
+def get_toolkit(tool):
     return JiraToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
         base_url=tool['settings'].get('base_url'),
@@ -32,17 +33,18 @@ def get_tools(tool):
         embedding_model=tool['settings'].get('embedding_model'),
         vectorstore_type="PGVector",
         toolkit_name=tool.get('toolkit_name')
-    ).get_tools()
+    )
+
+def get_tools(tool):
+    return get_toolkit(tool).get_tools()
             
 
 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):
@@ -68,7 +70,7 @@ 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=(Optional[str], Field(description="Rest API version: optional. Default is 2", default="2")),
+            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,
@@ -109,18 +111,23 @@ 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.base_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']}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/jira/api_wrapper.py

@@ -453,41 +453,63 @@ class JiraApiWrapper(NonCodeIndexerToolkit):
         return super().validate_toolkit(values)
 
     def _parse_issues(self, issues: Dict) -> List[dict]:
-        parsed = []
-        for issue in issues["issues"]:
-            if len(parsed) >= self.limit:
+        parsed: List[dict] = []
+        issues_list = issues.get("issues") if isinstance(issues, dict) else None
+        if not isinstance(issues_list, list):
+            return parsed
+
+        for issue in issues_list:
+            if self.limit and len(parsed) >= self.limit:
                 break
-            issue_fields = issue["fields"]
-            key = issue["key"]
-            id = issue["id"]
-            summary = issue_fields["summary"]
-            description = issue_fields["description"]
-            created = issue_fields["created"][0:10]
-            updated = issue_fields["updated"]
-            duedate = issue_fields["duedate"]
-            priority = issue_fields["priority"]["name"]
-            status = issue_fields["status"]["name"]
-            project_id = issue_fields["project"]["id"]
-            issue_url = f"{self._client.url}browse/{key}"
-            try:
-                assignee = issue_fields["assignee"]["displayName"]
-            except Exception:
-                assignee = "None"
+
+            issue_fields = issue.get("fields") or {}
+            key = issue.get("key", "")
+            issue_id = issue.get("id", "")
+
+            summary = issue_fields.get("summary") or ""
+            description = issue_fields.get("description") or ""
+            created_raw = issue_fields.get("created") or ""
+            created = created_raw[:10] if created_raw else ""
+            updated = issue_fields.get("updated") or ""
+            duedate = issue_fields.get("duedate")
+
+            priority_info = issue_fields.get("priority") or {}
+            priority = priority_info.get("name") or "None"
+
+            status_info = issue_fields.get("status") or {}
+            status = status_info.get("name") or "Unknown"
+
+            project_info = issue_fields.get("project") or {}
+            project_id = project_info.get("id") or ""
+
+            issue_url = f"{self._client.url}browse/{key}" if key else self._client.url
+
+            assignee_info = issue_fields.get("assignee") or {}
+            assignee = assignee_info.get("displayName") or "None"
+
             rel_issues = {}
-            for related_issue in issue_fields["issuelinks"]:
-                if "inwardIssue" in related_issue.keys():
-                    rel_type = related_issue["type"]["inward"]
-                    rel_key = related_issue["inwardIssue"]["key"]
+            for related_issue in issue_fields.get("issuelinks") or []:
+                rel_type = None
+                rel_key = None
+                if related_issue.get("inwardIssue"):
+                    rel_type = related_issue.get("type", {}).get("inward")
+                    rel_key = related_issue["inwardIssue"].get("key")
                     # rel_summary = related_issue["inwardIssue"]["fields"]["summary"]
-                if "outwardIssue" in related_issue.keys():
-                    rel_type = related_issue["type"]["outward"]
-                    rel_key = related_issue["outwardIssue"]["key"]
+                elif related_issue.get("outwardIssue"):
+                    rel_type = related_issue.get("type", {}).get("outward")
+                    rel_key = related_issue["outwardIssue"].get("key")
                     # rel_summary = related_issue["outwardIssue"]["fields"]["summary"]
-                rel_issues = {"type": rel_type, "key": rel_key, "url": f"{self._client.url}browse/{rel_key}"}
+
+                if rel_type and rel_key:
+                    rel_issues = {
+                        "type": rel_type,
+                        "key": rel_key,
+                        "url": f"{self._client.url}browse/{rel_key}",
+                    }
 
             parsed_issue = {
                 "key": key,
-                "id": id,
+                "id": issue_id,
                 "projectId": project_id,
                 "summary": summary,
                 "description": description,
@@ -500,10 +522,13 @@ class JiraApiWrapper(NonCodeIndexerToolkit):
                 "url": issue_url,
                 "related_issues": rel_issues,
             }
-            for field in self.additional_fields:
-                field_value = issue_fields.get(field, None)
+
+            for field in (self.additional_fields or []):
+                field_value = issue_fields.get(field)
                 parsed_issue[field] = field_value
+
             parsed.append(parsed_issue)
+
         return parsed
 
     @staticmethod
@@ -563,7 +588,7 @@ class JiraApiWrapper(NonCodeIndexerToolkit):
         Use the appropriate issue link type (e.g., "Test", "Relates", "Blocks").
         If we use "Test" linktype, the test is inward issue, the story/other issue is outward issue.."""
 
-        comment = "This test is linked to the story."
+        comment = f"Issue {inward_issue_key} was linked to {outward_issue_key}."
         comment_body = {"content": [{"content": [{"text": comment,"type": "text"}],"type": "paragraph"}],"type": "doc","version": 1} if self.api_version == "3" else comment
         link_data = {
             "type": {"name": f"{linktype}"},
@@ -749,13 +774,24 @@ class JiraApiWrapper(NonCodeIndexerToolkit):
 
         attachment_data = []
         attachments = self._client.get_attachments_ids_from_issue(issue=jira_issue_key)
+        api_version = str(getattr(self._client, "api_version", "2"))
         for attachment in attachments:
             if attachment_pattern and not re.search(attachment_pattern, attachment['filename']):
                 logger.info(f"Skipping attachment {attachment['filename']} as it does not match pattern {attachment_pattern}")
                 continue
             logger.info(f"Processing attachment {attachment['filename']} with ID {attachment['attachment_id']}")
             try:
-                attachment_content = self._client.get_attachment_content(attachment['attachment_id'])
+                attachment_content = None
+
+                # Cloud (REST v3) attachments require signed URLs returned from metadata
+                if api_version in {"3", "latest"} or self.cloud:
+                    attachment_content = self._download_attachment_v3(
+                        attachment['attachment_id'],
+                        attachment['filename']
+                    )
+
+                if attachment_content is None:
+                    attachment_content = self._client.get_attachment_content(attachment['attachment_id'])
             except Exception as e:
                 logger.error(
                     f"Failed to download attachment {attachment['filename']} for issue {jira_issue_key}: {str(e)}")
@@ -797,15 +833,6 @@ class JiraApiWrapper(NonCodeIndexerToolkit):
         logger.debug(response_string)
         return response_string
 
-    def _extract_attachment_content(self, attachment):
-        """Extract attachment's content if possible (used for api v.2)"""
-
-        try:
-            content = self._client.get(attachment['content'].replace(self.base_url, ''))
-        except Exception as e:
-            content = f"Unable to parse content of '{attachment['filename']}' due to: {str(e)}"
-        return f"filename: {attachment['filename']}\ncontent: {content}"
-
     # Helper functions for image processing
     @staticmethod
     def _collect_context_for_image(content: str, image_marker: str, context_radius: int = 500) -> str:
@@ -1038,6 +1065,30 @@ class JiraApiWrapper(NonCodeIndexerToolkit):
             logger.error(f"Error downloading attachment: {str(e)}")
             return None
 
+    def _download_attachment_v3(self, attachment_id: str, filename: str | None = None) -> Optional[bytes]:
+        """Download Jira attachment using metadata content URL (required for REST v3 / Cloud)."""
+        try:
+            metadata = self._client.get_attachment(attachment_id)
+        except Exception as e:
+            logger.error(f"Failed to retrieve metadata for attachment {attachment_id}: {str(e)}")
+            return None
+
+        download_url = metadata.get('content') or metadata.get('_links', {}).get('content')
+
+        if not download_url:
+            logger.warning(
+                f"Attachment {attachment_id} ({filename}) metadata does not include a content URL; falling back.")
+            return None
+
+        logger.info(f"Downloading attachment {attachment_id} via metadata content URL (v3).")
+        content = self._download_attachment(download_url)
+
+        if content is None:
+            logger.error(
+                f"Failed to download attachment {attachment_id} ({filename}) from v3 content URL: {download_url}")
+
+        return content
+
     def _extract_image_data(self, field_data):
         """
         Extracts image data from general JSON response.

alita_sdk/tools/keycloak/__init__.py

@@ -5,7 +5,8 @@ from pydantic import BaseModel, ConfigDict, create_model, Field, SecretStr
 
 from .api_wrapper import KeycloakApiWrapper
 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
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "keycloak"
 
@@ -21,15 +22,13 @@ def get_tools(tool):
 
 class KeycloakToolkit(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 KeycloakApiWrapper.model_construct().get_available_tools()}
-        KeycloakToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            base_url=(str, Field(default="", title="Server URL", description="Keycloak server URL", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': KeycloakToolkit.toolkit_max_length})),
+            base_url=(str, Field(default="", title="Server URL", description="Keycloak server URL", json_schema_extra={'toolkit_name': True})),
             realm=(str, Field(default="", title="Realm", description="Keycloak realm")),
             client_id=(str, Field(default="", title="Client ID", description="Keycloak client ID")),
             client_secret=(SecretStr, Field(default="", title="Client sercet", description="Keycloak client secret", json_schema_extra={'secret': True})),
@@ -42,17 +41,21 @@ class KeycloakToolkit(BaseToolkit):
         if selected_tools is None:
             selected_tools = []
         keycloak_api_wrapper = KeycloakApiWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = keycloak_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = f"{tool['description']}\nUrl: {keycloak_api_wrapper.base_url}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=keycloak_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"{tool['description']}\nUrl: {keycloak_api_wrapper.base_url}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/localgit/__init__.py

@@ -5,6 +5,7 @@ from pydantic import BaseModel, ConfigDict, create_model, Field
 
 from .local_git import LocalGit
 from .tool import LocalGitAction
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "localgit"
 
@@ -34,7 +35,7 @@ class AlitaLocalGitToolkit(BaseToolkit):
         )
 
     @classmethod
-    def get_toolkit(cls, selected_tools: list[str] | None = None, **kwargs):
+    def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
         local_git_tool = LocalGit(**kwargs)
@@ -45,12 +46,17 @@ class AlitaLocalGitToolkit(BaseToolkit):
             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(LocalGitAction(
                 api_wrapper=local_git_tool,
                 name=repo + "_" + tool["name"],
                 mode=tool["mode"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

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 [
             {