alita-sdk 0.3.207__py3-none-any.whl → 0.3.209__py3-none-any.whl

alita_sdk/runtime/clients/client.py

@@ -634,27 +634,112 @@ class AlitaClient:
                     "execution_time_seconds": 0.0
                 }
             
-            # Find the specific tool
+            # Find the specific tool with smart name matching
             target_tool = None
+            toolkit_name = toolkit_config.get('toolkit_name', '').lower()
+            
+            # Helper function to extract base tool name from full name
+            def extract_base_tool_name(full_name: str) -> str:
+                """Extract base tool name from toolkit___toolname format."""
+                if '___' in full_name:
+                    return full_name.split('___', 1)[1]
+                return full_name
+            
+            # Helper function to create full tool name
+            def create_full_tool_name(base_name: str, toolkit_name: str) -> str:
+                """Create full tool name in toolkit___toolname format."""
+                return f"{toolkit_name}___{base_name}"
+            
+            # Normalize tool_name to handle both formats
+            # If user provides toolkit___toolname, extract just the tool name
+            # If user provides just toolname, keep as is
+            if '___' in tool_name:
+                normalized_tool_name = extract_base_tool_name(tool_name)
+                logger.info(f"Extracted base tool name '{normalized_tool_name}' from full name '{tool_name}'")
+            else:
+                normalized_tool_name = tool_name
+            
+            # Try multiple matching strategies
             for tool in tools:
-                if hasattr(tool, 'name') and tool.name == tool_name:
-                    target_tool = tool
-                    break
-                elif hasattr(tool, 'func') and hasattr(tool.func, '__name__') and tool.func.__name__ == tool_name:
-                    target_tool = tool
-                    break
+                tool_name_attr = None
+                if hasattr(tool, 'name'):
+                    tool_name_attr = tool.name
+                elif hasattr(tool, 'func') and hasattr(tool.func, '__name__'):
+                    tool_name_attr = tool.func.__name__
+                
+                if tool_name_attr:
+                    # Strategy 1: Exact match with provided name (handles both formats)
+                    if tool_name_attr == tool_name:
+                        target_tool = tool
+                        logger.info(f"Found tool using exact match: '{tool_name_attr}'")
+                        break
+                    
+                    # Strategy 2: Match normalized name with toolkit prefix
+                    expected_full_name = create_full_tool_name(normalized_tool_name, toolkit_name)
+                    if tool_name_attr == expected_full_name:
+                        target_tool = tool
+                        logger.info(f"Found tool using toolkit prefix mapping: '{tool_name_attr}' for normalized name '{normalized_tool_name}'")
+                        break
+                    
+                    # Strategy 3: Match base names (extract from both sides)
+                    base_tool_name = extract_base_tool_name(tool_name_attr)
+                    if base_tool_name == normalized_tool_name:
+                        target_tool = tool
+                        logger.info(f"Found tool using base name mapping: '{tool_name_attr}' -> '{base_tool_name}' matches '{normalized_tool_name}'")
+                        break
+                    
+                    # Strategy 4: Match provided name with base tool name (reverse lookup)
+                    if tool_name_attr == normalized_tool_name:
+                        target_tool = tool
+                        logger.info(f"Found tool using direct name match: '{tool_name_attr}' matches normalized '{normalized_tool_name}'")
+                        break
             
             if target_tool is None:
                 available_tools = []
+                base_available_tools = []
+                full_available_tools = []
+                
                 for tool in tools:
+                    tool_name_attr = None
                     if hasattr(tool, 'name'):
-                        available_tools.append(tool.name)
+                        tool_name_attr = tool.name
                     elif hasattr(tool, 'func') and hasattr(tool.func, '__name__'):
-                        available_tools.append(tool.func.__name__)
+                        tool_name_attr = tool.func.__name__
+                    
+                    if tool_name_attr:
+                        available_tools.append(tool_name_attr)
+                        
+                        # Extract base name for user-friendly error
+                        base_name = extract_base_tool_name(tool_name_attr)
+                        if base_name not in base_available_tools:
+                            base_available_tools.append(base_name)
+                        
+                        # Track full names separately
+                        if '___' in tool_name_attr:
+                            full_available_tools.append(tool_name_attr)
+                
+                # Create comprehensive error message
+                error_msg = f"Tool '{tool_name}' not found in toolkit '{toolkit_config.get('toolkit_name')}'."
+                
+                if base_available_tools and full_available_tools:
+                    error_msg += f" Available tools: {base_available_tools} (base names) or {full_available_tools} (full names)"
+                elif base_available_tools:
+                    error_msg += f" Available tools: {base_available_tools}"
+                elif available_tools:
+                    error_msg += f" Available tools: {available_tools}"
+                else:
+                    error_msg += " No tools found in the toolkit."
+                
+                # Add helpful hint about naming conventions
+                if '___' in tool_name:
+                    error_msg += f" Note: You provided a full name '{tool_name}'. Try using just the base name '{extract_base_tool_name(tool_name)}'."
+                elif full_available_tools:
+                    possible_full_name = create_full_tool_name(tool_name, toolkit_name)
+                    error_msg += f" Note: You provided a base name '{tool_name}'. The full name might be '{possible_full_name}'."
                 
                 return {
                     "success": False,
-                    "error": f"Tool '{tool_name}' not found. Available tools: {available_tools}",
+                    "error": error_msg,
                     "tool_name": tool_name,
                     "toolkit_config": toolkit_config,
                     "llm_model": llm_model,
@@ -664,7 +749,22 @@ class AlitaClient:
             
             # Execute the tool with callback support
             try:
-                logger.info(f"Executing tool '{tool_name}' with parameters: {tool_params}")
+                # Log which tool was found and how
+                actual_tool_name = getattr(target_tool, 'name', None) or getattr(target_tool.func, '__name__', 'unknown')
+                
+                # Determine which matching strategy was used
+                if actual_tool_name == tool_name:
+                    logger.info(f"Found tool '{tool_name}' using exact match")
+                elif actual_tool_name == create_full_tool_name(normalized_tool_name, toolkit_name):
+                    logger.info(f"Found tool '{tool_name}' using toolkit prefix mapping ('{actual_tool_name}' for normalized '{normalized_tool_name}')")
+                elif extract_base_tool_name(actual_tool_name) == normalized_tool_name:
+                    logger.info(f"Found tool '{tool_name}' using base name mapping ('{actual_tool_name}' -> '{extract_base_tool_name(actual_tool_name)}')")
+                elif actual_tool_name == normalized_tool_name:
+                    logger.info(f"Found tool '{tool_name}' using direct normalized name match ('{actual_tool_name}')")
+                else:
+                    logger.info(f"Found tool '{tool_name}' using fallback matching ('{actual_tool_name}')")
+                
+                logger.info(f"Executing tool '{tool_name}' (internal name: '{actual_tool_name}') with parameters: {tool_params}")
                 
                 # Start timing the tool execution
                 start_time = time.time()

alita_sdk/runtime/langchain/langraph_agent.py

@@ -9,7 +9,7 @@ from langchain_core.callbacks import dispatch_custom_event
 from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, BaseMessage
 from langchain_core.runnables import Runnable
 from langchain_core.runnables import RunnableConfig
-from langchain_core.tools import BaseTool
+from langchain_core.tools import BaseTool, ToolException
 from langgraph.channels.ephemeral_value import EphemeralValue
 from langgraph.graph import StateGraph
 from langgraph.graph.graph import END, START
@@ -506,10 +506,10 @@ def create_graph(
                     for toolkit, selected_tools in connected_tools.items():
                         for tool in selected_tools:
                             tool_names.append(f"{toolkit}___{tool}")
+                elif isinstance(connected_tools, list):
+                    # for cases when tools are provided as a list of names with already bound toolkit_name
+                    tool_names = connected_tools
                 
-                # Filter tools if specific tool names are provided
-                available_tools = []
-            
                 if tool_names:
                     # Filter tools by name
                     tool_dict = {tool.name: tool for tool in tools if isinstance(tool, BaseTool)}
@@ -580,7 +580,10 @@ def create_graph(
                     default_output=node['condition'].get('default_output', 'END')))
 
         # set default value for state variable at START
-        entry_point = clean_string(schema['entry_point'])
+        try:
+            entry_point = clean_string(schema['entry_point'])
+        except KeyError:
+            raise ToolException("Entry point is not defined in the schema. Please define 'entry_point' in the schema.")
         for key, value in state.items():
             if 'type' in value and 'value' in value:
                 # set default value for state variable if it is defined in the schema

alita_sdk/runtime/tools/vectorstore.py

@@ -199,13 +199,12 @@ class VectorStoreWrapper(BaseToolApiWrapper):
             data = store.get(include=['documents', 'metadatas'])
             # re-structure data to be more usable
             for doc_str, meta, db_id in zip(data['documents'], data['metadatas'], data['ids']):
-                doc = json.loads(doc_str)
                 doc_id = str(meta['id'])
                 dependent_docs = meta.get(IndexerKeywords.DEPENDENT_DOCS.value, [])
                 parent_id = meta.get(IndexerKeywords.PARENT.value, -1)
                 result[doc_id] = {
                     'metadata': meta,
-                    'document': doc,
+                    'document': doc_str,
                     'id': db_id,
                     IndexerKeywords.DEPENDENT_DOCS.value: dependent_docs,
                     IndexerKeywords.PARENT.value: parent_id

alita_sdk/tools/ado/test_plan/test_plan_wrapper.py

@@ -1,7 +1,10 @@
 import json
 import logging
-from typing import Optional
+from typing import Any, Dict, Generator, List, Optional
 
+from langchain_core.documents import Document
+
+from alita_sdk.tools.elitea_base import BaseIndexParams
 from azure.devops.connection import Connection
 from azure.devops.v7_0.test_plan.models import TestPlanCreateParams, TestSuiteCreateParams, \
     SuiteTestCaseCreateUpdateParameters
@@ -13,7 +16,11 @@ from pydantic.fields import FieldInfo as Field
 import xml.etree.ElementTree as ET
 
 from ..work_item import AzureDevOpsApiWrapper
-from ...elitea_base import BaseToolApiWrapper
+from ...elitea_base import BaseVectorStoreToolApiWrapper, extend_with_vector_tools
+try:
+    from alita_sdk.runtime.langchain.interfaces.llm_processor import get_embeddings
+except ImportError:
+    from alita_sdk.langchain.interfaces.llm_processor import get_embeddings
 
 logger = logging.getLogger(__name__)
 
@@ -96,7 +103,6 @@ TestCaseAddModel = create_model(
     suite_id=(int, Field(description="ID of the test suite to which test cases are to be added"))
 )
 
-
 test_steps_description = """Json or XML array string with test steps. 
     Json example: [{"stepNumber": 1, "action": "Some action", "expectedResult": "Some expectation"},...]
     XML example: 
@@ -158,7 +164,19 @@ TestCasesGetModel = create_model(
     suite_id=(int, Field(description="ID of the test suite for which test cases are requested"))
 )
 
-class TestPlanApiWrapper(BaseToolApiWrapper):
+# Schema for indexing ADO Wiki pages into vector store
+indexData = create_model(
+    "indexData",
+    __base__=BaseIndexParams,
+    plan_id=(int, Field(description="ID of the test plan for which test cases are requested")),
+    suite_ids=(list[int], Field(description="List of test suite IDs for which test cases are requested (can be empty)")),
+    progress_step=(Optional[int], Field(default=None, ge=0, le=100,
+                         description="Optional step size for progress reporting during indexing")),
+    clean_index=(Optional[bool], Field(default=False,
+                       description="Optional flag to enforce clean existing index before indexing new data")),
+)
+
+class TestPlanApiWrapper(BaseVectorStoreToolApiWrapper):
     __test__ = False
     organization_url: str
     project: str
@@ -166,6 +184,13 @@ class TestPlanApiWrapper(BaseToolApiWrapper):
     limit: Optional[int] = 5
     _client: Optional[TestPlanClient] = PrivateAttr()
 
+    llm: Any = None
+    connection_string: Optional[SecretStr] = None
+    collection_name: Optional[str] = None
+    embedding_model: Optional[str] = "HuggingFaceEmbeddings"
+    embedding_model_params: Optional[Dict[str, Any]] = {"model_name": "sentence-transformers/all-MiniLM-L6-v2"}
+    vectorstore_type: Optional[str] = "PGVector"
+
     class Config:
         arbitrary_types_allowed = True
 
@@ -250,8 +275,10 @@ class TestPlanApiWrapper(BaseToolApiWrapper):
         try:
             if isinstance(suite_test_case_create_update_parameters, str):
                 suite_test_case_create_update_parameters = json.loads(suite_test_case_create_update_parameters)
-            suite_test_case_create_update_params_obj = [SuiteTestCaseCreateUpdateParameters(**param) for param in suite_test_case_create_update_parameters]
-            test_cases = self._client.add_test_cases_to_suite(suite_test_case_create_update_params_obj, self.project, plan_id, suite_id)
+            suite_test_case_create_update_params_obj = [SuiteTestCaseCreateUpdateParameters(**param) for param in
+                                                        suite_test_case_create_update_parameters]
+            test_cases = self._client.add_test_cases_to_suite(suite_test_case_create_update_params_obj, self.project,
+                                                              plan_id, suite_id)
             return [test_case.as_dict() for test_case in test_cases]
         except Exception as e:
             logger.error(f"Error adding test case: {e}")
@@ -268,10 +295,11 @@ class TestPlanApiWrapper(BaseToolApiWrapper):
             test_steps=test_case['test_steps'],
             test_steps_format=test_case['test_steps_format']) for test_case in test_cases]
 
-
-    def create_test_case(self, plan_id: int, suite_id: int, title: str, description: str, test_steps: str, test_steps_format: str = 'json'):
+    def create_test_case(self, plan_id: int, suite_id: int, title: str, description: str, test_steps: str,
+                         test_steps_format: str = 'json'):
         """Creates a new test case in specified suite in Azure DevOps."""
-        work_item_wrapper = AzureDevOpsApiWrapper(organization_url=self.organization_url, token=self.token.get_secret_value(), project=self.project)
+        work_item_wrapper = AzureDevOpsApiWrapper(organization_url=self.organization_url,
+                                                  token=self.token.get_secret_value(), project=self.project)
         if test_steps_format == 'json':
             steps_xml = self.get_test_steps_xml(json.loads(test_steps))
         elif test_steps_format == 'xml':
@@ -279,8 +307,9 @@ class TestPlanApiWrapper(BaseToolApiWrapper):
         else:
             return ToolException("Unknown test steps format: " + test_steps_format)
         work_item_json = self.build_ado_test_case(title, description, steps_xml)
-        created_work_item_id = work_item_wrapper.create_work_item(work_item_json=json.dumps(work_item_json), wi_type="Test Case")['id']
-        return self.add_test_case([{"work_item":{"id":created_work_item_id}}], plan_id, suite_id)
+        created_work_item_id = \
+        work_item_wrapper.create_work_item(work_item_json=json.dumps(work_item_json), wi_type="Test Case")['id']
+        return self.add_test_case([{"work_item": {"id": created_work_item_id}}], plan_id, suite_id)
 
     def build_ado_test_case(self, title, description, steps_xml):
         """
@@ -355,6 +384,42 @@ class TestPlanApiWrapper(BaseToolApiWrapper):
             logger.error(f"Error getting test cases: {e}")
             return ToolException(f"Error getting test cases: {e}")
 
+    def index_data(self,
+            plan_id: str,
+            suite_ids: list[str] = [],
+            collection_suffix: str = '',
+            progress_step: int = None,
+            clean_index: bool = False
+    ):
+        """Load ADO TestCases into the vector store."""
+        docs = self._base_loader(plan_id, suite_ids)
+        embedding = get_embeddings(self.embedding_model, self.embedding_model_params)
+        vs = self._init_vector_store(collection_suffix, embeddings=embedding)
+        return vs.index_documents(docs, progress_step=progress_step, clean_index=clean_index)
+
+    def _base_loader(self, plan_id: str, suite_ids: Optional[list[str]] = []) -> Generator[Document, None, None]:
+        cases = []
+        for sid in suite_ids:
+            cases.extend(self.get_test_cases(plan_id, sid))
+        #
+        for case in cases:
+            field_dicts = case.get('work_item', {}).get('work_item_fields', [])
+            data = {k: v for d in field_dicts for k, v in d.items()}
+            yield Document(
+                page_content=data.get('Microsoft.VSTS.TCM.Steps', ''),
+                metadata={
+                    'id': case.get('work_item', {}).get('id', ''),
+                    'title': case.get('work_item', {}).get('name', ''),
+                    'plan_id': case.get('test_plan', {}).get('id', ''),
+                    'suite_id': case.get('test_suite', {}).get('id', ''),
+                    'description': data.get('System.Description', ''),
+                    'updated_on': data.get('System.Rev', ''),
+                })
+
+    def _process_document(self, document: Document) -> Generator[Document, None, None]:
+        yield document
+
+    @extend_with_vector_tools
     def get_available_tools(self):
         """Return a list of available tools."""
         return [
@@ -423,5 +488,11 @@ class TestPlanApiWrapper(BaseToolApiWrapper):
                 "description": self.get_test_cases.__doc__,
                 "args_schema": TestCasesGetModel,
                 "ref": self.get_test_cases,
+            },
+            {
+                "name": "index_data",
+                "ref": self.index_data,
+                "description": self.index_data.__doc__,
+                "args_schema": indexData,
             }
         ]

alita_sdk/tools/ado/wiki/ado_wrapper.py

@@ -1,6 +1,10 @@
 import logging
-from typing import Optional
+from typing import Any, Dict, Generator, List, Optional
 
+from alita_sdk.tools.elitea_base import BaseIndexParams
+from langchain_core.documents import Document
+
+from ...elitea_base import BaseVectorStoreToolApiWrapper, extend_with_vector_tools
 from azure.devops.connection import Connection
 from azure.devops.exceptions import AzureDevOpsServiceError
 from azure.devops.v7_0.core import CoreClient
@@ -12,6 +16,10 @@ from msrest.authentication import BasicAuthentication
 from pydantic import create_model, PrivateAttr, SecretStr
 from pydantic import model_validator
 from pydantic.fields import Field
+try:
+    from alita_sdk.runtime.langchain.interfaces.llm_processor import get_embeddings
+except ImportError:
+    from alita_sdk.langchain.interfaces.llm_processor import get_embeddings
 
 from ...elitea_base import BaseToolApiWrapper
 
@@ -52,14 +60,32 @@ RenamePageInput = create_model(
     version_type=(Optional[str], Field(description="Version type (branch, tag, or commit). Determines how Id is interpreted", default="branch"))
 )
 
+# Schema for indexing ADO Wiki pages into vector store
+indexData = create_model(
+    "indexData",
+    __base__=BaseIndexParams,
+    wiki_identifier=(str, Field(description="Wiki identifier to index, e.g., 'ABCProject.wiki'")),
+    progress_step=(Optional[int], Field(default=None, ge=0, le=100,
+                         description="Optional step size for progress reporting during indexing")),
+    clean_index=(Optional[bool], Field(default=False,
+                       description="Optional flag to enforce clean existing index before indexing new data")),
+)
+
 
-class AzureDevOpsApiWrapper(BaseToolApiWrapper):
+class AzureDevOpsApiWrapper(BaseVectorStoreToolApiWrapper):
     organization_url: str
     project: str
     token: SecretStr
     _client: Optional[WikiClient] = PrivateAttr()  # Private attribute for the wiki client
     _core_client: Optional[CoreClient] = PrivateAttr()  # Private attribute for the CoreClient client
 
+    llm: Any = None
+    connection_string: Optional[SecretStr] = None
+    collection_name: Optional[str] = None
+    embedding_model: Optional[str] = "HuggingFaceEmbeddings"
+    embedding_model_params: Optional[Dict[str, Any]] = {"model_name": "sentence-transformers/all-MiniLM-L6-v2"}
+    vectorstore_type: Optional[str] = "PGVector"
+
     class Config:
         arbitrary_types_allowed = True  # Allow arbitrary types (e.g., WorkItemTrackingClient)
 
@@ -216,6 +242,34 @@ class AzureDevOpsApiWrapper(BaseToolApiWrapper):
             logger.error(f"Unable to modify wiki page: {str(e)}")
             return ToolException(f"Unable to modify wiki page: {str(e)}")
 
+    def index_data(
+            self,
+            wiki_identifier: str,
+            collection_suffix: str = '',
+            progress_step: int = None,
+            clean_index: bool = False
+    ):
+        """Load ADO Wiki pages into the vector store."""
+        docs = self._base_loader(wiki_identifier)
+        embedding = get_embeddings(self.embedding_model, self.embedding_model_params)
+        vs = self._init_vector_store(collection_suffix, embeddings=embedding)
+        return vs.index_documents(docs, progress_step=progress_step, clean_index=clean_index)
+
+    def _base_loader(self, wiki_identifier: str) -> Generator[Document, None, None]:
+        pages = self._client.get_pages_batch(pages_batch_request={}, project=self.project, wiki_identifier=wiki_identifier)
+        #
+        for page in pages:
+            content = self._client.get_page_by_id(project=self.project, wiki_identifier=wiki_identifier, id=page.id, include_content=True).page.content
+            yield Document(page_content=content, metadata={
+                'id': page.id, 
+                'path': page.path,
+                'updated_on': ''
+            })
+
+    def _process_document(self, document: Document) -> Generator[Document, None, None]:
+        yield document
+
+    @extend_with_vector_tools
     def get_available_tools(self):
         """Return a list of available tools."""
         return [
@@ -260,5 +314,11 @@ class AzureDevOpsApiWrapper(BaseToolApiWrapper):
                 "description": self.rename_wiki_page.__doc__,
                 "args_schema": RenamePageInput,
                 "ref": self.rename_wiki_page,
+            },
+            {
+                "name": "index_data",
+                "ref": self.index_data,
+                "description": self.index_data.__doc__,
+                "args_schema": indexData,
             }
         ]

alita_sdk/tools/chunkers/sematic/markdown_chunker.py

@@ -1,12 +1,13 @@
 from typing import Generator
 from langchain.schema import Document
+from langchain_core.documents import Document
 from langchain_text_splitters import MarkdownHeaderTextSplitter
 from langchain.text_splitter import TokenTextSplitter
 from ..utils import tiktoken_length
 from copy import deepcopy as copy
 
 
-def markdown_chunker(file_content_generator: Generator[Document, None, None], config: dict, *args, **kwargs) -> Generator[str, None, None]:
+def markdown_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", [])

alita_sdk/tools/sharepoint/api_wrapper.py

@@ -1,7 +1,8 @@
 import json
 import logging
-from typing import Optional, List, Dict, Any
+from typing import Optional, List, Dict, Any, Generator
 
+from ..chunkers import markdown_chunker
 from ..utils.content_parser import parse_file_content
 from langchain_core.tools import ToolException
 from office365.runtime.auth.client_credential import ClientCredential
@@ -184,11 +185,19 @@ class SharepointApiWrapper(BaseVectorStoreToolApiWrapper):
         vs = self._init_vector_store(collection_suffix, embeddings=embedding)
         return vs.index_documents(docs, progress_step=progress_step, clean_index=clean_index)
 
-    def _process_document(self, document: Document) -> Document:
-        page_content = self.read_file(document.metadata['Path'], is_capture_image=True)
+    def _process_document(self, document: Document) -> Generator[Document, None, None]:
+        config = {
+            "max_tokens": self.llm.model_config.get('max_tokens', 512),
+            "token_overlap": self.llm.model_config.get('token_overlap',
+                                                       int(self.llm.model_config.get('max_tokens', 512) * 0.05))
+        }
+        chunks = markdown_chunker(file_content_generator=self._generate_file_content(document), config=config)
+        yield from chunks
 
