alita-sdk 0.3.270__py3-none-any.whl → 0.3.272__py3-none-any.whl

alita_sdk/tools/report_portal/__init__.py

@@ -2,20 +2,19 @@ from typing import List, Literal, Optional
 
 from langchain_core.tools import BaseToolkit, BaseTool
 
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from .api_wrapper import ReportPortalApiWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...configurations.report_portal import ReportPortalConfiguration
 
 name = "report_portal"
 
 def get_tools(tool):
     return ReportPortalToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        endpoint=tool['settings']['endpoint'],
-        api_key=tool['settings']['api_key'],
-        project=tool['settings']['project'],
+        report_portal_configuration=tool['settings']['report_portal_configuration'],
         toolkit_name=tool.get('toolkit_name')
     ).get_tools()
 
@@ -30,9 +29,7 @@ class ReportPortalToolkit(BaseToolkit):
         ReportPortalToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            endpoint=(str, Field(description="Report Portal endpoint", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': ReportPortalToolkit.toolkit_max_length})),
-            project=(str, Field(description="Report Portal project")),
-            api_key=(SecretStr, Field(description="User API key", json_schema_extra={'secret': True})),
+            report_portal_configuration=(ReportPortalConfiguration, Field(description="Report Portal Configuration", json_schema_extra={'configuration_types': ['report_portal']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Report Portal", "icon_url": "reportportal-icon.svg",
                                                                   "categories": ["testing"],
@@ -43,7 +40,11 @@ class ReportPortalToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        report_portal_api_wrapper = ReportPortalApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('report_portal_configuration', {}),
+        }
+        report_portal_api_wrapper = ReportPortalApiWrapper(**wrapper_payload)
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = report_portal_api_wrapper.get_available_tools()
         tools = []

alita_sdk/tools/salesforce/__init__.py

@@ -2,17 +2,16 @@ from typing import List, Optional, Literal
 from .api_wrapper import SalesforceApiWrapper
 from langchain_core.tools import BaseTool, BaseToolkit
 from ..base.tool import BaseAction
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 from ..utils import clean_string, TOOLKIT_SPLITTER,get_max_toolkit_length
+from ...configurations.salesforce import SalesforceConfiguration
 
 name = "salesforce"
 
 def get_tools(tool):
     return SalesforceToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        base_url=tool['settings'].get('base_url'),
-        client_id=tool['settings'].get('client_id'),
-        client_secret=tool['settings'].get('client_secret'),
+        salesforce_configuration=tool['settings']['salesforce_configuration'],
         api_version=tool['settings'].get('api_version', 'v59.0')
     ).get_tools()
 
@@ -25,10 +24,8 @@ class SalesforceToolkit(BaseToolkit):
         SalesforceToolkit.toolkit_max_length = get_max_toolkit_length(available_tools)
         return create_model(
             name,
-            base_url=(str, Field(description="Salesforce instance URL", json_schema_extra={'toolkit_name': True})),
-            client_id=(str, Field(description="Salesforce Connected App Client ID")),
-            client_secret=(SecretStr, Field(description="Salesforce Connected App Client Secret", json_schema_extra={'secret': True})),
             api_version=(str, Field(description="Salesforce API Version", default='v59.0')),
+            salesforce_configuration=(SalesforceConfiguration, Field(description="Salesforce Configuration", json_schema_extra={'configuration_types': ['salesforce']})),
             selected_tools=(List[Literal[tuple(available_tools)]], Field(default=[], json_schema_extra={'args_schemas': available_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {
                 "label": "Salesforce", "icon_url": "salesforce-icon.svg",
@@ -42,7 +39,11 @@ class SalesforceToolkit(BaseToolkit):
         if selected_tools is None:
             selected_tools = []
 
-        api_wrapper = SalesforceApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('salesforce_configuration', {}),
+        }
+        api_wrapper = SalesforceApiWrapper(**wrapper_payload)
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         tools = []
 

alita_sdk/tools/servicenow/__init__.py

@@ -37,7 +37,7 @@ class ServiceNowToolkit(BaseToolkit):
                              json_schema_extra={
                                  'toolkit_name': True, 'max_toolkit_length': ServiceNowToolkit.toolkit_max_length})),
             response_fields=(Optional[str], Field(description="Response fields", default=None)),
-            servicenow_configuration=(Optional[ServiceNowConfiguration], Field(description="ServiceNow Configuration",
+            servicenow_configuration=(ServiceNowConfiguration, Field(description="ServiceNow Configuration",
                                                                                json_schema_extra={
                                                                                    'configuration_types': [
                                                                                        'service_now']})),

alita_sdk/tools/sharepoint/__init__.py

@@ -1,11 +1,12 @@
 from typing import List, Literal, Optional
 
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 from .api_wrapper import SharepointApiWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
 from ...configurations.pgvector import PgVectorConfiguration
+from ...configurations.sharepoint import SharepointConfiguration
 
 name = "sharepoint"
 
@@ -13,9 +14,7 @@ def get_tools(tool):
     return (SharepointToolkit()
             .get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        site_url=tool['settings'].get('site_url', None),
-        client_id=tool['settings'].get('client_id', None),
-        client_secret=tool['settings'].get('client_secret', None),
+        sharepoint_configuration=tool['settings']['sharepoint_configuration'],
         toolkit_name=tool.get('toolkit_name'),
         llm=tool['settings'].get('llm'),
         alita=tool['settings'].get('alita', None),
@@ -37,9 +36,7 @@ class SharepointToolkit(BaseToolkit):
         SharepointToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            site_url=(str, Field(description="Sharepoint site's URL", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': SharepointToolkit.toolkit_max_length})),
-            client_id=(str, Field(description="Client ID")),
-            client_secret=(SecretStr, Field(description="Client Secret", json_schema_extra={'secret': True})),
+            sharepoint_configuration=(SharepointConfiguration, Field(description="SharePoint Configuration", json_schema_extra={'configuration_types': ['sharepoint']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None,
@@ -61,6 +58,7 @@ class SharepointToolkit(BaseToolkit):
             selected_tools = []
         wrapper_payload = {
             **kwargs,
+            **kwargs.get('sharepoint_configuration', {}),
             **(kwargs.get('pgvector_configuration') or {}),
         }
         sharepoint_api_wrapper = SharepointApiWrapper(**wrapper_payload)

alita_sdk/tools/slack/__init__.py

@@ -50,7 +50,7 @@ class SlackToolkit(BaseToolkit):
 
          model = create_model(
              name,
-             slack_configuration=(Optional[SlackConfiguration], Field(default=None, description="Slack configuration",
+             slack_configuration=(SlackConfiguration, Field(default=None, description="Slack configuration",
                                                              json_schema_extra={'configuration_types': ['slack']})),
              selected_tools=(List[Literal[tuple(selected_tools)]],
                              Field(default=[], json_schema_extra={'args_schemas': selected_tools})),

alita_sdk/tools/sql/__init__.py

@@ -1,12 +1,13 @@
 from typing import List, Literal, Optional
 
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from .api_wrapper import SQLApiWrapper
 from ..base.tool import BaseAction
 from .models import SQLDialect
 from ..utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length
+from ...configurations.sql import SqlConfiguration
 
 name = "sql"
 
@@ -14,11 +15,8 @@ def get_tools(tool):
     return SQLToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
         dialect=tool['settings']['dialect'],
-        host=tool['settings']['host'],
-        port=tool['settings']['port'],
-        username=tool['settings']['username'],
-        password=tool['settings']['password'],
         database_name=tool['settings']['database_name'],
+        sql_configuration=tool['settings']['sql_configuration'],
         toolkit_name=tool.get('toolkit_name')
     ).get_tools()
 
@@ -35,11 +33,8 @@ class SQLToolkit(BaseToolkit):
         return create_model(
             name,
             dialect=(Literal[tuple(supported_dialects)], Field(description="Database dialect (mysql or postgres)")),
-            host=(str, Field(description="Database server address")),
-            port=(str, Field(description="Database server port")),
-            username=(str, Field(description="Database username")),
-            password=(SecretStr, Field(description="Database password", json_schema_extra={'secret': True})),
             database_name=(str, Field(description="Database name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': SQLToolkit.toolkit_max_length})),
+            sql_configuration=(SqlConfiguration, Field(description="SQL Configuration", json_schema_extra={'configuration_types': ['sql']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra=
                                   {
@@ -54,7 +49,11 @@ class SQLToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        sql_api_wrapper = SQLApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('sql_configuration', {}),
+        }
+        sql_api_wrapper = SQLApiWrapper(**wrapper_payload)
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = sql_api_wrapper.get_available_tools()
         tools = []
@@ -71,4 +70,3 @@ class SQLToolkit(BaseToolkit):
 
     def get_tools(self) -> list[BaseTool]:
         return self.tools
-

alita_sdk/tools/testio/__init__.py

@@ -1,19 +1,19 @@
 from typing import List, Literal, Optional
 
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from .api_wrapper import TestIOApiWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...configurations.testio import TestIOConfiguration
 
 name = "testio"
 
 def get_tools(tool):
     return TestIOToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        endpoint=tool['settings']['endpoint'],
-        api_key=tool['settings']['api_key'],
+        testio_configuration=tool['settings']['testio_configuration'],
         toolkit_name=tool['toolkit_name']
     ).get_tools()
 
@@ -29,8 +29,7 @@ class TestIOToolkit(BaseToolkit):
         selected_tools = {x['name']: x['args_schema'].schema() for x in TestIOApiWrapper.model_construct().get_available_tools()}
         return create_model(
             name,
-            endpoint=(str, Field(description="TestIO endpoint", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': TOOLKIT_MAX_LENGTH})),
-            api_key=(SecretStr, Field(description="API key", json_schema_extra={'secret': True})),
+            testio_configuration=(TestIOConfiguration, Field(description="TestIO Configuration", json_schema_extra={'configuration_types': ['testio']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "TestIO", "icon_url": "testio-icon.svg",
                                                                   "categories": ["testing"],
@@ -41,7 +40,11 @@ class TestIOToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        testio_api_wrapper = TestIOApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('testio_configuration', {}),
+        }
+        testio_api_wrapper = TestIOApiWrapper(**wrapper_payload)
         prefix = clean_string(toolkit_name, TOOLKIT_MAX_LENGTH) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = testio_api_wrapper.get_available_tools()
         tools = []

alita_sdk/tools/utils/content_parser.py

@@ -2,7 +2,7 @@ import os
 import tempfile
 from logging import getLogger
 from pathlib import Path
-from typing import Generator
+from typing import Generator, List
 
 from langchain_core.documents import Document
 from langchain_core.tools import ToolException
@@ -73,17 +73,56 @@ def parse_file_content(file_name=None, file_content=None, is_capture_image: bool
     Raises:
         ToolException: If the file type is not supported or if there is an error reading the file.
         """
+    loader = prepare_loader(
+        file_name=file_name,
+        file_content=file_content,
+        is_capture_image=is_capture_image,
+        page_number=page_number,
+        sheet_name=sheet_name,
+        llm=llm,
+        file_path=file_path,
+        excel_by_sheets=excel_by_sheets
+    )
 
-    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 not loader:
+        return ToolException(
+            "Not supported type of files entered. Supported types are TXT, DOCX, PDF, PPTX, XLSX and XLS only.")
 
-    extension = Path(file_path if file_path else file_name).suffix
+    if hasattr(loader, 'get_content'):
+        return loader.get_content()
+    else:
+        extension = Path(file_path if file_path else file_name).suffix
+        loader_kwargs = get_loader_kwargs(loaders_map.get(extension), file_name, file_content, is_capture_image, page_number, sheet_name, llm, file_path, excel_by_sheets)
+        if file_content:
+            return load_content_from_bytes(file_content=file_content,
+                                           extension=extension,
+                                           loader_extra_config=loader_kwargs,
+                                           llm=llm)
+        else:
+            return load_content(file_path=file_path,
+                                extension=extension,
+                                loader_extra_config=loader_kwargs,
+                                llm=llm)
 
-    loader_object = loaders_map.get(extension)
-    if not loader_object:
-        logger.warning(f"No loader found for file extension: {extension}. File: {file_path if file_path else file_name}")
+def load_file_docs(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, excel_by_sheets: bool = False) -> List[Document] | ToolException:
+    loader = prepare_loader(
+        file_name=file_name,
+        file_content=file_content,
+        is_capture_image=is_capture_image,
+        page_number=page_number,
+        sheet_name=sheet_name,
+        llm=llm,
+        file_path=file_path,
+        excel_by_sheets=excel_by_sheets
+    )
+    if not loader:
         return ToolException(
             "Not supported type of files entered. Supported types are TXT, DOCX, PDF, PPTX, XLSX and XLS only.")
+    return loader.load()
+
+def get_loader_kwargs(loader_object, 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, excel_by_sheets: bool = False):
     loader_kwargs = loader_object['kwargs']
     loader_kwargs.update({
         "file_path": file_path,
@@ -97,25 +136,21 @@ def parse_file_content(file_name=None, file_content=None, is_capture_image: bool
         "row_content": True,
         "json_documents": False
     })
-    loader = loader_object['class'](**loader_kwargs)
+    return loader_kwargs
 
-    if not loader:
-        return ToolException(
-            "Not supported type of files entered. Supported types are TXT, DOCX, PDF, PPTX, XLSX and XLS only.")
+def prepare_loader(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, excel_by_sheets: bool = False):
+        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 hasattr(loader, 'get_content'):
-        return loader.get_content()
-    else:
-        if file_content:
-            return load_content_from_bytes(file_content=file_content,
-                                           extension=extension,
-                                           loader_extra_config=loader_kwargs,
-                                           llm=llm)
-        else:
-            return load_content(file_path=file_path,
-                                extension=extension,
-                                loader_extra_config=loader_kwargs,
-                                llm=llm)
+        extension = Path(file_path if file_path else file_name).suffix
+
+        loader_object = loaders_map.get(extension)
+        if not loader_object:
+            return None
+        loader_kwargs = get_loader_kwargs(loader_object, file_name, file_content, is_capture_image, page_number, sheet_name, llm, file_path, excel_by_sheets)
+        loader = loader_object['class'](**loader_kwargs)
+        return loader
 
 # TODO: review usage of this function alongside with functions above
 def load_content(file_path: str, extension: str = None, loader_extra_config: dict = None, llm = None) -> str:

alita_sdk/tools/zephyr_enterprise/__init__.py

@@ -36,7 +36,7 @@ class ZephyrEnterpriseToolkit(BaseToolkit):
         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']},

alita_sdk/tools/zephyr_essential/__init__.py

@@ -7,13 +7,14 @@ from .api_wrapper import ZephyrEssentialApiWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, TOOLKIT_SPLITTER, 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),
@@ -35,8 +36,7 @@ class ZephyrEssentialToolkit(BaseToolkit):
         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",
@@ -56,6 +56,7 @@ class ZephyrEssentialToolkit(BaseToolkit):
             selected_tools = []
         wrapper_payload = {
             **kwargs,
+            **kwargs.get('zephyr_essential_configuration', {}),
             **(kwargs.get('pgvector_configuration') or {}),
         }
         zephyr_api_wrapper = ZephyrEssentialApiWrapper(**wrapper_payload)

alita_sdk/tools/zephyr_essential/api_wrapper.py

@@ -657,13 +657,43 @@ CreateTestCaseTestSteps = create_model(
     test_case_key=(str, Field(description="Key of the test case to create test steps for.")),
     json=(str, Field(description=("""
         JSON body to create test steps. Example:
-        [
-          {
-            "step": "Step 1",
-            "data": "Test Data",
-            "result": "Expected Result"
-          }
-        ]
+        {
+          "mode": "APPEND",
+          "items": [
+            {
+              "inline": {
+                "description": "Attempt to login to the application",
+                "testData": "Username = SmartBear Password = weLoveAtlassian",
+                "expectedResult": "Login succeeds, web-app redirects to the dashboard view",
+                "customFields": {
+                  "Build Number": 20,
+                  "Release Date": "2020-01-01",
+                  "Pre-Condition(s)": "User should have logged in. <br> User should have navigated to the administration panel.",
+                  "Implemented": false,
+                  "Category": [
+                    "Performance",
+                    "Regression"
+                  ],
+                  "Tester": "fa2e582e-5e15-521e-92e3-47e6ca2e7256"
+                }
+              },
+              "testCase": {
+                "self": "string",
+                "testCaseKey": "PROJ-T123",
+                "parameters": [
+                  {
+                    "name": "username",
+                    "type": "DEFAULT_VALUE",
+                    "value": "admin"
+                  }
+                ]
+              }
+            }
+          ]
+        }
+        Where:
+        mode: str - required - Valid values: "APPEND", "OVERWRITE",
+        items - The list of test steps. Each step should be an object containing inline or testCase. They should only include one of these fields at a time.
         """
     )))
 )
@@ -848,10 +878,12 @@ CreateFolder = create_model(
     json=(str, Field(description=("""
         JSON body to create a folder. Example:
         {
-          "name": "Folder Name",
-          "description": "Folder Description",
-          "projectKey": "PROJECT_KEY"
+            "parentId": 24389289,
+            "name": "ZephyrEssential_test",
+            "projectKey": "EL",
+            "folderType": "TEST_CASE"
         }
+        Possible folder types: "TEST_CASE", "TEST_PLAN", "TEST_CYCLE"
         """
     )))
 )

alita_sdk/tools/zephyr_scale/__init__.py

@@ -40,7 +40,7 @@ class ZephyrScaleToolkit(BaseToolkit):
         return create_model(
             name,
             max_results=(int, Field(default=100, description="Results count to show")),
-            zephyr_configuration=(Optional[ZephyrConfiguration], Field(description="Zephyr Configuration",
+            zephyr_configuration=(ZephyrConfiguration, Field(description="Zephyr Configuration",
                                                                        json_schema_extra={'configuration_types': ['zephyr']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None, description="PgVector Configuration",
                                                                            json_schema_extra={

{alita_sdk-0.3.270.dist-info → alita_sdk-0.3.272.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.270
+Version: 0.3.272
 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