alita-sdk 0.3.252__tar.gz → 0.3.254__tar.gz

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.252
+Version: 0.3.254
 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.252 → alita_sdk-0.3.254}/alita_sdk/configurations/ado.py

@@ -30,7 +30,7 @@ class AdoReposConfiguration(BaseModel):
             }
         }
     )
-    repository_id: Optional[str] = Field(description="ADO repository ID", default=None)
+    repository_id: str = Field(description="ADO repository ID")
 
     ado_configuration: AdoConfiguration = Field(
         default_factory=AdoConfiguration,

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/alita_sdk/configurations/bitbucket.py

@@ -11,7 +11,7 @@ class BitbucketConfiguration(BaseModel):
                 "icon_url": "bitbucket-icon.svg",
                 "sections": {
                     "auth": {
-                        "required": False,
+                        "required": True,
                         "subsections": [
                             {
                                 "name": "Username & Password",
@@ -27,6 +27,6 @@ class BitbucketConfiguration(BaseModel):
             }
         }
     )
-    url: str = Field(description="Bitbucket URL")
+    url: Optional[str] = Field(description="Bitbucket URL", default="https://api.bitbucket.org/")
     username: Optional[str] = Field(description="Bitbucket Username", default=None)
     password: Optional[SecretStr] = Field(description="Bitbucket Password/App Password", default=None)

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/alita_sdk/configurations/confluence.py

@@ -11,7 +11,7 @@ class ConfluenceConfiguration(BaseModel):
                 "icon_url": "confluence.svg",
                 "sections": {
                     "auth": {
-                        "required": False,
+                        "required": True,
                         "subsections": [
                             {
                                 "name": "Basic",

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/alita_sdk/configurations/jira.py

@@ -11,7 +11,7 @@ class JiraConfiguration(BaseModel):
                 "icon_url": "jira.svg",
                 "sections": {
                     "auth": {
-                        "required": False,
+                        "required": True,
                         "subsections": [
                             {
                                 "name": "Basic",

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/alita_sdk/configurations/postman.py

@@ -11,7 +11,7 @@ class PostmanConfiguration(BaseModel):
                 "icon_url": "postman.svg",
                 "sections": {
                     "auth": {
-                        "required": False,
+                        "required": True,
                         "subsections": [
                             {
                                 "name": "API Key",

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/alita_sdk/configurations/service_now.py

@@ -11,7 +11,7 @@ class ServiceNowConfiguration(BaseModel):
                 "icon_url": "servicenow.svg",
                 "sections": {
                     "auth": {
-                        "required": False,
+                        "required": True,
                         "subsections": [
                             {
                                 "name": "Username & Password",

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/alita_sdk/configurations/slack.py

@@ -11,14 +11,10 @@ class SlackConfiguration(BaseModel):
                 "icon_url": "slack.svg",
                 "sections": {
                     "auth": {
-                        "required": False,
+                        "required": True,
                         "subsections": [
                             {
-                                "name": "Bot Token",
-                                "fields": ["name"]
-                            },
-                            {
-                                "name": "User Token",
+                                "name": "Slack Token",
                                 "fields": ["slack_token"]
                             }
                         ]

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/alita_sdk/configurations/xray.py

@@ -11,7 +11,7 @@ class XrayConfiguration(BaseModel):
                 "icon_url": "xray.svg",
                 "sections": {
                     "auth": {
-                        "required": False,
+                        "required": True,
                         "subsections": [
                             {
                                 "name": "Client Credentials",

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/alita_sdk/configurations/zephyr.py

@@ -11,7 +11,7 @@ class ZephyrConfiguration(BaseModel):
                 "icon_url": "zephyr.svg",
                 "sections": {
                     "auth": {
-                        "required": False,
+                        "required": True,
                         "subsections": [
                             {
                                 "name": "Token",

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/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.254/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.252 → alita_sdk-0.3.254}/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': {
@@ -130,11 +131,9 @@ loaders_map = {
         'kwargs': {}
     },
     '.json': {
-        'class': AlitaTextLoader,
+        'class': AlitaJSONLoader,
         'is_multimodal_processing': False,
-        'kwargs': {
-            'autodetect_encoding': True
-        }
+        'kwargs': {}
     },
     '.jsonl': {
         'class': AirbyteJSONLoader,
@@ -154,12 +153,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.254/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.252 → alita_sdk-0.3.254}/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.252 → alita_sdk-0.3.254}/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.252 → alita_sdk-0.3.254}/alita_sdk/tools/bitbucket/api_wrapper.py

@@ -65,8 +65,10 @@ class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
                 "atlassian-python-api is not installed. "
                 "Please install it with `pip install atlassian-python-api`"
             )
+        from langchain_core.utils import get_from_dict_or_env
+        url_value = get_from_dict_or_env(values, ["url"], "BITBUCKET_BASE_URL", default='https://api.bitbucket.org/')
         cls._bitbucket = BitbucketCloudApi(
-            url=values['url'],
+            url=url_value,
             username=values['username'],
             password=values['password'],
             workspace=values['project'],

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/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.252 → alita_sdk-0.3.254}/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:

{alita_sdk-0.3.252 → alita_sdk-0.3.254}/alita_sdk/tools/elitea_base.py

@@ -124,6 +124,26 @@ class BaseToolApiWrapper(BaseModel):
     def get_available_tools(self):
         raise NotImplementedError("Subclasses should implement this method")
 
+    def _log_tool_event(self, message: str, tool_name: str = None):
+        """Log data and dispatch custom event for the tool"""
+
+        try:
+            from langchain_core.callbacks import dispatch_custom_event
+
+            if tool_name is None:
+                tool_name = 'tool_progress'
+            dispatch_custom_event(
+                name="tool_execution_step",
+                data={
+                    "message": message,
+                    "tool_name": tool_name,
+                    "toolkit": self.__class__.__name__,
+                },
+            )
+        except Exception as e:
+            logger.warning(f"Failed to dispatch progress event: {str(e)}")
+
+
     def run(self, mode: str, *args: Any, **kwargs: Any):
         if TOOLKIT_SPLITTER in mode:
             mode = mode.rsplit(TOOLKIT_SPLITTER, maxsplit=1)[1]