alita-sdk 0.3.233__py3-none-any.whl → 0.3.235__py3-none-any.whl

alita_sdk/configurations/embedding.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class EmbeddingConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Embedding Vector Storage",
+                "icon_url": None,
+                "section": "vectorstorage",
+                "type": "embedding"
+            }
+        }
+    )
+    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/configurations/testrail.py

@@ -16,5 +16,6 @@ class TestRailConfiguration(BaseModel):
             }
         }
     )
-    email: Optional[str] = Field(description="TestRail Email", default=None)
-    password: Optional[SecretStr] = Field(description="TestRail Password", default=None)
+    url: str = Field(description="Testrail URL")
+    email: str = Field(description="TestRail Email")
+    password: SecretStr = Field(description="TestRail Password")

alita_sdk/runtime/clients/client.py

@@ -1,4 +1,6 @@
 import logging
+from copy import deepcopy
+
 import requests
 from urllib.parse import quote
 
@@ -18,7 +20,7 @@ from .prompt import AlitaPrompt
 from .datasource import AlitaDataSource
 from .artifact import Artifact
 from ..langchain.chat_message_template import Jinja2TemplatedChatMessagesTemplate
-
+from ...tools import get_available_toolkit_models
 
 logger = logging.getLogger(__name__)
 
@@ -141,7 +143,7 @@ class AlitaClient:
                 break
 
         return apps
-            
+
     def fetch_available_configurations(self) -> list:
         resp = requests.get(self.configurations_url, headers=self.headers, verify=False)
         if resp.ok:
@@ -157,19 +159,19 @@ class AlitaClient:
     def get_llm(self, model_name: str, model_config: dict) -> ChatOpenAI:
         """
         Get a ChatOpenAI model instance based on the model name and configuration.
-        
+
         Args:
             model_name: Name of the model to retrieve
             model_config: Configuration parameters for the model
-            
+
         Returns:
             An instance of ChatOpenAI configured with the provided parameters.
         """
         if not model_name:
             raise ValueError("Model name must be provided")
-        
+
         logger.info(f"Creating ChatOpenAI model: {model_name} with config: {model_config}")
-        
+
         return ChatOpenAI(
             base_url=f"{self.base_url}{self.llm_path}",
             model=model_name,
@@ -182,8 +184,8 @@ class AlitaClient:
             seed=model_config.get("seed", None),
             openai_organization=str(self.project_id),
         )
-         
-    
+
+
     def get_app_version_details(self, application_id: int, application_version_id: int) -> dict:
         url = f"{self.application_versions}/{application_id}/{application_version_id}"
         if self.configurations:
@@ -401,7 +403,7 @@ class AlitaClient:
     def predict(self, messages: list[BaseMessage], model_settings: dict, variables: list[dict] = None):
         prompt_data = self._prepare_payload(messages, model_settings, variables)
         response = requests.post(self.predict_url, headers=self.headers, json=prompt_data, verify=False)
-        
+
         if response.status_code != 200:
             logger.error(f"Error in response of predict: {response.content}")
             raise requests.exceptions.HTTPError(response.content)
@@ -465,7 +467,7 @@ class AlitaClient:
         content = resp_data["findings"]
         references = resp_data['references']
         return AIMessage(content=content, additional_kwargs={"references": references})
-    
+
     def _get_real_user_id(self):
         try:
             import tasknode_task # pylint: disable=E0401
@@ -512,16 +514,16 @@ class AlitaClient:
         return LangChainAssistant(self, agent_data, llm,
                                   chat_history, "predict", memory=memory, store=store).runnable()
 
