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

alita_sdk/tools/gitlab_org/__init__.py

@@ -6,7 +6,7 @@ from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 
 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
 
 name = "gitlab_org"
@@ -22,16 +22,12 @@ 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=(GitlabConfiguration, Field(description="GitLab configuration",
                                                                        json_schema_extra={
                                                                            'configuration_types': ['gitlab']})),
@@ -63,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
@@ -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

@@ -6,7 +6,7 @@ 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
 
 name = "google_places"
@@ -22,15 +22,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,16 +53,19 @@ 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"],
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/tools/jira/__init__.py

@@ -6,7 +6,7 @@ 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
 
@@ -37,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):
@@ -68,7 +66,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,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)

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,23 +774,31 @@ 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']}")
-            if self.api_version == "3":
-                attachment_data.append(self._client.get_attachment_content(attachment['attachment_id']))
-            else:
-                try:
+            try:
+                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)}")
-                    attachment_content = self._client.get(
-                        path=f"secure/attachment/{attachment['attachment_id']}/{attachment['filename']}", not_json_response=True)
-                content_docs = process_content_by_type(attachment_content, attachment['filename'], llm=self.llm)
-                attachment_data.append("filename: " + attachment['filename'] + "\ncontent: " + str([doc.page_content for doc in content_docs]))
+            except Exception as e:
+                logger.error(
+                    f"Failed to download attachment {attachment['filename']} for issue {jira_issue_key}: {str(e)}")
+                attachment_content = self._client.get(
+                    path=f"secure/attachment/{attachment['attachment_id']}/{attachment['filename']}", not_json_response=True)
+            content_docs = process_content_by_type(attachment_content, attachment['filename'], llm=self.llm, fallback_extensions=[".txt", ".png"])
+            attachment_data.append("filename: " + attachment['filename'] + "\ncontent: " + str([doc.page_content for doc in content_docs]))
 
         return "\n\n".join(attachment_data)
 
@@ -800,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:
@@ -1041,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.
@@ -1330,7 +1378,7 @@ class JiraApiWrapper(NonCodeIndexerToolkit):
 
             # Use provided JQL query or default to all issues
             if not jql:
-                jql_query = "ORDER BY updated DESC"  # Default to get all issues ordered by update time
+                jql_query = "created >= \"1970-01-01\" ORDER BY updated DESC"  # Default to get all issues ordered by update time
             else:
                 jql_query = jql
 

alita_sdk/tools/keycloak/__init__.py

@@ -5,7 +5,7 @@ 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
 
 name = "keycloak"
 
@@ -21,15 +21,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,16 +40,19 @@ 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}",
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         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
+from ..utils.text_operations import parse_old_new_markers
 
 logger = logging.getLogger(__name__)
 CREATE_FILE_PROMPT = """Create new file in your local repository."""
@@ -128,58 +129,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 +182,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 +315,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 +333,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/memory/__init__.py

@@ -61,7 +61,7 @@ class MemoryToolkit(BaseToolkit):
 
         return create_model(
             'memory',
-            namespace=(str, Field(description="Memory namespace", json_schema_extra={'toolkit_name': True})),
+            namespace=(str, Field(description="Memory namespace")),
             pgvector_configuration=(PgVectorConfiguration, Field(description="PgVector Configuration",
                                                                            json_schema_extra={
                                                                                'configuration_types': ['pgvector']})),

alita_sdk/tools/non_code_indexer_toolkit.py

@@ -6,11 +6,12 @@ from alita_sdk.tools.base_indexer_toolkit import BaseIndexerToolkit
 
 
 class NonCodeIndexerToolkit(BaseIndexerToolkit):
-    def _get_indexed_data(self, collection_suffix: str):
+    def _get_indexed_data(self, index_name: str):
+        self._ensure_vectorstore_initialized()
         if not self.vector_adapter:
             raise ToolException("Vector adapter is not initialized. "
                              "Check your configuration: embedding_model and vectorstore_type.")
-        return self.vector_adapter.get_indexed_data(self, collection_suffix)
+        return self.vector_adapter.get_indexed_data(self, index_name)
 
     def key_fn(self, document: Document):
         return document.metadata.get('id')