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

alita_sdk/tools/zephyr/__init__.py

@@ -7,7 +7,8 @@ from pydantic import create_model, BaseModel, Field, SecretStr
 
 from ..base.tool import BaseAction
 from .api_wrapper import ZephyrV1ApiWrapper
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
 
 name = "zephyr"
 
@@ -22,15 +23,13 @@ def get_tools(tool):
 
 class ZephyrToolkit(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 ZephyrV1ApiWrapper.model_construct().get_available_tools()}
-        ZephyrToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            base_url=(str, Field(description="Base URL", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': ZephyrToolkit.toolkit_max_length})),
+            base_url=(str, Field(description="Base URL")),
             username=(str, Field(description="Username")),
             password=(SecretStr, Field(description="Password", json_schema_extra={'secret': True})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
@@ -45,19 +44,23 @@ class ZephyrToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         zephyr_api_wrapper = ZephyrV1ApiWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = zephyr_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=zephyr_api_wrapper,
                 name=tool["name"],
-                description=tool["description"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/tools/zephyr_enterprise/__init__.py

@@ -4,7 +4,8 @@ from typing import List, Literal, Optional
 
 from .api_wrapper import ZephyrApiWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.pgvector import PgVectorConfiguration
 from ...configurations.zephyr_enterprise import ZephyrEnterpriseConfiguration
 
@@ -27,23 +28,22 @@ def get_tools(tool):
 
 class ZephyrEnterpriseToolkit(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
                           ZephyrApiWrapper.model_construct().get_available_tools()}
-        ZephyrEnterpriseToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            zephyr_configuration=(Optional[ZephyrEnterpriseConfiguration], Field(description="Zephyr Configuration", json_schema_extra={'configuration_types': ['zephyr-enterprise']})),
+            zephyr_configuration=(ZephyrEnterpriseConfiguration, Field(description="Zephyr Configuration", json_schema_extra={'configuration_types': ['zephyr_enterprise']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration",
                                                                            json_schema_extra={
                                                                                'configuration_types': ['pgvector']},
                                                                            default=None)),
             # embedder settings
             embedding_model=(Optional[str], Field(default=None, description="Embedding configuration.", json_schema_extra={'configuration_model': 'embedding'})),
-            selected_tools=(List[Literal[tuple(selected_tools)]], []),
+            selected_tools=(List[Literal[tuple(selected_tools)]],
+                            Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {
                     "label": "Zephyr Enterprise", "icon_url": "zephyr.svg",
@@ -53,6 +53,7 @@ class ZephyrEnterpriseToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -64,16 +65,20 @@ class ZephyrEnterpriseToolkit(BaseToolkit):
             **(kwargs.get('embedding_configuration') or {}),
         }
         zephyr_api_wrapper = ZephyrApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = zephyr_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description + "\nZephyr Enterprise instance: " + zephyr_api_wrapper.base_url
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=zephyr_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + "\nZephyr Enterprise instance: " + zephyr_api_wrapper.base_url,
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/tools/zephyr_enterprise/api_wrapper.py

@@ -1,3 +1,4 @@
+import json
 import logging
 from typing import Optional, List, Generator, Literal
 
@@ -8,6 +9,8 @@ from langchain_core.documents import Document
 from .zephyr_enterprise import ZephyrClient
 from ..non_code_indexer_toolkit import NonCodeIndexerToolkit
 from ..utils.available_tools_decorator import extend_with_parent_available_tools
+from ..utils.content_parser import file_extension_by_chunker
+from ...runtime.utils.utils import IndexerKeywords
 
 logger = logging.getLogger(__name__)
 
@@ -152,17 +155,23 @@ class ZephyrApiWrapper(NonCodeIndexerToolkit):
         Returns a list of fields for index_data args schema.
         """
         return {
-            "zql": (str, Field(description=zql_description, examples=["folder=\"TestToolkit\"", "name~\"TestToolkit5\""])),
-            'chunking_tool': (Literal['json'], Field(description="Name of chunking tool", default='json'))
+            'chunking_tool': (Literal['json', ''], Field(description="Name of chunking tool", default='json')),
+            "zql": (str, Field(description=zql_description, examples=["folder=\"TestToolkit\"", "name~\"TestToolkit5\""]))
+
         }
 
     def _base_loader(self, zql: str, **kwargs) -> Generator[Document, None, None]:
-        test_cases = self.get_testcases_by_zql(zql)
+        self._chunking_tool = kwargs.get('chunking_tool', None)
+        test_cases = self.get_testcases_by_zql(zql=zql, return_as_list=True)
         for test_case in test_cases:
             metadata = {
-                ("updated_on" if k == "lastModifiedOn" else "id" if k == "testcaseId" else k): str(v)
-                for k, v in test_case
-                if k != "id"
+                "updated_on": str(test_case.get("lastModifiedOn")),
+                "id": str(test_case.get("id")),
+                "name": test_case.get("name"),
+                "testcaseId": str(test_case.get("testcaseId")),
+                "projectId": test_case.get("projectId"),
+                "projectName": test_case.get("projectName"),
+                "testcaseType": test_case.get("testcaseType"),
             }
             yield Document(page_content='', metadata=metadata)
 
@@ -171,7 +180,8 @@ class ZephyrApiWrapper(NonCodeIndexerToolkit):
             try:
                 id = document.metadata['id']
                 test_case_content = self.get_test_case_steps(id)
-                document.page_content = test_case_content
+                page_content = json.dumps(test_case_content)
+                document.metadata[IndexerKeywords.CONTENT_IN_BYTES.value] = page_content.encode('utf-8')
             except Exception as e:
                 logging.error(f"Failed to process document: {e}")
             yield document

alita_sdk/tools/zephyr_essential/__init__.py

@@ -5,15 +5,17 @@ from pydantic import create_model, BaseModel, Field
 
 from .api_wrapper import ZephyrEssentialApiWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.pgvector import PgVectorConfiguration
+from ...configurations.zephyr_essential import ZephyrEssentialConfiguration
 
 name = "zephyr_essential"
 
 def get_tools(tool):
     return ZephyrEssentialToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        token=tool['settings']["token"],
+        zephyr_essential_configuration=tool['settings']['zephyr_essential_configuration'],
         toolkit_name=tool.get('toolkit_name'),
         llm = tool['settings'].get('llm', None),
         alita=tool['settings'].get('alita', None),
@@ -27,16 +29,13 @@ def get_tools(tool):
 
 class ZephyrEssentialToolkit(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 ZephyrEssentialApiWrapper.model_construct().get_available_tools()}
-        ZephyrEssentialToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            token=(str, Field(description="Bearer api token")),
-            base_url=(Optional[str], Field(description="Zephyr Essential base url", default=None)),
+            zephyr_essential_configuration=(ZephyrEssentialConfiguration, Field(description="Zephyr Essential Configuration", json_schema_extra={'configuration_types': ['zephyr_essential']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None,
                                                                            description="PgVector Configuration",
@@ -51,25 +50,30 @@ class ZephyrEssentialToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
         wrapper_payload = {
             **kwargs,
+            **kwargs.get('zephyr_essential_configuration', {}),
             **(kwargs.get('pgvector_configuration') or {}),
         }
         zephyr_api_wrapper = ZephyrEssentialApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = zephyr_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=zephyr_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)