alita-sdk 0.3.228__py3-none-any.whl → 0.3.230__py3-none-any.whl

alita_sdk/tools/figma/__init__.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, ConfigDict, Field, create_model, SecretStr
 from ..base.tool import BaseAction
 from .api_wrapper import FigmaApiWrapper, GLOBAL_LIMIT
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...configurations.pgvector import PgVectorConfiguration
 
 name = "figma"
 
@@ -21,7 +22,7 @@ def get_tools(tool):
             toolkit_name=tool.get('toolkit_name'),
             # indexer settings
             llm=tool['settings'].get('llm', None),
-            connection_string = tool['settings'].get('connection_string', None),
+            pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
             collection_name=str(tool['toolkit_name']),
             doctype='doc',
             embedding_model="HuggingFaceEmbeddings",
@@ -54,9 +55,7 @@ class FigmaToolkit(BaseToolkit):
                 Field(default=[], json_schema_extra={"args_schemas": selected_tools}),
             ),
             # indexer settings
-            connection_string = (Optional[SecretStr], Field(description="Connection string for vectorstore",
-                                                            default=None,
-                                                            json_schema_extra={'secret': True})),
+            pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
 
             # embedder settings
             embedding_model=(str, Field(description="Embedding model: i.e. 'HuggingFaceEmbeddings', etc.", default="HuggingFaceEmbeddings")),
@@ -93,7 +92,11 @@ class FigmaToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        figma_api_wrapper = FigmaApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            **(kwargs.get('pgvector_configuration') or {}),
+        }
+        figma_api_wrapper = FigmaApiWrapper(**wrapper_payload)
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = figma_api_wrapper.get_available_tools()
         tools = []

alita_sdk/tools/figma/api_wrapper.py

@@ -4,7 +4,7 @@ import json
 import logging
 import re
 from enum import Enum
-from typing import Dict, Generator, Optional, Union
+from typing import Dict, List, Generator, Optional, Union
 
 import requests
 from FigmaPy import FigmaPy
@@ -13,6 +13,7 @@ from langchain_core.tools import ToolException
 from pydantic import Field, PrivateAttr, create_model, model_validator, SecretStr
 
 from ..elitea_base import BaseVectorStoreToolApiWrapper, extend_with_vector_tools
+from ..utils.content_parser import load_content_from_bytes
 
 GLOBAL_LIMIT = 10000
 
@@ -235,15 +236,27 @@ class FigmaApiWrapper(BaseVectorStoreToolApiWrapper):
     global_regexp: Optional[str] = Field(default=None)
     _client: Optional[FigmaPy] = PrivateAttr()
 
-    def _base_loader(self, project_id: str, **kwargs) -> Generator[Document, None, None]:
-        files = json.loads(self.get_project_files(project_id)).get('files', [])
-        for file in files:
-            yield Document(page_content=json.dumps(file), metadata={
-                'id': file.get('key', ''),
-                'file_key': file.get('key', ''),
-                'name': file.get('name', ''),
-                'updated_on': file.get('last_modified', '')
-            })
+    def _base_loader(self, project_id: Optional[str] = None, file_keys: Optional[List[str]] = None, **kwargs) -> Generator[Document, None, None]:
+        files = []
+        if project_id:
+            files = json.loads(self.get_project_files(project_id)).get('files', [])
+            for file in files:
+                yield Document(page_content=json.dumps(file), metadata={
+                    'id': file.get('key', ''),
+                    'file_key': file.get('key', ''),
+                    'name': file.get('name', ''),
+                    'updated_on': file.get('last_modified', '')
+                })
+        elif file_keys:
+            for file_key in file_keys:
+                file = self._client.get_file(file_key)
+                metadata = {
+                    'id': file_key,
+                    'file_key': file_key,
+                    'name': file.name,
+                    'updated_on': file.last_modified
+                }
+                yield Document(page_content=json.dumps(metadata), metadata=metadata)
 
     def _process_document(self, document: Document) -> Generator[Document, None, None]:
         file_key = document.metadata.get('id', '')
@@ -257,12 +270,19 @@ class FigmaApiWrapper(BaseVectorStoreToolApiWrapper):
 
         # iterate over images values
         for node_id, image_url in images.items():
