alita-sdk 0.3.253__tar.gz → 0.3.255__tar.gz

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.253
+Version: 0.3.255
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/configurations/slack.py

@@ -27,6 +27,6 @@ class SlackConfiguration(BaseModel):
             }
         }
     )
-    name: Optional[SecretStr] = Field(description="Slack Bot Token")
+    name: Optional[str] = Field(description="Slack name")
     slack_token: Optional[SecretStr] = Field(description="Slack Token like XOXB-*****-*****-*****-*****")
     channel_id:Optional[str] = Field(description="Channel ID")

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/runtime/clients/client.py

@@ -602,16 +602,22 @@ class AlitaClient:
         import logging
         logger = logging.getLogger(__name__)
         toolkit_config_parsed_json = None
+        events_dispatched = []
+
         try:
             toolkit_config_type = toolkit_config.get('type')
-            toolkit_class = get_available_toolkit_models().get(toolkit_config_type)['toolkit_class']
-            toolkit_config_model_class = toolkit_class.toolkit_config_schema()
-            toolkit_config_validated_settings = toolkit_config_model_class(
-                **toolkit_config.get('settings', {})
-            ).model_dump(mode='json')
-
+            available_toolkit_models = get_available_toolkit_models().get(toolkit_config_type)
             toolkit_config_parsed_json = deepcopy(toolkit_config)
