alita-sdk 0.3.236__tar.gz → 0.3.238__tar.gz

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.236
+Version: 0.3.238
 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.236 → alita_sdk-0.3.238}/alita_sdk/configurations/bitbucket.py

@@ -27,5 +27,6 @@ class BitbucketConfiguration(BaseModel):
             }
         }
     )
+    url: str = Field(description="Bitbucket URL")
     username: Optional[str] = Field(description="Bitbucket Username", default=None)
     password: Optional[SecretStr] = Field(description="Bitbucket Password/App Password", default=None)

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/configurations/embedding.py

@@ -5,10 +5,10 @@ class EmbeddingConfiguration(BaseModel):
     model_config = ConfigDict(
         json_schema_extra={
             "metadata": {
-                "label": "Embedding",
+                "label": "Embedding Configuration",
                 "icon_url": None,
-                "section": "embeddings_configuration",
-                "type": "embedding"
+                "section": "embedding",
+                "type": "embedding_model"
             }
         }
     )
@@ -16,4 +16,4 @@ class EmbeddingConfiguration(BaseModel):
                                  default="HuggingFaceEmbeddings")
     embedding_model_params: dict = Field(
         description="Embedding model parameters: i.e. `{'model_name': 'sentence-transformers/all-MiniLM-L6-v2'}",
-        default={"model_name": "sentence-transformers/all-MiniLM-L6-v2"})
+        default={"model_name": "sentence-transformers/all-MiniLM-L6-v2"})

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/configurations/gitlab.py

@@ -27,5 +27,5 @@ class GitlabConfiguration(BaseModel):
             }
         }
     )
+    url: str = Field(description="GitLab URL")
     private_token: Optional[SecretStr] = Field(description="GitLab private token", default=None)
-

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/configurations/jira.py

@@ -14,11 +14,11 @@ class JiraConfiguration(BaseModel):
                         "required": False,
                         "subsections": [
                             {
-                                "name": "API Key",
+                                "name": "Basic",
                                 "fields": ["username", "api_key"]
                             },
                             {
-                                "name": "Token",
+                                "name": "Bearer",
                                 "fields": ["token"]
                             }
                         ]
@@ -31,6 +31,7 @@ class JiraConfiguration(BaseModel):
             }
         }
     )
+    base_url: str = Field(description="Jira URL")
     username: Optional[str] = Field(description="Jira Username", default=None)
     api_key: Optional[SecretStr] = Field(description="Jira API Key", default=None)
     token: Optional[SecretStr] = Field(description="Jira Token", default=None)

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/configurations/postman.py

@@ -27,4 +27,6 @@ class PostmanConfiguration(BaseModel):
             }
         }
     )
+    base_url: str = Field(description="Postman API base URL", default="https://api.getpostman.com")
+    workspace_id: str = Field(description="Default workspace ID")
     api_key: Optional[SecretStr] = Field(description="Postman API Key", default=None)

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/configurations/qtest.py

@@ -16,5 +16,6 @@ class QtestConfiguration(BaseModel):
             }
         }
     )
+    base_url: str = Field(description="QTest base url")
     qtest_api_token: Optional[SecretStr] = Field(description="QTest API token", default=None)
 

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/configurations/service_now.py

@@ -27,5 +27,6 @@ class ServiceNowConfiguration(BaseModel):
             }
         }
     )
+    base_url: str = Field(description="ServiceNow URL")
     username: Optional[str] = Field(description="ServiceNow Username", default=None)
     password: Optional[SecretStr] = Field(description="ServiceNow Password", default=None)

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/configurations/slack.py

@@ -33,3 +33,4 @@ class SlackConfiguration(BaseModel):
     )
     name: Optional[SecretStr] = Field(description="Slack Bot Token")
     slack_token: Optional[SecretStr] = Field(description="Slack Token like XOXB-*****-*****-*****-*****")
+    channel_id:Optional[str] = Field(default=None, description="Channel ID")

alita_sdk-0.3.238/alita_sdk/configurations/xray.py

@@ -0,0 +1,32 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class XrayConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Xray",
+                "icon_url": "xray.svg",
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "Client Credentials",
+                                "fields": ["client_id", "client_secret"]
+                            }
+                        ]
+                    },
+                },
+                "section": "credentials",
+                "type": "xray",
+                "categories": ["test management"],
+                "extra_categories": ["xray", "test automation", "test case management", "test planning"],
+            }
+        }
+    )
+    base_url: str = Field(description="Xray URL")
+    client_id: Optional[str] = Field(description="Client ID", default=None)
+    client_secret: Optional[SecretStr] = Field(description="Client secret", default=None)

alita_sdk-0.3.238/alita_sdk/configurations/zephyr.py

@@ -0,0 +1,42 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class ZephyrConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Zephyr",
+                "icon_url": "zephyr.svg",
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "Token",
+                                "fields": ["token"]
+                            },
+                            {
+                                "name": "Username & Password",
+                                "fields": ["username", "password"]
+                            },
+                            {
+                                "name": "Cookies",
+                                "fields": ["cookies"]
+                            }
+                        ]
+                    },
+                },
+                "section": "credentials",
+                "type": "zephyr",
+                "categories": ["test management"],
+                "extra_categories": ["zephyr", "test automation", "test case management", "test planning"],
+            }
+        }
+    )
+    base_url: str = Field(description="Zephyr base URL")
+    token: Optional[SecretStr] = Field(description="API token", default=None)
+    username: Optional[str] = Field(description="Username", default=None)
+    password: Optional[SecretStr] = Field(description="Password", default=None)
+    cookies: Optional[str] = Field(description="Cookies", default=None)

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/runtime/clients/client.py

@@ -176,6 +176,7 @@ class AlitaClient:
             base_url=f"{self.base_url}{self.llm_path}",
             model=model_name,
             api_key=self.auth_token,
+            streaming=model_config.get("streaming", True),
             stream_usage=model_config.get("stream_usage", True),
             max_tokens=model_config.get("max_tokens", None),
             top_p=model_config.get("top_p"),

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -18,7 +18,6 @@ from langchain_community.document_loaders import (
         UnstructuredPowerPointLoader, PythonLoader)
 
 from .AlitaCSVLoader import AlitaCSVLoader
-from .AlitaDocLoader import AlitaDocLoader
 from .AlitaDocxMammothLoader import AlitaDocxMammothLoader
 from .AlitaExcelLoader import AlitaExcelLoader
 from .AlitaImageLoader import AlitaImageLoader
@@ -126,7 +125,7 @@ loaders_map = {
         'kwargs': {}
     },
     '.doc': {
-        'class': AlitaDocLoader,
+        'class': AlitaTextLoader,
         'is_multimodal_processing': True,
         'kwargs': {}
     },

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/runtime/langchain/interfaces/llm_processor.py

@@ -29,6 +29,7 @@ from langchain.prompts import PromptTemplate  # pylint: disable=E0401
 
 from langchain.schema import HumanMessage, SystemMessage
 
+from ...clients import AlitaClient
 from ...llms.preloaded import PreloadedEmbeddings, PreloadedChatModel  # pylint: disable=E0401
 from ..retrievers.AlitaRetriever import AlitaRetriever
 from ..tools.log import print_log
@@ -59,28 +60,29 @@ def get_model(model_type: str, model_params: dict):
     raise RuntimeError(f"Unknown model type: {model_type}")
 
 
-def get_embeddings(embeddings_model: str, embeddings_params: dict):
+def get_embeddings(elitea_client: AlitaClient, embeddings_model: str, embeddings_params: dict):
     """ Get *Embeddings """
-    if embeddings_model is None:
-        return None
-    if "." in embeddings_model:
-        target_pkg, target_name = embeddings_model.rsplit(".", 1)
-        target_cls = getattr(
-            importlib.import_module(target_pkg),
-            target_name
-        )
-        return target_cls(**embeddings_params)
-    if embeddings_model == "PreloadedEmbeddings":
-        return PreloadedEmbeddings(**embeddings_params)
-    if embeddings_model == "Chroma":
-        from langchain_chroma import Chroma
-        return Chroma(**embeddings_params)
-    if embeddings_model in embeddings:
-        model = getattr(
-            __import__("langchain_community.embeddings", fromlist=[embeddings_model]),
-            embeddings_model
-        )
-        return model(**embeddings_params)
+    # if embeddings_model is None:
+    #     return None
+    # if "." in embeddings_model:
+    #     target_pkg, target_name = embeddings_model.rsplit(".", 1)
+    #     target_cls = getattr(
+    #         importlib.import_module(target_pkg),
+    #         target_name
+    #     )
+    #     return target_cls(**embeddings_params)
+    # if embeddings_model == "PreloadedEmbeddings":
+    #     return PreloadedEmbeddings(**embeddings_params)
+    # if embeddings_model == "Chroma":
+    #     from langchain_chroma import Chroma
+    #     return Chroma(**embeddings_params)
+    # if embeddings_model in embeddings:
+    #     model = getattr(
+    #         __import__("langchain_community.embeddings", fromlist=[embeddings_model]),
+    #         embeddings_model
+    #     )
+    #     return model(**embeddings_params)
+    elitea_client.get_llm(embeddings_model, embeddings_params)
     raise RuntimeError(f"Unknown Embedding type: {embeddings_model}")
 
 

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/runtime/tools/artifact.py

@@ -1,5 +1,6 @@
 import hashlib
 import json
+import logging
 from typing import Any, Optional, Generator, List
 
 from langchain_core.documents import Document
@@ -82,7 +83,10 @@ class ArtifactWrapper(BaseVectorStoreToolApiWrapper):
         return hasher.hexdigest()
 
     def _process_document(self, document: Document) -> Generator[Document, None, None]:
-        page_content = self.read_file(document.metadata['name'], is_capture_image=True, excel_by_sheets=True)
+        try:
+            page_content = self.read_file(document.metadata['name'], is_capture_image=True, excel_by_sheets=True)
+        except Exception as e:
+            logging.error(f"Failed while parsing the file 'document.metadata['Path']': {e}")
         if isinstance(page_content, dict):
             for key, value in page_content.items():
                 metadata = document.metadata

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/bitbucket/__init__.py

@@ -51,7 +51,6 @@ class AlitaBitbucketToolkit(BaseToolkit):
         AlitaBitbucketToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            url=(str, Field(description="Bitbucket URL", json_schema_extra={'configuration': True, 'configuration_title': True})),
             project=(str, Field(description="Project/Workspace", json_schema_extra={'configuration': True})),
             repository=(str, Field(description="Repository", json_schema_extra={'max_toolkit_length': AlitaBitbucketToolkit.toolkit_max_length, 'configuration': True})),
             branch=(str, Field(description="Main branch", default="main")),
@@ -59,7 +58,7 @@ class AlitaBitbucketToolkit(BaseToolkit):
             bitbucket_configuration=(Optional[BitbucketConfiguration], Field(description="Bitbucket Configuration", json_schema_extra={'configuration_types': ['bitbucket']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", default={'configuration_types': ['pgvector']})),
             # embedder settings
-            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(default=None, description="Embedding configuration.",
                                                                              json_schema_extra={'configuration_types': [
                                                                                  'embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
@@ -76,11 +75,16 @@ class AlitaBitbucketToolkit(BaseToolkit):
 
         @check_connection_response
         def check_connection(self):
+            bitbucket_config = self.bitbucket_configuration or {}
+            url = bitbucket_config.get('url', '')
+            username = bitbucket_config.get('username', '')
+            password = bitbucket_config.get('password', '')
+
             if self.cloud:
-                request_url = f"{self.url}/2.0/repositories/{self.project}/{self.repository}"
+                request_url = f"{url}/2.0/repositories/{self.project}/{self.repository}"
             else:
-                request_url = f"{self.url}/rest/api/1.0/projects/{self.project}/repos/{self.repository}"
-            response = requests.get(request_url, auth=HTTPBasicAuth(self.username, self.password))
+                request_url = f"{url}/rest/api/1.0/projects/{self.project}/repos/{self.repository}"
+            response = requests.get(request_url, auth=HTTPBasicAuth(username, password))
             return response
 
         m.check_connection = check_connection

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/confluence/__init__.py

@@ -83,7 +83,7 @@ class ConfluenceToolkit(BaseToolkit):
             confluence_configuration=(Optional[ConfluenceConfiguration], Field(description="Confluence Configuration", json_schema_extra={'configuration_types': ['confluence']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
-            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(default=None, description="Embedding configuration.",
                                                                              json_schema_extra={'configuration_types': [
                                                                                  'embedding']})),
 

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/elitea_base.py

@@ -222,6 +222,7 @@ class BaseVectorStoreToolApiWrapper(BaseToolApiWrapper):
     embedding_model_params: Optional[Dict[str, Any]] = {"model_name": "sentence-transformers/all-MiniLM-L6-v2"}
     vectorstore_type: Optional[str] = "PGVector"
     _vector_store: Optional[Any] = None
+    alita: Any = None # Elitea client, if available
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -274,7 +275,7 @@ class BaseVectorStoreToolApiWrapper(BaseToolApiWrapper):
     def index_data(self, **kwargs):
         from alita_sdk.tools.chunkers import __confluence_chunkers__ as chunkers, __confluence_models__ as models
         docs = self._base_loader(**kwargs)
-        embedding = get_embeddings(self.embedding_model, self.embedding_model_params)
+        embedding = get_embeddings(self.alita, self.embedding_model, self.embedding_model_params)
         chunking_tool = kwargs.get("chunking_tool")
         if chunking_tool:
             # Resolve chunker from the provided chunking_tool name

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/figma/__init__.py

@@ -23,6 +23,7 @@ def get_tools(tool):
             toolkit_name=tool.get('toolkit_name'),
             # indexer settings
             llm=tool['settings'].get('llm', None),
+            alita=tool['settings'].get('alita', None),
             pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
             collection_name=str(tool['toolkit_name']),
             doctype='doc',
@@ -59,7 +60,7 @@ class FigmaToolkit(BaseToolkit):
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
 
             # embedder settings
-            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(default=None, description="Embedding configuration.",
                                                                              json_schema_extra={'configuration_types': [
                                                                                  'embedding']})),
             __config__=ConfigDict(

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/github/__init__.py

@@ -68,7 +68,7 @@ class AlitaGitHubToolkit(BaseToolkit):
             active_branch=(Optional[str], Field(description="Active branch", default="main")),
             base_branch=(Optional[str], Field(description="Github Base branch", default="main")),
             # embedder settings
-            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(default=None, description="Embedding configuration.",
                                                                              json_schema_extra={'configuration_types': [
                                                                                  'embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]],

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/gitlab/__init__.py

@@ -45,14 +45,13 @@ class AlitaGitlabToolkit(BaseToolkit):
         AlitaGitlabToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            url=(str, Field(description="GitLab URL", json_schema_extra={'configuration': True, 'configuration_title': True})),
             repository=(str, Field(description="GitLab repository", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AlitaGitlabToolkit.toolkit_max_length})),
             gitlab_configuration=(Optional[GitlabConfiguration], Field(description="GitLab configuration", json_schema_extra={'configuration_types': ['gitlab']})),
             branch=(str, Field(description="Main branch", default="main")),
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
-            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(default=None, description="Embedding configuration.",
                                                                              json_schema_extra={'configuration_types': [
                                                                                  'embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/jira/__init__.py

@@ -45,10 +45,11 @@ class JiraToolkit(BaseToolkit):
 
         @check_connection_response
         def check_connection(self):
-            url = self.base_url.rstrip('/') + '/rest/api/2/myself'
+            jira_config = self.jira_configuration or {}
+            base_url = jira_config.get('base_url', '')
+            url = base_url.rstrip('/') + '/rest/api/2/myself'
             headers = {'Accept': 'application/json'}
             auth = None
-            jira_config = self.jira_configuration or {}
             token = jira_config.get('token')
             username = jira_config.get('username')
             api_key = jira_config.get('api_key')
@@ -64,17 +65,6 @@ class JiraToolkit(BaseToolkit):
 
         model = create_model(
             name,
-            base_url=(
-                str,
-                Field(
-                    description="Jira URL",
-                    json_schema_extra={
-                        'max_toolkit_length': JiraToolkit.toolkit_max_length,
-                        'configuration': True,
-                        'configuration_title': True
-                    }
-                )
-            ),
             cloud=(bool, Field(description="Hosting Option", json_schema_extra={'configuration': True})),
             limit=(int, Field(description="Limit issues")),
             labels=(Optional[str], Field(
@@ -87,7 +77,7 @@ class JiraToolkit(BaseToolkit):
             jira_configuration=(Optional[JiraConfiguration], Field(description="Jira Configuration", json_schema_extra={'configuration_types': ['jira']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
-            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(default=None, description="Embedding configuration.",
                                                                              json_schema_extra={'configuration_types': [
                                                                                  'embedding']})),
 
@@ -96,21 +86,6 @@ class JiraToolkit(BaseToolkit):
                 'metadata': {
                     "label": "Jira",
                     "icon_url": "jira-icon.svg",
-                    "sections": {
-                        "auth": {
-                            "required": True,
-                            "subsections": [
-                                {
-                                    "name": "Bearer",
-                                    "fields": ["token"]
-                                },
-                                {
-                                    "name": "Basic",
-                                    "fields": ["username", "api_key"]
-                                }
-                            ]
-                        }
-                    },
                     "categories": ["project management"],
                     "extra_categories": ["jira", "atlassian", "issue tracking", "project management", "task management"],
                 }

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/postman/__init__.py

@@ -55,15 +55,8 @@ class PostmanToolkit(BaseToolkit):
             name,
             postman_configuration=(Optional[PostmanConfiguration], Field(description="Postman Configuration",
                                                                          json_schema_extra={'configuration_types': ['postman']})),
-            base_url=(str, Field(description="Postman API base URL",
-                      default="https://api.getpostman.com", json_schema_extra={'configuration': True})),
             collection_id=(str, Field(description="Default collection ID", json_schema_extra={
                            'toolkit_name': True, 'max_toolkit_length': PostmanToolkit.toolkit_max_length})),
-            workspace_id=(str, Field(description="Default workspace ID",
-                                     json_schema_extra={
-                                         'configuration': True,
-                                         'configuration_title': True
-                                     })),
             environment_config=(dict, Field(
                 description="JSON configuration for request execution (auth headers, project IDs, base URLs, etc.)",
                 default={})),

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/qtest/__init__.py

@@ -33,13 +33,17 @@ class QtestToolkit(BaseToolkit):
         QtestToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            base_url=(str, Field(description="QTest base url", json_schema_extra={'configuration': True, 'configuration_title': True})),
-            qtest_project_id=(int, Field(description="QTest project id", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': QtestToolkit.toolkit_max_length})),
-            qtest_configuration=(Optional[QtestConfiguration], Field(description="QTest API token", json_schema_extra={'configuration_types': ['qtest']})),
-            selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
+            qtest_configuration=(Optional[QtestConfiguration], Field(description="QTest API token", json_schema_extra={
+                'configuration_types': ['qtest']})),
+            qtest_project_id=(int, Field(description="QTest project id", json_schema_extra={'toolkit_name': True,
+                                                                                            'max_toolkit_length': QtestToolkit.toolkit_max_length})),
+            selected_tools=(List[Literal[tuple(selected_tools)]],
+                            Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "QTest", "icon_url": "qtest.svg",
                                                                   "categories": ["test management"],
-                                                                  "extra_categories": ["quality assurance", "test case management", "test planning"]}})
+                                                                  "extra_categories": ["quality assurance",
+                                                                                       "test case management",
+                                                                                       "test planning"]}})
         )
 
         @check_connection_response

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/servicenow/__init__.py

@@ -33,14 +33,14 @@ class ServiceNowToolkit(BaseToolkit):
         ServiceNowToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            base_url=(str, Field(description="ServiceNow URL", json_schema_extra={
-                        'max_toolkit_length': ServiceNowToolkit.toolkit_max_length,
-                        'configuration': True,
-                        'configuration_title': True
-                    })),
+            name=(str, Field(description="Toolkit name",
+                             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",
-                                                                               json_schema_extra={'configuration_types': ['service_now']})),
+                                                                               json_schema_extra={
+                                                                                   'configuration_types': [
+                                                                                       'service_now']})),
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/sharepoint/__init__.py

@@ -10,13 +10,15 @@ from ...configurations.pgvector import PgVectorConfiguration
 name = "sharepoint"
 
 def get_tools(tool):
-    return (SharepointToolkit().get_toolkit(
+    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),
         toolkit_name=tool.get('toolkit_name'),
         llm=tool['settings'].get('llm'),
+        alita=tool['settings'].get('alita', None),
         # indexer settings
         pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
         collection_name=str(tool['toolkit_name']),

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/sharepoint/api_wrapper.py

@@ -162,9 +162,13 @@ class SharepointApiWrapper(BaseVectorStoreToolApiWrapper):
             yield Document(page_content="", metadata=metadata)
 
     def _process_document(self, document: Document) -> Generator[Document, None, None]:
-        doc_content = self.read_file(document.metadata['Path'],
+        doc_content = ""
+        try:
+            doc_content = self.read_file(document.metadata['Path'],
                                       is_capture_image=True,
                                       excel_by_sheets=True)
+        except Exception as e:
+            logging.error(f"Failed while parsing the file '{document.metadata['Path']}': {e}")
         if isinstance(doc_content, dict):
             for page, content in doc_content:
                 new_metadata = document.metadata

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/slack/__init__.py

@@ -52,7 +52,6 @@ class SlackToolkit(BaseToolkit):
              name,
              slack_configuration=(Optional[SlackConfiguration], Field(default=None, description="Slack configuration",
                                                              json_schema_extra={'configuration_types': ['slack']})),
-             channel_id=(Optional[str], Field(default=None, description="Channel ID", json_schema_extra={'configuration': True})),
              selected_tools=(List[Literal[tuple(selected_tools)]],
                              Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
              __config__={'json_schema_extra': {

{alita_sdk-0.3.236 → alita_sdk-0.3.238}/alita_sdk/tools/testrail/__init__.py

@@ -20,6 +20,7 @@ def get_tools(tool):
         testrail_configuration=tool['settings']['testrail_configuration'],
         toolkit_name=tool.get('toolkit_name'),
         llm=tool['settings'].get('llm', None),
+        alita=tool['settings'].get('alita', None),
 
         # indexer settings
         pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
@@ -46,7 +47,7 @@ class TestrailToolkit(BaseToolkit):
             testrail_configuration=(Optional[TestRailConfiguration], Field(description="TestRail Configuration", json_schema_extra={'configuration_types': ['testrail']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
-            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.", json_schema_extra={'configuration_types': ['embedding']})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(default=None, description="Embedding configuration.", json_schema_extra={'configuration_types': ['embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata':
                                                          {"label": "Testrail", "icon_url": "testrail-icon.svg",