alita-sdk 0.3.554__py3-none-any.whl → 0.3.603__py3-none-any.whl

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/cloud/aws/__init__.py

@@ -7,6 +7,7 @@ from .api_wrapper import AWSToolConfig
 from ...base.tool import BaseAction
 from ...elitea_base import filter_missconfigured_index_tools
 from ...utils import clean_string, get_max_toolkit_length
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "aws"
 
@@ -64,7 +65,7 @@ class AWSToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                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/cloud/azure/__init__.py

@@ -7,6 +7,7 @@ from .api_wrapper import AzureApiWrapper
 from ...base.tool import BaseAction
 from ...elitea_base import filter_missconfigured_index_tools
 from ...utils import clean_string, get_max_toolkit_length
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "azure"
 
@@ -57,7 +58,7 @@ class AzureToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                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/cloud/gcp/__init__.py

@@ -7,6 +7,7 @@ from .api_wrapper import GCPApiWrapper
 from ...base.tool import BaseAction
 from ...elitea_base import filter_missconfigured_index_tools
 from ...utils import clean_string, get_max_toolkit_length
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "gcp"
 
@@ -51,7 +52,7 @@ class GCPToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                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/cloud/k8s/__init__.py

@@ -7,6 +7,7 @@ from .api_wrapper import KubernetesApiWrapper
 from ...base.tool import BaseAction
 from ...elitea_base import filter_missconfigured_index_tools
 from ...utils import clean_string, get_max_toolkit_length
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "kubernetes"
 
@@ -61,7 +62,7 @@ class KubernetesToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                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/code/linter/__init__.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, create_model, Field
 from .api_wrapper import PythonLinter
 from ...base.tool import BaseAction
 from ...utils import clean_string, get_max_toolkit_length
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "python_linter"
 
@@ -49,7 +50,7 @@ class PythonLinterToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                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/code/sonar/__init__.py

@@ -7,6 +7,7 @@ from ...base.tool import BaseAction
 from ...elitea_base import filter_missconfigured_index_tools
 from ...utils import clean_string, get_max_toolkit_length
 from ....configurations.sonar import SonarConfiguration
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "sonar"
 
@@ -65,7 +66,7 @@ class SonarToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                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/code_indexer_toolkit.py

@@ -38,12 +38,14 @@ class CodeIndexerToolkit(BaseIndexerToolkit):
             branch: Optional[str] = None,
             whitelist: Optional[List[str]] = None,
             blacklist: Optional[List[str]] = None,
+            chunking_config: Optional[dict] = None,
             **kwargs) -> Generator[Document, None, None]:
         """Index repository files in the vector store using code parsing."""
         yield from self.loader(
             branch=branch,
             whitelist=whitelist,
-            blacklist=blacklist
+            blacklist=blacklist,
+            chunking_config=chunking_config
         )
 
     def _extend_data(self, documents: Generator[Document, None, None]):
@@ -67,7 +69,8 @@ class CodeIndexerToolkit(BaseIndexerToolkit):
                branch: Optional[str] = None,
                whitelist: Optional[List[str]] = None,
                blacklist: Optional[List[str]] = None,
-               chunked: bool = True) -> Generator[Document, None, None]:
+               chunked: bool = True,
+               chunking_config: Optional[dict] = None) -> Generator[Document, None, None]:
         """
         Generates Documents from files in a branch, respecting whitelist and blacklist patterns.
     
@@ -77,6 +80,7 @@ class CodeIndexerToolkit(BaseIndexerToolkit):
         - blacklist (Optional[List[str]]): File extensions or paths to exclude. Defaults to no exclusions if None.
         - chunked (bool): If True (default), applies universal chunker based on file type.
                          If False, returns raw Documents without chunking.
+        - chunking_config (Optional[dict]): Chunking configuration by file extension
     
         Returns:
         - generator: Yields Documents from files matching the whitelist but not the blacklist.
@@ -101,6 +105,19 @@ class CodeIndexerToolkit(BaseIndexerToolkit):
         """
         import hashlib
     
+        # Auto-include extensions from chunking_config if whitelist is specified
+        # This allows chunking config to work without manually adding extensions to whitelist
+        if chunking_config and whitelist:
+            for ext_pattern in chunking_config.keys():
+                # Normalize extension pattern (both ".cbl" and "*.cbl" should work)
+                normalized = ext_pattern if ext_pattern.startswith('*') else f'*{ext_pattern}'
+                if normalized not in whitelist:
+                    whitelist.append(normalized)
+                    self._log_tool_event(
+                        message=f"Auto-included extension '{normalized}' from chunking_config",
+                        tool_name="loader"
+                    )
+    
         _files = self.__handle_get_files("", self.__get_branch(branch))
         self._log_tool_event(message="Listing files in branch", tool_name="loader")
         logger.info(f"Files in branch: {_files}")

alita_sdk/tools/confluence/__init__.py

@@ -10,6 +10,7 @@ from ..utils import clean_string, get_max_toolkit_length, parse_list, check_conn
 from ...configurations.confluence import ConfluenceConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 import requests
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "confluence"
 
@@ -70,16 +71,16 @@ class ConfluenceToolkit(BaseToolkit):
             name,
             space=(str, Field(description="Space")),
             cloud=(bool, Field(description="Hosting Option", json_schema_extra={'configuration': True})),
-            limit=(int, Field(description="Pages limit per request", default=5)),
+            limit=(int, Field(description="Pages limit per request", default=5, gt=0)),
             labels=(Optional[str], Field(
                 description="List of comma separated labels used for labeling of agent's created or updated entities",
                 default=None,
                 examples="alita,elitea;another-label"
             )),
-            max_pages=(int, Field(description="Max total pages", default=10)),
-            number_of_retries=(int, Field(description="Number of retries", default=2)),
-            min_retry_seconds=(int, Field(description="Min retry, sec", default=10)),
-            max_retry_seconds=(int, Field(description="Max retry, sec", default=60)),
+            max_pages=(int, Field(description="Max total pages", default=10, gt=0)),
+            number_of_retries=(int, Field(description="Number of retries", default=2, ge=0)),
+            min_retry_seconds=(int, Field(description="Min retry, sec", default=10, ge=0)),
+            max_retry_seconds=(int, Field(description="Max retry, sec", default=60, ge=0)),
             # optional field for custom headers as dictionary
             custom_headers=(Optional[dict], Field(description="Custom headers for API requests", default={})),
             confluence_configuration=(ConfluenceConfiguration, Field(description="Confluence Configuration", json_schema_extra={'configuration_types': ['confluence']})),
@@ -131,7 +132,7 @@ class ConfluenceToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                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/confluence/api_wrapper.py

@@ -1730,8 +1730,8 @@ class ConfluenceAPIWrapper(NonCodeIndexerToolkit):
             "page_ids": (Optional[List[str]], Field(description="List of page IDs to retrieve.", default=None)),
             "label": (Optional[str], Field(description="Label to filter pages.", default=None)),
             "cql": (Optional[str], Field(description="CQL query to filter pages.", default=None)),
-            "limit": (Optional[int], Field(description="Limit the number of results.", default=10)),
-            "max_pages": (Optional[int], Field(description="Maximum number of pages to retrieve.", default=1000)),
+            "limit": (Optional[int], Field(description="Limit the number of results.", default=10, gt=0)),
+            "max_pages": (Optional[int], Field(description="Maximum number of pages to retrieve.", default=1000, gt=0)),
             "include_restricted_content": (Optional[bool], Field(description="Include restricted content.", default=False)),
             "include_archived_content": (Optional[bool], Field(description="Include archived content.", default=False)),
             "include_attachments": (Optional[bool], Field(description="Include attachments.", default=False)),

alita_sdk/tools/custom_open_api/__init__.py

@@ -6,6 +6,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 from .api_wrapper import OpenApiWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "openapi"
 
@@ -57,7 +58,7 @@ class OpenApiToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                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/elastic/__init__.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, ConfigDict, create_model, Field, SecretStr
 from .api_wrapper import ELITEAElasticApiWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, get_max_toolkit_length
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "elastic"
 
@@ -58,7 +59,7 @@ class ElasticToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                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/elitea_base.py

@@ -842,7 +842,7 @@ class BaseCodeToolApiWrapper(BaseVectorStoreToolApiWrapper):
         Raises:
             ToolException: If file is not text-editable or edit fails
         """
-        from .utils.text_operations import parse_old_new_markers, is_text_editable
+        from .utils.text_operations import parse_old_new_markers, is_text_editable, try_apply_edit
         from langchain_core.callbacks import dispatch_custom_event
         
         # Validate file is text-editable
@@ -863,26 +863,45 @@ class BaseCodeToolApiWrapper(BaseVectorStoreToolApiWrapper):
         # Read current file content
         try:
             current_content = self._read_file(file_path, branch)
+            if not isinstance(current_content, str):
+                # If current_content is a ToolException or any non-str, raise or return it
+                raise current_content if isinstance(current_content, Exception) else ToolException(str(current_content))
         except Exception as e:
             raise ToolException(f"Failed to read file {file_path}: {e}")
         
-        # Apply all edits
+        # Apply all edits (with tolerant fallback)
         updated_content = current_content
+        fallbacks_used = 0
+        edits_applied = 0
         for old_text, new_text in edits:
             if not old_text.strip():
                 continue
             
-            if old_text not in updated_content:
+            new_updated, used_fallback = try_apply_edit(
+                content=updated_content,
+                old_text=old_text,
+                new_text=new_text,
+                file_path=file_path,
+            )
+
+            if new_updated == updated_content:
+                # No change applied for this pair (exact nor fallback)
                 logger.warning(
-                    f"Old content not found in {file_path}. "
-                    f"Looking for: {old_text[:100]}..."
+                    "Old content not found or could not be safely matched in %s. Snippet: %s...",
+                    file_path,
+                    old_text[:100].replace("\n", "\\n"),
                 )
                 continue
-            
-            updated_content = updated_content.replace(old_text, new_text)
+
+            # A replacement was applied
+            edits_applied += 1
+            if used_fallback:
+                fallbacks_used += 1
+
+            updated_content = new_updated
         
         # Check if any changes were made
-        if current_content == updated_content:
+        if current_content == updated_content or edits_applied == 0:
             return (
                 f"No changes made to {file_path}. "
                 "Old content was not found or is empty. "
@@ -908,7 +927,7 @@ class BaseCodeToolApiWrapper(BaseVectorStoreToolApiWrapper):
                 "tool_name": "edit_file",
                 "toolkit": self.__class__.__name__,
                 "operation_type": "modify",
-                "edits_applied": len(edits)
+                "edits_applied": edits_applied,
             })
         except Exception as e:
             logger.warning(f"Failed to dispatch file_modified event: {e}")

alita_sdk/tools/figma/__init__.py

@@ -1,14 +1,20 @@
-from typing import List, Literal, Optional
+from typing import Dict, List, Literal, Optional
 
 from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import BaseModel, ConfigDict, Field, create_model
 
 from ..base.tool import BaseAction
-from .api_wrapper import FigmaApiWrapper, GLOBAL_LIMIT
+from .api_wrapper import (
+    FigmaApiWrapper,
+    GLOBAL_LIMIT,
+    DEFAULT_FIGMA_IMAGES_PROMPT,
+    DEFAULT_FIGMA_SUMMARY_PROMPT,
+    DEFAULT_NUMBER_OF_THREADS,
+)
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.figma import FigmaConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "figma"
 
@@ -28,7 +34,14 @@ def get_tools(tool):
             collection_name=str(tool['toolkit_name']),
             doctype='doc',
             embedding_model=tool['settings'].get('embedding_model'),
-            vectorstore_type="PGVector"
+            vectorstore_type="PGVector",
+            # figma summary/image prompt settings (toolkit-level)
+            # TODO disabled until new requirements
+            # apply_images_prompt=tool["settings"].get("apply_images_prompt"),
+            # images_prompt=tool["settings"].get("images_prompt"),
+            # apply_summary_prompt=tool["settings"].get("apply_summary_prompt"),
+            # summary_prompt=tool["settings"].get("summary_prompt"),
+            # number_of_threads=tool["settings"].get("number_of_threads"),
         )
         .get_tools()
     )
@@ -45,7 +58,40 @@ class FigmaToolkit(BaseToolkit):
         }
         return create_model(
             name,
-            global_limit=(Optional[int], Field(description="Global limit", default=GLOBAL_LIMIT)),
+            # TODO disabled until new requirements
+            # apply_images_prompt=(Optional[bool], Field(
+            #     description="Enable advanced image processing instructions for Figma image nodes.",
+            #     default=True,
+            # )),
+            # images_prompt=(Optional[Dict[str, str]], Field(
+            #     description=(
+            #         "Instruction for how to analyze image-based nodes "
+            #         "(screenshots, diagrams, etc.) during Figma file retrieving. "
+            #         "Must contain a single 'prompt' key with the text."
+            #     ),
+            #     default=DEFAULT_FIGMA_IMAGES_PROMPT,
+            # )),
+            # apply_summary_prompt=(Optional[bool], Field(
+            #     description="Enable LLM-based summarization over loaded Figma data.",
+            #     default=True,
+            # )),
+            # summary_prompt=(Optional[Dict[str, str]], Field(
+            #     description=(
+            #         "Instruction for the LLM on how to summarize loaded Figma data. "
+            #         "Must contain a single 'prompt' key with the text."
+            #     ),
+            #     default=DEFAULT_FIGMA_SUMMARY_PROMPT,
+            # )),
+            number_of_threads=(Optional[int], Field(
+                description=(
+                    "Number of worker threads to use when downloading and processing Figma images. "
+                    f"Valid values are from 1 to 5. Default is {DEFAULT_NUMBER_OF_THREADS}."
+                ),
+                default=DEFAULT_NUMBER_OF_THREADS,
+                ge=1,
+                le=5,
+            )),
+            global_limit=(Optional[int], Field(description="Global limit", default=GLOBAL_LIMIT, gt=0)),
             global_regexp=(Optional[str], Field(description="Global regex pattern", default=None)),
             selected_tools=(
                 List[Literal[tuple(selected_tools)]],
@@ -98,7 +144,7 @@ class FigmaToolkit(BaseToolkit):
                     name=tool["name"],
                     description=description,
                     args_schema=tool["args_schema"],
-                    metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                    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)