-            toolkit_config_parsed_json['settings'] = toolkit_config_validated_settings
+            if available_toolkit_models:
+                toolkit_class = available_toolkit_models['toolkit_class']
+                toolkit_config_model_class = toolkit_class.toolkit_config_schema()
+                toolkit_config_validated_settings = toolkit_config_model_class(
+                    **toolkit_config.get('settings', {})
+                ).model_dump(mode='json')
+                toolkit_config_parsed_json['settings'] = toolkit_config_validated_settings
+            else:
+                logger.warning(f"Toolkit type '{toolkit_config_type}' is skipping model validation")
+                toolkit_config_parsed_json['settings'] = None
         except Exception as toolkit_config_error:
             logger.error(f"Failed to validate toolkit configuration: {str(toolkit_config_error)}")
             return {
@@ -635,7 +641,6 @@ class AlitaClient:
             # Create RunnableConfig for callback support
             config = None
             callbacks = []
-            events_dispatched = []
 
             if runtime_config:
                 callbacks = runtime_config.get('callbacks', [])

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/runtime/langchain/document_loaders/AlitaDocxMammothLoader.py

@@ -9,6 +9,7 @@ from langchain_core.documents import Document
 from mammoth import convert_to_html
 from markdownify import markdownify
 
+from alita_sdk.tools.chunkers.sematic.markdown_chunker import markdown_by_headers_chunker
 from .utils import perform_llm_prediction_for_image_bytes
 
 
@@ -35,6 +36,7 @@ class AlitaDocxMammothLoader(BaseLoader):
         self.extract_images = kwargs.get('extract_images')
         self.llm = kwargs.get("llm")
         self.prompt = kwargs.get("prompt")
+        self.max_tokens = kwargs.get('max_tokens', 512)
 
     def __handle_image(self, image) -> dict:
         """
@@ -100,11 +102,11 @@ class AlitaDocxMammothLoader(BaseLoader):
         Loads and converts the Docx file to markdown format.
 
         Returns:
-            List[Document]: A list containing a single Document with the markdown content
+            List[Document]: A list containing a Documents with the markdown content
                           and metadata including the source file path.
         """
         result_content = self.get_content()
-        return [Document(page_content=result_content, metadata={'source': str(self.path)})]
+        return list(markdown_by_headers_chunker(iter([Document(page_content=result_content, metadata={'source': str(self.path)})]), config={'max_tokens':self.max_tokens}))
 
     def get_content(self):
         """

alita_sdk-0.3.255/alita_sdk/runtime/langchain/document_loaders/AlitaJSONLoader.py

@@ -0,0 +1,73 @@
+import json
+from typing import Iterator
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.document_loaders.helpers import detect_file_encodings
+from langchain_core.tools import ToolException
+from langchain_text_splitters import RecursiveJsonSplitter
+
+
+class AlitaJSONLoader(BaseLoader):
+
+    def __init__(self, **kwargs):
+        """Initialize with file path."""
+        if kwargs.get('file_path'):
+            self.file_path = kwargs['file_path']
+        elif kwargs.get('file_content'):
+            self.file_content = kwargs['file_content']
+            self.file_name = kwargs['file_name']
+        else:
+            raise ToolException("'file_path' or 'file_content' parameter should be provided.")
+        self.encoding = kwargs.get('encoding', 'utf-8')
+        self.autodetect_encoding = kwargs.get('autodetect_encoding', False)
+        self.max_tokens = kwargs.get('max_tokens', 512)
+
+    def get_content(self):
+        try:
+            if hasattr(self, 'file_path') and self.file_path:
+                with open(self.file_path, encoding=self.encoding) as f:
+                    return json.load(f)
+            elif hasattr(self, 'file_content') and self.file_content:
+                return json.load(self.file_content)
+            else:
+                raise ValueError("Neither file_path nor file_content is provided.")
+
+        except UnicodeDecodeError as e:
+            if self.autodetect_encoding:
+                if hasattr(self, 'file_path') and self.file_path:
+                    detected_encodings = detect_file_encodings(self.file_path)
+                    for encoding in detected_encodings:
+                        try:
+                            with open(self.file_path, encoding=encoding.encoding) as f:
+                                return f.read()
+                            break
+                        except UnicodeDecodeError:
+                            continue
+                elif hasattr(self, 'file_content') and self.file_content:
+                    detected_encodings = detect_file_encodings(self.file_content)
+                    for encoding in detected_encodings:
+                        try:
+                            return self.file_content.decode(encoding.encoding)
+                        except UnicodeDecodeError:
+                            continue
+                else:
+                    raise ValueError("Neither file_path nor file_content is provided for encoding detection.")
+            else:
+                raise RuntimeError(f"Error loading content with encoding {self.encoding}.") from e
+        except Exception as e:
+            raise RuntimeError(f"Error loading content.") from e
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Load from file path."""
+        content_json = self.get_content()
+
+        if isinstance(content_json, list):
+            data_dict = {str(i): item for i, item in enumerate(content_json)}
+        else:
+            data_dict = content_json
+        chunks = RecursiveJsonSplitter(max_chunk_size=self.max_tokens).split_json(json_data=data_dict)
+        for chunk in chunks:
+            metadata = {"source": str(self.file_path) if hasattr(self, 'file_path') else self.file_name}
+            yield Document(page_content=json.dumps(chunk), metadata=metadata)

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -13,17 +13,18 @@
 # limitations under the License.
 
 from langchain_community.document_loaders import (
-        UnstructuredMarkdownLoader,
-        AirbyteJSONLoader, UnstructuredHTMLLoader,
-        UnstructuredPowerPointLoader, PythonLoader)
+    UnstructuredMarkdownLoader,
+    AirbyteJSONLoader, UnstructuredHTMLLoader,
+    PythonLoader)
 
 from .AlitaCSVLoader import AlitaCSVLoader
 from .AlitaDocxMammothLoader import AlitaDocxMammothLoader
 from .AlitaExcelLoader import AlitaExcelLoader
 from .AlitaImageLoader import AlitaImageLoader
+from .AlitaJSONLoader import AlitaJSONLoader
 from .AlitaPDFLoader import AlitaPDFLoader
-from .AlitaTextLoader import AlitaTextLoader
 from .AlitaPowerPointLoader import AlitaPowerPointLoader
