alita-sdk 0.3.532__py3-none-any.whl → 0.3.602__py3-none-any.whl

alita_sdk/tools/ado/work_item/ado_wrapper.py

@@ -127,7 +127,29 @@ class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
             cls._core_client = connection.clients_v7_1.get_core_client()
 
         except Exception as e:
-            return ImportError(f"Failed to connect to Azure DevOps: {e}")
+            error_msg = str(e).lower()
+            if "expired" in error_msg or "token" in error_msg and ("invalid" in error_msg or "unauthorized" in error_msg):
+                raise ValueError(
+                    "Azure DevOps connection failed: Your access token has expired or is invalid. "
+                    "Please refresh your token in the toolkit configuration."
+                )
+            elif "401" in error_msg or "unauthorized" in error_msg:
+                raise ValueError(
+                    "Azure DevOps connection failed: Authentication failed. "
+                    "Please check your credentials in the toolkit configuration."
+                )
+            elif "404" in error_msg or "not found" in error_msg:
+                raise ValueError(
+                    "Azure DevOps connection failed: Organization or project not found. "
+                    "Please verify your organization URL and project name."
+                )
+            elif "timeout" in error_msg or "timed out" in error_msg:
+                raise ValueError(
+                    "Azure DevOps connection failed: Connection timed out. "
+                    "Please check your network connection and try again."
+                )
+            else:
+                raise ValueError(f"Azure DevOps connection failed: {e}")
 
         return super().validate_toolkit(values)
 
@@ -576,9 +598,40 @@ class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
         return b"".join(content_generator)
 
     def _process_document(self, document: Document) -> Generator[Document, None, None]:
-        for attachment_id, file_name in document.metadata.get('attachment_ids', {}).items():
+        raw_attachment_ids = document.metadata.get('attachment_ids', {})
+
+        # Normalize attachment_ids: accept dict or JSON string, raise otherwise
+        if isinstance(raw_attachment_ids, str):
+            try:
+                loaded = json.loads(raw_attachment_ids)
+            except json.JSONDecodeError:
+                raise TypeError(
+                    f"Expected dict or JSON string for 'attachment_ids', got non-JSON string for id="
+                    f"{document.metadata.get('id')}: {raw_attachment_ids!r}"
+                )
+            if not isinstance(loaded, dict):
+                raise TypeError(
+                    f"'attachment_ids' JSON did not decode to dict for id={document.metadata.get('id')}: {loaded!r}"
+                )
+            attachment_ids = loaded
+        elif isinstance(raw_attachment_ids, dict):
+            attachment_ids = raw_attachment_ids
+        else:
+            raise TypeError(
+                f"Expected 'attachment_ids' to be dict or JSON string, got {type(raw_attachment_ids)} "
+                f"for id={document.metadata.get('id')}: {raw_attachment_ids!r}"
+            )
+
+        for attachment_id, file_name in attachment_ids.items():
             content = self.get_attachment_content(attachment_id=attachment_id)
-            yield Document(page_content="", metadata={'id': attachment_id, IndexerKeywords.CONTENT_FILE_NAME.value: file_name, IndexerKeywords.CONTENT_IN_BYTES.value: content})
+            yield Document(
+                page_content="",
+                metadata={
+                    'id': attachment_id,
+                    IndexerKeywords.CONTENT_FILE_NAME.value: file_name,
+                    IndexerKeywords.CONTENT_IN_BYTES.value: content,
+                },
+            )
 
     def _index_tool_params(self):
         """Return the parameters for indexing data."""

alita_sdk/tools/advanced_jira_mining/__init__.py

@@ -7,6 +7,7 @@ from .data_mining_wrapper import AdvancedJiraMiningWrapper
 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 = "advanced_jira_mining"
 
