alita-sdk 0.3.373__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/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-0.3.373.dist-info → alita_sdk-0.3.374.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.373
+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.373.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
@@ -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,7 +121,7 @@ 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=wixvgLrC2tQOeIjFMCD-7869K7YfERzk2Tzmo-fgsTE,28350
@@ -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.373.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.373.dist-info/METADATA,sha256=vQ5k6GviISnUnBtw9mvNReIJl5AWR4pT0---RvUQA_A,19071
-alita_sdk-0.3.373.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.373.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.373.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,,