alita-sdk 0.3.257__py3-none-any.whl → 0.3.562__py3-none-any.whl

alita_sdk/tools/rally/__init__.py

@@ -4,7 +4,8 @@ from pydantic import BaseModel, ConfigDict, Field, create_model, SecretStr
 from .api_wrapper import RallyApiWrapper
 from langchain_core.tools import BaseTool
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.rally import RallyConfiguration
 
 name = "rally"
@@ -20,17 +21,13 @@ def get_tools(tool):
 
 class RallyToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in RallyApiWrapper.model_construct().get_available_tools()}
-        RallyToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True,
-                                                                            'max_toolkit_length': RallyToolkit.toolkit_max_length})),
-            rally_configuration=(Optional[RallyConfiguration], Field(description="Rally configuration", json_schema_extra={'configuration_types': ['rally']})),
+            rally_configuration=(RallyConfiguration, Field(description="Rally configuration", json_schema_extra={'configuration_types': ['rally']})),
             workspace=(Optional[str], Field(default=None, description="Rally workspace")),
             project=(Optional[str], Field(default=None, description="Rally project")),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
@@ -45,6 +42,7 @@ class RallyToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -53,18 +51,22 @@ class RallyToolkit(BaseToolkit):
             **kwargs.get('rally_configuration'),
         }
         rally_api_wrapper = RallyApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = rally_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = f"{tool['description']}\nWorkspace: {rally_api_wrapper.workspace}. Project: {rally_api_wrapper.project}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=rally_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"{tool['description']}\nWorkspace: {rally_api_wrapper.workspace}. Project: {rally_api_wrapper.project}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/report_portal/__init__.py

@@ -2,37 +2,33 @@ from typing import List, Literal, Optional
 
 from langchain_core.tools import BaseToolkit, BaseTool
 
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from .api_wrapper import ReportPortalApiWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
+from ...configurations.report_portal import ReportPortalConfiguration
 
 name = "report_portal"
 
 def get_tools(tool):
     return ReportPortalToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        endpoint=tool['settings']['endpoint'],
-        api_key=tool['settings']['api_key'],
-        project=tool['settings']['project'],
+        report_portal_configuration=tool['settings']['report_portal_configuration'],
         toolkit_name=tool.get('toolkit_name')
     ).get_tools()
 
 
 class ReportPortalToolkit(BaseToolkit):