+from .AlitaTextLoader import AlitaTextLoader
 
 loaders_map = {
     '.png': {
@@ -122,7 +123,9 @@ loaders_map = {
     '.docx': {
         'class': AlitaDocxMammothLoader,
         'is_multimodal_processing': True,
-        'kwargs': {}
+        'kwargs': {
+            'extract_images': True
+        }
     },
     '.doc': {
         'class': AlitaTextLoader,
@@ -130,11 +133,9 @@ loaders_map = {
         'kwargs': {}
     },
     '.json': {
-        'class': AlitaTextLoader,
+        'class': AlitaJSONLoader,
         'is_multimodal_processing': False,
-        'kwargs': {
-            'autodetect_encoding': True
-        }
+        'kwargs': {}
     },
     '.jsonl': {
         'class': AirbyteJSONLoader,
@@ -154,12 +155,16 @@ loaders_map = {
     '.ppt': {
         'class': AlitaPowerPointLoader,
         'is_multimodal_processing': False,
-        'kwargs': {}
+        'kwargs': {
+            'mode': 'paged'
+        }
     },
     '.pptx': {
         'class': AlitaPowerPointLoader,
         'is_multimodal_processing': False,
-        'kwargs': {}
+        'kwargs': {
+            'mode': 'paged'
+        }
     },
     '.py': {
         'class': PythonLoader,

alita_sdk-0.3.255/alita_sdk/runtime/tools/mcp_server_tool.py

@@ -0,0 +1,101 @@
+import uuid
+from logging import getLogger
+from typing import Any, Type, Literal, Optional, Union, List
+
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field, create_model, EmailStr, constr
+
+logger = getLogger(__name__)
+
+
+class McpServerTool(BaseTool):
+    name: str
+    description: str
+    args_schema: Optional[Type[BaseModel]] = None
+    return_type: str = "str"
+    client: Any
+    server: str
+    tool_timeout_sec: int = 60
+
+
+    @staticmethod
+    def create_pydantic_model_from_schema(schema: dict, model_name: str = "ArgsSchema"):
+        def parse_type(field: dict, name: str = "Field") -> Any:
+            if "allOf" in field:
+                merged = {}
+                required = set()
+                for idx, subschema in enumerate(field["allOf"]):
+                    sub_type = parse_type(subschema, f"{name}AllOf{idx}")
+                    if hasattr(sub_type, "__fields__"):
+                        merged.update({k: (v.outer_type_, v.default) for k, v in sub_type.__fields__.items()})
+                        required.update({k for k, v in sub_type.__fields__.items() if v.required})
+                if merged:
+                    return create_model(f"{name}AllOf", **merged)
+                return Any
+            if "anyOf" in field or "oneOf" in field:
+                key = "anyOf" if "anyOf" in field else "oneOf"
+                types = [parse_type(sub, f"{name}{key.capitalize()}{i}") for i, sub in enumerate(field[key])]
+                # Check for null type
+                if any(sub.get("type") == "null" for sub in field[key]):
+                    non_null_types = [parse_type(sub, f"{name}{key.capitalize()}{i}")
+                                      for i, sub in enumerate(field[key]) if sub.get("type") != "null"]
+                    if len(non_null_types) == 1:
+                        return Optional[non_null_types[0]]
+                return Union[tuple(types)]
+            t = field.get("type")
+            if isinstance(t, list):
+                if "null" in t:
+                    non_null = [x for x in t if x != "null"]
+                    if len(non_null) == 1:
+                        field = dict(field)
+                        field["type"] = non_null[0]
+                        return Optional[parse_type(field, name)]
+                    return Any
+                return Any
+            if t == "string":
+                if "enum" in field:
+                    return Literal[tuple(field["enum"])]
+                if field.get("format") == "email":
+                    return EmailStr
+                if "pattern" in field:
+                    return constr(regex=field["pattern"])
+                return str
+            if t == "integer":
+                return int
+            if t == "number":
+                return float
+            if t == "boolean":
+                return bool
+            if t == "object":
+                return McpServerTool.create_pydantic_model_from_schema(field, name.capitalize())
+            if t == "array":
+                items = field.get("items", {})
+                return List[parse_type(items, name + "Item")]
+            return Any
+
+        properties = schema.get("properties", {})
+        required = set(schema.get("required", []))
+        fields = {}
+        for name, prop in properties.items():
+            typ = parse_type(prop, name.capitalize())
+            default = prop.get("default", ... if name in required else None)
+            field_args = {}
+            if "description" in prop:
+                field_args["description"] = prop["description"]
+            if "format" in prop:
+                field_args["format"] = prop["format"]
+            fields[name] = (typ, Field(default, **field_args))
+        return create_model(model_name, **fields)
+
+    def _run(self, *args, **kwargs):
+        call_data = {
+            "server": self.server,
+            "tool_timeout_sec": self.tool_timeout_sec,
+            "tool_call_id": str(uuid.uuid4()),
+            "params": {
+                "name": self.name,
+                "arguments": kwargs
+            }
+        }
+        
+        return self.client.mcp_tool_call(call_data)

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/runtime/tools/vectorstore.py

@@ -336,6 +336,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
 
         from ..langchain.interfaces.llm_processor import add_documents
 
+        self._log_tool_event(message=f"Starting the indexing... Parameters: {collection_suffix=}, {clean_index=}, {is_code}", tool_name="index_documents")
         # pre-process documents if needed (find duplicates, etc.)
         if clean_index:
             logger.info("Cleaning index before re-indexing all documents.")
@@ -351,9 +352,15 @@ class VectorStoreWrapper(BaseToolApiWrapper):
             if isinstance(documents, types.GeneratorType):
                 documents = list(documents)
         else:
+            self._log_tool_event(
+                message="Filter for duplicates",
+                tool_name="index_documents")
             # remove duplicates based on metadata 'id' and 'updated_on' or 'commit_hash' fields
             documents = self._reduce_code_duplicates(documents, collection_suffix) if is_code \
                 else self._reduce_non_code_duplicates(documents, collection_suffix)
+            self._log_tool_event(
+                message="All the duplicates were filtered out. Proceeding with indexing.",
+                tool_name="index_documents")
 
         if not documents or len(documents) == 0:
             logger.info("No new documents to index after duplicate check.")
@@ -362,8 +369,8 @@ class VectorStoreWrapper(BaseToolApiWrapper):
         # if func is provided, apply it to documents
         # used for processing of documents before indexing,
         # e.g. to avoid time-consuming operations for documents that are already indexed
+        self._log_tool_event(message=f"Processing the dependent documents (attachments, etc.)", tool_name="index_documents")
         dependent_docs_generator = self.process_document_func(documents) if self.process_document_func else []
-
         # notify user about missed required metadata fields: id, updated_on
         # it is not required to have them, but it is recommended to have them for proper re-indexing and duplicate detection
         for doc in documents:
@@ -375,6 +382,9 @@ class VectorStoreWrapper(BaseToolApiWrapper):
 
         documents = documents + list(dependent_docs_generator)
 
+        self._log_tool_event(message=f"Documents for indexing were processed. Total documents: {len(documents)}",
+                             tool_name="index_documents")
+
         # if collection_suffix is provided, add it to metadata of each document
         if collection_suffix:
             for doc in documents:
@@ -386,7 +396,8 @@ class VectorStoreWrapper(BaseToolApiWrapper):
         total_docs = len(documents)
         documents_count = 0
         _documents = []
-
+        self._log_tool_event(message=f"Starting the indexing of processed documents. Total documents: {len(documents)}",
+                             tool_name="index_documents")
         # set default progress step to 20 if out of 0...100 or None
         progress_step = 20 if progress_step not in range(0, 100) else progress_step
         next_progress_point = progress_step

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/runtime/tools/vectorstore_base.py

@@ -1,18 +1,16 @@
 import json
 import math
-import types
-from typing import Any, Optional, List, Dict, Callable, Generator
+from logging import getLogger
+from typing import Any, Optional, List, Dict, Generator
 
 from langchain_core.documents import Document
-from pydantic import BaseModel, model_validator, Field
-from ..langchain.tools.vector import VectorAdapter
 from langchain_core.messages import HumanMessage
+from pydantic import BaseModel, model_validator, Field
+
 from alita_sdk.tools.elitea_base import BaseToolApiWrapper
 from alita_sdk.tools.vector_adapters.VectorStoreAdapter import VectorStoreAdapterFactory
-from logging import getLogger
-
+from ..langchain.tools.vector import VectorAdapter
 from ..utils.logging import dispatch_custom_event
-from ..utils.utils import IndexerKeywords
 
 logger = getLogger(__name__)
 
@@ -212,10 +210,6 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
             tool_name="_clean_collection"
         )
 
-    def _add_to_collection(self, entry_id, new_collection_value):
-        """Add a new collection name to the `collection` key in the `metadata` column."""
-        self.vector_adapter.add_to_collection(self, entry_id, new_collection_value)
-
     def index_documents(self, documents: Generator[Document, None, None], collection_suffix: str, progress_step: int = 20, clean_index: bool = True):
         """ Index documents in the vectorstore.
 

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/tools/ado/work_item/__init__.py

@@ -26,7 +26,7 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
                                  'toolkit_name': True,
                                  'max_toolkit_length': AzureDevOpsWorkItemsToolkit.toolkit_max_length})
                   ),
-            ado_configuration=(AdoConfiguration, Field(description="Ado Work Item configuration", json_schema_extra={'configuration_types': ['ado_work_item']})),
+            ado_configuration=(AdoConfiguration, Field(description="Ado Work Item configuration", json_schema_extra={'configuration_types': ['ado']})),
             limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             # indexer settings

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/tools/base_indexer_toolkit.py

@@ -6,7 +6,6 @@ from langchain_core.documents import Document
 from pydantic import create_model, Field, SecretStr
 
 # from alita_sdk.runtime.langchain.interfaces.llm_processor import get_embeddings
-from .chunkers import markdown_chunker
 from .utils.content_parser import process_content_by_type
 from .vector_adapters.VectorStoreAdapter import VectorStoreAdapterFactory
 from ..runtime.tools.vectorstore_base import VectorStoreWrapperBase
@@ -141,7 +140,7 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
     def _base_loader(self, **kwargs) -> Generator[Document, None, None]:
         """ Loads documents from a source, processes them,
         and returns a list of Document objects with base metadata: id and created_on."""
-        pass
+        yield from ()
 
     def _process_document(self, base_document: Document) -> Generator[Document, None, None]:
         """ Process an existing base document to extract relevant metadata for full document preparation.
@@ -153,7 +152,7 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
 
         Returns:
             Document: The processed document with metadata."""
-        pass
+        yield from ()
 
     def index_data(self, **kwargs):
         collection_suffix = kwargs.get("collection_suffix")
@@ -174,18 +173,20 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
         return self._save_index(list(documents), collection_suffix=collection_suffix, progress_step=progress_step)
     
     def _apply_loaders_chunkers(self, documents: Generator[Document, None, None], chunking_tool: str=None, chunking_config=None) -> Generator[Document, None, None]:
-        from alita_sdk.tools.chunkers import __confluence_chunkers__ as chunkers, __confluence_models__ as models
+        from alita_sdk.tools.chunkers import __confluence_chunkers__ as chunkers
 
         if chunking_config is None:
             chunking_config = {}
         chunking_config['embedding'] = self._embedding
         chunking_config['llm'] = self.llm
-            
+        
         for document in documents:
             if content_type := document.metadata.get('loader_content_type', None):
                 # apply parsing based on content type and chunk if chunker was applied to parent doc
+                content = document.metadata.pop('loader_content', None)
                 yield from process_content_by_type(
                     document=document,
+                    content=content,
                     extension_source=content_type, llm=self.llm, chunking_config=chunking_config)
             elif chunking_tool:
                 # apply default chunker from toolkit config. No parsing.
@@ -205,9 +206,6 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
             for dep in dependencies:
                 dep.metadata[IndexerKeywords.PARENT.value] = document.metadata.get('id', None)
                 yield dep
-    
-    def _content_loader(self):
-        pass
 
     def _reduce_duplicates(
             self,
@@ -255,36 +253,6 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
     def remove_ids_fn(self, idx_data, key: str):
         raise NotImplementedError("Subclasses must implement this method")
 
-    def _process_documents(self, documents: List[Document]) -> Generator[Document, None, None]:
-        """
-        Process a list of base documents to extract relevant metadata for full document preparation.
-        Used for late processing of documents after we ensure that the documents have to be indexed to avoid
-        time-consuming operations for documents which might be useless.
-        This function passed to index_documents method of vector store and called after _reduce_duplicates method.
-
-        Args:
-            documents (List[Document]): The base documents to process.
-
-        Returns:
-            Generator[Document, None, None]: A generator yielding processed documents with metadata.
-        """
-        for doc in documents:
-            # Filter documents to process only those that either:
-            # - do not have a 'chunk_id' in their metadata, or
-            # - have 'chunk_id' explicitly set to 1.
-            # This prevents processing of irrelevant or duplicate chunks, improving efficiency.
-            chunk_id = doc.metadata.get("chunk_id")
-            if chunk_id is None or chunk_id == 1:
-                processed_docs = self._process_document(doc)
-                if processed_docs:  # Only proceed if the list is not empty
-                    for processed_doc in processed_docs:
-                        # map processed document (child) to the original document (parent)
-                        processed_doc.metadata[IndexerKeywords.PARENT.value] = doc.metadata.get('id', None)
-                        if chunker:=self._get_dependencies_chunker(processed_doc):
-                            yield from chunker(file_content_generator=iter([processed_doc]), config=self._get_dependencies_chunker_config())
-                        else:
-                            yield processed_doc
-
     def remove_index(self, collection_suffix: str = ""):
         """Cleans the indexed data in the collection."""
         super()._clean_collection(collection_suffix=collection_suffix)

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/tools/chunkers/sematic/markdown_chunker.py

@@ -1,7 +1,6 @@
 from typing import Generator
-from langchain.schema import Document
 from langchain_core.documents import Document
-from langchain_text_splitters import MarkdownHeaderTextSplitter
+from langchain_text_splitters import MarkdownHeaderTextSplitter, ExperimentalMarkdownSyntaxTextSplitter
 from langchain.text_splitter import TokenTextSplitter
 from ..utils import tiktoken_length
 from copy import deepcopy as copy
@@ -50,4 +49,32 @@ def markdown_chunker(file_content_generator: Generator[Document, None, None], co
                 yield Document(
                     page_content=chunk.page_content,
                     metadata=docmeta
-                )
+                )
+
+
+def markdown_by_headers_chunker(file_content_generator: Generator[Document, None, None], config: dict, *args, **kwargs) -> Generator[Document, None, None]:
+    strip_header = config.get("strip_header", False)
+    return_each_line = config.get("return_each_line", False)
+    headers_to_split_on = config.get("headers_to_split_on", [])
+    headers_to_split_on = [header.split(' ', 1) for header in headers_to_split_on]
+    for doc in file_content_generator:
+        doc_metadata = doc.metadata
+        doc_content = doc.page_content
+        chunk_id = 0
+        markdown_splitter = ExperimentalMarkdownSyntaxTextSplitter(
+            headers_to_split_on=headers_to_split_on, 
+            strip_headers=strip_header,
+            return_each_line=return_each_line
+        )
+        md_header_splits = markdown_splitter.split_text(doc_content)
+        for chunk in md_header_splits:
+            chunk_id += 1
+            headers_meta = list(chunk.metadata.values())
+            docmeta = copy(doc_metadata)
+            docmeta.update({"headers": "; ".join(headers_meta)})
+            docmeta['chunk_id'] = chunk_id
+            docmeta['chunk_type'] = "document"
+            yield Document(
+                page_content=chunk.page_content,
+                metadata=docmeta
+            )

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/tools/confluence/__init__.py

@@ -20,6 +20,7 @@ def get_tools(tool):
         confluence_configuration=tool['settings']['confluence_configuration'],
         limit=tool['settings'].get('limit', 5),
         labels=parse_list(tool['settings'].get('labels', None)),
+        custom_headers=tool['settings'].get('custom_headers', {}),
         additional_fields=tool['settings'].get('additional_fields', []),
         verify_ssl=tool['settings'].get('verify_ssl', True),
         alita=tool['settings'].get('alita'),
@@ -78,6 +79,8 @@ class ConfluenceToolkit(BaseToolkit):
             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)),
+            # optional field for custom headers as dictionary
+            custom_headers=(Optional[dict], Field(description="Custom headers for API requests", default=None)),
             confluence_configuration=(Optional[ConfluenceConfiguration], Field(description="Confluence Configuration", json_schema_extra={'configuration_types': ['confluence']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default = None,
                                                                            description="PgVector Configuration",

{alita_sdk-0.3.253 → alita_sdk-0.3.255}/alita_sdk/tools/confluence/api_wrapper.py

@@ -223,16 +223,21 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
         username = values.get('username')
         token = values.get('token')
         cloud = values.get('cloud')
-        # if values.get('collection_name'):
-        #     values['collection_name'] = shortuuid.encode(values['collection_name'])
         if token and is_cookie_token(token):
             session = requests.Session()
             session.cookies.update(parse_cookie_string(token))
-            values['client'] = Confluence(url=url, session=session, cloud=cloud)
+            client_instance = Confluence(url=url, session=session, cloud=cloud)
         elif token:
-            values['client'] = Confluence(url=url, token=token, cloud=cloud)
+            client_instance = Confluence(url=url, token=token, cloud=cloud)
         else:
-            values['client'] = Confluence(url=url, username=username, password=api_key, cloud=cloud)
+            client_instance = Confluence(url=url, username=username, password=api_key, cloud=cloud)
+
+        custom_headers = values.get('custom_headers', {})
+        logger.info(f"Jira tool: custom headers length: {len(custom_headers)}")
+        for header, value in custom_headers.items():
+            client_instance._update_header(header, value)
+
+        values['client'] = client_instance
         return values
 
     def __unquote_confluence_space(self) -> str | None: