alita-sdk 0.3.372__py3-none-any.whl → 0.3.374__py3-none-any.whl

alita_sdk/runtime/clients/artifact.py

@@ -4,7 +4,7 @@ from json import dumps
 import chardet
 import logging
 
-from alita_sdk.tools.utils.content_parser import parse_file_content
+from ...tools.utils.content_parser import parse_file_content
 
 logger = logging.getLogger(__name__)
 

alita_sdk/runtime/clients/sandbox_client.py

@@ -0,0 +1,365 @@
+import logging
+from typing import Dict, Optional
+from urllib.parse import quote
+
+import requests
+from typing import Any
+from json import dumps
+import chardet
+
+logger = logging.getLogger(__name__)
+
+
+class ApiDetailsRequestError(Exception):
+    ...
+
+
+class SandboxArtifact:
+    def __init__(self, client: Any, bucket_name: str):
+        self.client = client
+        self.bucket_name = bucket_name
+        if not self.client.bucket_exists(bucket_name):
+            self.client.create_bucket(bucket_name)
+
+    def create(self, artifact_name: str, artifact_data: Any, bucket_name: str = None):
+        try:
+            if not bucket_name:
+                bucket_name = self.bucket_name
+            return dumps(self.client.create_artifact(bucket_name, artifact_name, artifact_data))
+        except Exception as e:
+            logger.error(f'Error: {e}')
+            return f'Error: {e}'
+
+    def get(self,
+            artifact_name: str,
+            bucket_name: str = None,
+            is_capture_image: bool = False,
+            page_number: int = None,
+            sheet_name: str = None,
+            excel_by_sheets: bool = False,
+            llm=None):
+        if not bucket_name:
+            bucket_name = self.bucket_name
+        data = self.client.download_artifact(bucket_name, artifact_name)
+        if len(data) == 0:
+            # empty file might be created
+            return ''
+        if isinstance(data, dict) and data['error']:
+            return f'{data['error']}. {data['content'] if data['content'] else ''}'
+        detected = chardet.detect(data)
+        return data
+        # TODO: add proper handling for binary files (images, pdf, etc.) for sandbox
+        # if detected['encoding'] is not None:
+        #     try:
+        #         return data.decode(detected['encoding'])
+        #     except Exception:
+        #         logger.error('Error while default encoding')
+        #         return parse_file_content(file_name=artifact_name,
+        #                                   file_content=data,
+        #                                   is_capture_image=is_capture_image,
+        #                                   page_number=page_number,
+        #                                   sheet_name=sheet_name,
+        #                                   excel_by_sheets=excel_by_sheets,
+        #                                   llm=llm)
+        # else:
+        #     return parse_file_content(file_name=artifact_name,
+        #                               file_content=data,
+        #                               is_capture_image=is_capture_image,
+        #                               page_number=page_number,
+        #                               sheet_name=sheet_name,
+        #                               excel_by_sheets=excel_by_sheets,
+        #                               llm=llm)
+
+    def delete(self, artifact_name: str, bucket_name=None):
+        if not bucket_name:
+            bucket_name = self.bucket_name
+        self.client.delete_artifact(bucket_name, artifact_name)
+
+    def list(self, bucket_name: str = None, return_as_string=True) -> str | dict:
+        if not bucket_name:
+            bucket_name = self.bucket_name
+        artifacts = self.client.list_artifacts(bucket_name)
+        return str(artifacts) if return_as_string else artifacts
+
+    def append(self, artifact_name: str, additional_data: Any, bucket_name: str = None):
+        if not bucket_name:
+            bucket_name = self.bucket_name
+        data = self.get(artifact_name, bucket_name)
+        if data == 'Could not detect encoding':
+            return data
+        data += f'{additional_data}' if len(data) > 0 else additional_data
+        self.client.create_artifact(bucket_name, artifact_name, data)
+        return 'Data appended successfully'
+
+    def overwrite(self, artifact_name: str, new_data: Any, bucket_name: str = None):
+        if not bucket_name:
+            bucket_name = self.bucket_name
+        return self.create(artifact_name, new_data, bucket_name)
+
+    def get_content_bytes(self,
+                          artifact_name: str,
+                          bucket_name: str = None):
+        if not bucket_name:
+            bucket_name = self.bucket_name
+        return self.client.download_artifact(bucket_name, artifact_name)
+
+
+class SandboxClient:
+    def __init__(self,
+                 base_url: str,
+                 project_id: int,
+                 auth_token: str,
+                 api_extra_headers: Optional[dict] = None,
+                 configurations: Optional[list] = None,
+                 **kwargs):
+
+        self.base_url = base_url.rstrip('/')
+        self.api_path = '/api/v1'
+        self.llm_path = '/llm/v1'
+        self.project_id = project_id
+        self.auth_token = auth_token
+        self.headers = {
+            'Authorization': f'Bearer {auth_token}',
+            'X-SECRET': kwargs.get('XSECRET', 'secret')
+        }
+        if api_extra_headers is not None:
+            self.headers.update(api_extra_headers)
+        self.predict_url = f'{self.base_url}{self.api_path}/prompt_lib/predict/prompt_lib/{self.project_id}'
+        self.prompt_versions = f'{self.base_url}{self.api_path}/prompt_lib/version/prompt_lib/{self.project_id}'
+        self.prompts = f'{self.base_url}{self.api_path}/prompt_lib/prompt/prompt_lib/{self.project_id}'
+        self.datasources = f'{self.base_url}{self.api_path}/datasources/datasource/prompt_lib/{self.project_id}'
+        self.datasources_predict = f'{self.base_url}{self.api_path}/datasources/predict/prompt_lib/{self.project_id}'
+        self.datasources_search = f'{self.base_url}{self.api_path}/datasources/search/prompt_lib/{self.project_id}'
+        self.app = f'{self.base_url}{self.api_path}/applications/application/prompt_lib/{self.project_id}'
+        self.mcp_tools_list = f'{self.base_url}{self.api_path}/mcp_sse/tools_list/{self.project_id}'
+        self.mcp_tools_call = f'{self.base_url}{self.api_path}/mcp_sse/tools_call/{self.project_id}'
+        self.application_versions = f'{self.base_url}{self.api_path}/applications/version/prompt_lib/{self.project_id}'
+        self.list_apps_url = f'{self.base_url}{self.api_path}/applications/applications/prompt_lib/{self.project_id}'
+        self.integration_details = f'{self.base_url}{self.api_path}/integrations/integration/{self.project_id}'
+        self.secrets_url = f'{self.base_url}{self.api_path}/secrets/secret/{self.project_id}'
+        self.artifacts_url = f'{self.base_url}{self.api_path}/artifacts/artifacts/default/{self.project_id}'
+        self.artifact_url = f'{self.base_url}{self.api_path}/artifacts/artifact/default/{self.project_id}'
+        self.bucket_url = f'{self.base_url}{self.api_path}/artifacts/buckets/{self.project_id}'
+        self.configurations_url = f'{self.base_url}{self.api_path}/integrations/integrations/default/{self.project_id}?section=configurations&unsecret=true'
+        self.ai_section_url = f'{self.base_url}{self.api_path}/integrations/integrations/default/{self.project_id}?section=ai'
+        self.image_generation_url = f'{self.base_url}{self.llm_path}/images/generations'
+        self.configurations: list = configurations or []
+        self.model_timeout = kwargs.get('model_timeout', 120)
+        self.model_image_generation = kwargs.get('model_image_generation')
+
+    def get_mcp_toolkits(self):
+        if user_id := self._get_real_user_id():
+            url = f'{self.mcp_tools_list}/{user_id}'
+            data = requests.get(url, headers=self.headers, verify=False).json()
+            return data
+        else:
+            return []
+
+    def mcp_tool_call(self, params: dict[str, Any]):
+        if user_id := self._get_real_user_id():
+            url = f'{self.mcp_tools_call}/{user_id}'
+            #
+            # This loop iterates over each key-value pair in the arguments dictionary,
+            # and if a value is a Pydantic object, it replaces it with its dictionary representation using .dict().
+            for arg_name, arg_value in params.get('params', {}).get('arguments', {}).items():
+                if isinstance(arg_value, list):
+                    params['params']['arguments'][arg_name] = [
+                        item.dict() if hasattr(item, 'dict') and callable(item.dict) else item
+                        for item in arg_value
+                    ]
+                elif hasattr(arg_value, 'dict') and callable(arg_value.dict):
+                    params['params']['arguments'][arg_name] = arg_value.dict()
+            #
+            response = requests.post(url, headers=self.headers, json=params, verify=False)
+            try:
+                return response.json()
+            except (ValueError, TypeError):
+                return response.text
+        else:
+            return f'Error: Could not determine user ID for MCP tool call'
+
+    def get_app_details(self, application_id: int):
+        url = f'{self.app}/{application_id}'
+        data = requests.get(url, headers=self.headers, verify=False).json()
+        return data
+
+    def get_list_of_apps(self):
+        apps = []
+        limit = 10
+        offset = 0
+        total_count = None
+
+        while total_count is None or offset < total_count:
+            params = {'offset': offset, 'limit': limit}
+            resp = requests.get(self.list_apps_url, headers=self.headers, params=params, verify=False)
+
+            if resp.ok:
+                data = resp.json()
+                total_count = data.get('total')
+                apps.extend([{'name': app['name'], 'id': app['id']} for app in data.get('rows', [])])
+                offset += limit
+            else:
+                break
+
+        return apps
+
+    def fetch_available_configurations(self) -> list:
+        resp = requests.get(self.configurations_url, headers=self.headers, verify=False)
+        if resp.ok:
+            return resp.json()
+        return []
+
+    def all_models_and_integrations(self):
+        resp = requests.get(self.ai_section_url, headers=self.headers, verify=False)
+        if resp.ok:
+            return resp.json()
+        return []
+
+    def generate_image(self,
+                       prompt: str,
+                       n: int = 1,
+                       size: str = 'auto',
+                       quality: str = 'auto',
+                       response_format: str = 'b64_json',
+                       style: Optional[str] = None) -> dict:
+
+        if not self.model_image_generation:
+            raise ValueError('Image generation model is not configured for this client')
+
+        image_generation_data = {
+            'prompt': prompt,
+            'model': self.model_image_generation,
+            'n': n,
+            'response_format': response_format,
+        }
+
+        # Only add optional parameters if they have meaningful values
+        if size and size.lower() != 'auto':
+            image_generation_data['size'] = size
+
+        if quality and quality.lower() != 'auto':
+            image_generation_data['quality'] = quality
+
+        if style:
+            image_generation_data['style'] = style
+
+        # Standard headers for image generation
+        image_headers = self.headers.copy()
+        image_headers.update({
+            'Content-Type': 'application/json',
+        })
+
+        logger.info(f'Generating image with model: {self.model_image_generation}, prompt: {prompt[:50]}...')
+
+        try:
+            response = requests.post(
+                self.image_generation_url,
+                headers=image_headers,
+                json=image_generation_data,
+                verify=False,
+                timeout=self.model_timeout
+            )
+            response.raise_for_status()
+            return response.json()
+
+        except requests.exceptions.HTTPError as e:
+            logger.error(f'Image generation failed: {e.response.status_code} - {e.response.text}')
+            raise
+        except requests.exceptions.RequestException as e:
+            logger.error(f'Image generation request failed: {e}')
+            raise
+
+    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:
+            configs = self.configurations
+        else:
+            configs = self.fetch_available_configurations()
+
+        resp = requests.patch(url, headers=self.headers, verify=False, json={'configurations': configs})
+        if resp.ok:
+            return resp.json()
+        logger.error(f'Failed to fetch application version details: {resp.status_code} - {resp.text}.'
+                     f' Application ID: {application_id}, Version ID: {application_version_id}')
+        raise ApiDetailsRequestError(
+            f'Failed to fetch application version details for {application_id}/{application_version_id}.')
+
+    def get_integration_details(self, integration_id: str, format_for_model: bool = False):
+        url = f'{self.integration_details}/{integration_id}'
+        data = requests.get(url, headers=self.headers, verify=False).json()
+        return data
+
+    def unsecret(self, secret_name: str):
+        url = f'{self.secrets_url}/{secret_name}'
+        data = requests.get(url, headers=self.headers, verify=False).json()
+        logger.info(f'Unsecret response: {data}')
+        return data.get('value', None)
+
+    def artifact(self, bucket_name):
+        return SandboxArtifact(self, bucket_name)
+
+    def _process_requst(self, data: requests.Response) -> Dict[str, str]:
+        if data.status_code == 403:
+            return {'error': 'You are not authorized to access this resource'}
+        elif data.status_code == 404:
+            return {'error': 'Resource not found'}
+        elif data.status_code != 200:
+            return {
+                'error': 'An error occurred while fetching the resource',
+                'content': data.text
+            }
+        else:
+            return data.json()
+
+    def bucket_exists(self, bucket_name):
+        try:
+            resp = self._process_requst(
+                requests.get(f'{self.bucket_url}', headers=self.headers, verify=False)
+            )
+            for each in resp.get('rows', []):
+                if each['name'] == bucket_name:
+                    return True
+            return False
+        except:
+            return False
+
+    def create_bucket(self, bucket_name, expiration_measure='months', expiration_value=1):
+        post_data = {
+            'name': bucket_name,
+            'expiration_measure': expiration_measure,
+            'expiration_value': expiration_value
+        }
+        resp = requests.post(f'{self.bucket_url}', headers=self.headers, json=post_data, verify=False)
+        return self._process_requst(resp)
+
+    def list_artifacts(self, bucket_name: str):
+        # Ensure bucket name is lowercase as required by the API
+        url = f'{self.artifacts_url}/{bucket_name.lower()}'
+        data = requests.get(url, headers=self.headers, verify=False)
+        return self._process_requst(data)
+
+    def create_artifact(self, bucket_name, artifact_name, artifact_data):
+        url = f'{self.artifacts_url}/{bucket_name.lower()}'
+        data = requests.post(url, headers=self.headers, files={
+            'file': (artifact_name, artifact_data)
+        }, verify=False)
+        return self._process_requst(data)
+
+    def download_artifact(self, bucket_name, artifact_name):
+        url = f'{self.artifact_url}/{bucket_name.lower()}/{artifact_name}'
+        data = requests.get(url, headers=self.headers, verify=False)
+        if data.status_code == 403:
+            return {'error': 'You are not authorized to access this resource'}
+        elif data.status_code == 404:
+            return {'error': 'Resource not found'}
+        elif data.status_code != 200:
+            return {
+                'error': 'An error occurred while fetching the resource',
+                'content': data.content
+            }
+        return data.content
+
+    def delete_artifact(self, bucket_name, artifact_name):
+        url = f'{self.artifact_url}/{bucket_name}'
+        data = requests.delete(url, headers=self.headers, verify=False, params={'filename': quote(artifact_name)})
+        return self._process_requst(data)