+    def _generate_file_content(self, document: Document) -> Generator[Document, None, None]:
+        page_content = self.read_file(document.metadata['Path'], is_capture_image=True)
         document.page_content = json.dumps(str(page_content))
-        return document
+        yield document
 
     def get_available_tools(self):
         return [

alita_sdk/tools/testrail/api_wrapper.py

@@ -11,6 +11,7 @@ from ..elitea_base import BaseVectorStoreToolApiWrapper, BaseIndexParams
 from langchain_core.documents import Document
 
 from ...runtime.utils.utils import IndexerKeywords
+from ..utils.content_parser import parse_file_content
 
 try:
     from alita_sdk.runtime.langchain.interfaces.llm_processor import get_embeddings
@@ -658,8 +659,12 @@ class TestrailAPIWrapper(BaseVectorStoreToolApiWrapper):
         page_content = "This filetype is not supported."
         if attachment['filetype'] == 'txt' :
             page_content =  self._client.get(endpoint=f"get_attachment/{attachment['id']}")
-        # TODO: add support for other file types
-        # use utility to handle different types (tools/utils)
+        else:
+            try:
+                attachment_path = self._client.attachments.get_attachment(attachment_id=attachment['id'], path=f"./{attachment['filename']}")
+                page_content = parse_file_content(file_name=attachment['filename'], file_content=attachment_path.read_bytes(), llm=self.llm, is_capture_image=True)
+            except Exception as e:
+                logger.error(f"Unable to parse page's content with type: {attachment['filetype']}: {e}")
         return page_content
 
     def _to_markup(self, data: List[Dict], output_format: str) -> str:

alita_sdk/tools/utils/content_parser.py

@@ -11,9 +11,12 @@ import pymupdf
 from langchain_core.tools import ToolException
 from transformers import BlipProcessor, BlipForConditionalGeneration
 from langchain_core.messages import HumanMessage
+from logging import getLogger
 
 from ...runtime.langchain.tools.utils import bytes_to_base64
 
+logger = getLogger(__name__)
+
 image_processing_prompt='''
 You are an AI model designed for analyzing images. Your task is to accurately describe the content of the given image. Depending on the type of image, follow these specific instructions:
 
@@ -56,7 +59,33 @@ Be as precise and thorough as possible in your responses. If something is unclea
 
 IMAGE_EXTENSIONS = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'tiff', 'webp', 'svg']
 
-def parse_file_content(file_name, file_content, is_capture_image: bool = False, page_number: int = None, sheet_name: str = None, llm=None):
+
+def parse_file_content(file_name=None, file_content=None, is_capture_image: bool = False, page_number: int = None,
+                       sheet_name: str = None, llm=None, file_path: str = None):
+    """Parse the content of a file based on its type and return the parsed content.
+
+    Args:
+        file_name (str): The name of the file to parse.
+        file_content (bytes): The content of the file as bytes.
+        is_capture_image (bool): Whether to capture images from the file.
+        page_number (int, optional): The specific page number to parse for PDF or PPTX files.
+        sheet_name (str, optional): The specific sheet name to parse for Excel files.
+        llm: The language model to use for image processing.
+        file_path (str, optional): The path to the file if it needs to be read from disk.
+    Returns:
+        str: The parsed content of the file.
+    Raises:
+        ToolException: If the file type is not supported or if there is an error reading the file.
+        """
+
+    if (file_path and (file_name or file_content)) or (not file_path and (not file_name or file_content is None)):
+        raise ToolException("Either (file_name and file_content) or file_path must be provided, but not both.")
+
+    if file_path:
+        file_content = file_to_bytes(file_path)
+        if file_content is None:
+            return ToolException(f"File not found or could not be read: {file_path}")
+        file_name = file_path.split('/')[-1]  # Extract file name from path
     if file_name.endswith('.txt'):
         return parse_txt(file_content)
     elif file_name.endswith('.docx'):
@@ -176,4 +205,25 @@ def __perform_llm_prediction_for_image(llm, image: bytes, image_format='png', pr
                 },
             ])
     ])
-    return f"\n[Image description: {result.content}]\n"
+    return f"\n[Image description: {result.content}]\n"
+
+def file_to_bytes(filepath):
+    """
+    Reads a file and returns its content as a bytes object.
+
+    Args:
+        filepath (str): The path to the file.
+
+    Returns:
+        bytes: The content of the file as a bytes object.
+    """
+    try:
+        with open(filepath, "rb") as f:
+            file_content_bytes = f.read()
+        return file_content_bytes
+    except FileNotFoundError:
+        logger.error(f"File not found: {filepath}")
+        return None
+    except Exception as e:
+        logger.error(f"Error reading file {filepath}: {e}")
+        return None

{alita_sdk-0.3.207.dist-info → alita_sdk-0.3.209.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.207
+Version: 0.3.209
 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.207.dist-info → alita_sdk-0.3.209.dist-info}/RECORD

@@ -4,7 +4,7 @@ alita_sdk/community/utils.py,sha256=lvuCJaNqVPHOORJV6kIPcXJcdprVW_TJvERtYAEgpjM,
 alita_sdk/runtime/__init__.py,sha256=4W0UF-nl3QF2bvET5lnah4o24CoTwSoKXhuN0YnwvEE,828
 alita_sdk/runtime/clients/__init__.py,sha256=BdehU5GBztN1Qi1Wul0cqlU46FxUfMnI6Vq2Zd_oq1M,296
 alita_sdk/runtime/clients/artifact.py,sha256=4N2t5x3GibyXLq3Fvrv2o_VA7Z000yNfc-UN4eGsHZg,2679
-alita_sdk/runtime/clients/client.py,sha256=R2ISXLCi7ODQaw6juPlknCtWkcSeZw-lmq3VOc6V-yM,35783
+alita_sdk/runtime/clients/client.py,sha256=xTmrgKWVMfLPZG_BKkMheTMlJUK-a7URCIk6YiFyxVY,41868
 alita_sdk/runtime/clients/datasource.py,sha256=HAZovoQN9jBg0_-lIlGBQzb4FJdczPhkHehAiVG3Wx0,1020
 alita_sdk/runtime/clients/prompt.py,sha256=li1RG9eBwgNK_Qf0qUaZ8QNTmsncFrAL2pv3kbxZRZg,1447
 alita_sdk/runtime/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -12,7 +12,7 @@ alita_sdk/runtime/langchain/assistant.py,sha256=Bn9vUyZlFAP-D9Bh3zc2G1ZQkh5rr2c2
 alita_sdk/runtime/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
 alita_sdk/runtime/langchain/constants.py,sha256=eHVJ_beJNTf1WJo4yq7KMK64fxsRvs3lKc34QCXSbpk,3319
 alita_sdk/runtime/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
-alita_sdk/runtime/langchain/langraph_agent.py,sha256=QwD9NZ74Hp4rZvP7nirzOmjFJhfJ7eiuAvsq7aAW4Uw,43563
+alita_sdk/runtime/langchain/langraph_agent.py,sha256=csK5vNXULMImBsfNzb6B2HgXuCWgCNYf3DIVvnmk5uQ,43835
 alita_sdk/runtime/langchain/mixedAgentParser.py,sha256=M256lvtsL3YtYflBCEp-rWKrKtcY1dJIyRGVv7KW9ME,2611
 alita_sdk/runtime/langchain/mixedAgentRenderes.py,sha256=asBtKqm88QhZRILditjYICwFVKF5KfO38hu2O-WrSWE,5964
 alita_sdk/runtime/langchain/store_manager.py,sha256=i8Fl11IXJhrBXq1F1ukEVln57B1IBe-tqSUvfUmBV4A,2218
@@ -79,7 +79,7 @@ alita_sdk/runtime/tools/pgvector_search.py,sha256=NN2BGAnq4SsDHIhUcFZ8d_dbEOM8Qw
 alita_sdk/runtime/tools/prompt.py,sha256=nJafb_e5aOM1Rr3qGFCR-SKziU9uCsiP2okIMs9PppM,741
 alita_sdk/runtime/tools/router.py,sha256=wCvZjVkdXK9dMMeEerrgKf5M790RudH68pDortnHSz0,1517
 alita_sdk/runtime/tools/tool.py,sha256=lE1hGi6qOAXG7qxtqxarD_XMQqTghdywf261DZawwno,5631
-alita_sdk/runtime/tools/vectorstore.py,sha256=RhGg2gGY5PFfllouuwB5uLkM_lAlr_SqpsziLKgXq1U,30672
+alita_sdk/runtime/tools/vectorstore.py,sha256=o818tabxkG-o1Opv7zQy9lIL4sW2lfEHNCJrNiU7uPU,30634
 alita_sdk/runtime/utils/AlitaCallback.py,sha256=E4LlSBuCHWiUq6W7IZExERHZY0qcmdjzc_rJlF2iQIw,7356
 alita_sdk/runtime/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/utils/constants.py,sha256=Xntx1b_uxUzT4clwqHA_U6K8y5bBqf_4lSQwXdcWrp4,13586
@@ -97,9 +97,9 @@ alita_sdk/tools/ado/utils.py,sha256=PTCludvaQmPLakF2EbCGy66Mro4-rjDtavVP-xcB2Wc,
 alita_sdk/tools/ado/repos/__init__.py,sha256=guYY95Gtyb0S4Jj0V1qO0x2jlRoH0H1cKjHXNwmShow,6388
 alita_sdk/tools/ado/repos/repos_wrapper.py,sha256=spBq-0QdRRNctz_Qbl4IIDpnjitzQLhvJzRIW_6jKNA,48583
 alita_sdk/tools/ado/test_plan/__init__.py,sha256=bVywTYTvdm1rUeP2krVVMRN-xDCY--ze7NFdTxJP9ow,4708
-alita_sdk/tools/ado/test_plan/test_plan_wrapper.py,sha256=p1Mptd_1J6bmkyrvf2M-FB79s8THzEesBlfgaOnRXb8,18152
+alita_sdk/tools/ado/test_plan/test_plan_wrapper.py,sha256=p1S5vQJSSfXXXZ3MH8qaqKZiH9MeT_pCHGU56Xn5UdI,21639
 alita_sdk/tools/ado/wiki/__init__.py,sha256=WCIKOisU2h3E4SNDvGfWCMZ3nRMxfH_ZhIffmSHH3XI,4576
-alita_sdk/tools/ado/wiki/ado_wrapper.py,sha256=l4bc2QoKSUXg9UqNcx0ylv7YL9JPPQd35Ti5MXyEgC4,12690
+alita_sdk/tools/ado/wiki/ado_wrapper.py,sha256=2mIuvYbVnX1eYSBzr4PQTrOZa_s0btONCT-e8MWNUbU,15482
 alita_sdk/tools/ado/work_item/__init__.py,sha256=k6gZ6pEE7gvNWvCDoDV05jltzbqxC_NPm06CEr5Wwcs,4726
 alita_sdk/tools/ado/work_item/ado_wrapper.py,sha256=aLB-aSNQST0FCwP7I01OXanCpZHKVarZZB1u9j2H1LA,26253
 alita_sdk/tools/advanced_jira_mining/__init__.py,sha256=pUTzECqGvYaR5qWY3JPUhrImrZgc7pCXuqSe5eWIE80,4604
@@ -164,7 +164,7 @@ alita_sdk/tools/chunkers/code/treesitter/treesitter_rs.py,sha256=LgKyNffBy30gIr8
 alita_sdk/tools/chunkers/code/treesitter/treesitter_ts.py,sha256=Qs1a_BBN296iZc5hh8UNF9sc0G0-A_XZVhP3Na1ZNDg,387
 alita_sdk/tools/chunkers/sematic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/tools/chunkers/sematic/base.py,sha256=bRHpCFbOy-KPe4HBGpegrvIhvOsd7sDRfmb06T8tSuU,349
-alita_sdk/tools/chunkers/sematic/markdown_chunker.py,sha256=clmhRgewfBD-Ho1v0bSWKkCg_Fc9RSNfiwky1QM7AdU,2523
+alita_sdk/tools/chunkers/sematic/markdown_chunker.py,sha256=NZCZi0Xzi58Bm7-9LzwGoAhdNZhvUERb_sK1bNQpqCQ,2574
 alita_sdk/tools/chunkers/sematic/proposal_chunker.py,sha256=t8JjX9TH6yHXXaemiDK1E6000tlES2Kl8XfyezmlIoo,5116
 alita_sdk/tools/chunkers/sematic/statistical_chunker.py,sha256=VDQcMC-ky72GqdWJiHMmcRmfJTTU5XglBF1IWg2Qews,13403
 alita_sdk/tools/cloud/__init__.py,sha256=ekqANTJAyuURqpjNTn6MmSn2q6qEKwENxEXBUFGkkck,512
@@ -269,7 +269,7 @@ alita_sdk/tools/servicenow/__init__.py,sha256=VHH3qpUbEJ0tdtrIiWakohCmbifUOPgCVX
 alita_sdk/tools/servicenow/api_wrapper.py,sha256=WpH-bBLGFdhehs4g-K-WAkNuaD1CSrwsDpdgB3RG53s,6120
 alita_sdk/tools/servicenow/servicenow_client.py,sha256=Rdqfu-ll-qbnclMzChLZBsfXRDzgoX_FdeI2WLApWxc,3269
 alita_sdk/tools/sharepoint/__init__.py,sha256=CiaOmzPl-9WNWZU9AtP-Y-Mg_uBnxeKFTnUjJ5aQbmA,3036
-alita_sdk/tools/sharepoint/api_wrapper.py,sha256=YNtXmathHN46FCD4M9zDs2li0USdKW35lRXckYU8XdU,10011
+alita_sdk/tools/sharepoint/api_wrapper.py,sha256=o9z8-_d3F4qfgvonJIed9obVPvTYC06zmkwk2XZ1UfI,10600
 alita_sdk/tools/sharepoint/authorization_helper.py,sha256=n-nL5dlBoLMK70nHu7P2RYCb8C6c9HMA_gEaw8LxuhE,2007
 alita_sdk/tools/sharepoint/utils.py,sha256=fZ1YzAu5CTjKSZeslowpOPH974902S8vCp1Wu7L44LM,446
 alita_sdk/tools/slack/__init__.py,sha256=mbP2JiHybGSAH0ay8pxvPCqeU2eb9CK_NaCKG1uhPE4,3894
@@ -280,9 +280,9 @@ alita_sdk/tools/sql/models.py,sha256=AKJgSl_kEEz4fZfw3kbvdGHXaRZ-yiaqfJOB6YOj3i0
 alita_sdk/tools/testio/__init__.py,sha256=qi12wyJXN02hrUXg08CbijcCL5pi30JMbJfiXjn1Zr0,2646
 alita_sdk/tools/testio/api_wrapper.py,sha256=BvmL5h634BzG6p7ajnQLmj-uoAw1gjWnd4FHHu1h--Q,21638
 alita_sdk/tools/testrail/__init__.py,sha256=YILz5ZjkHfBg1tQ-FKFBP_s0uo2WDY110Qgsg0kBntM,4157
-alita_sdk/tools/testrail/api_wrapper.py,sha256=Sfe_5sJk-cIAYRlpO7DcCN117UAPbBIzf_HI6fVrOQ8,31999
+alita_sdk/tools/testrail/api_wrapper.py,sha256=5T5Mowo2xW-s2k4mB9IL7kSHok8I7C2UMcz1Uq25_NY,32419
 alita_sdk/tools/utils/__init__.py,sha256=155xepXPr4OEzs2Mz5YnjXcBpxSv1X2eznRUVoPtyK0,3268
-alita_sdk/tools/utils/content_parser.py,sha256=Ou967dO3JnnL9kAidzofwV6TVe2_ul86ZMjcBOK-VnA,7811
+alita_sdk/tools/utils/content_parser.py,sha256=JiL3zXCadDR0DVt6Zgq03LxWXwxuYv8us84bYMeqYa4,9788
 alita_sdk/tools/xray/__init__.py,sha256=dn-Ine9mHF8c_yZ-pWkn-gvSvSmGwdrqxPJOz6Cmqc4,3297
 alita_sdk/tools/xray/api_wrapper.py,sha256=l7Cwvh_5bEaH0IM3yLo1PSClqV1E20wH_sEHaJntM3s,8517
 alita_sdk/tools/yagmail/__init__.py,sha256=c4Qn3em0tLxzRmFKpzbBgY9W2EnOoKf0azoDJHng5CY,2208
@@ -299,8 +299,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=VDsSFUTnBne1mFNssX2eLFxThXAhX
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=0AI_j27xVO5Gk5HQMFrqPTd4uvuVTpiZUicBrdfEpKg,2796
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=kmw_xol8YIYFplBLWTqP_VKPRhL_1ItDD0_vXTe_UuI,14906
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=R371waHsms4sllHCbijKYs90C-9Yu0sSR3N4SUfQOgU,5066
-alita_sdk-0.3.207.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.207.dist-info/METADATA,sha256=5lVazejNDrCxd8_C-cvo3UuvhtgU7mVpW6WZAUqR_6Q,18917
-alita_sdk-0.3.207.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.207.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.207.dist-info/RECORD,,
+alita_sdk-0.3.209.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.209.dist-info/METADATA,sha256=mnXZpgZ6MJkT3kLO1byDa9SR9lTbzhkEaTZb803EPoo,18917
+alita_sdk-0.3.209.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.209.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.209.dist-info/RECORD,,