-    def test_toolkit_tool(self, toolkit_config: dict, tool_name: str, tool_params: dict = None, 
-                          runtime_config: dict = None, llm_model: str = None, 
+    def test_toolkit_tool(self, toolkit_config: dict, tool_name: str, tool_params: dict = None,
+                          runtime_config: dict = None, llm_model: str = None,
                           llm_config: dict = None) -> dict:
         """
         Test a single tool from a toolkit with given parameters and runtime callbacks.
-        
+
         This method initializes a toolkit, calls a specific tool, and supports runtime
         callbacks for event dispatching, enabling tools to send custom events back to
         the platform during execution.
-        
+
         Args:
             toolkit_config: Configuration dictionary for the toolkit containing:
                 - toolkit_name: Name of the toolkit (e.g., 'github', 'jira')
@@ -537,7 +539,7 @@ class AlitaClient:
                 - max_tokens: Maximum tokens for response (default: 1000)
                 - temperature: Temperature for response generation (default: 0.1)
                 - top_p: Top-p value for response generation (default: 1.0)
-            
+
         Returns:
             Dictionary containing:
                 - success: Boolean indicating if the operation was successful
@@ -548,25 +550,25 @@ class AlitaClient:
                 - events_dispatched: List of custom events dispatched during execution
                 - llm_model: LLM model used for the test
                 - execution_time_seconds: Time taken to execute the tool in seconds
-            
+
         Example:
             >>> from langchain_core.callbacks import BaseCallbackHandler
-            >>> 
+            >>>
             >>> class TestCallback(BaseCallbackHandler):
             ...     def __init__(self):
             ...         self.events = []
             ...     def on_custom_event(self, name, data, **kwargs):
             ...         self.events.append({'name': name, 'data': data})
-            >>> 
+            >>>
             >>> callback = TestCallback()
             >>> runtime_config = {'callbacks': [callback]}
-            >>> 
+            >>>
             >>> config = {
             ...     'toolkit_name': 'github',
             ...     'settings': {'github_token': 'your_token'}
             ... }
             >>> result = client.test_toolkit_tool(
-            ...     config, 'get_repository_info', 
+            ...     config, 'get_repository_info',
             ...     {'repo_name': 'alita'}, runtime_config,
             ...     llm_model='gpt-4o-mini',
             ...     llm_config={'temperature': 0.1}
@@ -582,21 +584,44 @@ class AlitaClient:
                 'temperature': 0.1,
                 'top_p': 1.0
             }
-            
+        import logging
+        logger = logging.getLogger(__name__)
+        toolkit_config_parsed_json = None
+        try:
+            toolkit_config_type = toolkit_config.get('type')
+            toolkit_class = get_available_toolkit_models().get(toolkit_config_type)['toolkit_class']
+            toolkit_config_model_class = toolkit_class.toolkit_config_schema()
+            toolkit_config_validated_settings = toolkit_config_model_class(
+                **toolkit_config.get('settings', {})
+            ).model_dump(mode='json')
+
+            toolkit_config_parsed_json = deepcopy(toolkit_config)
+            toolkit_config_parsed_json['settings'] = toolkit_config_validated_settings
+        except Exception as toolkit_config_error:
+            logger.error(f"Failed to validate toolkit configuration: {str(toolkit_config_error)}")
+            return {
+                "success": False,
+                "error": f"Failed to validate toolkit configuration: {str(toolkit_config_error)}",
+                "tool_name": tool_name,
+                "toolkit_config": None,
+                "llm_model": llm_model,
+                "events_dispatched": events_dispatched,
+                "execution_time_seconds": 0.0
+            }
+
         try:
             from ..utils.toolkit_utils import instantiate_toolkit_with_client
             from langchain_core.runnables import RunnableConfig
             import logging
             import time
-            
-            logger = logging.getLogger(__name__)
+
             logger.info(f"Testing tool '{tool_name}' from toolkit '{toolkit_config.get('toolkit_name')}' with LLM '{llm_model}'")
-            
+
             # Create RunnableConfig for callback support
             config = None
             callbacks = []
             events_dispatched = []
-            
+
             if runtime_config:
                 callbacks = runtime_config.get('callbacks', [])
                 if callbacks:
@@ -605,7 +630,7 @@ class AlitaClient:
                         configurable=runtime_config.get('configurable', {}),
                         tags=runtime_config.get('tags', [])
                     )
-            
+
             # Create LLM instance using the client's get_llm method
             try:
                 llm = self.get_llm(llm_model, llm_config)
@@ -616,42 +641,42 @@ class AlitaClient:
                     "success": False,
                     "error": f"Failed to create LLM instance '{llm_model}': {str(llm_error)}",
                     "tool_name": tool_name,
-                    "toolkit_config": toolkit_config,
+                    "toolkit_config": toolkit_config_parsed_json,
                     "llm_model": llm_model,
                     "events_dispatched": events_dispatched,
                     "execution_time_seconds": 0.0
                 }
-            
+
             # Instantiate the toolkit with client and LLM support
             tools = instantiate_toolkit_with_client(toolkit_config, llm, self)
-            
+
             if not tools:
                 return {
                     "success": False,
                     "error": f"Failed to instantiate toolkit '{toolkit_config.get('toolkit_name')}' or no tools found",
                     "tool_name": tool_name,
-                    "toolkit_config": toolkit_config,
+                    "toolkit_config": toolkit_config_parsed_json,
                     "llm_model": llm_model,
                     "events_dispatched": events_dispatched,
                     "execution_time_seconds": 0.0
                 }
-            
+
             # Find the specific tool with smart name matching
             target_tool = None
             toolkit_name = toolkit_config.get('toolkit_name', '').lower()
-            
+
             # Helper function to extract base tool name from full name
             def extract_base_tool_name(full_name: str) -> str:
                 """Extract base tool name from toolkit___toolname format."""
                 if '___' in full_name:
                     return full_name.split('___', 1)[1]
                 return full_name
-            
+
             # Helper function to create full tool name
             def create_full_tool_name(base_name: str, toolkit_name: str) -> str:
                 """Create full tool name in toolkit___toolname format."""
                 return f"{toolkit_name}___{base_name}"
-            
+
             # Normalize tool_name to handle both formats
             # If user provides toolkit___toolname, extract just the tool name
             # If user provides just toolname, keep as is
@@ -660,7 +685,7 @@ class AlitaClient:
                 logger.info(f"Extracted base tool name '{normalized_tool_name}' from full name '{tool_name}'")
             else:
                 normalized_tool_name = tool_name
-            
+
             # Try multiple matching strategies
             for tool in tools:
                 tool_name_attr = None
@@ -668,61 +693,61 @@ class AlitaClient:
                     tool_name_attr = tool.name
                 elif hasattr(tool, 'func') and hasattr(tool.func, '__name__'):
                     tool_name_attr = tool.func.__name__
-                
+
                 if tool_name_attr:
                     # Strategy 1: Exact match with provided name (handles both formats)
                     if tool_name_attr == tool_name:
                         target_tool = tool
                         logger.info(f"Found tool using exact match: '{tool_name_attr}'")
                         break
-                    
+
                     # Strategy 2: Match normalized name with toolkit prefix
                     expected_full_name = create_full_tool_name(normalized_tool_name, toolkit_name)
                     if tool_name_attr == expected_full_name:
                         target_tool = tool
                         logger.info(f"Found tool using toolkit prefix mapping: '{tool_name_attr}' for normalized name '{normalized_tool_name}'")
                         break
-                    
+
                     # Strategy 3: Match base names (extract from both sides)
                     base_tool_name = extract_base_tool_name(tool_name_attr)
                     if base_tool_name == normalized_tool_name:
                         target_tool = tool
                         logger.info(f"Found tool using base name mapping: '{tool_name_attr}' -> '{base_tool_name}' matches '{normalized_tool_name}'")
                         break
-                    
+
                     # Strategy 4: Match provided name with base tool name (reverse lookup)
                     if tool_name_attr == normalized_tool_name:
                         target_tool = tool
                         logger.info(f"Found tool using direct name match: '{tool_name_attr}' matches normalized '{normalized_tool_name}'")
                         break
-            
+
             if target_tool is None:
                 available_tools = []
                 base_available_tools = []
                 full_available_tools = []
-                
+
                 for tool in tools:
                     tool_name_attr = None
                     if hasattr(tool, 'name'):
                         tool_name_attr = tool.name
                     elif hasattr(tool, 'func') and hasattr(tool.func, '__name__'):
                         tool_name_attr = tool.func.__name__
-                    
+
                     if tool_name_attr:
                         available_tools.append(tool_name_attr)
-                        
+
                         # Extract base name for user-friendly error
                         base_name = extract_base_tool_name(tool_name_attr)
                         if base_name not in base_available_tools:
                             base_available_tools.append(base_name)
-                        
+
                         # Track full names separately
                         if '___' in tool_name_attr:
                             full_available_tools.append(tool_name_attr)
-                
+
                 # Create comprehensive error message
                 error_msg = f"Tool '{tool_name}' not found in toolkit '{toolkit_config.get('toolkit_name')}'."
-                
+
                 if base_available_tools and full_available_tools:
                     error_msg += f" Available tools: {base_available_tools} (base names) or {full_available_tools} (full names)"
                 elif base_available_tools:
@@ -731,29 +756,29 @@ class AlitaClient:
                     error_msg += f" Available tools: {available_tools}"
                 else:
                     error_msg += " No tools found in the toolkit."
-                
+
                 # Add helpful hint about naming conventions
                 if '___' in tool_name:
                     error_msg += f" Note: You provided a full name '{tool_name}'. Try using just the base name '{extract_base_tool_name(tool_name)}'."
                 elif full_available_tools:
                     possible_full_name = create_full_tool_name(tool_name, toolkit_name)
                     error_msg += f" Note: You provided a base name '{tool_name}'. The full name might be '{possible_full_name}'."
-                
+
                 return {
                     "success": False,
                     "error": error_msg,
                     "tool_name": tool_name,
-                    "toolkit_config": toolkit_config,
+                    "toolkit_config": toolkit_config_parsed_json,
                     "llm_model": llm_model,
                     "events_dispatched": events_dispatched,
                     "execution_time_seconds": 0.0
                 }
-            
+
             # Execute the tool with callback support
             try:
                 # Log which tool was found and how
                 actual_tool_name = getattr(target_tool, 'name', None) or getattr(target_tool.func, '__name__', 'unknown')
-                
+
                 # Determine which matching strategy was used
                 if actual_tool_name == tool_name:
                     logger.info(f"Found tool '{tool_name}' using exact match")
@@ -765,12 +790,12 @@ class AlitaClient:
                     logger.info(f"Found tool '{tool_name}' using direct normalized name match ('{actual_tool_name}')")
                 else:
                     logger.info(f"Found tool '{tool_name}' using fallback matching ('{actual_tool_name}')")
-                
+
                 logger.info(f"Executing tool '{tool_name}' (internal name: '{actual_tool_name}') with parameters: {tool_params}")
-                
+
                 # Start timing the tool execution
                 start_time = time.time()
-                
+
                 # Different tools might have different invocation patterns
                 if hasattr(target_tool, 'invoke'):
                     # Use config for tools that support RunnableConfig
@@ -788,15 +813,15 @@ class AlitaClient:
                         "success": False,
                         "error": f"Tool '{tool_name}' is not callable",
                         "tool_name": tool_name,
-                        "toolkit_config": toolkit_config,
+                        "toolkit_config": toolkit_config_parsed_json,
                         "llm_model": llm_model,
                         "events_dispatched": events_dispatched,
                         "execution_time_seconds": execution_time
                     }
-                
+
                 # Calculate execution time
                 execution_time = time.time() - start_time
-                
+
                 # Extract events from callbacks if they support it
                 for callback in callbacks:
                     if hasattr(callback, 'events'):
@@ -805,24 +830,24 @@ class AlitaClient:
                         events_dispatched.extend(callback.get_events())
                     elif hasattr(callback, 'dispatched_events'):
                         events_dispatched.extend(callback.dispatched_events)
-                
+
                 logger.info(f"Tool '{tool_name}' executed successfully in {execution_time:.3f} seconds")
-                
+
                 return {
                     "success": True,
                     "result": result,
                     "tool_name": tool_name,
-                    "toolkit_config": toolkit_config,
+                    "toolkit_config": toolkit_config_parsed_json,
                     "llm_model": llm_model,
                     "events_dispatched": events_dispatched,
                     "execution_time_seconds": execution_time
                 }
-                
+
             except Exception as tool_error:
                 # Calculate execution time even for failed executions
                 execution_time = time.time() - start_time
                 logger.error(f"Error executing tool '{tool_name}' after {execution_time:.3f} seconds: {str(tool_error)}")
-                
+
                 # Still collect events even if tool execution failed
                 for callback in callbacks:
                     if hasattr(callback, 'events'):
@@ -831,17 +856,17 @@ class AlitaClient:
                         events_dispatched.extend(callback.get_events())
                     elif hasattr(callback, 'dispatched_events'):
                         events_dispatched.extend(callback.dispatched_events)
-                
+
                 return {
                     "success": False,
                     "error": f"Tool execution failed: {str(tool_error)}",
                     "tool_name": tool_name,
-                    "toolkit_config": toolkit_config,
+                    "toolkit_config": toolkit_config_parsed_json,
                     "llm_model": llm_model,
                     "events_dispatched": events_dispatched,
                     "execution_time_seconds": execution_time
                 }
-                
+
         except Exception as e:
             logger = logging.getLogger(__name__)
             logger.error(f"Error in test_toolkit_tool: {str(e)}")
@@ -849,12 +874,12 @@ class AlitaClient:
                 "success": False,
                 "error": f"Method execution failed: {str(e)}",
                 "tool_name": tool_name,
-                "toolkit_config": toolkit_config,
+                "toolkit_config": toolkit_config_parsed_json,
                 "llm_model": llm_model if 'llm_model' in locals() else None,
                 "events_dispatched": [],
                 "execution_time_seconds": 0.0
             }
-    
+
     def _get_real_user_id(self) -> str:
         """Extract the real user ID from the auth token for MCP tool calls."""
         try:
@@ -874,4 +899,4 @@ class AlitaClient:
         except Exception as e:
             logger.error(f"Error extracting user ID from token: {e}")
         return None
-        
+

alita_sdk/tools/__init__.py

@@ -1,4 +1,5 @@
 import logging
+from copy import deepcopy
 from importlib import import_module
 from typing import Optional
 
@@ -177,6 +178,10 @@ def get_available_toolkits():
     """Return list of available toolkit class names."""
     return list(AVAILABLE_TOOLKITS.keys())
 
+def get_available_toolkit_models():
+    """Return dict with available toolkit classes."""
+    return deepcopy(AVAILABLE_TOOLS)
+
 def diagnose_imports():
     """Print diagnostic information about tool imports."""
     available_count = len(AVAILABLE_TOOLS)
@@ -216,5 +221,6 @@ __all__ = [
     'get_available_tools',
     'get_failed_imports',
     'get_available_toolkits',
+    'get_available_toolkit_models',
     'diagnose_imports'
 ]

alita_sdk/tools/ado/repos/__init__.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, Field, create_model
 import requests
 
 from ....configurations.ado import AdoReposConfiguration
+from ....configurations.embedding import EmbeddingConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
 from .repos_wrapper import ReposApiWrapper
@@ -54,11 +55,8 @@ class AzureDevOpsReposToolkit(BaseToolkit):
             # indexer settings
             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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                            json_schema_extra={'configuration_types': ['embedding']})),
 
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__={'json_schema_extra': {'metadata':

alita_sdk/tools/ado/test_plan/__init__.py

@@ -5,6 +5,7 @@ from pydantic import create_model, BaseModel, Field
 
 import requests
 from ....configurations.ado import AdoConfiguration
+from ....configurations.embedding import EmbeddingConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from .test_plan_wrapper import TestPlanApiWrapper
 from ...base.tool import BaseAction
@@ -31,11 +32,9 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
             # indexer settings
             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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__={'json_schema_extra': {'metadata':
                 {

alita_sdk/tools/ado/wiki/__init__.py

@@ -5,6 +5,7 @@ from pydantic import create_model, BaseModel, Field
 
 import requests
 from ....configurations.ado import AdoConfiguration
+from ....configurations.embedding import EmbeddingConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
 from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
@@ -31,11 +32,9 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
             # indexer settings
             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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__={

alita_sdk/tools/ado/work_item/__init__.py

@@ -5,6 +5,7 @@ from pydantic import create_model, BaseModel, Field
 
 import requests
 from ....configurations.ado import AdoConfiguration
+from ....configurations.embedding import EmbeddingConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
 from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
@@ -32,11 +33,9 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
             # indexer settings
             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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
             __config__={
                 'json_schema_extra': {
                     'metadata': {

alita_sdk/tools/bitbucket/__init__.py

@@ -9,6 +9,7 @@ from langchain_core.tools import BaseTool
 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.embedding import EmbeddingConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 import requests
 
@@ -58,8 +59,9 @@ class AlitaBitbucketToolkit(BaseToolkit):
             bitbucket_configuration=(Optional[BitbucketConfiguration], Field(description="Bitbucket Configuration", json_schema_extra={'configuration_types': ['bitbucket']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", default={'configuration_types': ['pgvector']})),
             # embedder settings
-            embedding_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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra=
             {

alita_sdk/tools/confluence/__init__.py

@@ -6,6 +6,7 @@ from ..base.tool import BaseAction
 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.embedding import EmbeddingConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 import requests
 
@@ -81,8 +82,10 @@ class ConfluenceToolkit(BaseToolkit):
             max_retry_seconds=(int, Field(description="Max retry, sec", default=60)),
             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"})),
+            # embedder settings
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
 
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),

alita_sdk/tools/elitea_base.py

@@ -118,7 +118,7 @@ BaseIndexDataParams = create_model(
                          description="Optional step size for progress reporting during indexing")),
     clean_index=(Optional[bool], Field(default=False,
                        description="Optional flag to enforce clean existing index before indexing new data")),
-    chunking_tool=(Literal['','markdown', 'statistical', 'proposal'], Field(description="Name of chunking tool", default=None)),
+    chunking_tool=(Literal[None,'markdown', 'statistical', 'proposal'], Field(description="Name of chunking tool", default=None)),
     chunking_config=(Optional[dict], Field(description="Chunking tool configuration", default_factory=dict)),
 )
 

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.embedding import EmbeddingConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
 name = "figma"
@@ -58,8 +59,9 @@ class FigmaToolkit(BaseToolkit):
             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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
             __config__=ConfigDict(
                 json_schema_extra={
                      "metadata": {

alita_sdk/tools/github/__init__.py

@@ -7,6 +7,7 @@ from .api_wrapper import AlitaGitHubAPIWrapper
 from .tool import GitHubAction
 
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...configurations.embedding import EmbeddingConfiguration
 from ...configurations.github import GithubConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -66,9 +67,10 @@ class AlitaGitHubToolkit(BaseToolkit):
                                                                                        '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
-            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"})),
+            # embedder settings
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools}))
         )

alita_sdk/tools/gitlab/__init__.py

@@ -8,6 +8,7 @@ from pydantic.fields import Field
 
 from .api_wrapper import GitLabAPIWrapper
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...configurations.embedding import EmbeddingConfiguration
 from ...configurations.gitlab import GitlabConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -51,8 +52,9 @@ class AlitaGitlabToolkit(BaseToolkit):
             # indexer settings
             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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {

alita_sdk/tools/jira/__init__.py

@@ -6,6 +6,7 @@ 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.embedding import EmbeddingConfiguration
 from ...configurations.jira import JiraConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -86,8 +87,9 @@ class JiraToolkit(BaseToolkit):
             jira_configuration=(Optional[JiraConfiguration], Field(description="Jira Configuration", json_schema_extra={'configuration_types': ['jira']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
-            embedding_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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
 
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={

alita_sdk/tools/testrail/__init__.py

@@ -7,6 +7,7 @@ import requests
 from .api_wrapper import TestrailAPIWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...configurations.embedding import EmbeddingConfiguration
 from ...configurations.testrail import TestRailConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -39,22 +40,13 @@ class TestrailToolkit(BaseToolkit):
         TestrailToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            url=(
-                str,
-                Field(
-                    description="Testrail URL",
-                    json_schema_extra={
-                        "max_length": TestrailToolkit.toolkit_max_length,
-                        "configuration": True,
-                        "configuration_title": True
-                    }
-                )
-            ),
+            name=(str, Field(description="Toolkit name", json_schema_extra={
+                'toolkit_name': True,
+                "max_length": TestrailToolkit.toolkit_max_length})),
             testrail_configuration=(Optional[TestRailConfiguration], Field(description="TestRail Configuration", json_schema_extra={'configuration_types': ['testrail']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
-            embedding_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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.", json_schema_extra={'configuration_types': ['embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata':
                                                          {"label": "Testrail", "icon_url": "testrail-icon.svg",

alita_sdk/tools/utils/content_parser.py

@@ -78,9 +78,9 @@ def parse_file_content(file_name=None, file_content=None, is_capture_image: bool
 
     loader_object = loaders_map.get(extension)
     if not loader_object:
-        raise ToolException(
-            f"Not supported type ({extension}) of files entered. "
-            f"Supported types are TXT, DOCX, PDF, PPTX, XLSX and XLS only.")
+        logger.warning(f"No loader found for file extension: {extension}. File: {file_path if file_path else file_name}")
+        return ToolException(
+            "Not supported type of files entered. Supported types are TXT, DOCX, PDF, PPTX, XLSX and XLS only.")
     loader_kwargs = loader_object['kwargs']
     loader_kwargs.update({
         "file_path": file_path,

alita_sdk/tools/xray/__init__.py

@@ -8,6 +8,8 @@ from pydantic import create_model, BaseModel, Field, SecretStr
 from .api_wrapper import XrayApiWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER
+from ...configurations.embedding import EmbeddingConfiguration
+from ...configurations.pgvector import PgVectorConfiguration
 
 name = "xray_cloud"
 
@@ -46,14 +48,13 @@ class XrayToolkit(BaseToolkit):
             client_secret=(SecretStr, Field(description="Client secret", json_schema_extra={'secret': True})),
             limit=(Optional[int], Field(description="Limit", default=100)),
 
-            # 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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
 
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__={'json_schema_extra':

alita_sdk/tools/zephyr_enterprise/__init__.py

@@ -5,6 +5,8 @@ from typing import List, Literal, Optional
 from .api_wrapper import ZephyrApiWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER
+from ...configurations.embedding import EmbeddingConfiguration
+from ...configurations.pgvector import PgVectorConfiguration
 
 name = "zephyr_enterprise"
 
@@ -37,14 +39,13 @@ class ZephyrEnterpriseToolkit(BaseToolkit):
             name,
             base_url=(str, Field(description="Zephyr Enterprise base URL", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': ZephyrEnterpriseToolkit.toolkit_max_length })),
             token=(SecretStr, Field(description="API token", json_schema_extra={'secret': True})),
-            # 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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], []),
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {

alita_sdk/tools/zephyr_essential/__init__.py

@@ -6,6 +6,8 @@ from pydantic import create_model, BaseModel, Field, SecretStr
 from .api_wrapper import ZephyrEssentialApiWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...configurations.embedding import EmbeddingConfiguration
+from ...configurations.pgvector import PgVectorConfiguration
 
 name = "zephyr_essential"
 
@@ -37,14 +39,13 @@ class ZephyrEssentialToolkit(BaseToolkit):
             token=(str, Field(description="Bearer api token")),
             base_url=(Optional[str], Field(description="Zephyr Essential base url", default=None)),
             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})),
-
+            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"})),
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
             __config__={'json_schema_extra': {'metadata': {"label": "Zephyr Essential", "icon_url": "zephyr.svg",
                             "categories": ["test management"],
                             "extra_categories": ["test automation", "test case management", "test planning"]

alita_sdk/tools/zephyr_scale/__init__.py

@@ -7,6 +7,8 @@ from pydantic import create_model, BaseModel, Field, SecretStr
 from .api_wrapper import ZephyrScaleApiWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER
+from ...configurations.embedding import EmbeddingConfiguration
+from ...configurations.pgvector import PgVectorConfiguration
 
 name = "zephyr_scale"
 
@@ -41,6 +43,13 @@ class ZephyrScaleToolkit(BaseToolkit):
             password=(Optional[SecretStr], Field(default=None, description="Password", json_schema_extra={'secret': True})),
             cookies=(Optional[str], Field(default=None, description="Cookies", json_schema_extra={'secret': True})),
             max_results=(int, Field(default=100, description="Results count to show")),
+            pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration",
+                                                                           json_schema_extra={
+                                                                               'configuration_types': ['pgvector']})),
+            # embedder settings
+            embedding_configuration=(Optional[EmbeddingConfiguration], Field(description="Embedding configuration.",
+                                                                             json_schema_extra={'configuration_types': [
+                                                                                 'embedding']})),
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__={

{alita_sdk-0.3.233.dist-info → alita_sdk-0.3.235.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.233
+Version: 0.3.235
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.233.dist-info → alita_sdk-0.3.235.dist-info}/RECORD

@@ -8,6 +8,7 @@ alita_sdk/configurations/bigquery.py,sha256=NlyfUm7jMmiDcPSbpHhrpYy7wgbSTdP_cdti
 alita_sdk/configurations/bitbucket.py,sha256=wSmvFwGuiSTaRg4DTSVJNrj1J_6VlY2Tci3s28mXfPk,1156
 alita_sdk/configurations/confluence.py,sha256=LFFjhp0whiWcAN-2DnOVSUnQmjURBmV4C4iDyKs7vys,1423
 alita_sdk/configurations/delta_lake.py,sha256=MTVsX6stX6D1uEfFMgbb3fYBJRqCrB6cktfUKc9S9ho,1101
+alita_sdk/configurations/embedding.py,sha256=mKQRFqYFKfo1MUYUC7Arqv65q4ppCVbDN0Lf4A7ib4Q,781
 alita_sdk/configurations/github.py,sha256=GSj6sA4f6SfW0ZpoHXKi5FzbPDC6wE1AlscwWqIPj14,1832
 alita_sdk/configurations/gitlab.py,sha256=zCI4RDZ3UZFLMWPcAYwuGosUbb-piTwtQjuY4QCJWBk,1031
 alita_sdk/configurations/jira.py,sha256=B44oNZtt2ECL0QUcFpO2NpDEACn0jl46j7aWhpd2P1s,1331
@@ -16,11 +17,11 @@ alita_sdk/configurations/postman.py,sha256=srup-SaimnSHO8UW1jr05sfUBqd_zKdVc5hs4
 alita_sdk/configurations/qtest.py,sha256=u1kkhOJJ-oT5YsjAO8pS5F6pLdQV0yiZzcPf9qazMaE,639
 alita_sdk/configurations/service_now.py,sha256=na3gBBBLFNBbsk-AW08h8dd60HC5UvNSlxWwc_6w1U4,1141
 alita_sdk/configurations/slack.py,sha256=l4D_rYgRsKak6Kx7l0WoxCzWaWf1---FlKY6y2ZWGYk,1252
-alita_sdk/configurations/testrail.py,sha256=K8J3PmYVeDMWuIcgRDqFzbbgzXRXs78SP6H6VNq_aqQ,724
+alita_sdk/configurations/testrail.py,sha256=k0fPmHBIrWAfEKhrDdB9Rdirw-UFHFoXkRePyrsqcWI,725
 alita_sdk/runtime/__init__.py,sha256=4W0UF-nl3QF2bvET5lnah4o24CoTwSoKXhuN0YnwvEE,828
 alita_sdk/runtime/clients/__init__.py,sha256=BdehU5GBztN1Qi1Wul0cqlU46FxUfMnI6Vq2Zd_oq1M,296
 alita_sdk/runtime/clients/artifact.py,sha256=H3pJAh5G-zWVyJ6YbqHGk4jA8U6HfacQduiTivpJZ3Y,3210
-alita_sdk/runtime/clients/client.py,sha256=hbATwaA_H70ViTv5gHSYVu3MZ64YXY5ZyZ7TVsoI138,42005
+alita_sdk/runtime/clients/client.py,sha256=X9-xCPhp5NimIkpRwdaueQ6Iwh9U_JrAHHe8Ja73UCI,42625
 alita_sdk/runtime/clients/datasource.py,sha256=HAZovoQN9jBg0_-lIlGBQzb4FJdczPhkHehAiVG3Wx0,1020
 alita_sdk/runtime/clients/prompt.py,sha256=li1RG9eBwgNK_Qf0qUaZ8QNTmsncFrAL2pv3kbxZRZg,1447
 alita_sdk/runtime/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -111,17 +112,17 @@ alita_sdk/runtime/utils/streamlit.py,sha256=ZgHpibL2ARHt6qrWj5JhK6HNZv2UjxQ04qTk
 alita_sdk/runtime/utils/toolkit_runtime.py,sha256=MU63Fpxj0b5_r1IUUc0Q3-PN9VwL7rUxp2MRR4tmYR8,5136
 alita_sdk/runtime/utils/toolkit_utils.py,sha256=I9QFqnaqfVgN26LUr6s3XlBlG6y0CoHURnCzG7XcwVs,5311
 alita_sdk/runtime/utils/utils.py,sha256=CpEl3LCeLbhzQySz08lkKPm7Auac6IiLF7WB8wmArMI,589
-alita_sdk/tools/__init__.py,sha256=1AHqP2xyLjn92xVm70l9XIke6FkfHkLo5OoQVe4BuP8,10421
-alita_sdk/tools/elitea_base.py,sha256=WeYunN9QqXx2EZB0GwYiSxjTJs0djO8iSwPorZZuaOE,30302
+alita_sdk/tools/__init__.py,sha256=ko5TToGYZFmBrho26DRAVvrkHWxQ2sfs8gVAASinYp8,10611
+alita_sdk/tools/elitea_base.py,sha256=PW4so3vZsVlSzGTuCR-_LkWR9P-zuw7UsTGETtdTUxc,30304
 alita_sdk/tools/ado/__init__.py,sha256=j4lt6MLWlpkIIVkHmAyVG3i_qQeQ3ZmL_g8BfMhVhVI,1289
 alita_sdk/tools/ado/utils.py,sha256=PTCludvaQmPLakF2EbCGy66Mro4-rjDtavVP-xcB2Wc,1252
-alita_sdk/tools/ado/repos/__init__.py,sha256=kc4ZJI3B9CDUp4q3jRSj7JZNc3fJwwMTsV40CiKO7Po,6111
+alita_sdk/tools/ado/repos/__init__.py,sha256=mZqU0-9Yyw7HOt61980ndl3yPJ00Ihw2UlvWawheONU,5987
 alita_sdk/tools/ado/repos/repos_wrapper.py,sha256=nPVsS10Se52yHmZ_YXVGywCSaYLlBEYBTBlhBcDJr80,50143
-alita_sdk/tools/ado/test_plan/__init__.py,sha256=w-tHu1uJakZSrREx0tD8sZ3-0Lz0rrv8Uj4phTzF4wU,5429
+alita_sdk/tools/ado/test_plan/__init__.py,sha256=1_Q8-utQ-Ii85BpS1vkwHOcb4Ts1WXLyb8zaz48eoOs,5392
 alita_sdk/tools/ado/test_plan/test_plan_wrapper.py,sha256=jQt8kFmdAzsopjByLTMiSnWtoqz_IUOmYkhPTVGeMnU,20265
-alita_sdk/tools/ado/wiki/__init__.py,sha256=ARjmIAdx-1DcNvh_WW9Z-ZuFp86RKK-gDvzStxZHL_0,5358
+alita_sdk/tools/ado/wiki/__init__.py,sha256=K6Au92gFl2_NuxhFF_VaplzdEI3_oIZ3XwHcXod_giE,5321
 alita_sdk/tools/ado/wiki/ado_wrapper.py,sha256=zg6wMRar1DTp-ZRlYaQifBEnpYmTrHXskTNPdrLdy8s,14759
-alita_sdk/tools/ado/work_item/__init__.py,sha256=L7uYqUn1eAlJwtTiFWYdeSdc-33Am0beFdlC99DRXVY,5493
+alita_sdk/tools/ado/work_item/__init__.py,sha256=1rvgE-i4UtdYxNvgIhCZoqgjcjDTXRo2Y48zmLy6KJg,5456
 alita_sdk/tools/ado/work_item/ado_wrapper.py,sha256=ubeF2m8J6CGZF_gnkTEbmW_eh6YWsk7bD2clu9FmZpY,28313
 alita_sdk/tools/advanced_jira_mining/__init__.py,sha256=pUTzECqGvYaR5qWY3JPUhrImrZgc7pCXuqSe5eWIE80,4604
 alita_sdk/tools/advanced_jira_mining/data_mining_wrapper.py,sha256=nZPtuwVWp8VeHw1B8q9kdwf-6ZvHnlXTOGdcIMDkKpw,44211
@@ -135,7 +136,7 @@ alita_sdk/tools/azure_ai/search/__init__.py,sha256=FVWNSW4LlOXKt34fVUgXut5oZcok9
 alita_sdk/tools/azure_ai/search/api_wrapper.py,sha256=E4p6HPDlwgxfT_i6cvg9rN4Vn_47CVAyNBAKLIGq3mU,7265
 alita_sdk/tools/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/tools/base/tool.py,sha256=-N27AodZS49vdPCgFkU-bFS9bxoPopZBnNrmwInx3d0,864
-alita_sdk/tools/bitbucket/__init__.py,sha256=P5YgZI7PfL3PNLi1CCVxSMc7OZpdlTkY-j_mbJV22xo,5587
+alita_sdk/tools/bitbucket/__init__.py,sha256=W44kX-zEFVJNhrXfa8YsRnByR9vnFZ3EbQ1IMwLsrGQ,5622
 alita_sdk/tools/bitbucket/api_wrapper.py,sha256=OU55KjtFalYIZ4ioeBck0zjqTewB6BdwQuAS3Kud4R0,10847
 alita_sdk/tools/bitbucket/bitbucket_constants.py,sha256=UsbhQ1iEvrKoxceTFPWTYhaXS1zSxbmjs1TwY0-P4gw,462
 alita_sdk/tools/bitbucket/cloud_api_wrapper.py,sha256=VELi65tLXvszwCGQSqVfyVal0ylx9DgAmAGpRQL_Zkg,15522
@@ -203,7 +204,7 @@ alita_sdk/tools/code/linter/api_wrapper.py,sha256=wylpwhAw02Jt8L18CqBq2He5PbwIkx
 alita_sdk/tools/code/loaders/codesearcher.py,sha256=XoXXZtIQZhvjIwZlnl_4wVGHC-3saYzFo5oDR_Zh3EY,529
 alita_sdk/tools/code/sonar/__init__.py,sha256=u8wpgXJ_shToLl3G9-XEtGDor5dhmsnurIImh1-e-U0,3165
 alita_sdk/tools/code/sonar/api_wrapper.py,sha256=nNqxcWN_6W8c0ckj-Er9HkNuAdgQLoWBXh5UyzNutis,2653
-alita_sdk/tools/confluence/__init__.py,sha256=B8JiTA-iUN8G21nAb3HyXwbA05ZjNzvjhb0vmymjna4,7252
+alita_sdk/tools/confluence/__init__.py,sha256=TjG_Zi-Xf_SdJf3135p5VFf6-iMzJ9BMM_giu7PBftE,7319
 alita_sdk/tools/confluence/api_wrapper.py,sha256=4WqjVeFWyFeb4-VD5v4_J69pbyjire4Op7cBSKU9EXw,85057
 alita_sdk/tools/confluence/loader.py,sha256=4bf5qrJMEiJzuZp2NlxO2XObLD1w7fxss_WyMUpe8sg,9290
 alita_sdk/tools/confluence/utils.py,sha256=Lxo6dBD0OlvM4o0JuK6qeB_4LV9BptiwJA9e1vqNcDw,435
@@ -211,16 +212,16 @@ alita_sdk/tools/custom_open_api/__init__.py,sha256=9aT5SPNPWcJC6jMZEM-3rUCXVULj_
 alita_sdk/tools/custom_open_api/api_wrapper.py,sha256=sDSFpvEqpSvXHGiBISdQQcUecfO3md-_F8hAi6p2dvg,4340
 alita_sdk/tools/elastic/__init__.py,sha256=iwnSRppRpzvJ1da2K3Glu8Uu41MhBDCYbguboLkEbW0,2818
 alita_sdk/tools/elastic/api_wrapper.py,sha256=pl8CqQxteJAGwyOhMcld-ZgtOTFwwbv42OITQVe8rM0,1948
-alita_sdk/tools/figma/__init__.py,sha256=281OU_aw4Y87Do09HhDSi5zL5ne9YlrsRLZQo8s1U8Q,5316
+alita_sdk/tools/figma/__init__.py,sha256=B6oDmoSFxONa_74qSbdLCw_Su00KLcEMr7fH-OwZ3sE,5351
 alita_sdk/tools/figma/api_wrapper.py,sha256=Rtgt9FvR8VD0oPdYhlgvVyXLVqLTjtiOPTlwNeaV80w,20560
-alita_sdk/tools/github/__init__.py,sha256=CtU52t6-jd6JErWe3M2HF5XXWzFj9CqGmG7HBjUet6E,5348
+alita_sdk/tools/github/__init__.py,sha256=IZwU7CCs8be4zwK1AVbv13N38cnLkzjxCH0wiCugkyY,5384
 alita_sdk/tools/github/api_wrapper.py,sha256=uDwYckdnpYRJtb0uZnDkaz2udvdDLVxuCh1tSwspsiU,8411
 alita_sdk/tools/github/github_client.py,sha256=nxnSXsDul2PPbWvYZS8TmAFFmR-5ALyakNoV5LN2D4U,86617
 alita_sdk/tools/github/graphql_client_wrapper.py,sha256=d3AGjzLGH_hdQV2V8HeAX92dJ4dlnE5OXqUlCO_PBr0,71539
 alita_sdk/tools/github/schemas.py,sha256=yFsqivfjCPRk9GxFJrL8sTz6nnjFCZ0j5DIfPtGSsvA,13852
 alita_sdk/tools/github/tool.py,sha256=Jnnv5lenV5ds8AAdyo2m8hSzyJ117HZBjzHC6T1ck-M,1037
 alita_sdk/tools/github/tool_prompts.py,sha256=y6ZW_FpUCE87Uop3WuQAZVRnzxO5t7xjBOI5bCqiluw,30194
-alita_sdk/tools/gitlab/__init__.py,sha256=WuaIouTnMoQF7OTsfm7GblWW60Yf2IbUyQxjFHpK3ck,5127
+alita_sdk/tools/gitlab/__init__.py,sha256=FkmYj2EQLTSwpTmEbTIKRonZ-cfJC0HJDRX8P0aYYlY,5162
 alita_sdk/tools/gitlab/api_wrapper.py,sha256=KYCRO2pF8EPTLhWuEj64XsHPCYSucsf8S3R_ofJttrA,22301
 alita_sdk/tools/gitlab/tools.py,sha256=vOGTlSaGaFmWn6LS6YFP-FuTqUPun9vnv1VrUcUHAZQ,16500
 alita_sdk/tools/gitlab/utils.py,sha256=Z2XiqIg54ouqqt1to-geFybmkCb1I6bpE91wfnINH1I,2320
@@ -236,7 +237,7 @@ alita_sdk/tools/google/bigquery/schemas.py,sha256=Gb8KQZSoRkmjXiz21dTC95c1MHEHFc
 alita_sdk/tools/google/bigquery/tool.py,sha256=Esf9Hsp8I0e7-5EdkFqQ-bid0cfrg-bfSoHoW_IIARo,1027
 alita_sdk/tools/google_places/__init__.py,sha256=mHKc7u9P2gqGDzqqJNQC9qiZYEm5gncnM_1XjtrM17o,3152
 alita_sdk/tools/google_places/api_wrapper.py,sha256=7nZly6nk4f4Tm7s2MVdnnwlb-1_WHRrDhyjDiqoyPjA,4674
-alita_sdk/tools/jira/__init__.py,sha256=CuE3LPxFuTtdel9YR7RS37wZzvxniPVCY6pDu4cBAdk,6927
+alita_sdk/tools/jira/__init__.py,sha256=LQlU_PeoE2tUxWxq6ce8BduZfF6pdRJ60pOXYwK4m7Y,6962
 alita_sdk/tools/jira/api_wrapper.py,sha256=gZXEtOZtWvINHipHPj8Dg6uNyYKZariLo4Bs3_wLJrA,75932
 alita_sdk/tools/keycloak/__init__.py,sha256=0WB9yXMUUAHQRni1ghDEmd7GYa7aJPsTVlZgMCM9cQ0,3050
 alita_sdk/tools/keycloak/api_wrapper.py,sha256=cOGr0f3S3-c6tRDBWI8wMnetjoNSxiV5rvC_0VHb8uw,3100
@@ -300,13 +301,13 @@ alita_sdk/tools/sql/api_wrapper.py,sha256=Rky0_CX9HWDQ2mClHGAgP3LHjYVX4iymPuilZM
 alita_sdk/tools/sql/models.py,sha256=AKJgSl_kEEz4fZfw3kbvdGHXaRZ-yiaqfJOB6YOj3i0,641
 alita_sdk/tools/testio/__init__.py,sha256=qi12wyJXN02hrUXg08CbijcCL5pi30JMbJfiXjn1Zr0,2646
 alita_sdk/tools/testio/api_wrapper.py,sha256=BvmL5h634BzG6p7ajnQLmj-uoAw1gjWnd4FHHu1h--Q,21638
-alita_sdk/tools/testrail/__init__.py,sha256=577XVaOAoXG3mDkojCsy5XCUlxCsdJf_2-_5U-afkOo,4961
+alita_sdk/tools/testrail/__init__.py,sha256=H3vLFaVtXzhuhFMjldmDykrlLC-njXIDlrudhcBCJcc,4643
 alita_sdk/tools/testrail/api_wrapper.py,sha256=Aax0jspgidXYNxLIw6qTWu3dO2JOIS0ALIqsCzQuFbQ,32087
 alita_sdk/tools/utils/__init__.py,sha256=155xepXPr4OEzs2Mz5YnjXcBpxSv1X2eznRUVoPtyK0,3268
-alita_sdk/tools/utils/content_parser.py,sha256=yi1IDLreqfM41w-PnoFEvVLtSV50qpNvKshJwbDTgqs,7172
+alita_sdk/tools/utils/content_parser.py,sha256=Azm-eUr_hOc55BxdQVxMNpWQTLOQjoAq-fyiuOXhrO0,7264
 alita_sdk/tools/vector_adapters/VectorStoreAdapter.py,sha256=a6FAsiix_EvATIKUf5YT6vHh5LDyJ5uSP3LJqoxFo04,17367
 alita_sdk/tools/vector_adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-alita_sdk/tools/xray/__init__.py,sha256=OYa1wveTm-lAhsJaGXMnwOrDQWl6ch--NjNLBeR63eM,4331
+alita_sdk/tools/xray/__init__.py,sha256=g8f1JoNwbYEIs35l6o7t-9mctCjkaiLJMYmaLVbOqxU,4447
 alita_sdk/tools/xray/api_wrapper.py,sha256=A8PJmY2k7TowaD_vk6ZxkMnSUoZUt9A6g4TJrZfNTAw,32225
 alita_sdk/tools/yagmail/__init__.py,sha256=c4Qn3em0tLxzRmFKpzbBgY9W2EnOoKf0azoDJHng5CY,2208
 alita_sdk/tools/yagmail/yagmail_wrapper.py,sha256=SKoGVd1X4Ew3ad5tOdtPoY00M6jStNdT3q7GXEjQc5g,1952
@@ -314,19 +315,19 @@ alita_sdk/tools/zephyr/Zephyr.py,sha256=ODZbg9Aw0H0Rbv-HcDXLI4KHbPiLDHoteDofshw9
 alita_sdk/tools/zephyr/__init__.py,sha256=8B2Ibz5QTmB5WkV0q8Sq4kuj92FFaFWZLrT877zRRLg,2897
 alita_sdk/tools/zephyr/api_wrapper.py,sha256=lJCYPG03ej0qgdpLflnS7LFB4HSAfGzIvTjAJt07CQs,6244
 alita_sdk/tools/zephyr/rest_client.py,sha256=7vSD3oYIX-3KbAFed-mphSQif_VRuXrq5O07ryNQ7Pk,6208
-alita_sdk/tools/zephyr_enterprise/__init__.py,sha256=XAWLj4WgMpEz3xnP8VW1lzHVW48K3CxIXdgeubjMvaw,3885
+alita_sdk/tools/zephyr_enterprise/__init__.py,sha256=CsTiwTwIlDVFO3ouE0P6tWr2x5clvVXy7IoGvVXOQL0,4001
 alita_sdk/tools/zephyr_enterprise/api_wrapper.py,sha256=p9EpkO5tif3JJzprz2_VuLsQ1yET7TwwBfPOKJGwt9c,11215
 alita_sdk/tools/zephyr_enterprise/zephyr_enterprise.py,sha256=hV9LIrYfJT6oYp-ZfQR0YHflqBFPsUw2Oc55HwK0H48,6809
-alita_sdk/tools/zephyr_essential/__init__.py,sha256=-VS-smytUSjqNLLi6HmqbsU3NfmNFTrzPjzNiEtOi5c,3628
+alita_sdk/tools/zephyr_essential/__init__.py,sha256=Ws3KVjU5MPZzqfeKmnn-m1p7_TqaCrJMpDYyY5olpH0,3744
 alita_sdk/tools/zephyr_essential/api_wrapper.py,sha256=TpNov35XPgjM9eymCEFqv22mbpdVvLMBTb9WVqUcvNA,36795
 alita_sdk/tools/zephyr_essential/client.py,sha256=bfNcUKNqj9MFWTludGbbqD4qZlxrBaC2JtWsCfZMqSY,9722
-alita_sdk/tools/zephyr_scale/__init__.py,sha256=2NTcdrfkx4GSegqyXhsPLsEpc4FlACuDy85b0fk6cAo,4572
+alita_sdk/tools/zephyr_scale/__init__.py,sha256=bk7u0JbVf3FLyhvp3IYfMX_lvpQQaT-DQE8085P23J8,5391
 alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=JAeWf-RXohsxheUpT0iMDClc_izj-zxMwafXCW4jtC0,78015
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=0AI_j27xVO5Gk5HQMFrqPTd4uvuVTpiZUicBrdfEpKg,2796
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=kmw_xol8YIYFplBLWTqP_VKPRhL_1ItDD0_vXTe_UuI,14906
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=R371waHsms4sllHCbijKYs90C-9Yu0sSR3N4SUfQOgU,5066
-alita_sdk-0.3.233.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.233.dist-info/METADATA,sha256=SnQfpYgQ6ClxxESrl0oE_3RKxWpQ-1ETR3HjiAjxqMs,18896
-alita_sdk-0.3.233.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.233.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.233.dist-info/RECORD,,
+alita_sdk-0.3.235.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.235.dist-info/METADATA,sha256=7_FPq7ypcRFMlmIGX072cg_pvaIwAqy--yLeipG3S7s,18896
+alita_sdk-0.3.235.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.235.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.235.dist-info/RECORD,,