alita_sdk/runtime/langchain/assistant.py

@@ -314,7 +314,8 @@ class Assistant:
             memory=checkpointer,
             store=self.store,
             debug=False,
-            for_subgraph=False
+            for_subgraph=False,
+            alita_client=self.alita_client
         )
         
         return agent
@@ -328,7 +329,8 @@ class Assistant:
         #
         agent = create_graph(
             client=self.client, tools=self.tools,
-            yaml_schema=self.prompt, memory=memory
+            yaml_schema=self.prompt, memory=memory,
+            alita_client=self.alita_client
         )
         #
         return agent

alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -30,10 +30,18 @@ from enum import Enum
 
 
 class LoaderProperties(Enum):
-    LLM = 'llm'
+    LLM = 'use_llm'
+    PROMPT_DEFAULT = 'use_default_prompt'
     PROMPT = 'prompt'
-    PROMPT_DEFAULT = 'prompt_default'
 
+DEFAULT_ALLOWED_BASE = {'max_tokens': 512}
+
+DEFAULT_ALLOWED_WITH_LLM = {
+    **DEFAULT_ALLOWED_BASE,
+    LoaderProperties.LLM.value: False,
+    LoaderProperties.PROMPT_DEFAULT.value: False,
+    LoaderProperties.PROMPT.value: "",
+}
 
 # Image file loaders mapping
 image_loaders_map = {
@@ -42,66 +50,42 @@ image_loaders_map = {
         'mime_type': 'image/png',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ],
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM,
     },
     '.jpg': {
         'class': AlitaImageLoader,
         'mime_type': 'image/jpeg',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.jpeg': {
         'class': AlitaImageLoader,
         'mime_type': 'image/jpeg',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.gif': {
         'class': AlitaImageLoader,
         'mime_type': 'image/gif',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.bmp': {
         'class': AlitaImageLoader,
         'mime_type': 'image/bmp',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.svg': {
         'class': AlitaImageLoader,
         'mime_type': 'image/svg+xml',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     }
 }
 
@@ -114,7 +98,7 @@ document_loaders_map = {
         'kwargs': {
             'autodetect_encoding': True
         },
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.yml': {
         'class': AlitaTextLoader,
@@ -123,7 +107,7 @@ document_loaders_map = {
         'kwargs': {
             'autodetect_encoding': True
         },
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.yaml': {
         'class': AlitaTextLoader,
@@ -132,7 +116,7 @@ document_loaders_map = {
         'kwargs': {
             'autodetect_encoding': True
         },
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.groovy': {
         'class': AlitaTextLoader,
@@ -141,14 +125,14 @@ document_loaders_map = {
         'kwargs': {
             'autodetect_encoding': True
         },
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.md': {
         'class': AlitaMarkdownLoader,
         'mime_type': 'text/markdown',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.csv': {
         'class': AlitaCSVLoader,
@@ -159,7 +143,7 @@ document_loaders_map = {
             'raw_content': True,
             'cleanse': False
         },
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.xlsx': {
         'class': AlitaExcelLoader,
@@ -171,11 +155,7 @@ document_loaders_map = {
             'raw_content': True,
             'cleanse': False
         },
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.xls': {
         'class': AlitaExcelLoader,
@@ -186,22 +166,14 @@ document_loaders_map = {
             'raw_content': True,
             'cleanse': False
         },
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.pdf': {
         'class': AlitaPDFLoader,
         'mime_type': 'application/pdf',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.docx': {
         'class': AlitaDocxMammothLoader,
@@ -211,58 +183,42 @@ document_loaders_map = {
         'kwargs': {
             'extract_images': True
         },
-        'allowed_to_override': [
-            'max_tokens', 'mode', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': {**DEFAULT_ALLOWED_WITH_LLM, 'mode': 'paged'}
     },
     '.json': {
         'class': AlitaJSONLoader,
         'mime_type': 'application/json',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.jsonl': {
         'class': AirbyteJSONLoader,
         'mime_type': 'application/jsonl',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.htm': {
         'class': UnstructuredHTMLLoader,
         'mime_type': 'text/html',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.html': {
         'class': UnstructuredHTMLLoader,
         'mime_type': 'text/html',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.xml': {
         'class': UnstructuredXMLLoader,
         'mime_type': 'text/xml',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.ppt': {
         'class': AlitaPowerPointLoader,
@@ -271,11 +227,7 @@ document_loaders_map = {
         'kwargs': {
             'mode': 'paged'
         },
-        'allowed_to_override': [
-            'max_tokens', 'mode', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': {**DEFAULT_ALLOWED_WITH_LLM, 'mode': 'paged'}
     },
     '.pptx': {
         'class': AlitaPowerPointLoader,
@@ -285,20 +237,19 @@ document_loaders_map = {
         'kwargs': {
             'mode': 'paged'
         },
-        'allowed_to_override': [
-            'max_tokens', 'mode', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value,
-            "pages_per_chunk",
-            "extract_images"
-        ]
+        'allowed_to_override': {
+            **DEFAULT_ALLOWED_WITH_LLM,
+            'mode': 'paged',
+            'pages_per_chunk': 5,
+            'extract_images': False,
+        }
     },
     '.py': {
         'class': AlitaPythonLoader,
         'mime_type': 'text/x-python',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     }
 }
 
@@ -335,10 +286,16 @@ default_loader_config = {
     'mime_type': 'text/plain',
     'is_multimodal_processing': False,
     'kwargs': {},
-    'allowed_to_override': ['max_tokens']
+    'allowed_to_override': DEFAULT_ALLOWED_BASE
 }
 
 code_loaders_map = {ext: default_loader_config for ext in code_extensions}
 
 # Combined mapping for backward compatibility
 loaders_map = {**image_loaders_map, **document_loaders_map, **code_loaders_map}
+
+loaders_allowed_to_override = {
+    extension: config.get('allowed_to_override')
+    for extension, config in loaders_map.items()
+    if 'allowed_to_override' in config
+}

alita_sdk/runtime/langchain/langraph_agent.py

@@ -553,6 +553,18 @@ def create_graph(
                                 input_variables=node.get('input', ['messages']),
                                 structured_output=node.get('structured_output', False)))
                         break
+            elif node_type == 'code':
+                from ..tools.sandbox import create_sandbox_tool
+                sandbox_tool = create_sandbox_tool(stateful=False, allow_net=True)
+                code = node.get('code', "return 'Code block is empty'")
+                lg_builder.add_node(node_id, FunctionTool(
+                    tool=sandbox_tool, name=node['id'], return_type='dict',
+                    output_variables=node.get('output', []),
+                    input_mapping={'code': {'type': 'fixed', 'value': code}},
+                    input_variables=node.get('input', ['messages']),
+                    structured_output=node.get('structured_output', False),
+                    alita_client=kwargs.get('alita_client', None)
+                ))
             elif node_type == 'llm':
                 output_vars = node.get('output', [])
                 output_vars_dict = {

alita_sdk/runtime/tools/function.py

@@ -1,4 +1,6 @@
+import json
 import logging
+from copy import deepcopy
 from json import dumps
 
 from langchain_core.callbacks import dispatch_custom_event
@@ -8,6 +10,7 @@ from langchain_core.tools import BaseTool, ToolException
 from typing import Any, Optional, Union, Annotated
 from langchain_core.utils.function_calling import convert_to_openai_tool
 from pydantic import ValidationError
+
 from ..langchain.utils import propagate_the_input_mapping
 
 logger = logging.getLogger(__name__)
@@ -21,6 +24,63 @@ class FunctionTool(BaseTool):
     input_variables: Optional[list[str]] = None
     input_mapping: Optional[dict[str, dict]] = None
     output_variables: Optional[list[str]] = None
+    structured_output: Optional[bool] = False
+    alita_client: Optional[Any] = None
+
+    def _prepare_pyodide_input(self, state: Union[str, dict, ToolCall]) -> str:
+        """Prepare input for PyodideSandboxTool by injecting state into the code block."""
+        # add state into the code block here since it might be changed during the execution of the code
+        state_copy = deepcopy(state)
+        # pickle state
+        import pickle
+
+        del state_copy['messages']  # remove messages to avoid issues with pickling without langchain-core
+        serialized_state = pickle.dumps(state_copy)
+        # inject state into the code block as alita_state variable
+        pyodide_predata = f"""import pickle\nalita_state = pickle.loads({serialized_state})\n"""
+        # add classes related to sandbox client
+        # read the content of alita_sdk/runtime/cliens/sandbox_client.py
+        try:
+            with open('alita_sdk/runtime/clients/sandbox_client.py', 'r') as f:
+                sandbox_client_code = f.read()
+            pyodide_predata += f"\n{sandbox_client_code}\n"
+            pyodide_predata += (f"alita_client = SandboxClient(base_url='{self.alita_client.base_url}',"
+                                f"project_id={self.alita_client.project_id},"
+                                f"auth_token='{self.alita_client.auth_token}')")
+        except FileNotFoundError:
+            logger.error("sandbox_client.py not found. Ensure 'alita_sdk/runtime/clients/sandbox_client.py' exists.")
+        return pyodide_predata
+
+    def _handle_pyodide_output(self, tool_result: Any) -> dict:
+        """Handle output processing for PyodideSandboxTool results."""
+        tool_result_converted = {}
+
+        if self.output_variables:
+            for var in self.output_variables:
+                if isinstance(tool_result, dict) and var in tool_result:
+                    tool_result_converted[var] = tool_result[var]
+                else:
+                    # handler in case user points to a var that is not in the output of the tool
+                    tool_result_converted[var] = tool_result.get('result',
+                                                                 tool_result.get('error') if tool_result.get('error')
+                                                                 else 'Execution result is missing')
+        else:
+            tool_result_converted.update({"messages": [{"role": "assistant", "content": dumps(tool_result)}]})
+
+        if self.structured_output:
+            # execute code tool and update state variables
+            try:
+                result_value = tool_result.get('result', {})
+                tool_result_converted.update(result_value if isinstance(result_value, dict)
+                                           else json.loads(result_value))
+            except json.JSONDecodeError:
+                logger.error(f"JSONDecodeError: {tool_result}")
+
+        return tool_result_converted
+
+    def _is_pyodide_tool(self) -> bool:
+        """Check if the current tool is a PyodideSandboxTool."""
+        return self.tool.name.lower() == 'pyodide_sandbox'
 
     def invoke(
             self,
@@ -31,8 +91,14 @@ class FunctionTool(BaseTool):
         params = convert_to_openai_tool(self.tool).get(
             'function', {'parameters': {}}).get(
             'parameters', {'properties': {}}).get('properties', {})
+
         func_args = propagate_the_input_mapping(input_mapping=self.input_mapping, input_variables=self.input_variables,
                                                 state=state)
+
+        # special handler for PyodideSandboxTool
+        if self._is_pyodide_tool():
+            code = func_args['code']
+            func_args['code'] = f"{self._prepare_pyodide_input(state)}\n{code}"
         try:
             tool_result = self.tool.invoke(func_args, config, **kwargs)
             dispatch_custom_event(
@@ -44,6 +110,11 @@ class FunctionTool(BaseTool):
                 }, config=config
             )
             logger.info(f"ToolNode response: {tool_result}")
+
+            # handler for PyodideSandboxTool
+            if self._is_pyodide_tool():
+                return self._handle_pyodide_output(tool_result)
+
             if not self.output_variables:
                 return {"messages": [{"role": "assistant", "content": dumps(tool_result)}]}
             else:

alita_sdk/runtime/tools/sandbox.py

@@ -1,10 +1,10 @@
-import logging
 import asyncio
+import logging
 import subprocess
 import os
-from typing import Any, Type, Optional, Union, Dict
+from typing import Any, Type, Optional, Dict
 from langchain_core.tools import BaseTool
-from pydantic import BaseModel, Field, create_model
+from pydantic import BaseModel, create_model
 from pydantic.fields import FieldInfo
 
 logger = logging.getLogger(__name__)
@@ -190,30 +190,28 @@ class PyodideSandboxTool(BaseTool):
                 self.session_bytes = result.session_bytes
                 self.session_metadata = result.session_metadata
             
-            # Format the output
-            output_parts = []
-            
+            result_dict = {}
+
             if result.result is not None:
-                output_parts.append(f"Result: {result.result}")
-            
+                result_dict["result"] = result.result
+
             if result.stdout:
-                output_parts.append(f"Output: {result.stdout}")
-            
+                result_dict["output"] = result.stdout
+
             if result.stderr:
-                output_parts.append(f"Error: {result.stderr}")
-            
+                result_dict["error"] = result.stderr
+
             if result.status == 'error':
-                output_parts.append(f"Execution failed with status: {result.status}")
-            
+                result_dict["status"] = "Execution failed"
+
             execution_info = f"Execution time: {result.execution_time:.2f}s"
             if result.session_metadata and 'packages' in result.session_metadata:
                 packages = result.session_metadata.get('packages', [])
                 if packages:
                     execution_info += f", Packages: {', '.join(packages)}"
-            
-            output_parts.append(execution_info)
-            
-            return "\n".join(output_parts) if output_parts else "Code executed successfully (no output)"
+
+            result_dict["execution_info"] = execution_info
+            return result_dict
             
         except Exception as e:
             logger.error(f"Error executing code in sandbox: {e}")

alita_sdk/runtime/tools/vectorstore_base.py

@@ -177,6 +177,37 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
             except Exception as e:
                 logger.error(f"Failed to initialize PGVectorSearch: {str(e)}")
 
+    def _similarity_search_with_score(self, query: str, filter: dict = None, k: int = 10):
+        """
+        Perform similarity search with proper exception handling for DataException.
+
+        Args:
+            query: Search query string
+            filter: Optional filter dictionary
+            k: Number of results to return
+
+        Returns:
+            List of (Document, score) tuples
+
+        Raises:
+            ToolException: When DataException occurs or other search errors
+        """
+        try:
+            return self.vectorstore.similarity_search_with_score(
+                query, filter=filter, k=k
+            )
+        except DataException as dimException:
+            exception_str = str(dimException)
+            if 'different vector dimensions' in exception_str:
+                logger.error(f"Data exception: {exception_str}")
+                raise ToolException(f"Global search cannot be completed since collections were indexed using "
+                                    f"different embedding models. Use search within a single collection."
+                                    f"\nDetails: {exception_str}")
+            raise ToolException(f"Data exception during search. Possibly invalid filter: {exception_str}")
+        except Exception as e:
+            logger.error(f"Error during similarity search: {str(e)}")
+            raise ToolException(f"Search failed: {str(e)}")
+
     def list_collections(self) -> List[str]:
         """List all collections in the vectorstore."""
 
@@ -311,7 +342,7 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
                 }
                 
             try:
-                document_items = self.vectorstore.similarity_search_with_score(
+                document_items = self._similarity_search_with_score(
                     query, filter=document_filter, k=search_top
                 )                
                 # Add document results to unique docs
@@ -324,15 +355,6 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
                     if doc_id not in unique_docs or score > chunk_type_scores.get(doc_id, 0):
                         unique_docs[doc_id] = doc
                         chunk_type_scores[doc_id] = score
-            except DataException as dimException:
-                exception_str = str(dimException)
-                if 'different vector dimensions' in exception_str:
-                    logger.error(f"Data exception: {exception_str}")
-                    raise ToolException(f"Global search cannot be completed since collections were indexed using "
-                                        f"different embedding models. Use search within a single collection."
-                                        f"\nDetails: {exception_str}")
-                raise ToolException(f"Data exception during search. Possibly invalid filter: {exception_str}")
-
             except Exception as e:
                 logger.warning(f"Error searching for document chunks: {str(e)}")
             
@@ -353,18 +375,16 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
                     }
                 
                 try:
-                    chunk_items = self.vectorstore.similarity_search_with_score(
+                    chunk_items = self._similarity_search_with_score(
                         query, filter=chunk_filter, k=search_top
                     )
-                    
-                    logger.debug(f"Chunk items for {chunk_type}: {chunk_items[0]}")
-                    
+
                     for doc, score in chunk_items:
                         # Create unique identifier for document
                         source = doc.metadata.get('source')
                         chunk_id = doc.metadata.get('chunk_id')
                         doc_id = f"{source}_{chunk_id}" if source and chunk_id else str(doc.metadata.get('id', id(doc)))
-                        
+
                         # Store document and its score
                         if doc_id not in unique_docs:
                             unique_docs[doc_id] = doc
@@ -384,9 +404,9 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
                                 doc_filter = {
                                     "$and": doc_filter_parts
                                 }
-                                
+
                             try:
-                                fetch_items = self.vectorstore.similarity_search_with_score(
+                                fetch_items = self._similarity_search_with_score(
                                     query, filter=doc_filter, k=1
                                 )
                                 if fetch_items:
@@ -400,7 +420,7 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
         else:
             # Default search behavior (unchanged)
             max_search_results = 30 if search_top * 3 > 30 else search_top * 3
-            vector_items = self.vectorstore.similarity_search_with_score(
+            vector_items = self._similarity_search_with_score(
                 query, filter=filter, k=max_search_results
             )
             
@@ -418,7 +438,7 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
         doc_map = OrderedDict(
             sorted(doc_map.items(), key=lambda x: x[1][1], reverse=True)
         )
-        
+
         # Process full-text search if configured
         if full_text_search and full_text_search.get('enabled') and full_text_search.get('fields'):
             language = full_text_search.get('language', 'english')
@@ -431,7 +451,7 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
                 for field_name in full_text_search.get('fields', []):
                     try:
                         text_results = self.pg_helper.full_text_search(field_name, query)
-                        
+
                         # Combine text search results with vector results
                         for result in text_results:
                             doc_id = result['id']

alita_sdk/tools/base_indexer_toolkit.py

@@ -7,8 +7,10 @@ from typing import Any, Optional, List, Dict, Generator
 from langchain_core.documents import Document
 from pydantic import create_model, Field, SecretStr
 
+from .utils import make_json_serializable
 from .utils.content_parser import file_extension_by_chunker, process_document_by_type
 from .vector_adapters.VectorStoreAdapter import VectorStoreAdapterFactory
+from ..runtime.langchain.document_loaders.constants import loaders_allowed_to_override
 from ..runtime.tools.vectorstore_base import VectorStoreWrapperBase
 from ..runtime.utils.utils import IndexerKeywords
 
@@ -93,7 +95,7 @@ BaseIndexDataParams = create_model(
                        description="Optional flag to enforce clean existing index before indexing new data")),
     progress_step=(Optional[int], Field(default=10, ge=0, le=100,
                          description="Optional step size for progress reporting during indexing")),
-    chunking_config=(Optional[dict], Field(description="Chunking tool configuration", default_factory=dict)),
+    chunking_config=(Optional[dict], Field(description="Chunking tool configuration", default=loaders_allowed_to_override)),
 )
 
 

alita_sdk/tools/utils/__init__.py

@@ -97,3 +97,20 @@ def check_connection_response(check_fun):
         else:
             return f"Service Unreachable: return code {response.status_code}"
     return _wrapper
+
+
+def make_json_serializable(obj):
+    if isinstance(obj, BaseModel):
+        return obj.model_dump()
+    if isinstance(obj, dict):
+        return {k: make_json_serializable(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [make_json_serializable(i) for i in obj]
+    if isinstance(obj, bool):
+        return bool(obj)
+    if isinstance(obj, (str, int, float)) or obj is None:
+        return obj
+    # Fallback: handle objects that look like booleans but were not caught above
+    if str(obj) in ("True", "False"):
+        return str(obj) == "True"
+    return str(obj)

alita_sdk/tools/utils/content_parser.py

@@ -262,18 +262,18 @@ def process_content_by_type(content, filename: str, llm=None, chunking_config=No
                 loader_kwargs = loader_config['kwargs']
                 # Determine which loader configuration keys are allowed to be overridden by user input.
                 # If 'allowed_to_override' is specified in the loader configuration, use it; otherwise, allow all keys in loader_kwargs.
-                allowed_to_override = loader_config.get('allowed_to_override', list(loader_kwargs.keys()))
+                allowed_to_override = loader_config.get('allowed_to_override', loader_kwargs)
                 # If a chunking_config is provided and contains custom configuration for the current file extension,
-                # update loader_kwargs with user-supplied values, but only for keys explicitly permitted in allowed_to_override.
+                # update loader_kwargs with user-supplied values, but only for keys explicitly permitted in allowed_to_override and if value differs from default.
                 # This ensures that only safe and intended parameters can be customized, preventing accidental or unauthorized changes
                 # to critical loader settings.
                 if chunking_config and (users_config_for_extension := chunking_config.get(extension, {})):
-                    for key in set(users_config_for_extension.keys()) & set(allowed_to_override):
-                        loader_kwargs[key] = users_config_for_extension[key]
-                if LoaderProperties.LLM.value in loader_kwargs:
-                    loader_kwargs[LoaderProperties.LLM.value] = llm
-                if LoaderProperties.PROMPT_DEFAULT.value in loader_kwargs:
-                    loader_kwargs.pop(LoaderProperties.PROMPT_DEFAULT.value)
+                    for key in set(users_config_for_extension.keys()) & set(allowed_to_override.keys()):
+                        if users_config_for_extension[key] != allowed_to_override[key]:
+                            loader_kwargs[key] = users_config_for_extension[key]
+                if LoaderProperties.LLM.value in loader_kwargs and loader_kwargs.pop(LoaderProperties.LLM.value):
+                    loader_kwargs['llm'] = llm
+                if LoaderProperties.PROMPT_DEFAULT.value in loader_kwargs and loader_kwargs.pop(LoaderProperties.PROMPT_DEFAULT.value):
                     loader_kwargs[LoaderProperties.PROMPT.value] = image_processing_prompt
                 loader = loader_cls(file_path=temp_file_path, **loader_kwargs)
                 yield from loader.load()

{alita_sdk-0.3.372.dist-info → alita_sdk-0.3.374.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.372
+Version: 0.3.374
 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 <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.372.dist-info → alita_sdk-0.3.374.dist-info}/RECORD

@@ -35,16 +35,17 @@ alita_sdk/configurations/zephyr_enterprise.py,sha256=UaBk3qWcT2-bCzko5HEPvgxArw1
 alita_sdk/configurations/zephyr_essential.py,sha256=tUIrh-PRNvdrLBj6rJXqlF-h6oaMXUQI1wgit07kFBw,752
 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=Tt3aWcxu20bVW6EX7s_iX5CTmcItKhUnkk8Q2gv2vw0,4036
+alita_sdk/runtime/clients/artifact.py,sha256=b7hVuGRROt6qUcT11uAZqzJqslzmlgW-Y6oGsiwNmjI,4029
 alita_sdk/runtime/clients/client.py,sha256=BIF6QSnhlTfsTQ_dQs-QZjeBJHZsOtSuv_q7_ABUUQg,45737
 alita_sdk/runtime/clients/datasource.py,sha256=HAZovoQN9jBg0_-lIlGBQzb4FJdczPhkHehAiVG3Wx0,1020
 alita_sdk/runtime/clients/prompt.py,sha256=li1RG9eBwgNK_Qf0qUaZ8QNTmsncFrAL2pv3kbxZRZg,1447
+alita_sdk/runtime/clients/sandbox_client.py,sha256=OhEasE0MxBBDw4o76xkxVCpNpr3xJ8spQsrsVxMrjUA,16192
 alita_sdk/runtime/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-alita_sdk/runtime/langchain/assistant.py,sha256=AKZ7LyYHrkwA3F987NgemHhrWAlZk18qt4N85CxqFyU,15426
+alita_sdk/runtime/langchain/assistant.py,sha256=YsxYNoaEidV02VlPwccdHP7PKeRRPp9M3tvUiYIDQ-I,15514
 alita_sdk/runtime/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
 alita_sdk/runtime/langchain/constants.py,sha256=eHVJ_beJNTf1WJo4yq7KMK64fxsRvs3lKc34QCXSbpk,3319
 alita_sdk/runtime/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
-alita_sdk/runtime/langchain/langraph_agent.py,sha256=oJg-k2wWfaa77zjG5Uvcw8CtXUZXbgbSjvRNjIIT84g,47769
+alita_sdk/runtime/langchain/langraph_agent.py,sha256=R4h_m_7NUgays7lt-F9WvKEOnGr1Yz7OgrmLMiGxurQ,48530
 alita_sdk/runtime/langchain/mixedAgentParser.py,sha256=M256lvtsL3YtYflBCEp-rWKrKtcY1dJIyRGVv7KW9ME,2611
 alita_sdk/runtime/langchain/mixedAgentRenderes.py,sha256=asBtKqm88QhZRILditjYICwFVKF5KfO38hu2O-WrSWE,5964
 alita_sdk/runtime/langchain/store_manager.py,sha256=i8Fl11IXJhrBXq1F1ukEVln57B1IBe-tqSUvfUmBV4A,2218
@@ -70,7 +71,7 @@ alita_sdk/runtime/langchain/document_loaders/AlitaTableLoader.py,sha256=EO1nJDRP
 alita_sdk/runtime/langchain/document_loaders/AlitaTextLoader.py,sha256=EiCIAF_OxSrbuwgOFk2IpxRMvFbctITt2jAI0g_atpk,3586
 alita_sdk/runtime/langchain/document_loaders/ImageParser.py,sha256=RQ4zGdSw42ec8c6Eb48uFadayWuiT4FbwhGVwhSw60s,1065
 alita_sdk/runtime/langchain/document_loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-alita_sdk/runtime/langchain/document_loaders/constants.py,sha256=XUNC63S7U2HjE_1sxyDTUcwCVMeE4KBuW_G9wU5IQmw,10462
+alita_sdk/runtime/langchain/document_loaders/constants.py,sha256=L8sgQsD5LH8kMSWEnGkc00j5FsC2VZQcUV95jpnbQlQ,9007
 alita_sdk/runtime/langchain/document_loaders/utils.py,sha256=9xghESf3axBbwxATyVuS0Yu-TWe8zWZnXgCD1ZVyNW0,2414
 alita_sdk/runtime/langchain/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/langchain/interfaces/kwextractor.py,sha256=kSJA9L8g8UArmHu7Bd9dIO0Rrq86JPUb8RYNlnN68FQ,3072
@@ -109,7 +110,7 @@ alita_sdk/runtime/tools/application.py,sha256=z3vLZODs-_xEEnZFmGF0fKz1j3VtNJxqsA
 alita_sdk/runtime/tools/artifact.py,sha256=u3szFwZqguHrPZ3tZJ7S_TiZl7cxlT3oHYd6zbdpRDE,13842
 alita_sdk/runtime/tools/datasource.py,sha256=pvbaSfI-ThQQnjHG-QhYNSTYRnZB0rYtZFpjCfpzxYI,2443
 alita_sdk/runtime/tools/echo.py,sha256=spw9eCweXzixJqHnZofHE1yWiSUa04L4VKycf3KCEaM,486
-alita_sdk/runtime/tools/function.py,sha256=0iZJ-UxaPbtcXAVX9G5Vsn7vmD7lrz3cBG1qylto1gs,2844
+alita_sdk/runtime/tools/function.py,sha256=0JL9D9NP31uzZ1G5br4Dhfop77l1wiqjx-7L8PHK4PA,6349
 alita_sdk/runtime/tools/graph.py,sha256=MbnZYqdmvZY7SGDp43lOVVIjUt5ARHSgj43mdtBjSjQ,3092
 alita_sdk/runtime/tools/image_generation.py,sha256=8ZH4SoRrbS4EzmtF6cpNMRvuFephCYD2S8uqNC9KGE4,4274
 alita_sdk/runtime/tools/indexer_tool.py,sha256=whSLPevB4WD6dhh2JDXEivDmTvbjiMV1MrPl9cz5eLA,4375
@@ -120,10 +121,10 @@ alita_sdk/runtime/tools/mcp_server_tool.py,sha256=MhLxZJ44LYrB_0GrojmkyqKoDRaqIH
 alita_sdk/runtime/tools/pgvector_search.py,sha256=NN2BGAnq4SsDHIhUcFZ8d_dbEOM8QwB0UwpsWCYruXU,11692
 alita_sdk/runtime/tools/prompt.py,sha256=nJafb_e5aOM1Rr3qGFCR-SKziU9uCsiP2okIMs9PppM,741
 alita_sdk/runtime/tools/router.py,sha256=p7e0tX6YAWw2M2Nq0A_xqw1E2P-Xz1DaJvhUstfoZn4,1584
-alita_sdk/runtime/tools/sandbox.py,sha256=WNz-aUMtkGCPg84dDy_0BPkyp-6YjoYB-xjIEFFrtKw,11601
+alita_sdk/runtime/tools/sandbox.py,sha256=0OjCNsDVO1N0cFNEFVr6GVICSaqGWesUzF6LcYg-Hn0,11349
 alita_sdk/runtime/tools/tool.py,sha256=lE1hGi6qOAXG7qxtqxarD_XMQqTghdywf261DZawwno,5631
 alita_sdk/runtime/tools/vectorstore.py,sha256=8vRhi1lGFEs3unvnflEi2p59U2MfV32lStpEizpDms0,34467
-alita_sdk/runtime/tools/vectorstore_base.py,sha256=WF-v3sGQKo9q8D8ULyuBo5dPdFcx79X0DCRjyoOd7DI,27844
+alita_sdk/runtime/tools/vectorstore_base.py,sha256=wixvgLrC2tQOeIjFMCD-7869K7YfERzk2Tzmo-fgsTE,28350
 alita_sdk/runtime/utils/AlitaCallback.py,sha256=E4LlSBuCHWiUq6W7IZExERHZY0qcmdjzc_rJlF2iQIw,7356
 alita_sdk/runtime/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/utils/constants.py,sha256=Xntx1b_uxUzT4clwqHA_U6K8y5bBqf_4lSQwXdcWrp4,13586
@@ -135,7 +136,7 @@ alita_sdk/runtime/utils/toolkit_runtime.py,sha256=MU63Fpxj0b5_r1IUUc0Q3-PN9VwL7r
 alita_sdk/runtime/utils/toolkit_utils.py,sha256=I9QFqnaqfVgN26LUr6s3XlBlG6y0CoHURnCzG7XcwVs,5311
 alita_sdk/runtime/utils/utils.py,sha256=BVEVLkYiiotcUD0XsHyx-wACpHfALsQg7PLZpObqvK8,1008
 alita_sdk/tools/__init__.py,sha256=jUj1ztC2FbkIUB-YYmiqaz_rqW7Il5kWzDPn1mJmj5w,10545
-alita_sdk/tools/base_indexer_toolkit.py,sha256=GpeIYY7kJZCjv0-gGcHNStY0uCtEBRl-I5XiISM0Tdo,26900
+alita_sdk/tools/base_indexer_toolkit.py,sha256=R8PQ1FZijtCT6LPuma68B1X6x0umH7gyROKwtp0xabw,27044
 alita_sdk/tools/code_indexer_toolkit.py,sha256=6QvI1by0OFdnKTx5TfNoDJjnMrvnTi9T56xaDxzeleU,7306
 alita_sdk/tools/elitea_base.py,sha256=up3HshASSDfjlHV_HPrs1aD4JIwwX0Ug26WGTzgIYvY,34724
 alita_sdk/tools/non_code_indexer_toolkit.py,sha256=B3QvhpT1F9QidkCcsOi3J_QrTOaNlTxqWFwe90VivQQ,1329
@@ -328,9 +329,9 @@ alita_sdk/tools/testio/__init__.py,sha256=NEvQtzsffqAXryaffVk0GpdcxZQ1AMkfeztnxH
 alita_sdk/tools/testio/api_wrapper.py,sha256=BvmL5h634BzG6p7ajnQLmj-uoAw1gjWnd4FHHu1h--Q,21638
 alita_sdk/tools/testrail/__init__.py,sha256=Xg4nVjULL_D8JpIXLYXppnwUfGF4-lguFwKHmP5VwxM,4696
 alita_sdk/tools/testrail/api_wrapper.py,sha256=tQcGlFJmftvs5ZiO4tsP19fCo4CrJeq_UEvQR1liVfE,39891
-alita_sdk/tools/utils/__init__.py,sha256=W9rCCUPtHCP5nGAbWp0n5jaNA84572aiRoqKneBnaS4,3330
+alita_sdk/tools/utils/__init__.py,sha256=xB9OQgW65DftadrSpoAAitnEIbIXZKBOCji0NDe7FRM,3923
 alita_sdk/tools/utils/available_tools_decorator.py,sha256=IbrdfeQkswxUFgvvN7-dyLMZMyXLiwvX7kgi3phciCk,273
-alita_sdk/tools/utils/content_parser.py,sha256=TuKAPUzIZx9F-pzHiVyrCFpI5emrGaOF8DgWHJP2cM4,15235
+alita_sdk/tools/utils/content_parser.py,sha256=7ohj8HeL_-rmc-Fv0TS8IpxIQC8tOpfuhyT3XlWx-gQ,15368
 alita_sdk/tools/vector_adapters/VectorStoreAdapter.py,sha256=p_9Cu5eausnfiKNsitbVxwu5eimZHRv3R-OMw7lBrts,19173
 alita_sdk/tools/vector_adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/tools/xray/__init__.py,sha256=eOMWP8VamFbbJgt1xrGpGPqB9ByOTA0Cd3LCaETzGk4,4376
@@ -352,8 +353,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=kT0TbmMvuKhDUZc0i7KO18O38JM9S
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=0ne8XLJEQSLOWfzd2HdnqOYmQlUliKHbBED5kW_Vias,2895
 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.372.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.372.dist-info/METADATA,sha256=A3hNTePpqTE8uzQhDG7RbgX5Iv7MoyOYgkucgkqKEpI,19071
-alita_sdk-0.3.372.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.372.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.372.dist-info/RECORD,,
+alita_sdk-0.3.374.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.374.dist-info/METADATA,sha256=b-L7XNDZ_LNpW-hoB_pDqOchYCdw9fOUStiXnQfSxUM,19071
+alita_sdk-0.3.374.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.374.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.374.dist-info/RECORD,,