+            if not image_url:
+                logging.warning(f"Image URL not found for node_id {node_id} in file {file_key}. Skipping.")
+                continue
             response = requests.get(image_url)
             if response.status_code == 200:
                 content_type = response.headers.get('Content-Type', '')
                 if 'text/html' not in content_type.lower():
+                    extension = f".{content_type.split('/')[-1]}" if content_type.startswith('image') else '.txt'
+                    page_content = load_content_from_bytes(
+                        file_content=response.content,
+                        extension=extension, llm = self.llm)
                     yield Document(
-                                    page_content=base64.b64encode(response.content).decode("utf-8"),
+                                    page_content=page_content,
                                     metadata={
                                         'file_key': file_key,
                                         'node_id': node_id,
@@ -273,7 +293,12 @@ class FigmaApiWrapper(BaseVectorStoreToolApiWrapper):
     def _index_tool_params(self):
         """Return the parameters for indexing data."""
         return {
-            "project_id": (str, Field(description="ID of the project to list files from", examples=["55391681"]))
+            "project_id": (Optional[str], Field(
+                description="ID of the project to list files from: i.e. '55391681'",
+                default=None)),
+            'file_keys': (Optional[List[str]], Field(
+                description="List of file keys to index: i.e. ['Fp24FuzPwH0L74ODSrCnQo', 'jmhAr6q78dJoMRqt48zisY']",
+                default=None))
         }
 
     def _send_request(

alita_sdk/tools/github/__init__.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Literal, Any
+from typing import Dict, List, Optional, Literal
 
 from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
@@ -7,6 +7,8 @@ from .api_wrapper import AlitaGitHubAPIWrapper
 from .tool import GitHubAction
 
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...configurations.github import GithubConfiguration
+from ...configurations.pgvector import PgVectorConfiguration
 
 name = "github"
 
@@ -17,14 +19,10 @@ def _get_toolkit(tool) -> BaseToolkit:
         github_repository=tool['settings']['repository'],
         active_branch=tool['settings']['active_branch'],
         github_base_branch=tool['settings']['base_branch'],
-        github_access_token=tool['settings'].get('access_token', ''),
-        github_username=tool['settings'].get('username', ''),
-        github_password=tool['settings'].get('password', ''),
-        github_app_id=tool['settings'].get('app_id', None),
-        github_app_private_key=tool['settings'].get('app_private_key', None),
+        github_configuration=tool['settings']['github_configuration'],
         llm=tool['settings'].get('llm', None),
         alita=tool['settings'].get('alita', None),
-        connection_string=tool['settings'].get('connection_string', None),
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
         collection_name=str(tool['toolkit_name']),
         doctype='code',
         embedding_model="HuggingFaceEmbeddings",
@@ -45,7 +43,8 @@ class AlitaGitHubToolkit(BaseToolkit):
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
-        selected_tools = {x['name']: x['args_schema'].schema() for x in AlitaGitHubAPIWrapper.model_construct().get_available_tools()}
+        selected_tools = {x['name']: x['args_schema'].schema() for x in
+                          AlitaGitHubAPIWrapper.model_construct().get_available_tools()}
         AlitaGitHubToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
@@ -54,60 +53,37 @@ class AlitaGitHubToolkit(BaseToolkit):
                     'metadata': {
                         "label": "GitHub",
                         "icon_url": None,
-                        "sections": {
-                            "auth": {
-                                "required": False,
-                                "subsections": [
-                                    {
-                                        "name": "Token",
-                                        "fields": ["access_token"]
-                                    },
-                                    {
-                                        "name": "Password",
-                                        "fields": ["username", "password"]
-                                    },
-                                    {
-                                        "name": "App private key",
-                                        "fields": ["app_id", "app_private_key"]
-                                    }
-                                ]
-                            },
-                        },
                         "categories": ["code repositories"],
                         "extra_categories": ["github", "git", "repository", "code", "version control"],
                     },
                 }
             ),
-            base_url=(Optional[str], Field(description="Base API URL", default="https://api.github.com", json_schema_extra={'configuration': True, 'configuration_title': True})),
-            app_id=(Optional[str], Field(description="Github APP ID", default=None, json_schema_extra={'configuration': True})),
-            app_private_key=(Optional[SecretStr], Field(description="Github APP private key", default=None, json_schema_extra={'secret': True, 'configuration': True})),
-
-            access_token=(Optional[SecretStr], Field(description="Github Access Token", default=None, json_schema_extra={'secret': True, 'configuration': True})),
-
-            username=(Optional[str], Field(description="Github Username", default=None, json_schema_extra={'configuration': True})),
-            password=(Optional[SecretStr], Field(description="Github Password", default=None, json_schema_extra={'secret': True, 'configuration': True})),
-
-            repository=(str, Field(description="Github repository", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AlitaGitHubToolkit.toolkit_max_length})),
+            github_configuration=(Optional[GithubConfiguration], Field(description="Github configuration", default=None,
+                                                                     json_schema_extra={'configuration_types': ['github']})),
+            pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector configuration", default=None,
+                                                                     json_schema_extra={'configuration_types': ['pgvector']})),
+            repository=(str, Field(description="Github repository", json_schema_extra={'toolkit_name': True,
+                                                                                       'max_toolkit_length': AlitaGitHubToolkit.toolkit_max_length})),
             active_branch=(Optional[str], Field(description="Active branch", default="main")),
             base_branch=(Optional[str], Field(description="Github Base branch", default="main")),
-            
             # indexer settings
-            connection_string = (Optional[SecretStr], Field(description="Connection string for vectorstore",
-                                                            default=None,
-                                                            json_schema_extra={'secret': True})),
-            
-            # embedder settings
             embedding_model=(str, Field(description="Embedding model: i.e. 'HuggingFaceEmbeddings', etc.", 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"})),
-
-            selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools}))
+            selected_tools=(List[Literal[tuple(selected_tools)]],
+                            Field(default=[], json_schema_extra={'args_schemas': selected_tools}))
         )
 
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        github_api_wrapper = AlitaGitHubAPIWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            # TODO use github_configuration fields
+            **kwargs['github_configuration'],
+            **(kwargs.get('pgvector_configuration') or {}),
+        }
+        github_api_wrapper = AlitaGitHubAPIWrapper(**wrapper_payload)
         available_tools: List[Dict] = github_api_wrapper.get_available_tools()
         tools = []
         prefix = clean_string(toolkit_name, AlitaGitHubToolkit.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''

alita_sdk/tools/gitlab/__init__.py

@@ -3,11 +3,13 @@ from typing import Dict, List, Literal, Optional
 from alita_sdk.tools.base.tool import BaseAction
 from langchain_core.tools import BaseTool
 from langchain_core.tools import BaseToolkit
-from pydantic import create_model, BaseModel, ConfigDict, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict
 from pydantic.fields import Field
 
 from .api_wrapper import GitLabAPIWrapper
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...configurations.gitlab import GitlabConfiguration
+from ...configurations.pgvector import PgVectorConfiguration
 
 name = "gitlab"
 
@@ -18,11 +20,11 @@ def get_tools(tool):
         url=tool['settings']['url'],
         repository=tool['settings']['repository'],
         branch=tool['settings']['branch'],
-        private_token=tool['settings']['private_token'],
+        gitlab_configuration=tool['settings']['gitlab_configuration'],
 
         llm=tool['settings'].get('llm', None),
         alita=tool['settings'].get('alita', None),
-        connection_string=tool['settings'].get('connection_string', None),
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
         collection_name=str(tool['toolkit_name']),
         doctype='code',
         embedding_model="HuggingFaceEmbeddings",
@@ -44,13 +46,10 @@ class AlitaGitlabToolkit(BaseToolkit):
             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})),
-            private_token=(SecretStr, Field(description="GitLab private token", json_schema_extra={'secret': True, 'configuration': True})),
+            gitlab_configuration=(Optional[GitlabConfiguration], Field(description="GitLab configuration", json_schema_extra={'configuration_types': ['gitlab']})),
             branch=(str, Field(description="Main branch", default="main")),
             # indexer settings
-            connection_string=(Optional[SecretStr], Field(description="Connection string for vectorstore",
-                                                          default=None,
-                                                          json_schema_extra={'secret': True})),
-
+            pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
             embedding_model=(str, Field(description="Embedding model: i.e. 'HuggingFaceEmbeddings', etc.", 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"})),
@@ -80,7 +79,13 @@ class AlitaGitlabToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        gitlab_api_wrapper = GitLabAPIWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            # TODO use gitlab_configuration fields
+            **kwargs['gitlab_configuration'],
+            **(kwargs.get('pgvector_configuration') or {}),
+        }
+        gitlab_api_wrapper = GitLabAPIWrapper(**wrapper_payload)
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools: List[Dict] = gitlab_api_wrapper.get_available_tools()
         tools = []

alita_sdk/tools/google/bigquery/__init__.py

@@ -2,8 +2,9 @@ from functools import lru_cache
 from typing import List, Optional, Type
 
 from langchain_core.tools import BaseTool, BaseToolkit
-from pydantic import BaseModel, Field, SecretStr, computed_field, field_validator
+from pydantic import BaseModel, Field, computed_field, field_validator
 
+from ....configurations.bigquery import BigQueryConfiguration
 from ...utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length
 from .api_wrapper import BigQueryApiWrapper
 from .tool import BigQueryAction
@@ -45,30 +46,8 @@ class BigQueryToolkitConfig(BaseModel):
             }
         }
 
-    api_key: Optional[SecretStr] = Field(
-        default=None,
-        description="GCP API key",
-        json_schema_extra={"secret": True, "configuration": True},
-    )
-    project: Optional[str] = Field(
-        default=None,
-        description="BigQuery project ID",
-        json_schema_extra={"configuration": True},
-    )
-    location: Optional[str] = Field(
-        default=None,
-        description="BigQuery location",
-        json_schema_extra={"configuration": True},
-    )
-    dataset: Optional[str] = Field(
-        default=None,
-        description="BigQuery dataset name",
-        json_schema_extra={"configuration": True, "configuration_title": True},
-    )
-    table: Optional[str] = Field(
-        default=None,
-        description="BigQuery table name",
-        json_schema_extra={"configuration": True},
+    bigquery_configuration: Optional[BigQueryConfiguration] = Field(
+        description="BigQuery configuration", json_schema_extra={"configuration_types": ["bigquery"]}
     )
     selected_tools: List[str] = Field(
         default=[],
@@ -85,7 +64,7 @@ class BigQueryToolkitConfig(BaseModel):
 def _get_toolkit(tool) -> BaseToolkit:
     return BigQueryToolkit().get_toolkit(
         selected_tools=tool["settings"].get("selected_tools", []),
-        api_key=tool["settings"].get("api_key", ""),
+        bigquery_configuration=tool["settings"]["bigquery_configuration"],
         toolkit_name=tool.get("toolkit_name"),
     )
 
@@ -130,7 +109,12 @@ class BigQueryToolkit(BaseToolkit):
         toolkit_name: Optional[str] = None,
         **kwargs,
     ) -> "BigQueryToolkit":
-        bigquery_api_wrapper = BigQueryApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            # TODO use bigquery_configuration fields
+            **kwargs['bigquery_configuration'],
+        }
+        bigquery_api_wrapper = BigQueryApiWrapper(**wrapper_payload)
         instance = cls(
             tools=[], api_wrapper=bigquery_api_wrapper, toolkit_name=toolkit_name
         )

alita_sdk/tools/jira/__init__.py

@@ -2,10 +2,12 @@ from typing import List, Optional, Literal
 from .api_wrapper import JiraApiWrapper
 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
 import requests
 
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list, check_connection_response
+from ...configurations.jira import JiraConfiguration
+from ...configurations.pgvector import PgVectorConfiguration
 
 name = "jira"
 
@@ -14,9 +16,7 @@ def get_tools(tool):
         selected_tools=tool['settings'].get('selected_tools', []),
         base_url=tool['settings'].get('base_url'),
         cloud=tool['settings'].get('cloud', True),
