alita-sdk 0.3.263__py3-none-any.whl → 0.3.499__py3-none-any.whl

alita_sdk/tools/ado/repos/repos_wrapper.py

@@ -24,7 +24,8 @@ from msrest.authentication import BasicAuthentication
 from pydantic import Field, PrivateAttr, create_model, model_validator, SecretStr
 
 from ..utils import extract_old_new_pairs, generate_diff, get_content_from_generator
-from ...elitea_base import BaseCodeToolApiWrapper
+from ...code_indexer_toolkit import CodeIndexerToolkit
+from ...utils.available_tools_decorator import extend_with_parent_available_tools
 
 logger = logging.getLogger(__name__)
 
@@ -110,8 +111,7 @@ class ArgsSchema(Enum):
             Field(
                 description=(
                     "Branch to be used for read file operation."
-                ),
-                default=None
+                )
             ),
         )
     )
@@ -159,6 +159,7 @@ class ArgsSchema(Enum):
             Field(
                 description="""List of comments, where each comment is a dictionary specifying details about the comment,
                 e.g. [{'file_path': 'src/main.py', 'comment_text': 'Logic needs improvement', 'right_line': 20}]""",
+                default=None,
                 examples=[
                     {
                         "file_path": "src/main.py",
@@ -241,7 +242,7 @@ class ArgsSchema(Enum):
     )
 
 
-class ReposApiWrapper(BaseCodeToolApiWrapper):
+class ReposApiWrapper(CodeIndexerToolkit):
     # TODO use ado_repos_configuration fields
     organization_url: Optional[str]
     project: Optional[str]
@@ -292,7 +293,7 @@ class ReposApiWrapper(BaseCodeToolApiWrapper):
             if not branch_exists(active_branch):
                 raise ToolException(f"The active branch '{active_branch}' does not exist.")
 
-        return values
+        return super().validate_toolkit(values)
 
     def _get_commits(self, file_path: str, branch: str, top: int = None) -> List[GitCommitRef]:
         """
@@ -643,6 +644,9 @@ class ReposApiWrapper(BaseCodeToolApiWrapper):
 
         return dumps(data)
 
+    def download_file(self, path):
+        return b"".join(self._client.get_item_content(self.repository_id, path=path, project=self.project, download=True))
+
     def get_file_content(self, commit_id, path):
         version_descriptor = GitVersionDescriptor(
             version=commit_id, version_type="commit"
@@ -1170,9 +1174,10 @@ class ReposApiWrapper(BaseCodeToolApiWrapper):
         except Exception as e:
             return ToolException(f"Unable to retrieve commits due to error:\n{str(e)}")
 
+    @extend_with_parent_available_tools
     def get_available_tools(self):
         """Return a list of available tools."""
-        tools = [
+        return [
             {
                 "ref": self.list_branches_in_repo,
                 "name": "list_branches_in_repo",
@@ -1263,8 +1268,4 @@ class ReposApiWrapper(BaseCodeToolApiWrapper):
                 "description": self.get_commits.__doc__,
                 "args_schema": ArgsSchema.GetCommits.value,
             },
-        ]        # Add vector search tools from base class (includes index_data + search tools)
-        vector_search_tools = self._get_vector_search_tools()
-        tools.extend(vector_search_tools)
-
-        return tools
+        ]

alita_sdk/tools/ado/test_plan/__init__.py

@@ -4,11 +4,13 @@ from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import create_model, BaseModel, Field
 
 import requests
+
+from ...elitea_base import filter_missconfigured_index_tools
 from ....configurations.ado import AdoConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from .test_plan_wrapper import TestPlanApiWrapper
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import clean_string, get_max_toolkit_length, check_connection_response
 
 
 name = "azure_devops_plans"
@@ -17,15 +19,12 @@ name_alias = "ado_plans"
 
 class AzureDevOpsPlansToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in TestPlanApiWrapper.model_construct().get_available_tools()}
-        AzureDevOpsPlansToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name_alias,
-            name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsPlansToolkit.toolkit_max_length})),
             ado_configuration=(AdoConfiguration, Field(description="Ado configuration", json_schema_extra={'configuration_types': ['ado']})),
             limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),
             # indexer settings
@@ -79,6 +78,7 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
         return m
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         from os import environ
         if not environ.get('AZURE_DEVOPS_CACHE_DIR', None):
@@ -94,16 +94,19 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
         azure_devops_api_wrapper = TestPlanApiWrapper(**wrapper_payload)
         available_tools = azure_devops_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
             print(tool)
+            description = tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=azure_devops_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}",
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/tools/ado/test_plan/test_plan_wrapper.py

@@ -1,7 +1,8 @@
 import json
 import logging
+import re
 import xml.etree.ElementTree as ET
-from typing import Generator, Optional
+from typing import Generator, Literal, Optional, List
 
 from azure.devops.connection import Connection
 from azure.devops.v7_0.test_plan.models import TestPlanCreateParams, TestSuiteCreateParams, \
@@ -14,7 +15,9 @@ from pydantic import create_model, PrivateAttr, model_validator, SecretStr
 from pydantic.fields import FieldInfo as Field
 
 from ..work_item import AzureDevOpsApiWrapper
-from ...elitea_base import BaseVectorStoreToolApiWrapper, extend_with_vector_tools
+from ...non_code_indexer_toolkit import NonCodeIndexerToolkit
+from ...utils.available_tools_decorator import extend_with_parent_available_tools
+from ....runtime.utils.utils import IndexerKeywords
 
 logger = logging.getLogger(__name__)
 
@@ -158,7 +161,7 @@ TestCasesGetModel = create_model(
     suite_id=(int, Field(description="ID of the test suite for which test cases are requested"))
 )
 
-class TestPlanApiWrapper(BaseVectorStoreToolApiWrapper):
+class TestPlanApiWrapper(NonCodeIndexerToolkit):
     # TODO use ado_configuration instead of organization_url, project and token
     __test__ = False
     organization_url: str
@@ -178,7 +181,7 @@ class TestPlanApiWrapper(BaseVectorStoreToolApiWrapper):
             cls._client = connection.clients.get_test_plan_client()
         except Exception as e:
             raise ImportError(f"Failed to connect to Azure DevOps: {e}")
-        return values
+        return super().validate_toolkit(values)
 
     def create_test_plan(self, test_plan_create_params: str):
         """Create a test plan in Azure DevOps."""
@@ -275,7 +278,7 @@ class TestPlanApiWrapper(BaseVectorStoreToolApiWrapper):
                          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)
+                                                  token=self.token.get_secret_value(), project=self.project, llm=self.llm)
         if test_steps_format == 'json':
             steps_xml = self.get_test_steps_xml(json.loads(test_steps))
         elif test_steps_format == 'xml':
@@ -357,40 +360,70 @@ class TestPlanApiWrapper(BaseVectorStoreToolApiWrapper):
             test_cases = self._client.get_test_case_list(self.project, plan_id, suite_id)
             return [test_case.as_dict() for test_case in test_cases]
         except Exception as e:
+            self._log_tool_event(f"Error getting test cases: {e}", 'get_test_cases')
             logger.error(f"Error getting test cases: {e}")
             return ToolException(f"Error getting test cases: {e}")
 
-    def _base_loader(self, plan_id: str, suite_ids: Optional[list[str]] = [], **kwargs) -> Generator[Document, None, None]:
+    def get_suites_in_plan(self, plan_id: int) -> List[dict]:
+        """Get all test suites in a test plan."""
+        try:
+            test_suites = self._client.get_test_suites_for_plan(self.project, plan_id)
+            return [suite.as_dict() for suite in test_suites]
+        except Exception as e:
+            logger.error(f"Error getting test suites: {e}")
+            return ToolException(f"Error getting test suites: {e}")
+
+    def _base_loader(self, plan_id: int, suite_ids: Optional[List[int]] = [], chunking_tool: str = None, **kwargs) -> Generator[Document, None, None]:
         cases = []
+        if not suite_ids:
+            suites = self.get_suites_in_plan(plan_id)
+            suite_ids = [suite['id'] for suite in suites if 'id' in suite]
         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]:
-        if False:
-            yield  # Unreachable, but keeps the function a generator
+            if chunking_tool:
+                steps = data.get('Microsoft.VSTS.TCM.Steps', '')
+                # Remove XML declaration if present (like <?xml version="1.0" encoding="utf-16"?>) to avoid encoding issues
+                steps_no_decl = re.sub(r'<\?xml[^>]*\?>', '', steps, count=1).lstrip()
+
+                yield Document(
+                    page_content='',
+                    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', ''),
+                        # content is in metadata for chunking tool post-processing
+                        IndexerKeywords.CONTENT_IN_BYTES.value: steps_no_decl.encode("utf-8")
+                    })
+            else:
+                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 _index_tool_params(self):
         """Return the parameters for indexing data."""
         return {
-            "plan_id": (str, Field(description="ID of the test plan for which test cases are requested")),
-            "suite_ids": (str, Field(description="List of test suite IDs for which test cases are requested (can be empty)"))
+            'chunking_tool': (Literal['xml', ''], Field(description="Name of chunking tool", default='xml')),
+            "plan_id": (int, Field(description="ID of the test plan for which test cases are requested")),
+            "suite_ids": (Optional[List[int]], Field(description='List of test suite IDs for which test cases are requested '
+                                                                 '(can be empty for all suites indexing from the plan). '
+                                                                 'Example: [2, 23]', default=[])),
         }
 
-    @extend_with_vector_tools
+    @extend_with_parent_available_tools
     def get_available_tools(self):
         """Return a list of available tools."""
         return [

alita_sdk/tools/ado/wiki/__init__.py

@@ -4,29 +4,24 @@ from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import create_model, BaseModel, Field
 
 import requests
+
+from ...elitea_base import filter_missconfigured_index_tools
 from ....configurations.ado import AdoConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import clean_string, get_max_toolkit_length, check_connection_response
 
 name = "azure_devops_wiki"
 name_alias = 'ado_wiki'
 
 class AzureDevOpsWikiToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AzureDevOpsApiWrapper.model_construct().get_available_tools()}
-        AzureDevOpsWikiToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name_alias,
-            name=(str, Field(description="Toolkit name",
-                             json_schema_extra={
-                                 'toolkit_name': True,
-                                 'max_toolkit_length': AzureDevOpsWikiToolkit.toolkit_max_length})
-                  ),
             ado_configuration=(AdoConfiguration, Field(description="Ado configuration", json_schema_extra={'configuration_types': ['ado']})),
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None,
@@ -77,6 +72,7 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
         return m
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         from os import environ
         if not environ.get('AZURE_DEVOPS_CACHE_DIR', None):
@@ -92,15 +88,18 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
         azure_devops_api_wrapper = AzureDevOpsApiWrapper(**wrapper_payload)
         available_tools = azure_devops_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}/{azure_devops_api_wrapper.project}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=azure_devops_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}/{azure_devops_api_wrapper.project}",
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/tools/ado/wiki/ado_wrapper.py

@@ -1,6 +1,8 @@
 import hashlib
 import logging
-from typing import Any, Dict, Generator, Optional
+import re
+import requests
+from typing import Generator, Literal, Optional
 
 from azure.devops.connection import Connection
 from azure.devops.exceptions import AzureDevOpsServiceError
@@ -15,7 +17,12 @@ from pydantic import create_model, PrivateAttr, SecretStr
 from pydantic import model_validator
 from pydantic.fields import Field
 
-from ...elitea_base import BaseVectorStoreToolApiWrapper, extend_with_vector_tools
+import alita_sdk.tools.ado.work_item
+from ..repos import ReposApiWrapper
+from ...non_code_indexer_toolkit import NonCodeIndexerToolkit
+from ...utils.available_tools_decorator import extend_with_parent_available_tools
+from ...utils.content_parser import parse_file_content
+from ....runtime.utils.utils import IndexerKeywords
 
 logger = logging.getLogger(__name__)
 
@@ -27,13 +34,17 @@ GetWikiInput = create_model(
 GetPageByPathInput = create_model(
     "GetPageByPathInput",
     wiki_identified=(str, Field(description="Wiki ID or wiki name")),
-    page_name=(str, Field(description="Wiki page path"))
+    page_name=(str, Field(description="Wiki page path")),
+    image_description_prompt=(Optional[str],
+                              Field(description="Prompt which is used for image description", default=None))
 )
 
 GetPageByIdInput = create_model(
     "GetPageByIdInput",
     wiki_identified=(str, Field(description="Wiki ID or wiki name")),
-    page_id=(int, Field(description="Wiki page ID"))
+    page_id=(int, Field(description="Wiki page ID")),
+    image_description_prompt=(Optional[str],
+                              Field(description="Prompt which is used for image description", default=None))
 )
 
 ModifyPageInput = create_model(
@@ -41,8 +52,9 @@ ModifyPageInput = create_model(
     wiki_identified=(str, Field(description="Wiki ID or wiki name")),
     page_name=(str, Field(description="Wiki page name")),
     page_content=(str, Field(description="Wiki page content")),
-    version_identifier=(str, Field(description="Version string identifier (name of tag/branch, SHA1 of commit)")),
-    version_type=(Optional[str], Field(description="Version type (branch, tag, or commit). Determines how Id is interpreted", default="branch"))
+    version_identifier=(str, Field(description="Version string identifier (name of tag/branch, SHA1 of commit). Usually for wiki the branch is 'wikiMaster'")),
+    version_type=(Optional[str], Field(description="Version type (branch, tag, or commit). Determines how Id is interpreted", default="branch")),
+    expanded=(Optional[bool], Field(description="Whether to return the full page object or just its simplified version.", default=False))
 )
 
 RenamePageInput = create_model(
@@ -55,7 +67,20 @@ RenamePageInput = create_model(
 )
 
 
-class AzureDevOpsApiWrapper(BaseVectorStoreToolApiWrapper):
+def _format_wiki_page_response(wiki_page_response, expanded: bool = False):
+    """Format wiki page response."""
+    try:
+        return {
+            'eTag': wiki_page_response.eTag,
+            'page': wiki_page_response.page.__dict__ if wiki_page_response.page else None
+        } if expanded else {"eTag": wiki_page_response.eTag, "id": wiki_page_response.page.id,
+                            "page": wiki_page_response.page.url}
+    except:
+        logger.error(f"Unable to format wiki page response: {wiki_page_response}")
+        return wiki_page_response
+
+
+class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
     # TODO use ado_configuration instead of organization_url, project and token
     organization_url: str
     project: str
@@ -82,7 +107,7 @@ class AzureDevOpsApiWrapper(BaseVectorStoreToolApiWrapper):
         except Exception as e:
             return ImportError(f"Failed to connect to Azure DevOps: {e}")
 
-        return values
+        return super().validate_toolkit(values)
 
     def get_wiki(self, wiki_identified: str):
         """Extract ADO wiki information."""
@@ -92,24 +117,75 @@ class AzureDevOpsApiWrapper(BaseVectorStoreToolApiWrapper):
             logger.error(f"Error during the attempt to extract wiki: {str(e)}")
             return ToolException(f"Error during the attempt to extract wiki: {str(e)}")
 
-    def get_wiki_page_by_path(self, wiki_identified: str, page_name: str):
+    def get_wiki_page_by_path(self, wiki_identified: str, page_name: str, image_description_prompt=None):
         """Extract ADO wiki page content."""
         try:
-            return self._client.get_page(project=self.project, wiki_identifier=wiki_identified, path=page_name,
-                                         include_content=True).page.content
+            return self._process_images(self._client.get_page(project=self.project, wiki_identifier=wiki_identified, path=page_name,
+                                         include_content=True).page.content,
+                                        image_description_prompt=image_description_prompt)
         except Exception as e:
             logger.error(f"Error during the attempt to extract wiki page: {str(e)}")
             return ToolException(f"Error during the attempt to extract wiki page: {str(e)}")
 
-    def get_wiki_page_by_id(self, wiki_identified: str, page_id: int):
+    def get_wiki_page_by_id(self, wiki_identified: str, page_id: int, image_description_prompt=None):
         """Extract ADO wiki page content."""
         try:
-            return (self._client.get_page_by_id(project=self.project, wiki_identifier=wiki_identified, id=page_id,
-                                                include_content=True).page.content)
+            return self._process_images(self._client.get_page_by_id(project=self.project, wiki_identifier=wiki_identified, id=page_id,
+                                                include_content=True).page.content,
+                                        image_description_prompt=image_description_prompt)
         except Exception as e:
             logger.error(f"Error during the attempt to extract wiki page: {str(e)}")
             return ToolException(f"Error during the attempt to extract wiki page: {str(e)}")
 
+    def _process_images(self, page_content: str, image_description_prompt=None):
+
+        image_pattern = r"!\[(.*?)\]\((.*?)\)"
+        matches = re.findall(image_pattern, page_content)
+
+        for image_name, image_url in matches:
+            if image_url.startswith("/.attachments/"):
+                try:
+                    description = self.process_attachment(attachment_url=image_url,
+                                                          attachment_name=image_name,
+                                                          image_description_prompt=image_description_prompt)
+                except Exception as e:
+                    logger.error(f"Error parsing attachment: {str(e)}")
+                    description = f"Error parsing attachment: {image_url}"
+            else:
+                try:
+                    response = requests.get(image_url)
+                    response.raise_for_status()
+                    file_content = response.content
+                    description = parse_file_content(
+                        file_content=file_content,
+                        file_name="image.png",
+                        llm=self.llm,
+                        prompt=image_description_prompt
+                    )
+                except Exception as e:
+                    logger.error(f"Error fetching external image: {str(e)}")
+                    description = f"Error fetching external image: image_url"
+
+            new_image_markdown = f"![{image_name}]({description})"
+            page_content = page_content.replace(f"![{image_name}]({image_url})", new_image_markdown)
+        return page_content
+
+    def process_attachment(self, attachment_url, attachment_name, image_description_prompt):
+        wiki_master_branch = "wikiMaster"
+        repos_wrapper = ReposApiWrapper(organization_url=self.organization_url,
+                                        project=self.project,
+                                        token=self.token.get_secret_value(),
+                                        repository_id="Test_agent.wiki",
+                                        base_branch=wiki_master_branch,
+                                        active_branch=wiki_master_branch)
+        attachment_content = repos_wrapper.download_file(path=attachment_url)
+        return parse_file_content(
+            file_content=attachment_content,
+            file_name=attachment_name,
+            llm=self.llm,
+            prompt=image_description_prompt
+        )
+
     def delete_page_by_path(self, wiki_identified: str, page_name: str):
         """Extract ADO wiki page content."""
         try:
@@ -164,7 +240,7 @@ class AzureDevOpsApiWrapper(BaseVectorStoreToolApiWrapper):
             logger.error(f"Unable to rename wiki page: {str(e)}")
             return ToolException(f"Unable to rename wiki page: {str(e)}")
 
-    def modify_wiki_page(self, wiki_identified: str, page_name: str, page_content: str, version_identifier: str, version_type: str = "branch"):
+    def modify_wiki_page(self, wiki_identified: str, page_name: str, page_content: str, version_identifier: str, version_type: str = "branch", expanded: Optional[bool] = False):
         """Create or Update ADO wiki page content."""
         try:
             all_wikis = [wiki.name for wiki in self._client.get_all_wikis(project=self.project)]
@@ -195,31 +271,31 @@ class AzureDevOpsApiWrapper(BaseVectorStoreToolApiWrapper):
                     return ToolException(f"Unable to extract page by path {page_name}: {str(get_page_e)}")
 
             try:
-                return self._client.create_or_update_page(
+                return _format_wiki_page_response(self._client.create_or_update_page(
                     project=self.project,
                     wiki_identifier=wiki_identified,
                     path=page_name,
                     parameters=WikiPageCreateOrUpdateParameters(content=page_content),
                     version=version,
                     version_descriptor=GitVersionDescriptor(version=version_identifier, version_type=version_type)
-                )
+                ), expanded=expanded)
             except AzureDevOpsServiceError as e:
                 if "The version '{0}' either is invalid or does not exist." in str(e):
                     # Retry the request without version_descriptor
-                    return self._client.create_or_update_page(
+                    return _format_wiki_page_response(wiki_page_response=self._client.create_or_update_page(
                         project=self.project,
                         wiki_identifier=wiki_identified,
                         path=page_name,
                         parameters=WikiPageCreateOrUpdateParameters(content=page_content),
                         version=version
-                    )
+                    ), expanded=expanded)
                 else:
                     raise
         except Exception as e:
             logger.error(f"Unable to modify wiki page: {str(e)}")
             return ToolException(f"Unable to modify wiki page: {str(e)}")
 
-    def _base_loader(self, wiki_identifier: str, title_contains: Optional[str] = None, **kwargs) -> Generator[Document, None, None]:
+    def _base_loader(self, wiki_identifier: str, chunking_tool: str = None, title_contains: Optional[str] = None, **kwargs) -> Generator[Document, None, None]:
         pages = self._client.get_pages_batch(pages_batch_request={}, project=self.project, wiki_identifier=wiki_identifier)
         #
         for page in pages:
@@ -227,21 +303,31 @@ class AzureDevOpsApiWrapper(BaseVectorStoreToolApiWrapper):
             content_hash = hashlib.sha256(content.encode("utf-8")).hexdigest()
             title = page.path.rsplit("/", 1)[-1]
             if not title_contains or (title_contains and title_contains.lower() in title.lower()):
-                yield Document(page_content=content, metadata={
-                    'id': str(page.id),
-                    'path': page.path,
-                    'title': title,
-                    'updated_on': content_hash
-                })
+                if chunking_tool:
+                    yield Document(page_content='', metadata={
+                        'id': str(page.id),
+                        'path': page.path,
+                        'title': title,
+                        'updated_on': content_hash,
+                        IndexerKeywords.CONTENT_IN_BYTES.value: content.encode("utf-8")
+                    })
+                else:
+                    yield Document(page_content=content, metadata={
+                        'id': str(page.id),
+                        'path': page.path,
+                        'title': title,
+                        'updated_on': content_hash
+                    })
 
     def _index_tool_params(self):
         """Return the parameters for indexing data."""
         return {
+            'chunking_tool': (Literal['markdown', ''], Field(description="Name of chunking tool", default='markdown')),
             "wiki_identifier": (str, Field(description="Wiki identifier to index, e.g., 'ABCProject.wiki'")),
-            'title_contains': (Optional[str], Field(default=None, description="Optional filter to include only pages with titles containing exact this string"))
+            'title_contains': (Optional[str], Field(default=None, description="Optional filter to include only pages with titles containing exact this string")),
         }
 
-    @extend_with_vector_tools
+    @extend_with_parent_available_tools
     def get_available_tools(self):
         """Return a list of available tools."""
         return [

alita_sdk/tools/ado/work_item/__init__.py

@@ -4,28 +4,23 @@ from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import create_model, BaseModel, Field
 
 import requests
+
+from ...elitea_base import filter_missconfigured_index_tools
 from ....configurations.ado import AdoConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import clean_string, get_max_toolkit_length, check_connection_response
 
 name = "ado_boards"
 
 class AzureDevOpsWorkItemsToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AzureDevOpsApiWrapper.model_construct().get_available_tools()}
-        AzureDevOpsWorkItemsToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            name=(str, Field(description="Toolkit name",
-                             json_schema_extra={
-                                 'toolkit_name': True,
-                                 'max_toolkit_length': AzureDevOpsWorkItemsToolkit.toolkit_max_length})
-                  ),
             ado_configuration=(AdoConfiguration, Field(description="Ado Work Item configuration", json_schema_extra={'configuration_types': ['ado']})),
             limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
@@ -77,6 +72,7 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
         return m
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         from os import environ
         if not environ.get('AZURE_DEVOPS_CACHE_DIR', None):
@@ -93,15 +89,18 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
         azure_devops_api_wrapper = AzureDevOpsApiWrapper(**wrapper_payload)
         available_tools = azure_devops_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}/{azure_devops_api_wrapper.project}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=azure_devops_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}/{azure_devops_api_wrapper.project}",
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)