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

alita_sdk/tools/aws/delta_lake/__init__.py

@@ -5,6 +5,7 @@ from typing import List, Optional, Type
 from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import BaseModel, Field, SecretStr, computed_field, field_validator
 
+from alita_sdk.configurations.delta_lake import DeltaLakeConfiguration
 from ...utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length
 from .api_wrapper import DeltaLakeApiWrapper
 from .tool import DeltaLakeAction
@@ -53,12 +54,7 @@ class DeltaLakeToolkitConfig(BaseModel):
             }
         }
 
-    aws_access_key_id: Optional[SecretStr] = Field(default=None, description="AWS access key ID", json_schema_extra={"secret": True, "configuration": True})
-    aws_secret_access_key: Optional[SecretStr] = Field(default=None, description="AWS secret access key", json_schema_extra={"secret": True, "configuration": True})
-    aws_session_token: Optional[SecretStr] = Field(default=None, description="AWS session token (optional)", json_schema_extra={"secret": True, "configuration": True})
-    aws_region: Optional[str] = Field(default=None, description="AWS region for Delta Lake storage", json_schema_extra={"configuration": True})
-    s3_path: Optional[str] = Field(default=None, description="S3 path to Delta Lake data (e.g., s3://bucket/path)", json_schema_extra={"configuration": True, "configuration_title": True})
-    table_path: Optional[str] = Field(default=None, description="Delta Lake table path (if not using s3_path)", json_schema_extra={"configuration": True})
+    delta_lake_configuration: Optional[DeltaLakeConfiguration] = Field(description="Delta Lake Configuration", json_schema_extra={"configuration_types": ["delta_lake"]})
     selected_tools: List[str] = Field(default=[], description="Selected tools", json_schema_extra={"args_schemas": get_available_tools()})
 
     @field_validator("selected_tools", mode="before", check_fields=False)
@@ -69,12 +65,12 @@ class DeltaLakeToolkitConfig(BaseModel):
 def _get_toolkit(tool) -> BaseToolkit:
     return DeltaLakeToolkit().get_toolkit(
         selected_tools=tool["settings"].get("selected_tools", []),
-        aws_access_key_id=tool["settings"].get("aws_access_key_id", None),
-        aws_secret_access_key=tool["settings"].get("aws_secret_access_key", None),
-        aws_session_token=tool["settings"].get("aws_session_token", None),
-        aws_region=tool["settings"].get("aws_region", None),
-        s3_path=tool["settings"].get("s3_path", None),
-        table_path=tool["settings"].get("table_path", None),
+        aws_access_key_id=tool["settings"].get("delta_lake_configuration").get("aws_access_key_id", None),
+        aws_secret_access_key=tool["settings"].get("delta_lake_configuration").get("aws_secret_access_key", None),
+        aws_session_token=tool["settings"].get("delta_lake_configuration").get("aws_session_token", None),
+        aws_region=tool["settings"].get("delta_lake_configuration").get("aws_region", None),
+        s3_path=tool["settings"].get("delta_lake_configuration").get("s3_path", None),
+        table_path=tool["settings"].get("delta_lake_configuration").get("table_path", None),
         toolkit_name=tool.get("toolkit_name"),
     )
 
@@ -103,9 +99,9 @@ class DeltaLakeToolkit(BaseToolkit):
     def available_tools(self) -> List[dict]:
         return self.api_wrapper.get_available_tools()
 
-    @staticmethod
     def toolkit_config_schema() -> Type[BaseModel]:
         return DeltaLakeToolkitConfig
+        return m
 
     @classmethod
     def get_toolkit(

alita_sdk/tools/azure_ai/search/__init__.py

@@ -3,8 +3,9 @@ from typing import List, Optional, Literal
 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 pydantic import create_model, BaseModel, ConfigDict, Field
 from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ....configurations.azure_search import AzureSearchConfiguration
 import requests
 
 logger = getLogger(__name__)
@@ -14,10 +15,10 @@ name = "azure_search"
 def get_tools(tool):
     return AzureSearchToolkit().get_toolkit(
             selected_tools=tool['settings'].get('selected_tools', []),
-            api_key=tool['settings'].get('api_key', None),
-            endpoint=tool['settings'].get('endpoint', None),
+            api_key=tool['settings'].get('azure_search_configuration', {}).get('api_key', None),
+            endpoint=tool['settings'].get('azure_search_configuration', {}).get('endpoint', None),
             index_name=tool['settings'].get('index_name', None),
-            api_base=tool['settings'].get('api_base', None),
+            api_base=tool['settings'].get('azure_search_configuration', {}).get('api_base', None),
             api_version=tool['settings'].get('api_version', None),
             openai_api_key=tool['settings'].get('access_token', None),
             model_name=tool['settings'].get('model_name', None),
@@ -38,18 +39,11 @@ class AzureSearchToolkit(BaseToolkit):
         AzureSearchToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            api_key=(SecretStr, Field(description="API key", json_schema_extra={'secret': True, 'configuration': True})),
-            endpoint=(str, Field(title="Azure Search endpoint",
-                                                   description="Azure Search endpoint",
-                                                   json_schema_extra={
-                                                       'configuration': True,
-                                                       "configuration_title": True
-                                                   })),
             index_name=(str, Field(description="Azure Search index name")),
-            api_base=(Optional[str], Field(description="Azure OpenAI base URL", default=None,
-                                           json_schema_extra={
-                                               'max_toolkit_length': AzureSearchToolkit.toolkit_max_length,
-                                               'configuration': True})),
+            azure_search_configuration=(
+                Optional[AzureSearchConfiguration],
+                Field(description="Azure Search Configuration", json_schema_extra={'configuration_types': ['azure_search']})
+            ),
             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)),

alita_sdk/tools/bitbucket/__init__.py

@@ -6,8 +6,10 @@ 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 pydantic import BaseModel, Field, ConfigDict, create_model
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...configurations.bitbucket import BitbucketConfiguration
+from ...configurations.pgvector import PgVectorConfiguration
 import requests
 
 
@@ -20,13 +22,13 @@ def get_tools(tool):
         url=tool['settings']['url'],
         project=tool['settings']['project'],
         repository=tool['settings']['repository'],
-        username=tool['settings']['username'],
-        password=tool['settings']['password'],
+        username=tool['settings'].get('bitbucket_configuration', {}).get('username', ''),
+        password=tool['settings'].get('bitbucket_configuration', {}).get('password', ''),
         branch=tool['settings']['branch'],
         cloud=tool['settings'].get('cloud'),
         llm=tool['settings'].get('llm', None),
         alita=tool['settings'].get('alita', None),
-        connection_string=tool['settings'].get('connection_string', None),
+        connection_string=tool['settings'].get('pgvector_configuration', {}).get('connection_string', None),
         collection_name=str(tool['toolkit_name']),
         doctype='code',
         embedding_model="HuggingFaceEmbeddings",
@@ -53,14 +55,9 @@ class AlitaBitbucketToolkit(BaseToolkit):
             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")),
-            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)),
-            # indexer settings
-            connection_string=(Optional[SecretStr], Field(description="Connection string for vectorstore",
-                                                          default=None,
-                                                          json_schema_extra={'secret': True})),
-
+            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_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"})),

alita_sdk/tools/confluence/__init__.py

@@ -3,8 +3,10 @@ from langchain_community.agent_toolkits.base import BaseToolkit
 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 pydantic import create_model, BaseModel, ConfigDict, Field
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list, check_connection_response
+from ...configurations.confluence import ConfluenceConfiguration
+from ...configurations.pgvector import PgVectorConfiguration
 import requests
 
 name = "confluence"
@@ -15,9 +17,9 @@ def get_tools(tool):
         base_url=tool['settings']['base_url'],
         space=tool['settings'].get('space', None),
         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),
+        api_key=tool['settings'].get('confluence_configuration', {}).get('api_key', None),
+        username=tool['settings'].get('confluence_configuration', {}).get('username', None),
+        token=tool['settings'].get('confluence_configuration', {}).get('token', None),
         limit=tool['settings'].get('limit', 5),
         labels=parse_list(tool['settings'].get('labels', None)),
         additional_fields=tool['settings'].get('additional_fields', []),
@@ -26,7 +28,7 @@ def get_tools(tool):
         llm=tool['settings'].get('llm', None),
         toolkit_name=tool.get('toolkit_name'),
         # indexer settings
-        connection_string = tool['settings'].get('connection_string', None),
+        connection_string = tool['settings'].get('pgvector_configuration', {}).get('connection_string', None),
         collection_name=str(tool['toolkit_name']),
         doctype='doc',
         embedding_model="HuggingFaceEmbeddings",
@@ -50,10 +52,15 @@ class ConfluenceToolkit(BaseToolkit):
             url = self.base_url.rstrip('/') + '/wiki/rest/api/space'
             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)
+            confluence_config = self.confluence_configuration or {}
+            token = confluence_config.get('token')
+            username = confluence_config.get('username')
+            api_key = confluence_config.get('api_key')
+
+            if token:
+                headers['Authorization'] = f'Bearer {token}'
+            elif username and api_key:
+                auth = (username, api_key)
             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))
@@ -62,9 +69,6 @@ class ConfluenceToolkit(BaseToolkit):
         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})),
-            api_key=(SecretStr, Field(description="API key", default=None, json_schema_extra={'secret': True, 'configuration': True})),
-            username=(str, Field(description="Username", default=None, json_schema_extra={'configuration': True})),
             space=(str, Field(description="Space", json_schema_extra={'toolkit_name': True,
                                                                                     'max_toolkit_length': ConfluenceToolkit.toolkit_max_length})),
             cloud=(bool, Field(description="Hosting Option", json_schema_extra={'configuration': True})),
@@ -78,17 +82,13 @@ class ConfluenceToolkit(BaseToolkit):
             number_of_retries=(int, Field(description="Number of retries", default=2)),
             min_retry_seconds=(int, Field(description="Min retry, sec", default=10)),
             max_retry_seconds=(int, Field(description="Max retry, sec", default=60)),
-            selected_tools=(List[Literal[tuple(selected_tools)]],
-                            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})),
-
-            # embedder settings
+            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']})),
             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})),
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {
                     "label": "Confluence",

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,14 @@ 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_access_token=tool['settings'].get('github_configuration', {}).get('access_token', ''),
+        github_username=tool['settings'].get('github_configuration', {}).get('username', ''),
+        github_password=tool['settings'].get('github_configuration', {}).get('password', ''),
+        github_app_id=tool['settings'].get('github_configuration', {}).get('app_id', None),
+        github_app_private_key=tool['settings'].get('github_configuration', {}).get('app_private_key', None),
         llm=tool['settings'].get('llm', None),
         alita=tool['settings'].get('alita', None),
-        connection_string=tool['settings'].get('connection_string', None),
+        connection_string=tool['settings'].get('pgvector_configuration', {}).get('connection_string', None),
         collection_name=str(tool['toolkit_name']),
         doctype='code',
         embedding_model="HuggingFaceEmbeddings",
@@ -45,7 +47,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,53 +57,27 @@ 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
+            connection_string=(Optional[SecretStr], Field(description="Connection string for vectorstore",
+                                                          default=None,
+                                                          json_schema_extra={'secret': True})),
             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

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'],
+        private_token=tool['settings'].get('gitlab_configuration', {}).get('private_token', ''),
 
         llm=tool['settings'].get('llm', None),
         alita=tool['settings'].get('alita', None),
-        connection_string=tool['settings'].get('connection_string', None),
+        connection_string=tool['settings'].get('pgvector_configuration', {}).get('connection_string', None),
         collection_name=str(tool['toolkit_name']),
         doctype='code',
         embedding_model="HuggingFaceEmbeddings",
@@ -44,13 +46,11 @@ 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", default=None,
+                                    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"})),

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", ""),
+        api_key=tool["settings"].get('bigquery_configuration').get("api_key", ""),
         toolkit_name=tool.get("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,9 @@ 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),
+        api_key=tool['settings'].get('jira_configuration', {}).get('api_key', None),
+        username=tool['settings'].get('jira_configuration', {}).get('username', None),
+        token=tool['settings'].get('jira_configuration', {}).get('token', None),
         limit=tool['settings'].get('limit', 5),
         labels=parse_list(tool['settings'].get('labels', [])),
         additional_fields=tool['settings'].get('additional_fields', []),
@@ -24,7 +26,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),
+        connection_string=tool['settings'].get('pgvector_configuration', {}).get('connection_string', None),
         collection_name=str(tool['toolkit_name']),
         embedding_model="HuggingFaceEmbeddings",
         embedding_model_params={"model_name": "sentence-transformers/all-MiniLM-L6-v2"},
@@ -47,10 +49,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 +77,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 +85,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"})),

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),
+        api_key=tool['settings'].get('postman_configuration', {}).get('api_key', None),
         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={

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_api_token=tool['settings'].get('qtest_configuration', {}).get('qtest_api_token', None),
         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"],

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,8 @@ 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),
+        password=tool['settings'].get('servicenow_configuration', {}).get('password', None),
+        username=tool['settings'].get('servicenow_configuration', {}).get('username', None),
         response_fields=tool['settings'].get('response_fields', None),
         toolkit_name=tool.get('toolkit_name')
     ).get_tools()
@@ -37,9 +39,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={