-    tools: list[BaseTool] = []
-    toolkit_max_length: int = 0
+    tools: List[BaseTool] = []
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in ReportPortalApiWrapper.model_construct().get_available_tools()}
-        ReportPortalToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            endpoint=(str, Field(description="Report Portal endpoint", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': ReportPortalToolkit.toolkit_max_length})),
-            project=(str, Field(description="Report Portal project")),
-            api_key=(SecretStr, Field(description="User API key", json_schema_extra={'secret': True})),
+            report_portal_configuration=(ReportPortalConfiguration, Field(description="Report Portal Configuration", json_schema_extra={'configuration_types': ['report_portal']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Report Portal", "icon_url": "reportportal-icon.svg",
                                                                   "categories": ["testing"],
@@ -40,21 +36,31 @@ class ReportPortalToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        report_portal_api_wrapper = ReportPortalApiWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('report_portal_configuration', {}),
+        }
+        report_portal_api_wrapper = ReportPortalApiWrapper(**wrapper_payload)
         available_tools = report_portal_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = tool['description']
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = f"{description}\nReport portal configuration: 'url - {report_portal_api_wrapper.endpoint}, project - {report_portal_api_wrapper.project}'"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=report_portal_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"{tool['description']}\nReport portal configuration: 'url - {report_portal_api_wrapper.endpoint}, project - {report_portal_api_wrapper.project}'",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/salesforce/__init__.py

@@ -2,33 +2,30 @@ from typing import List, Optional, Literal
 from .api_wrapper import SalesforceApiWrapper
 from langchain_core.tools import BaseTool, BaseToolkit
 from ..base.tool import BaseAction
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
-from ..utils import clean_string, TOOLKIT_SPLITTER,get_max_toolkit_length
+from pydantic import create_model, BaseModel, ConfigDict, Field
+
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
+from ...configurations.salesforce import SalesforceConfiguration
 
 name = "salesforce"
 
 def get_tools(tool):
     return SalesforceToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        base_url=tool['settings'].get('base_url'),
-        client_id=tool['settings'].get('client_id'),
-        client_secret=tool['settings'].get('client_secret'),
+        salesforce_configuration=tool['settings']['salesforce_configuration'],
         api_version=tool['settings'].get('api_version', 'v59.0')
     ).get_tools()
 
 class SalesforceToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         available_tools = {x['name']: x['args_schema'].schema() for x in SalesforceApiWrapper.model_construct().get_available_tools()}
-        SalesforceToolkit.toolkit_max_length = get_max_toolkit_length(available_tools)
         return create_model(
             name,
-            base_url=(str, Field(description="Salesforce instance URL", json_schema_extra={'toolkit_name': True})),
-            client_id=(str, Field(description="Salesforce Connected App Client ID")),
-            client_secret=(SecretStr, Field(description="Salesforce Connected App Client Secret", json_schema_extra={'secret': True})),
             api_version=(str, Field(description="Salesforce API Version", default='v59.0')),
+            salesforce_configuration=(SalesforceConfiguration, Field(description="Salesforce Configuration", json_schema_extra={'configuration_types': ['salesforce']})),
             selected_tools=(List[Literal[tuple(available_tools)]], Field(default=[], json_schema_extra={'args_schemas': available_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {
                 "label": "Salesforce", "icon_url": "salesforce-icon.svg",
@@ -38,23 +35,31 @@ class SalesforceToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
 
-        api_wrapper = SalesforceApiWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('salesforce_configuration', {}),
+        }
+        api_wrapper = SalesforceApiWrapper(**wrapper_payload)
         tools = []
 
         for tool in api_wrapper.get_available_tools():
             if selected_tools and tool["name"] not in selected_tools:
                 continue
-
+            description = f"Salesforce Tool: {tool['description']}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=api_wrapper,
-                name=prefix + tool["name"],
-                description=f"Salesforce Tool: {tool['description']}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
 
         return cls(tools=tools)

alita_sdk/tools/servicenow/__init__.py

@@ -5,39 +5,36 @@ from .api_wrapper import ServiceNowAPIWrapper
 from langchain_core.tools import BaseTool
 from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+
+from ..elitea_base import filter_missconfigured_index_tools
 from ...configurations.service_now import ServiceNowConfiguration
 
 
 name = "service_now"
 
 def get_tools(tool):
+    settings = tool.get('settings') or {}
+
     return ServiceNowToolkit().get_toolkit(
-        selected_tools=tool['settings'].get('selected_tools', []),
-        instance_alias=tool['settings'].get('instance_alias', None),
-        base_url=tool['settings']['base_url'],
-        servicenow_configuration=tool['settings']['servicenow_configuration'],
-        response_fields=tool['settings'].get('response_fields', None),
+        selected_tools=settings.get('selected_tools', []),
+        instance_alias=settings.get('instance_alias', None),
+        servicenow_configuration=settings.get('servicenow_configuration', None),
+        response_fields=settings.get('response_fields', None),
         toolkit_name=tool.get('toolkit_name')
     ).get_tools()
 
 
 class ServiceNowToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in
                           ServiceNowAPIWrapper.model_construct().get_available_tools()}
-        ServiceNowToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            name=(str, Field(description="Toolkit name",
-                             json_schema_extra={
-                                 'toolkit_name': True, 'max_toolkit_length': ServiceNowToolkit.toolkit_max_length})),
             response_fields=(Optional[str], Field(description="Response fields", default=None)),
-            servicenow_configuration=(Optional[ServiceNowConfiguration], Field(description="ServiceNow Configuration",
+            servicenow_configuration=(ServiceNowConfiguration, Field(description="ServiceNow Configuration",
                                                                                json_schema_extra={
                                                                                    'configuration_types': [
                                                                                        'service_now']})),
@@ -66,6 +63,7 @@ class ServiceNowToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -77,18 +75,24 @@ class ServiceNowToolkit(BaseToolkit):
             **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 = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            base_url = getattr(servicenow_api_wrapper, "base_url", "") or ""
+            description = tool.get("description", "") if isinstance(tool, dict) else ""
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = f"ServiceNow: {base_url}\n{description}".strip()
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=servicenow_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"ServiceNow: {servicenow_api_wrapper.base_url} " + tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/servicenow/api_wrapper.py

@@ -58,7 +58,7 @@ class ServiceNowAPIWrapper(BaseToolApiWrapper):
         password = SecretStr(values['password'])
         username = values['username']
         cls.fields = values.get('fields', ['sys_id', 'number', 'state', 'short_description', 'description', 'priority', 'category', 'urgency', 'impact', 'creation_date'])
-        cls.client = ServiceNowClient(base_url, (username, password.get_secret_value()))
+        cls.client = ServiceNowClient(instance=base_url, auth=(username, password.get_secret_value()))
         return values
 
     def get_incidents(self, data: Optional[Dict[str, Any]] = None) -> ToolException | str:

alita_sdk/tools/sharepoint/__init__.py

@@ -1,11 +1,13 @@
 from typing import List, Literal, Optional
 
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 from .api_wrapper import SharepointApiWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.pgvector import PgVectorConfiguration
+from ...configurations.sharepoint import SharepointConfiguration
 
 name = "sharepoint"
 
@@ -13,9 +15,7 @@ def get_tools(tool):
     return (SharepointToolkit()
             .get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        site_url=tool['settings'].get('site_url', None),
-        client_id=tool['settings'].get('client_id', None),
-        client_secret=tool['settings'].get('client_secret', None),
+        sharepoint_configuration=tool['settings']['sharepoint_configuration'],
         toolkit_name=tool.get('toolkit_name'),
         llm=tool['settings'].get('llm'),
         alita=tool['settings'].get('alita', None),
@@ -29,17 +29,13 @@ def get_tools(tool):
 
 class SharepointToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in SharepointApiWrapper.model_construct().get_available_tools()}
-        SharepointToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            site_url=(str, Field(description="Sharepoint site's URL", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': SharepointToolkit.toolkit_max_length})),
-            client_id=(str, Field(description="Client ID")),
-            client_secret=(SecretStr, Field(description="Client Secret", json_schema_extra={'secret': True})),
+            sharepoint_configuration=(SharepointConfiguration, Field(description="SharePoint Configuration", json_schema_extra={'configuration_types': ['sharepoint']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None,
@@ -56,26 +52,32 @@ class SharepointToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
         wrapper_payload = {
             **kwargs,
+            **kwargs.get('sharepoint_configuration', {}),
             **(kwargs.get('pgvector_configuration') or {}),
         }
         sharepoint_api_wrapper = SharepointApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = sharepoint_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = f"Sharepoint {sharepoint_api_wrapper.site_url}\n{tool['description']}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=sharepoint_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"Sharepoint {sharepoint_api_wrapper.site_url}\n{tool['description']}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)