@@ -78,7 +79,7 @@ class AdvancedJiraMiningToolkit(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/aws/delta_lake/__init__.py

@@ -9,6 +9,7 @@ from alita_sdk.configurations.delta_lake import DeltaLakeConfiguration
 from ...utils import clean_string, get_max_toolkit_length
 from .api_wrapper import DeltaLakeApiWrapper
 from .tool import DeltaLakeAction
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "delta_lake"
 
@@ -126,7 +127,7 @@ class DeltaLakeToolkit(BaseToolkit):
                             name=t["name"],
                             description=description,
                             args_schema=t["args_schema"],
-                            metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                            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/azure_ai/search/__init__.py

@@ -9,6 +9,7 @@ from ...elitea_base import filter_missconfigured_index_tools
 from ...utils import clean_string, get_max_toolkit_length, check_connection_response
 from ....configurations.azure_search import AzureSearchConfiguration
 import requests
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 logger = getLogger(__name__)
 
@@ -91,7 +92,7 @@ class AzureSearchToolkit(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/azure_ai/search/api_wrapper.py

@@ -11,7 +11,7 @@ logger = logging.getLogger(__name__)
 
 class AzureSearchInput(BaseModel):
     search_text: str = Field(..., description="The text to search for in the Azure Search index.")
-    limit: int = Field(10, description="The number of results to return.")
+    limit: int = Field(10, description="The number of results to return.", gt=0)
     selected_fields: Optional[List[str]] = Field(None, description="The fields to retrieve from the document.")
 
 class AzureDocumentInput(BaseModel):

alita_sdk/tools/base_indexer_toolkit.py

@@ -29,12 +29,6 @@ class IndexTools(str, Enum):
     REMOVE_INDEX = "remove_index"
     LIST_COLLECTIONS = "list_collections"
 
-# Base Vector Store Schema Models
-BaseIndexParams = create_model(
-    "BaseIndexParams",
-    index_name=(str, Field(description="Index name (max 7 characters)", min_length=1, max_length=7)),
-)
-
 RemoveIndexParams = create_model(
     "RemoveIndexParams",
     index_name=(Optional[str], Field(description="Optional index name (max 7 characters)", default="", max_length=7)),
@@ -52,7 +46,7 @@ BaseSearchParams = create_model(
         examples=["{\"key\": \"value\"}", "{\"status\": \"active\"}"]
     )),
     cut_off=(Optional[float], Field(description="Cut-off score for search results", default=DEFAULT_CUT_OFF, ge=0, le=1)),
-    search_top=(Optional[int], Field(description="Number of top results to return", default=10)),
+    search_top=(Optional[int], Field(description="Number of top results to return", default=10, gt=0)),
     full_text_search=(Optional[Dict[str, Any]], Field(
         description="Full text search parameters. Can be a dictionary with search options.",
         default=None
@@ -82,7 +76,7 @@ BaseStepbackSearchParams = create_model(
         examples=["{\"key\": \"value\"}", "{\"status\": \"active\"}"]
     )),
     cut_off=(Optional[float], Field(description="Cut-off score for search results", default=DEFAULT_CUT_OFF, ge=0, le=1)),
-    search_top=(Optional[int], Field(description="Number of top results to return", default=10)),
+    search_top=(Optional[int], Field(description="Number of top results to return", default=10, gt=0)),
     full_text_search=(Optional[Dict[str, Any]], Field(
         description="Full text search parameters. Can be a dictionary with search options.",
         default=None
@@ -101,16 +95,6 @@ BaseStepbackSearchParams = create_model(
         )),
 )
 
-BaseIndexDataParams = create_model(
-    "indexData",
-    __base__=BaseIndexParams,
-    clean_index=(Optional[bool], Field(default=False,
-                       description="Optional flag to enforce clean existing index before indexing new data")),
-    progress_step=(Optional[int], Field(default=10, ge=0, le=100,
-                         description="Optional step size for progress reporting during indexing")),
-    chunking_config=(Optional[dict], Field(description="Chunking tool configuration", default=loaders_allowed_to_override)),
-)
-
 
 class BaseIndexerToolkit(VectorStoreWrapperBase):
     """Base class for tool API wrappers that support vector store functionality."""
@@ -202,7 +186,7 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
             #
             results_count = result["count"]
             # Final update should always be forced
-            self.index_meta_update(index_name, IndexerKeywords.INDEX_META_COMPLETED.value, results_count, update_force=True)
+            self.index_meta_update(index_name, IndexerKeywords.INDEX_META_COMPLETED.value, results_count, update_force=True, error=None)
             self._emit_index_event(index_name)
             #
             return {"status": "ok", "message": f"successfully indexed {results_count} documents" if results_count > 0
@@ -211,8 +195,8 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
             # Do maximum effort at least send custom event for supposed changed status
             msg = str(e)
             try:
-                # Error update should also be forced
-                self.index_meta_update(index_name, IndexerKeywords.INDEX_META_FAILED.value, result["count"], update_force=True)
+                # Error update should also be forced and include the error message
+                self.index_meta_update(index_name, IndexerKeywords.INDEX_META_FAILED.value, result["count"], update_force=True, error=msg)
             except Exception as ie:
                 logger.error(f"Failed to update index meta status to FAILED for index '{index_name}': {ie}")
                 msg = f"{msg}; additionally failed to update index meta status to FAILED: {ie}"
@@ -236,7 +220,7 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
             self._log_tool_event(f"Dependent documents were processed. "
                                  f"Applying chunking tool '{chunking_tool}' if specified and preparing documents for indexing...")
             documents = self._apply_loaders_chunkers(documents, chunking_tool, chunking_config)
-            self._clean_metadata(documents)
+            documents = self._clean_metadata(documents)
 
             logger.debug(f"Indexing base document #{base_doc_counter}: {base_doc} and all dependent documents: {documents}")
 
@@ -521,12 +505,14 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
                 "task_id": None,
                 "conversation_id": None,
                 "toolkit_id": self.toolkit_id,
+                # Initialize error field to keep track of the latest failure reason if any
+                "error": None,
             }
             metadata["history"] = json.dumps([metadata])
             index_meta_doc = Document(page_content=f"{IndexerKeywords.INDEX_META_TYPE.value}_{index_name}", metadata=metadata)
             add_documents(vectorstore=self.vectorstore, documents=[index_meta_doc])
 
-    def index_meta_update(self, index_name: str, state: str, result: int, update_force: bool = True, interval: Optional[float] = None):
+    def index_meta_update(self, index_name: str, state: str, result: int, update_force: bool = True, interval: Optional[float] = None, error: Optional[str] = None):
         """Update `index_meta` document with optional time-based throttling.
 
         Args:
@@ -538,6 +524,7 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
             interval: Optional custom interval (in seconds) for this call when `update_force` is `False`.
                       If `None`, falls back to the value stored in `self._index_meta_config["update_interval"]`
                       if present, otherwise uses `INDEX_META_UPDATE_INTERVAL`.
+            error: Optional error message to record when the state represents a failed index.
         """
         self._ensure_vectorstore_initialized()
         if not hasattr(self, "_index_meta_last_update_time"):
@@ -576,6 +563,12 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
             metadata["updated"] = result
             metadata["state"] = state
             metadata["updated_on"] = time.time()
+            # Attach error if provided, else clear on success
+            if error is not None:
+                metadata["error"] = error
+            elif state == IndexerKeywords.INDEX_META_COMPLETED.value:
+                # Clear previous error on successful completion
+                metadata["error"] = None
             #
             history_raw = metadata.pop("history", "[]")
             try:
@@ -670,21 +663,49 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
         """
         Returns the standardized vector search tools (search operations only).
         Index operations are toolkit-specific and should be added manually to each toolkit.
-        
+
+        This method constructs the argument schemas for each tool, merging base parameters with any extra parameters
+        defined in the subclass. It also handles the special case for chunking tools and their configuration.
+
         Returns:
-            List of tool dictionaries with name, ref, description, and args_schema
+            list: List of tool dictionaries with name, ref, description, and args_schema.
         """
+        index_params = {
+            "index_name": (
+                str,
+                Field(description="Index name (max 7 characters)", min_length=1, max_length=7)
+            ),
+            "clean_index": (
+                Optional[bool],
+                Field(default=False, description="Optional flag to enforce clean existing index before indexing new data")
+            ),
+            "progress_step": (
+                Optional[int],
+                Field(default=10, ge=0, le=100, description="Optional step size for progress reporting during indexing")
+            ),
+        }
+        chunking_config = (
+            Optional[dict],
+            Field(description="Chunking tool configuration", default=loaders_allowed_to_override)
+        )
+
+        index_extra_params = self._index_tool_params() or {}
+        chunking_tool = index_extra_params.pop("chunking_tool", None)
+        if chunking_tool:
+            index_params = {
+                **index_params,
+                "chunking_tool": chunking_tool,
+            }
+        index_params["chunking_config"] = chunking_config
+        index_args_schema = create_model("IndexData", **index_params, **index_extra_params)
+
         return [
             {
                 "name": IndexTools.INDEX_DATA.value,
                 "mode": IndexTools.INDEX_DATA.value,
                 "ref": self.index_data,
                 "description": "Loads data to index.",
-                "args_schema": create_model(
-                    "IndexData",
-                    __base__=BaseIndexDataParams,
-                    **self._index_tool_params() if self._index_tool_params() else {}
-                )
+                "args_schema": index_args_schema,
             },
             {
                 "name": IndexTools.SEARCH_INDEX.value,

alita_sdk/tools/bitbucket/__init__.py

@@ -13,6 +13,7 @@ from ..utils import clean_string, get_max_toolkit_length, check_connection_respo
 from ...configurations.bitbucket import BitbucketConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 import requests
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 
 name = "bitbucket"
@@ -114,7 +115,7 @@ class AlitaBitbucketToolkit(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/bitbucket/api_wrapper.py

@@ -57,7 +57,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."))
 )
 

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)
@@ -145,7 +145,7 @@ class BitbucketServerApi(BitbucketApiAbstract):
     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):
+        for old, new in parse_old_new_markers(update_query):
             if not old.strip():
                 continue
             updated_file_content = updated_file_content.replace(old, new)
@@ -319,7 +319,7 @@ class BitbucketCloudApi(BitbucketApiAbstract):
 
         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):
+        for old, new in parse_old_new_markers(file_query=update_query):
             if not old.strip():
                 continue
             updated_file_content = updated_file_content.replace(old, new)

alita_sdk/tools/browser/__init__.py

@@ -128,7 +128,7 @@ class BrowserToolkit(BaseToolkit):
                 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}
+                    tool_entry.metadata = {"toolkit_name": toolkit_name, "toolkit_type": name}
                 tools.append(tool_entry)
         return cls(tools=tools)
 

alita_sdk/tools/carrier/__init__.py

@@ -77,7 +77,7 @@ class AlitaCarrierToolkit(BaseToolkit):
                 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}
+                    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/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}")