alita-sdk 0.3.207__tar.gz → 0.3.208__tar.gz

{alita_sdk-0.3.207 → alita_sdk-0.3.208}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.207
+Version: 0.3.208
 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 → alita_sdk-0.3.208}/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-0.3.207 → alita_sdk-0.3.208}/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-0.3.207 → alita_sdk-0.3.208}/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-0.3.207 → alita_sdk-0.3.208}/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-0.3.207 → alita_sdk-0.3.208}/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-0.3.207 → alita_sdk-0.3.208}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.207
+Version: 0.3.208
 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 → alita_sdk-0.3.208}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alita_sdk"
-version = "0.3.207"
+version = "0.3.208"
 description = "SDK for building langchain agents using resources from Alita"
 readme = "README.md"
 requires-python = ">=3.10"