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

alita_sdk/tools/bitbucket/api_wrapper.py

@@ -13,6 +13,8 @@ from pydantic.fields import 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, BaseCodeToolApiWrapper
+from ..utils.tool_prompts import EDIT_FILE_DESCRIPTION, UPDATE_FILE_PROMPT_NO_PATH
 
 logger = logging.getLogger(__name__)
 
@@ -37,9 +39,7 @@ CreateFileModel = create_model(
 UpdateFileModel = create_model(
     "UpdateFileModel",
     file_path=(str, Field(description="The path of the file")),
-    update_query=(str, Field(description="Contains the file contents required to be updated. "
-                                       "The old file contents is wrapped in OLD <<<< and >>>> OLD. "
-                                       "The new file contents is wrapped in NEW <<<< and >>>> NEW")),
+    update_query=(str, Field(description=UPDATE_FILE_PROMPT_NO_PATH)),
     branch=(str, Field(description="The branch to update the file in")),
 )
 
@@ -56,7 +56,7 @@ SetActiveBranchModel = create_model(
 
 ListBranchesInRepoModel = create_model(
     "ListBranchesInRepoModel",
-    limit=(Optional[int], Field(default=20, description="Maximum number of branches to return. If not provided, all branches will be returned.")),
+    limit=(Optional[int], Field(default=20, description="Maximum number of branches to return. If not provided, all branches will be returned.", gt=0)),
     branch_wildcard=(Optional[str], Field(default=None, description="Wildcard pattern to filter branches by name. If not provided, all branches will be returned."))
 )
 
@@ -93,7 +93,7 @@ DeleteFileModel = create_model(
     "DeleteFileModel",
     file_path=(str, Field(description="The path of the file")),
     branch=(str, Field(description="The branch to delete the file from")),
-    commit_message=(str, Field(default=None, description="Commit message for deleting the file. Optional.")),
+    commit_message=(Optional[str], Field(default=None, description="Commit message for deleting the file. Optional.")),
 )
 
 AppendFileModel = create_model(
@@ -123,6 +123,12 @@ class BitbucketAPIWrapper(CodeIndexerToolkit):
 
     _bitbucket: Any = PrivateAttr()
     _active_branch: Any = PrivateAttr()
+    
+    # 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
     url: str = ''
     project: str = ''
     """The key of the project this repo belongs to"""
@@ -263,11 +269,20 @@ class BitbucketAPIWrapper(CodeIndexerToolkit):
                 >>>> NEW
             branch(str): branch name (by default: active_branch)
         Returns:
-            str: A success or failure message
+            str | ToolException: A success message or a ToolException on failure.
         """
         try:
-            result = self._bitbucket.update_file(file_path=file_path, update_query=update_query, branch=branch)
-            return result if isinstance(result, ToolException) else f"File has been updated: {file_path}."
+            # Use the shared edit_file logic from BaseCodeToolApiWrapper, operating on
+            # this wrapper instance, which provides _read_file and _write_file.
+            result = self.edit_file(
+                file_path=file_path,
+                branch=branch,
+                file_query=update_query,
+            )
+            return result
+        except ToolException as e:
+            # Pass through ToolExceptions as-is so callers can handle them uniformly.
+            return e
         except Exception as e:
             return ToolException(f"File was not updated due to error: {str(e)}")
 
@@ -360,12 +375,15 @@ class BitbucketAPIWrapper(CodeIndexerToolkit):
     #     except Exception as e:
     #         raise ToolException(f"Can't extract file commit hash (`{file_path}`) due to error:\n{str(e)}")
 
-    def _read_file(self, file_path: str, branch: str) -> str:
+    def _read_file(self, file_path: str, branch: str, **kwargs) -> str:
         """
-        Reads a file from the gitlab repo
+        Reads a file from the bitbucket repo with optional partial read support.
+        
         Parameters:
             file_path(str): the file path
             branch(str): branch name (by default: active_branch)
+            **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
         """
@@ -399,8 +417,38 @@ class BitbucketAPIWrapper(CodeIndexerToolkit):
             return self._read_file(file_path, branch)
         except Exception as e:
             return f"Failed to read file {file_path}: {str(e)}"
+    
+    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) via the underlying Bitbucket client.
+
+        This delegates to the low-level BitbucketServerApi/BitbucketCloudApi `_write_file`
+        implementations, so all backend-specific commit behavior (server vs cloud) is
+        centralized there. Used by BaseCodeToolApiWrapper.edit_file.
+        """
+        branch = branch or self._active_branch
+        try:
+            # Delegate actual write/commit to the underlying API wrapper, which
+            # implements _write_file(file_path, content, branch, commit_message).
+            self._bitbucket._write_file(
+                file_path=file_path,
+                content=content,
+                branch=branch,
+                commit_message=commit_message or f"Update {file_path}",
+            )
+            return f"Update {file_path}"
+        except ToolException:
+            raise
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path} on branch {branch}: {str(e)}")
 
     @extend_with_parent_available_tools
+    @extend_with_file_operations
     def get_available_tools(self):
         return [
             {
@@ -442,7 +490,7 @@ class BitbucketAPIWrapper(CodeIndexerToolkit):
             {
                 "name": "update_file",
                 "ref": self.update_file,
-                "description": self.update_file.__doc__ or "Update the contents of a file in the repository.",
+                "description": EDIT_FILE_DESCRIPTION,
                 "args_schema": UpdateFileModel,
             },
             {

alita_sdk/tools/bitbucket/cloud_api_wrapper.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Any, Dict, List
 from atlassian.bitbucket import Bitbucket, Cloud
 from langchain_core.tools import ToolException
 from requests import Response
-from ..ado.utils import extract_old_new_pairs
+from ..utils.text_operations import parse_old_new_markers
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.DEBUG)
@@ -142,32 +142,28 @@ class BitbucketServerApi(BitbucketApiAbstract):
             filename=file_path
         )
 
-    def update_file(self, file_path: str, update_query: str, branch: str) -> str:
-        file_content = self.get_file(file_path=file_path, branch=branch)
-        updated_file_content = file_content
-        for old, new in extract_old_new_pairs(update_query):
-            if not old.strip():
-                continue
-            updated_file_content = updated_file_content.replace(old, new)
+    def _write_file(self, file_path: str, content: str, branch: str, commit_message: str) -> str:
+        """Write updated file content to Bitbucket Server.
 
-        if file_content == updated_file_content:
+        it creates a new commit on the given branch that edits the existing file.
+        """
+        # Get the latest commit on the branch (used as source_commit_id)
+        source_commit_generator = self.api_client.get_commits(project_key=self.project, repository_slug=self.repository,
+                                                              hash_newest=branch, limit=1)
+        source_commit = next(source_commit_generator, None)
+        if not source_commit:
             raise ToolException(
-                "File content was not updated because old content was not found or empty. "
-                "It may be helpful to use the read_file action to get "
-                "the current file contents."
+                f"Unable to determine latest commit on branch '{branch}' for repository '{self.repository}'."
             )
 
-        source_commit_generator = self.api_client.get_commits(project_key=self.project, repository_slug=self.repository,
-                                                              hash_newest=branch, limit=1)
-        source_commit = next(source_commit_generator)
         return self.api_client.update_file(
             project_key=self.project,
             repository_slug=self.repository,
-            content=updated_file_content,
-            message=f"Update {file_path}",
+            content=content,
+            message=commit_message or f"Update {file_path}",
             branch=branch,
             filename=file_path,
-            source_commit_id=source_commit['id']
+            source_commit_id=source_commit['id'],
         )
 
     def get_pull_request_commits(self, pr_id: str) -> List[Dict[str, Any]]:
@@ -294,7 +290,37 @@ class BitbucketCloudApi(BitbucketApiAbstract):
         return None
 
     def get_file(self, file_path: str, branch: str) -> str:
-        return self.repository.get(path=f'src/{branch}/{file_path}')
+        """Fetch a file's content from Bitbucket Cloud and return it as text.
+
+        Uses the 'get' endpoint with advanced_mode to get a rich response object.
+        """
+        try:
+            file_response = self.repository.get(
+                path=f"src/{branch}/{file_path}",
+                advanced_mode=True,
+            )
+
+            # Prefer HTTP status when available
+            status = getattr(file_response, "status_code", None)
+            if status is not None and status != 200:
+                raise ToolException(
+                    f"Failed to retrieve text from file '{file_path}' from branch '{branch}': "
+                    f"HTTP {status}"
+                )
+
+            # Safely extract text content
+            file_text = getattr(file_response, "text", None)
+            if not isinstance(file_text, str) or not file_text:
+                raise ToolException(
+                    f"File '{file_path}' from branch '{branch}' is empty or could not be retrieved."
+                )
+
+            return file_text
+        except Exception as e:
+            # Network/transport or client-level failure
+            raise ToolException(
+                f"Failed to retrieve text from file '{file_path}' from branch '{branch}': {e}"
+            )
 
     def get_files_list(self, file_path: str, branch: str) -> list:
         files_list = []
@@ -315,22 +341,10 @@ class BitbucketCloudApi(BitbucketApiAbstract):
         return self.repository.post(path='src', data=form_data, files={},
                                     headers={'Content-Type': 'application/x-www-form-urlencoded'})
 
-    def update_file(self, file_path: str, update_query: str, branch: str) -> ToolException | str:
-
-        file_content = self.get_file(file_path=file_path, branch=branch)
-        updated_file_content = file_content
-        for old, new in extract_old_new_pairs(file_query=update_query):
-            if not old.strip():
-                continue
-            updated_file_content = updated_file_content.replace(old, new)
-
-        if file_content == updated_file_content:
-            return ToolException(
-                "File content was not updated because old content was not found or empty. "
-                "It may be helpful to use the read_file action to get "
-                "the current file contents."
-            )
-        return self.create_file(file_path, updated_file_content, branch)
+    def _write_file(self, file_path: str, content: str, branch: str, commit_message: str) -> str:
+        """Write updated file content to Bitbucket Cloud.
+        """
+        return self.create_file(file_path=file_path, file_contents=content, branch=branch)
 
     def get_pull_request_commits(self, pr_id: str) -> List[Dict[str, Any]]:
         """

alita_sdk/tools/browser/__init__.py

@@ -8,7 +8,7 @@ from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
 from .google_search_rag import GoogleSearchResults
 from .crawler import SingleURLCrawler, MultiURLCrawler, GetHTMLContent, GetPDFContent
 from .wiki import WikipediaQueryRun
-from ..utils import get_max_toolkit_length, clean_string, TOOLKIT_SPLITTER
+from ..utils import get_max_toolkit_length, clean_string
 from ...configurations.browser import BrowserConfiguration
 from logging import getLogger
 
@@ -42,7 +42,6 @@ class BrowserToolkit(BaseToolkit):
             'google': GoogleSearchResults.__pydantic_fields__['args_schema'].default.schema(),
             'wiki': WikipediaQueryRun.__pydantic_fields__['args_schema'].default.schema()
         }
-        BrowserToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
 
         def validate_google_fields(cls, values):
             if 'google' in values.get('selected_tools', []):
@@ -90,7 +89,6 @@ class BrowserToolkit(BaseToolkit):
         }
 
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         if not selected_tools:
             selected_tools = [
                 'single_url_crawler',
@@ -127,7 +125,10 @@ class BrowserToolkit(BaseToolkit):
 
             # Only add the tool if it was successfully created
             if tool_entry is not None:
-                tool_entry.name = f"{prefix}{tool_entry.name}"
+                if toolkit_name:
+                    tool_entry.description = f"{tool_entry.description}\nToolkit: {toolkit_name}"
+                    tool_entry.description = tool_entry.description[:1000]
+                    tool_entry.metadata = {"toolkit_name": toolkit_name, "toolkit_type": name}
                 tools.append(tool_entry)
         return cls(tools=tools)
 

alita_sdk/tools/carrier/__init__.py

@@ -7,7 +7,7 @@ from functools import lru_cache
 from .api_wrapper import CarrierAPIWrapper
 from .tools import __all__
 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.carrier import CarrierConfiguration
 
 logger = logging.getLogger(__name__)
@@ -17,7 +17,6 @@ name = 'carrier'
 
 class AlitaCarrierToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 100
 
     @classmethod
     @lru_cache(maxsize=32)
@@ -26,7 +25,6 @@ class AlitaCarrierToolkit(BaseToolkit):
         for t in __all__:
             default = t['tool'].__pydantic_fields__['args_schema'].default
             selected_tools[t['name']] = default.schema() if default else default
-        cls.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             project_id=(Optional[str], Field(None, description="Optional project ID for scoped operations")),
@@ -70,15 +68,16 @@ class AlitaCarrierToolkit(BaseToolkit):
             logger.exception(f"[AlitaCarrierToolkit] Error initializing CarrierAPIWrapper: {e}")
             raise ValueError(f"CarrierAPIWrapper initialization error: {e}")
 
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
-
         tools = []
         for tool_def in __all__:
             if selected_tools and tool_def['name'] not in selected_tools:
                 continue
             try:
                 tool_instance = tool_def['tool'](api_wrapper=carrier_api_wrapper)
-                tool_instance.name = prefix + tool_instance.name
+                if toolkit_name:
+                    tool_instance.description = f"{tool_instance.description}\nToolkit: {toolkit_name}"
+                    tool_instance.description = tool_instance.description[:1000]
+                    tool_instance.metadata = {"toolkit_name": toolkit_name, "toolkit_type": name}
                 tools.append(tool_instance)
                 logger.info(f"[AlitaCarrierToolkit] Successfully initialized tool '{tool_instance.name}'")
             except Exception as e:

alita_sdk/tools/carrier/backend_reports_tool.py

@@ -4,7 +4,7 @@ import json
 import zipfile
 from itertools import islice
 import traceback
-from typing import Type
+from typing import Optional, Type
 from langchain_core.tools import BaseTool, ToolException
 from pydantic.fields import Field
 from pydantic import create_model, BaseModel
@@ -145,12 +145,12 @@ class CreateExcelReportTool(BaseTool):
     description: str = "Create excel report by report ID from Carrier."
     args_schema: Type[BaseModel] = create_model(
         "CreateExcelReportInput",
-        report_id=(str, Field(default=None, description="Report ID to retrieve")),
-        bucket=(str, Field(default=None, description="Bucket with jtl/log file")),
-        file_name=(str, Field(default=None, description="File name for .jtl or .log report")),
+        report_id=(Optional[str], Field(default=None, description="Report ID to retrieve")),
+        bucket=(Optional[str], Field(default=None, description="Bucket with jtl/log file")),
+        file_name=(Optional[str], Field(default=None, description="File name for .jtl or .log report")),
         **{
-            "think_time": (str, Field(default=None, description="Think time parameter")),
-            "pct": (str, Field(default=None, description="Percentile parameter")),
+            "think_time": (Optional[str], Field(default=None, description="Think time parameter")),
+            "pct": (Optional[str], Field(default=None, description="Percentile parameter")),
             "tp_threshold": (int, Field(default=None, description="Throughput threshold")),
             "rt_threshold": (int, Field(default=None, description="Response time threshold")),
             "er_threshold": (int, Field(default=None, description="Error rate threshold")),

alita_sdk/tools/carrier/run_ui_test_tool.py

@@ -1,7 +1,7 @@
 import logging
 import json
 import traceback
-from typing import Type
+from typing import Optional, Type
 from langchain_core.tools import BaseTool, ToolException
 from pydantic.fields import Field
 from pydantic import create_model, BaseModel
@@ -23,11 +23,11 @@ class RunUITestTool(BaseTool):
         "RunUITestInput",
         test_id=(str, Field(default="", description="Test ID to execute")),
         test_name=(str, Field(default="", description="Test name to execute")),
-        cpu_quota=(str, Field(default=None, description="CPU quota for the test runner")),
-        memory_quota=(str, Field(default=None, description="Memory quota for the test runner")),
-        cloud_settings=(str, Field(default=None, description="Cloud settings name for the test runner")),
-        custom_cmd=(str, Field(default=None, description="Custom command to run with the test")),
-        loops=(str, Field(default=None, description="Number of loops to run the test")),
+        cpu_quota=(Optional[str], Field(default=None, description="CPU quota for the test runner")),
+        memory_quota=(Optional[str], Field(default=None, description="Memory quota for the test runner")),
+        cloud_settings=(Optional[str], Field(default=None, description="Cloud settings name for the test runner")),
+        custom_cmd=(Optional[str], Field(default=None, description="Custom command to run with the test")),
+        loops=(Optional[str], Field(default=None, description="Number of loops to run the test")),
         proceed_with_defaults=(bool, Field(default=False, description="Proceed with default configuration. True ONLY when user directly wants to run the test with default parameters." \
         " If cpu_quota, memory_quota, cloud_settings, custom_cmd, or loops are provided, proceed_with_defaults must be False")),
     )

alita_sdk/tools/carrier/ui_reports_tool.py

@@ -2,7 +2,7 @@ import logging
 import json
 import traceback
 import datetime
-from typing import Type
+from typing import Optional, Type
 from langchain_core.tools import BaseTool, ToolException
 from pydantic.fields import Field
 from pydantic import create_model, BaseModel
@@ -19,9 +19,9 @@ class GetUIReportsTool(BaseTool):
         report_id=(str, Field(description="UI Report id to retrieve")),
         current_date=(str, Field(default=datetime.datetime.now().strftime("%Y-%m-%d"), description="Current date in YYYY-MM-DD format (auto-filled)")),
         **{
-            "name": (str, Field(default=None, description="Optional. Filter reports by name (case-insensitive, partial match)")),
-            "start_time": (str, Field(default=None, description="Start date/time for filtering reports (YYYY-MM-DD or ISO format)")),
-            "end_time": (str, Field(default=None, description="End date/time for filtering reports (YYYY-MM-DD or ISO format)")),
+            "name": (Optional[str], Field(default=None, description="Optional. Filter reports by name (case-insensitive, partial match)")),
+            "start_time": (Optional[str], Field(default=None, description="Start date/time for filtering reports (YYYY-MM-DD or ISO format)")),
+            "end_time": (Optional[str], Field(default=None, description="End date/time for filtering reports (YYYY-MM-DD or ISO format)")),
         }
     )
 
@@ -178,7 +178,7 @@ class GetUITestsTool(BaseTool):
     args_schema: Type[BaseModel] = create_model(
         "GetUITestsInput",
         **{
-            "name": (str, Field(default=None, description="Optional. Filter tests by name (case-insensitive, partial match)")),
+            "name": (Optional[str], Field(default=None, description="Optional. Filter tests by name (case-insensitive, partial match)")),
             "include_schedules": (bool, Field(default=False, description="Optional. Include test schedules in the response")),
             "include_config": (bool, Field(default=False, description="Optional. Include detailed configuration in the response")),
         }

alita_sdk/tools/chunkers/__init__.py

@@ -3,6 +3,7 @@ from .sematic.statistical_chunker import statistical_chunker
 from .sematic.markdown_chunker import markdown_chunker
 from .sematic.proposal_chunker import proposal_chunker
 from .sematic.json_chunker import json_chunker
+from .universal_chunker import universal_chunker, chunk_single_document, get_file_type
 from .models import StatisticalChunkerConfig, MarkdownChunkerConfig, ProposalChunkerConfig
 
 __all__ = {
@@ -10,7 +11,8 @@ __all__ = {
     'statistical': statistical_chunker,
     'markdown': markdown_chunker,
     'proposal': proposal_chunker,
-    'json': json_chunker
+    'json': json_chunker,
+    'universal': universal_chunker,
 }
 
 __confluence_chunkers__ = {

alita_sdk/tools/chunkers/code/treesitter/treesitter.py

@@ -40,25 +40,49 @@ class Treesitter(ABC):
         return TreesitterRegistry.create_treesitter(language)
 
     def parse(self, file_bytes: bytes) -> list[TreesitterMethodNode]:
-        """
-        Parses the given file bytes and extracts method nodes.
+        """Parses the given file bytes and extracts method nodes.
+
+        If no nodes matching the configured ``method_declaration_identifier`` are
+        found, a single fallback node spanning the entire file is returned so
+        that callers always receive at least one ``TreesitterMethodNode``.
 
         Args:
             file_bytes (bytes): The content of the file to be parsed.
 
         Returns:
-            list[TreesitterMethodNode]: A list of TreesitterMethodNode objects representing the methods in the file.
+            list[TreesitterMethodNode]: A list of TreesitterMethodNode objects
+            representing the methods in the file, or a single fallback node
+            covering the whole file when no methods are detected.
         """
         self.tree = self.parser.parse(file_bytes)
-        result = []
         methods = self._query_all_methods(self.tree.root_node)
-        for method in methods:
-            method_name = self._query_method_name(method["method"])
-            doc_comment = method["doc_comment"]
-            result.append(
-                TreesitterMethodNode(method_name, doc_comment, None, method["method"])
+
+        # Normal path: at least one method node was found.
+        if methods:
+            result: list[TreesitterMethodNode] = []
+            for method in methods:
+                method_name = self._query_method_name(method["method"])
+                doc_comment = method["doc_comment"]
+                result.append(
+                    TreesitterMethodNode(
+                        method_name, doc_comment, None, method["method"]
+                    )
+                )
+            return result
+
+        # Fallback path: no method nodes were found. Return a single node that
+        # spans the entire file so that callers can still index/summarize the
+        # content even when the language-specific patterns do not match.
+        full_source = file_bytes.decode(errors="replace")
+        fallback_node = self.tree.root_node
+        return [
+            TreesitterMethodNode(
+                name=None,
+                doc_comment=None,
+                method_source_code=full_source,
+                node=fallback_node,
             )
-        return result
+        ]
 
     def _query_all_methods(
         self,
@@ -71,7 +95,8 @@ class Treesitter(ABC):
             node (tree_sitter.Node): The root node to start the query from.
 
         Returns:
-            list: A list of dictionaries, each containing a method node and its associated doc comment (if any).
+            list: A list of dictionaries, each containing a method node and its
+            associated doc comment (if any).
         """
         methods = []
         if node.type == self.method_declaration_identifier:
@@ -88,8 +113,7 @@ class Treesitter(ABC):
         return methods
 
     def _query_method_name(self, node: tree_sitter.Node):
-        """
-        Queries the method name from the given syntax tree node.
+        """Queries the method name from the given syntax tree node.
 
         Args:
             node (tree_sitter.Node): The syntax tree node to query.

alita_sdk/tools/chunkers/sematic/json_chunker.py

@@ -17,6 +17,7 @@ def json_chunker(file_content_generator: Generator[Document, None, None], config
             for chunk in chunks:
                 metadata = doc.metadata.copy()
                 metadata['chunk_id'] = chunk_id
+                metadata['method_name'] = 'json'
                 chunk_id += 1
                 yield Document(page_content=json.dumps(chunk), metadata=metadata)
         except Exception as e: