alita-sdk 0.3.172__tar.gz → 0.3.174__tar.gz

{alita_sdk-0.3.172 → alita_sdk-0.3.174}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.172
+Version: 0.3.174
 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.172 → alita_sdk-0.3.174}/alita_sdk/tools/ado/repos/__init__.py

@@ -46,10 +46,10 @@ class AzureDevOpsReposToolkit(BaseToolkit):
         AzureDevOpsReposToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            organization_url=(Optional[str], Field(default="", title="Organization URL", description="ADO organization url")),
-            project=(Optional[str], Field(default="", title="Project", description="ADO project")),
-            repository_id=(Optional[str], Field(default="", title="Repository ID", description="ADO repository ID", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsReposToolkit.toolkit_max_length})),
-            token=(Optional[SecretStr], Field(default="", title="Token", description="ADO token", json_schema_extra={'secret': True})),
+            organization_url=(Optional[str], Field(default="", title="Organization URL", description="ADO organization url", json_schema_extra={'configuration': True})),
+            project=(Optional[str], Field(default="", title="Project", description="ADO project", json_schema_extra={'configuration': True})),
+            repository_id=(Optional[str], Field(default="", title="Repository ID", description="ADO repository ID", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsReposToolkit.toolkit_max_length, 'configuration': True})),
+            token=(Optional[SecretStr], Field(default="", title="Token", description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             base_branch=(Optional[str], Field(default="", title="Base branch", description="ADO base branch (e.g., main)")),
             active_branch=(Optional[str], Field(default="", title="Active branch", description="ADO active branch (e.g., main)")),
 

{alita_sdk-0.3.172 → alita_sdk-0.3.174}/alita_sdk/tools/ado/test_plan/__init__.py

@@ -3,9 +3,10 @@ from typing import List, Optional, Literal
 from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import create_model, BaseModel, Field, SecretStr
 
+import requests
 from .test_plan_wrapper import TestPlanApiWrapper
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
 
 
 name = "azure_devops_plans"
@@ -20,12 +21,12 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
     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)
-        return create_model(
+        m = create_model(
             name_alias,
             name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsPlansToolkit.toolkit_max_length})),
-            organization_url=(str, Field(description="ADO organization url")),
+            organization_url=(str, Field(description="ADO organization url", json_schema_extra={'configuration': True})),
             limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),
-            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True})),
+            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__={'json_schema_extra': {'metadata':
                 {
@@ -49,6 +50,18 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
             }
         )
 
+        @check_connection_response
+        def check_connection(self):
+            response = requests.get(
+                f'{self.organization_url}/{self.project}/_apis/testplan/plans?api-version=7.0',
+                headers = {'Authorization': f'Bearer {self.token}'},
+                timeout=5
+            )
+            return response
+
+        m.check_connection = check_connection
+        return m
+
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         from os import environ

{alita_sdk-0.3.172 → alita_sdk-0.3.174}/alita_sdk/tools/ado/wiki/__init__.py

@@ -3,8 +3,9 @@ from .ado_wrapper import AzureDevOpsApiWrapper  # Import the API wrapper for Azu
 from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import create_model, BaseModel, Field, SecretStr
 
+import requests
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
 
 name = "azure_devops_wiki"
 name_alias = 'ado_wiki'
@@ -17,16 +18,16 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
     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)
-        return create_model(
+        m = create_model(
             name_alias,
             name=(str, Field(description="Toolkit name",
                              json_schema_extra={
                                  'toolkit_name': True,
                                  'max_toolkit_length': AzureDevOpsWikiToolkit.toolkit_max_length})
                   ),
-            organization_url=(str, Field(description="ADO organization url")),
-            project=(str, Field(description="ADO project", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsWikiToolkit.toolkit_max_length})),
-            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True})),
+            organization_url=(str, Field(description="ADO organization url", json_schema_extra={'configuration': True})),
+            project=(str, Field(description="ADO project", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsWikiToolkit.toolkit_max_length, 'configuration': True})),
+            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__={
@@ -52,6 +53,18 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
             }
         )
 
+        @check_connection_response
+        def check_connection(self):
+            response = requests.get(
+                f'{self.organization_url}/{self.project}/_apis/wiki/wikis?api-version=7.0',
+                headers={'Authorization': f'Bearer {self.token}'},
+                timeout=5
+            )
+            return response
+
+        m.check_connection = check_connection
+        return m
+
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         from os import environ

{alita_sdk-0.3.172 → alita_sdk-0.3.174}/alita_sdk/tools/ado/work_item/__init__.py

@@ -3,8 +3,9 @@ from .ado_wrapper import AzureDevOpsApiWrapper  # Import the API wrapper for Azu
 from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import create_model, BaseModel, Field, SecretStr
 
+import requests
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
 
 name = "ado_boards"
 
@@ -16,16 +17,16 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
     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)
-        return create_model(
+        m = create_model(
             name,
             name=(str, Field(description="Toolkit name",
                              json_schema_extra={
                                  'toolkit_name': True,
                                  'max_toolkit_length': AzureDevOpsWorkItemsToolkit.toolkit_max_length})
                   ),
-            organization_url=(str, Field(description="ADO organization url")),
-            project=(str, Field(description="ADO project", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsWorkItemsToolkit.toolkit_max_length})),
-            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True})),
+            organization_url=(str, Field(description="ADO organization url", json_schema_extra={'configuration': True})),
+            project=(str, Field(description="ADO project", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsWorkItemsToolkit.toolkit_max_length, 'configuration': True})),
+            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             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})),
             __config__={
@@ -51,6 +52,18 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
             }
         )
 
+        @check_connection_response
+        def check_connection(self):
+            response = requests.get(
+                f'{self.organization_url}/{self.project}/_apis/wit/workitemtypes?api-version=7.0',
+                headers={'Authorization': f'Bearer {self.token}'},
+                timeout=5
+            )
+            return response
+
+        m.check_connection = check_connection
+        return m
+
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         from os import environ

{alita_sdk-0.3.172 → alita_sdk-0.3.174}/alita_sdk/tools/azure_ai/search/__init__.py

@@ -4,7 +4,8 @@ from .api_wrapper import AzureSearchApiWrapper
 from ...base.tool import BaseAction
 from langchain_core.tools import BaseToolkit, BaseTool
 from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+import requests
 
 logger = getLogger(__name__)
 
@@ -35,12 +36,12 @@ class AzureSearchToolkit(BaseToolkit):
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AzureSearchApiWrapper.model_construct().get_available_tools()}
         AzureSearchToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
-        return create_model(
+        m = create_model(
             name,
-            api_key=(SecretStr, Field(description="API key", json_schema_extra={'secret': True})),
+            api_key=(SecretStr, Field(description="API key", json_schema_extra={'secret': True, 'configuration': True})),
             endpoint=(str, Field(description="Azure Search endpoint")),
             index_name=(str, Field(description="Azure Search index name")),
-            api_base=(Optional[str], Field(description="Azure OpenAI base URL", default=None, json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureSearchToolkit.toolkit_max_length})),
+            api_base=(Optional[str], Field(description="Azure OpenAI base URL", default=None, json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureSearchToolkit.toolkit_max_length, 'configuration': True})),
             api_version=(Optional[str], Field(description="API version", default=None)),
             openai_api_key=(Optional[str], Field(description="Azure OpenAI API Key", default=None, json_schema_extra={'secret': True})),
             model_name=(str, Field(description="Model name for Embeddings model", default=None)),
@@ -54,6 +55,16 @@ class AzureSearchToolkit(BaseToolkit):
             })
         )
 
+        @check_connection_response
+        def check_connection(self):
+            response = requests.get(f"{self.api_base}/openai/deployments", headers={
+                "api-key": self.api_key
+            })
+            return response
+
+        m.check_connection = check_connection
+        return m
+
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:

{alita_sdk-0.3.172 → alita_sdk-0.3.174}/alita_sdk/tools/bitbucket/__init__.py

@@ -1,10 +1,14 @@
 from typing import Dict, List, Literal, Optional
+
+from requests.auth import HTTPBasicAuth
+
 from .api_wrapper import BitbucketAPIWrapper
 from .tools import __all__
 from langchain_core.tools import BaseToolkit
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel, Field, ConfigDict, create_model, SecretStr
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+import requests
 
 
 name = "bitbucket"
@@ -35,14 +39,14 @@ class AlitaBitbucketToolkit(BaseToolkit):
             default = t['tool'].__pydantic_fields__['args_schema'].default
             selected_tools[t['name']] = default.schema() if default else default
         AlitaBitbucketToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
-        return create_model(
+        m = create_model(
             name,
-            url=(str, Field(description="Bitbucket URL")),
-            project=(str, Field(description="Project/Workspace")),
-            repository=(str, Field(description="Repository", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AlitaBitbucketToolkit.toolkit_max_length})),
+            url=(str, Field(description="Bitbucket URL", json_schema_extra={'configuration': True})),
+            project=(str, Field(description="Project/Workspace", json_schema_extra={'configuration': True})),
+            repository=(str, Field(description="Repository", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AlitaBitbucketToolkit.toolkit_max_length, 'configuration': True})),
             branch=(str, Field(description="Main branch", default="main")),
-            username=(str, Field(description="Username")),
-            password=(SecretStr, Field(description="GitLab private token", json_schema_extra={'secret': True})),
+            username=(str, Field(description="Username", json_schema_extra={'configuration': True})),
+            password=(SecretStr, Field(description="GitLab private token", json_schema_extra={'secret': True, 'configuration': True})),
             cloud=(Optional[bool], Field(description="Hosting Option", default=None)),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra=
@@ -56,6 +60,18 @@ class AlitaBitbucketToolkit(BaseToolkit):
             })
         )
 
+        @check_connection_response
+        def check_connection(self):
+            if self.cloud:
+                request_url = f"{self.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))
+            return response
+
+        m.check_connection = check_connection
+        return m
+
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:

{alita_sdk-0.3.172 → alita_sdk-0.3.174}/alita_sdk/tools/confluence/__init__.py

@@ -4,7 +4,8 @@ from .api_wrapper import ConfluenceAPIWrapper
 from langchain_core.tools import BaseTool
 from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list
+from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list, check_connection_response
+import requests
 
 name = "confluence"
 
@@ -43,7 +44,21 @@ class ConfluenceToolkit(BaseToolkit):
         selected_tools = {x['name']: x['args_schema'].schema() for x in
                           ConfluenceAPIWrapper.model_construct().get_available_tools()}
         ConfluenceToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
-        return create_model(
+
+        @check_connection_response
+        def check_connection(self):
+            url = self.base_url.rstrip('/') + '/wiki/rest/api/space'
+            headers = {'Accept': 'application/json'}
+            auth = None
+            if self.token:
+                headers['Authorization'] = f'Bearer {self.token.get_secret_value()}'
+            elif self.username and self.api_key:
+                auth = (self.username, self.api_key.get_secret_value())
+            else:
+                raise ValueError('Confluence connection requires either token or username+api_key')
+            response = requests.get(url, headers=headers, auth=auth, timeout=5, verify=getattr(self, 'verify_ssl', True))
+            return response
+        model = create_model(
             name,
             base_url=(str, Field(description="Confluence URL", json_schema_extra={'configuration': True, 'configuration_title': True})),
             token=(SecretStr, Field(description="Token", default=None, json_schema_extra={'secret': True, 'configuration': True})),
@@ -92,6 +107,8 @@ class ConfluenceToolkit(BaseToolkit):
                 }
             })
         )
+        model.check_connection = check_connection
+        return model
 
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):