-        api_key=tool['settings'].get('api_key', None),
-        username=tool['settings'].get('username', None),
-        token=tool['settings'].get('token', None),
+        jira_configuration=tool['settings']['jira_configuration'],
         limit=tool['settings'].get('limit', 5),
         labels=parse_list(tool['settings'].get('labels', [])),
         additional_fields=tool['settings'].get('additional_fields', []),
@@ -24,7 +24,7 @@ def get_tools(tool):
         # indexer settings
         llm=tool['settings'].get('llm', None),
         alita=tool['settings'].get('alita', None),
-        connection_string=tool['settings'].get('connection_string', None),
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
         collection_name=str(tool['toolkit_name']),
         embedding_model="HuggingFaceEmbeddings",
         embedding_model_params={"model_name": "sentence-transformers/all-MiniLM-L6-v2"},
@@ -47,10 +47,15 @@ class JiraToolkit(BaseToolkit):
             url = self.base_url.rstrip('/') + '/rest/api/2/myself'
             headers = {'Accept': 'application/json'}
             auth = None
-            if self.token:
-                headers['Authorization'] = f'Bearer {self.token}'
-            elif self.username and self.api_key:
-                auth = (self.username, self.api_key)
+            jira_config = self.jira_configuration or {}
+            token = jira_config.get('token')
+            username = jira_config.get('username')
+            api_key = jira_config.get('api_key')
+
+            if token:
+                headers['Authorization'] = f'Bearer {token}'
+            elif username and api_key:
+                auth = (username, api_key)
             else:
                 raise ValueError('Jira connection requires either token or username+api_key')
             response = requests.get(url, headers=headers, auth=auth, timeout=5, verify=getattr(self, 'verify_ssl', True))
@@ -70,9 +75,6 @@ class JiraToolkit(BaseToolkit):
                 )
             ),
             cloud=(bool, Field(description="Hosting Option", json_schema_extra={'configuration': True})),
-            api_key=(Optional[SecretStr], Field(description="API key", default=None, json_schema_extra={'secret': True, 'configuration': True})),
-            username=(Optional[str], Field(description="Jira Username", default=None, json_schema_extra={'configuration': True})),
-            token=(Optional[SecretStr], Field(description="Jira token", default=None, json_schema_extra={'secret': True, 'configuration': True})),
             limit=(int, Field(description="Limit issues")),
             labels=(Optional[str], Field(
                 description="List of comma separated labels used for labeling of agent's created or updated entities",
@@ -81,12 +83,8 @@ class JiraToolkit(BaseToolkit):
             )),
             verify_ssl=(bool, Field(description="Verify SSL", default=True)),
             additional_fields=(Optional[str], Field(description="Additional fields", default="")),
-
-            # indexer settings
-            connection_string=(Optional[SecretStr], Field(description="Connection string for vectorstore",
-                                                          default=None,
-                                                          json_schema_extra={'secret': True})),
-
+            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_model=(str, Field(description="Embedding model: i.e. 'HuggingFaceEmbeddings', etc.", 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"})),
@@ -123,7 +121,13 @@ class JiraToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        jira_api_wrapper = JiraApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            # TODO use jira_configuration fields
+            **kwargs['jira_configuration'],
+            **(kwargs.get('pgvector_configuration') or {}),
+        }
+        jira_api_wrapper = JiraApiWrapper(**wrapper_payload)
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = jira_api_wrapper.get_available_tools()
         tools = []

alita_sdk/tools/postman/__init__.py

@@ -1,13 +1,13 @@
 from typing import List, Literal, Optional, Type
-import json
 
 import requests
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr, field_validator
+from pydantic import create_model, BaseModel, ConfigDict, Field, field_validator
 from ..base.tool import BaseAction
 
 from .api_wrapper import PostmanApiWrapper
 from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER, check_connection_response
+from ...configurations.postman import PostmanConfiguration
 
 name = "postman"
 
@@ -30,7 +30,7 @@ def get_tools(tool):
     environment_config = tool['settings'].get('environment_config', {})
     toolkit = PostmanToolkit.get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        api_key=tool['settings'].get('api_key', None),
+        postman_configuration=tool['settings']['postman_configuration'],
         base_url=tool['settings'].get(
             'base_url', 'https://api.getpostman.com'),
         collection_id=tool['settings'].get('collection_id', None),
@@ -53,8 +53,8 @@ class PostmanToolkit(BaseToolkit):
             selected_tools)
         m = create_model(
             name,
-            api_key=(SecretStr, Field(description="Postman API key",
-                     json_schema_extra={'secret': True, 'configuration': True})),
+            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={
@@ -91,7 +91,12 @@ class PostmanToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        postman_api_wrapper = PostmanApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            # TODO use postman_configuration fields
+            **kwargs['postman_configuration'],
+        }
+        postman_api_wrapper = PostmanApiWrapper(**wrapper_payload)
         prefix = clean_string(str(toolkit_name), cls.toolkit_max_length) + \
             TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = postman_api_wrapper.get_available_tools()

alita_sdk/tools/qtest/__init__.py

@@ -7,6 +7,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 from .api_wrapper import QtestApiWrapper
 from .tool import QtestAction
 from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER, check_connection_response
+from ...configurations.qtest import QtestConfiguration
 
 name = "qtest"
 
@@ -16,7 +17,7 @@ def get_tools(tool):
         selected_tools=tool['settings'].get('selected_tools', []),
         base_url=tool['settings'].get('base_url', None),
         qtest_project_id=tool['settings'].get('qtest_project_id', tool['settings'].get('project_id', None)),
-        qtest_api_token=tool['settings'].get('qtest_api_token', None),
+        qtest_configuration=tool['settings']['qtest_configuration'],
         toolkit_name=tool.get('toolkit_name')
     )
     return toolkit.tools
@@ -34,7 +35,7 @@ class QtestToolkit(BaseToolkit):
             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_api_token=(SecretStr, Field(description="QTest API token", json_schema_extra={'secret': True, 'configuration': True})),
+            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})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "QTest", "icon_url": "qtest.svg",
                                                                   "categories": ["test management"],
@@ -59,7 +60,12 @@ class QtestToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        qtest_api_wrapper = QtestApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            # TODO use qtest_configuration fields
+            **kwargs['qtest_configuration'],
+        }
+        qtest_api_wrapper = QtestApiWrapper(**wrapper_payload)
         prefix = clean_string(str(toolkit_name), cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = qtest_api_wrapper.get_available_tools()
         tools = []

alita_sdk/tools/servicenow/__init__.py

@@ -4,8 +4,10 @@ from langchain_community.agent_toolkits.base import BaseToolkit
 from .api_wrapper import ServiceNowAPIWrapper
 from langchain_core.tools import BaseTool
 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.service_now import ServiceNowConfiguration
+
 
 name = "service_now"
 
@@ -14,8 +16,7 @@ def get_tools(tool):
         selected_tools=tool['settings'].get('selected_tools', []),
         instance_alias=tool['settings'].get('instance_alias', None),
         base_url=tool['settings']['base_url'],
-        password=tool['settings'].get('password', None),
-        username=tool['settings'].get('username', None),
+        servicenow_configuration=tool['settings']['servicenow_configuration'],
         response_fields=tool['settings'].get('response_fields', None),
         toolkit_name=tool.get('toolkit_name')
     ).get_tools()
@@ -37,9 +38,9 @@ class ServiceNowToolkit(BaseToolkit):
                         'configuration': True,
                         'configuration_title': True
                     })),
-            username=(str, Field(description="Username", default=None, json_schema_extra={'configuration': True})),
-            password=(SecretStr, Field(description="Password", default=None, json_schema_extra={'secret': True, 'configuration': True})),
             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']})),
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={
@@ -70,7 +71,12 @@ class ServiceNowToolkit(BaseToolkit):
             selected_tools = []
         if 'response_fields' in kwargs and isinstance(kwargs['response_fields'], str):
             kwargs['fields'] = [field.strip().lower() for field in kwargs['response_fields'].split(',') if field.strip()]
-        servicenow_api_wrapper = ServiceNowAPIWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            # TODO use servicenow_configuration fields
+            **kwargs['servicenow_configuration'],
+        }
+        servicenow_api_wrapper = ServiceNowAPIWrapper(**wrapper_payload)
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = servicenow_api_wrapper.get_available_tools()
         tools = []