alita-sdk 0.3.378__py3-none-any.whl → 0.3.380__py3-none-any.whl

alita_sdk/runtime/langchain/assistant.py

@@ -77,11 +77,17 @@ class Assistant:
         else:
             # For predict agents, initialize memory store to None since they don't use memory
             self.store = None
-        
+
         # Lazy import to avoid circular dependency
         from ..toolkits.tools import get_tools
-        
-        self.tools = get_tools(data['tools'], alita_client=alita, llm=self.client, memory_store=self.store)
+        version_tools = data['tools']
+        # Handle internal tools
+        meta = data.get('meta', {})
+        if meta.get("internal_tools"):
+            for internal_tool_name in meta.get("internal_tools"):
+                version_tools.append({"type": "internal_tool", "name": internal_tool_name})
+
+        self.tools = get_tools(version_tools, alita_client=alita, llm=self.client, memory_store=self.store)
         if tools:
             self.tools += tools
         # Handle prompt setup
@@ -118,9 +124,11 @@ class Assistant:
             if variables:
                 self.prompt.partial_variables = variables
             try:
-                logger.info(f"Client was created with client setting: temperature - {self.client._get_model_default_parameters}")
+                logger.info(
+                    f"Client was created with client setting: temperature - {self.client._get_model_default_parameters}")
             except Exception as e:
-                logger.info(f"Client was created with client setting: temperature - {self.client.temperature} : {self.client.max_tokens}")
+                logger.info(
+                    f"Client was created with client setting: temperature - {self.client.temperature} : {self.client.max_tokens}")
 
     def _configure_store(self, memory_tool: dict | None) -> None:
         """
@@ -157,7 +165,6 @@ class Assistant:
         agent = create_json_chat_agent(llm=self.client, tools=simple_tools, prompt=self.prompt)
         return self._agent_executor(agent)
 
-
     def getXMLAgentExecutor(self):
         # Exclude compiled graph runnables from simple tool agents
         simple_tools = [t for t in self.tools if isinstance(t, (BaseTool, CompiledStateGraph))]
@@ -177,23 +184,6 @@ class Assistant:
         """
         # Exclude compiled graph runnables from simple tool agents
         simple_tools = [t for t in self.tools if isinstance(t, (BaseTool, CompiledStateGraph))]
-        
-        # Add sandbox tool by default for react agents
-        try:
-            from ..tools.sandbox import create_sandbox_tool
-            sandbox_tool = create_sandbox_tool(stateful=False, allow_net=True)
-            simple_tools.append(sandbox_tool)
-            logger.info("Added PyodideSandboxTool to react agent")
-        except ImportError as e:
-            logger.warning(f"Failed to add PyodideSandboxTool: {e}. Install langchain-sandbox to enable this feature.")
-        except RuntimeError as e:
-            if "Deno" in str(e):
-                logger.warning("Failed to add PyodideSandboxTool: Deno is required. Install from https://docs.deno.com/runtime/getting_started/installation/")
-            else:
-                logger.warning(f"Failed to add PyodideSandboxTool: {e}")
-        except Exception as e:
-            logger.error(f"Error adding PyodideSandboxTool: {e}")
-        
         # Add image generation tool if model is configured
         if self.alita_client.model_image_generation is not None:
             try:

alita_sdk/runtime/toolkits/tools.py

@@ -12,6 +12,7 @@ from .prompt import PromptToolkit
 from .subgraph import SubgraphToolkit
 from .vectorstore import VectorStoreToolkit
 from ..tools.mcp_server_tool import McpServerTool
+from ..tools.sandbox import SandboxToolkit
 # Import community tools
 from ...community import get_toolkits as community_toolkits, get_tools as community_tools
 from ...tools.memory import MemoryToolkit
@@ -24,7 +25,8 @@ def get_toolkits():
     core_toolkits = [
         ArtifactToolkit.toolkit_config_schema(),
         MemoryToolkit.toolkit_config_schema(),
-        VectorStoreToolkit.toolkit_config_schema()
+        VectorStoreToolkit.toolkit_config_schema(),
+        SandboxToolkit.toolkit_config_schema()
     ]
 
     return core_toolkits + community_toolkits() + alita_toolkits()
@@ -65,6 +67,13 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                 pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
                 store=memory_store,
             ).get_tools()
+        # TODO: update configuration of internal tools
+        elif tool['type'] == 'internal_tool':
+            if tool['name'] == 'pyodide':
+                tools += SandboxToolkit.get_toolkit(
+                    stateful=False,
+                    allow_net=True,
+                ).get_tools()
         elif tool['type'] == 'artifact':
             tools.extend(ArtifactToolkit.get_toolkit(
                 client=alita_client,

alita_sdk/runtime/tools/graph.py

@@ -47,8 +47,8 @@ def formulate_query(kwargs):
 
 
 class GraphTool(BaseTool):
-    name: str
-    description: str
+    name: str = 'GraphTool'
+    description: str = 'Graph tool for tools'
     graph: CompiledStateGraph
     args_schema: Type[BaseModel] = graphToolSchema
     return_type: str = "str"
@@ -65,10 +65,16 @@ class GraphTool(BaseTool):
         all_kwargs = {**kwargs, **extras, **schema_values}
         if config is None:
             config = {}
-        return self._run(*config, **all_kwargs)
+        # Pass the config to the _run empty or the one passed from the parent executor.
+        return self._run(config, **all_kwargs)
 
     def _run(self, *args, **kwargs):
-        response = self.graph.invoke(formulate_query(kwargs))
+        config = None
+        # From invoke method we are passing only 1 arg so it is safe to do this condition and config assignment.
+        # Default to None is safe because it will be checked also on the langchain side.
+        if args:
+            config = args[0]
+        response = self.graph.invoke(formulate_query(kwargs), config=config)
         if self.return_type == "str":
             return response["output"]
         else:

alita_sdk/runtime/tools/llm.py

@@ -177,7 +177,9 @@ class LLMNode(BaseTool):
                             if tool_to_execute:
                                 try:
                                     logger.info(f"Executing tool '{tool_name}' with args: {tool_args}")
-                                    tool_result = tool_to_execute.invoke(tool_args)
+                                    # Pass the underlying config to the tool execution invoke method
+                                    # since it may be another agent, graph, etc. to see it properly in thinking steps
+                                    tool_result = tool_to_execute.invoke(tool_args, config=config)
 
                                     # Create tool message with result - preserve structured content
                                     from langchain_core.messages import ToolMessage

alita_sdk/runtime/tools/sandbox.py

@@ -2,21 +2,56 @@ import asyncio
 import logging
 import subprocess
 import os
-from typing import Any, Type, Optional, Dict
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel, create_model
+from typing import Any, Type, Optional, Dict, List, Literal
+
+from langchain_core.tools import BaseTool, BaseToolkit
+from pydantic import BaseModel, create_model, ConfigDict, Field
 from pydantic.fields import FieldInfo
 
 logger = logging.getLogger(__name__)
 
+name = "pyodide"
+
+
+def get_tools(tools_list: list, alita_client=None, llm=None, memory_store=None):
+    """
+    Get sandbox tools for the provided tool configurations.
+
+    Args:
+        tools_list: List of tool configurations
+        alita_client: Alita client instance (unused for sandbox)
+        llm: LLM client instance (unused for sandbox)
+        memory_store: Optional memory store instance (unused for sandbox)
+
+    Returns:
+        List of sandbox tools
+    """
+    all_tools = []
+
+    for tool in tools_list:
+        if tool.get('type') == 'sandbox' or tool.get('toolkit_name') == 'sandbox':
+            try:
+                toolkit_instance = SandboxToolkit.get_toolkit(
+                    stateful=tool['settings'].get('stateful', False),
+                    allow_net=tool['settings'].get('allow_net', True),
+                    toolkit_name=tool.get('toolkit_name', '')
+                )
+                all_tools.extend(toolkit_instance.get_tools())
+            except Exception as e:
+                logger.error(f"Error in sandbox toolkit get_tools: {e}")
+                logger.error(f"Tool config: {tool}")
+                raise
+
+    return all_tools
+
 
 def _is_deno_available() -> bool:
     """Check if Deno is available in the PATH"""
     try:
         result = subprocess.run(
-            ["deno", "--version"], 
-            capture_output=True, 
-            text=True, 
+            ["deno", "--version"],
+            capture_output=True,
+            text=True,
             timeout=10
         )
         return result.returncode == 0
@@ -42,26 +77,26 @@ def _setup_pyodide_cache_env() -> None:
                             value = value.strip('"').strip("'")
                             os.environ[key] = value
                             logger.debug(f"Set Pyodide cache env: {key}={value}")
-        
+
         # Set default caching environment variables if not already set
         cache_defaults = {
             'PYODIDE_PACKAGES_PATH': os.path.expanduser('~/.cache/pyodide'),
             'DENO_DIR': os.path.expanduser('~/.cache/deno'),
             'PYODIDE_CACHE_DIR': os.path.expanduser('~/.cache/pyodide'),
         }
-        
+
         for key, default_value in cache_defaults.items():
             if key not in os.environ:
                 os.environ[key] = default_value
                 logger.debug(f"Set default Pyodide env: {key}={default_value}")
-                
+
     except Exception as e:
         logger.warning(f"Could not setup Pyodide cache environment: {e}")
 
 
 # Create input schema for the sandbox tool
 sandbox_tool_input = create_model(
-    "SandboxToolInput", 
+    "SandboxToolInput",
     code=(str, FieldInfo(description="Python code to execute in the sandbox environment"))
 )
 
@@ -72,7 +107,7 @@ class PyodideSandboxTool(BaseTool):
     This tool leverages langchain-sandbox to provide a safe environment for running untrusted Python code.
     Optimized for performance with caching and stateless execution by default.
     """
-    
+
     name: str = "pyodide_sandbox"
     description: str = """Execute Python code in a secure sandbox environment using Pyodide.
     This tool allows safe execution of Python code without access to the host system.
@@ -81,7 +116,7 @@ class PyodideSandboxTool(BaseTool):
     - Perform calculations or data analysis
     - Test Python algorithms
     - Run code that requires isolation from the host system
-    
+
     The sandbox supports most Python standard library modules and can install additional packages.
     Note: File access and some system operations are restricted for security.
     Optimized for performance with local caching (stateless by default for faster execution).
@@ -91,14 +126,14 @@ class PyodideSandboxTool(BaseTool):
     allow_net: bool = True
     session_bytes: Optional[bytes] = None
     session_metadata: Optional[Dict] = None
-    
+
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self._sandbox = None
         # Setup caching environment for optimal performance
         _setup_pyodide_cache_env()
         self._initialize_sandbox()
-    
+
     def _initialize_sandbox(self) -> None:
         """Initialize the PyodideSandbox instance with optimized settings"""
         try:
@@ -110,9 +145,9 @@ class PyodideSandboxTool(BaseTool):
                 )
                 logger.error(error_msg)
                 raise RuntimeError(error_msg)
-            
+
             from langchain_sandbox import PyodideSandbox
-            
+
             # Configure sandbox with performance optimizations
             self._sandbox = PyodideSandbox(
                 stateful=self.stateful,
@@ -135,7 +170,7 @@ class PyodideSandboxTool(BaseTool):
         except Exception as e:
             logger.error(f"Failed to initialize PyodideSandbox: {e}")
             raise
-    
+
     def _run(self, code: str) -> str:
         """
         Synchronous version - runs the async method in a new event loop
@@ -144,7 +179,7 @@ class PyodideSandboxTool(BaseTool):
             # Check if sandbox is initialized, if not try to initialize
             if self._sandbox is None:
                 self._initialize_sandbox()
-            
+
             # Check if we're already in an async context
             try:
                 loop = asyncio.get_running_loop()
@@ -169,7 +204,7 @@ class PyodideSandboxTool(BaseTool):
         except Exception as e:
             logger.error(f"Error executing code in sandbox: {e}")
             return f"Error executing code: {str(e)}"
-    
+
     async def _arun(self, code: str) -> str:
         """
         Execute Python code in the Pyodide sandbox
@@ -177,19 +212,19 @@ class PyodideSandboxTool(BaseTool):
         try:
             if self._sandbox is None:
                 self._initialize_sandbox()
-            
+
             # Execute the code with session state if available
             result = await self._sandbox.execute(
                 code,
                 session_bytes=self.session_bytes,
                 session_metadata=self.session_metadata
             )
-            
+
             # Update session state for stateful execution
             if self.stateful:
                 self.session_bytes = result.session_bytes
                 self.session_metadata = result.session_metadata
-            
+
             result_dict = {}
 
             if result.result is not None:
@@ -212,7 +247,7 @@ class PyodideSandboxTool(BaseTool):
 
             result_dict["execution_info"] = execution_info
             return result_dict
-            
+
         except Exception as e:
             logger.error(f"Error executing code in sandbox: {e}")
             return f"Error executing code: {str(e)}"
@@ -223,7 +258,7 @@ class StatefulPyodideSandboxTool(PyodideSandboxTool):
     A stateful version of the PyodideSandboxTool that maintains state between executions.
     This version preserves variables, imports, and function definitions across multiple tool calls.
     """
-    
+
     name: str = "stateful_pyodide_sandbox"
     description: str = """Execute Python code in a stateful sandbox environment using Pyodide.
     This tool maintains state between executions, preserving variables, imports, and function definitions.
@@ -232,11 +267,11 @@ class StatefulPyodideSandboxTool(PyodideSandboxTool):
     - Maintain variables across multiple calls
     - Develop complex programs step by step
     - Preserve imported libraries and defined functions
-    
+
     The sandbox supports most Python standard library modules and can install additional packages.
     Note: File access and some system operations are restricted for security.
     """
-    
+
     def __init__(self, **kwargs: Any) -> None:
         kwargs['stateful'] = True  # Force stateful mode
         super().__init__(**kwargs)
@@ -246,21 +281,21 @@ class StatefulPyodideSandboxTool(PyodideSandboxTool):
 def create_sandbox_tool(stateful: bool = False, allow_net: bool = True) -> BaseTool:
     """
     Factory function to create sandbox tools with specified configuration.
-    
+
     Note: This tool requires Deno to be installed and available in PATH.
     For installation and optimization, run the bootstrap.sh script.
-    
+
     Args:
         stateful: Whether to maintain state between executions (default: False for better performance)
         allow_net: Whether to allow network access (for package installation)
-    
+
     Returns:
         Configured sandbox tool instance
-        
+
     Raises:
         ImportError: If langchain-sandbox is not installed
         RuntimeError: If Deno is not found in PATH
-        
+
     Performance Notes:
         - Stateless mode (default) is faster and avoids session state overhead
         - Run bootstrap.sh script to enable local caching and reduce initialization time
@@ -269,4 +304,58 @@ def create_sandbox_tool(stateful: bool = False, allow_net: bool = True) -> BaseT
     if stateful:
         return StatefulPyodideSandboxTool(allow_net=allow_net)
     else:
-        return PyodideSandboxTool(stateful=False, allow_net=allow_net)
+        return PyodideSandboxTool(stateful=False, allow_net=allow_net)
+
+
+class SandboxToolkit(BaseToolkit):
+    tools: List[BaseTool] = []
+
+    @staticmethod
+    def toolkit_config_schema() -> BaseModel:
+        # Create sample tools to get their schemas
+        sample_tools = [
+            PyodideSandboxTool(),
+            StatefulPyodideSandboxTool()
+        ]
+        selected_tools = {x.name: x.args_schema.schema() for x in sample_tools}
+
+        return create_model(
+            'sandbox',
+            stateful=(bool, Field(default=False, description="Whether to maintain state between executions")),
+            allow_net=(bool, Field(default=True, description="Whether to allow network access for package installation")),
+            selected_tools=(List[Literal[tuple(selected_tools)]],
+                            Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
+
+            __config__=ConfigDict(json_schema_extra={
+                'metadata': {
+                    "label": "Python Sandbox",
+                    "icon_url": "sandbox.svg",
+                    "hidden": False,
+                    "categories": ["code", "execution", "internal_tool"],
+                    "extra_categories": ["python", "pyodide", "sandbox", "code execution"],
+                }
+            })
+        )
+
+    @classmethod
+    def get_toolkit(cls, stateful: bool = False, allow_net: bool = True, **kwargs):
+        """
+        Get toolkit with sandbox tools.
+
+        Args:
+            stateful: Whether to maintain state between executions
+            allow_net: Whether to allow network access
+            **kwargs: Additional arguments
+        """
+        tools = []
+
+        if stateful:
+            tools.append(StatefulPyodideSandboxTool(allow_net=allow_net))
+        else:
+            tools.append(PyodideSandboxTool(stateful=False, allow_net=allow_net))
+
+        return cls(tools=tools)
+
+    def get_tools(self):
+        return self.tools
+

alita_sdk/tools/__init__.py

@@ -97,7 +97,9 @@ def get_tools(tools_list, alita, llm, store: Optional[BaseStore] = None, *args,
         for tool_name in tool.get('settings', {}).get('selected_tools', []):
             if isinstance(tool_name, str) and tool_name.startswith('_'):
                 raise ValueError(f"Tool name '{tool_name}' from toolkit '{tool.get('type', '')}' cannot start with '_'")
-
+        if not tool.get('settings'):
+            logger.warning(f"Tool '{tool.get('type', '')}' has no settings, skipping...")
+            continue
         tool['settings']['alita'] = alita
         tool['settings']['llm'] = llm
         tool['settings']['store'] = store

{alita_sdk-0.3.378.dist-info → alita_sdk-0.3.380.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.378
+Version: 0.3.380
 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.378.dist-info → alita_sdk-0.3.380.dist-info}/RECORD

@@ -41,7 +41,7 @@ alita_sdk/runtime/clients/datasource.py,sha256=HAZovoQN9jBg0_-lIlGBQzb4FJdczPhkH
 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=rCtlB4Yuf9Sl-SSurUpALB4ETdADpGrdTngtbM7Aj3A,16184
+alita_sdk/runtime/langchain/assistant.py,sha256=HqFQ8nWrSdbXRx-huf0srA_zYCxcMjEndBCJVVriRMQ,15607
 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
@@ -102,7 +102,7 @@ alita_sdk/runtime/toolkits/configurations.py,sha256=kIDAlnryPQfbZyFxV-9SzN2-Vefz
 alita_sdk/runtime/toolkits/datasource.py,sha256=qk78OdPoReYPCWwahfkKLbKc4pfsu-061oXRryFLP6I,2498
 alita_sdk/runtime/toolkits/prompt.py,sha256=WIpTkkVYWqIqOWR_LlSWz3ug8uO9tm5jJ7aZYdiGRn0,1192
 alita_sdk/runtime/toolkits/subgraph.py,sha256=wwUK8JjPXkGzyVZ3tAukmvST6eGbqx_U11rpnmbrvtg,2105
-alita_sdk/runtime/toolkits/tools.py,sha256=WBTU-ou5u0R9QLses5N_JHP2TryrsWUr_gY8uG5xY3E,8319
+alita_sdk/runtime/toolkits/tools.py,sha256=Lo90zr6G_Mi378hpMNTRFmk05A7dDJDMbtVHEeFd5cM,8708
 alita_sdk/runtime/toolkits/vectorstore.py,sha256=BGppQADa1ZiLO17fC0uCACTTEvPHlodEDYEzUcBRbAA,2901
 alita_sdk/runtime/tools/__init__.py,sha256=TbHPnDtCdQvNzK1YQnk_ufkuI7FgHfvY1-JWUgycZhQ,497
 alita_sdk/runtime/tools/agent.py,sha256=m98QxOHwnCRTT9j18Olbb5UPS8-ZGeQaGiUyZJSyFck,3162
@@ -111,17 +111,17 @@ alita_sdk/runtime/tools/artifact.py,sha256=u3szFwZqguHrPZ3tZJ7S_TiZl7cxlT3oHYd6z
 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=4r-VbGtm8gN_RTU2I-1iUNVs_MWNgRqn-aQrr__lCTc,7001
-alita_sdk/runtime/tools/graph.py,sha256=MbnZYqdmvZY7SGDp43lOVVIjUt5ARHSgj43mdtBjSjQ,3092
+alita_sdk/runtime/tools/graph.py,sha256=7jImBBSEdP5Mjnn2keOiyUwdGDFhEXLUrgUiugO3mgA,3503
 alita_sdk/runtime/tools/image_generation.py,sha256=8ZH4SoRrbS4EzmtF6cpNMRvuFephCYD2S8uqNC9KGE4,4274
 alita_sdk/runtime/tools/indexer_tool.py,sha256=whSLPevB4WD6dhh2JDXEivDmTvbjiMV1MrPl9cz5eLA,4375
-alita_sdk/runtime/tools/llm.py,sha256=YDb0kIu3QCiv2DkgpnFv5-pbAor6CMQ5IcYnyVMQrtY,15142
+alita_sdk/runtime/tools/llm.py,sha256=AOxC3OEQ8FQCiI6f1we6s_X3a7DGyd2Z6yi1P_1jqoY,15376
 alita_sdk/runtime/tools/loop.py,sha256=uds0WhZvwMxDVFI6MZHrcmMle637cQfBNg682iLxoJA,8335
 alita_sdk/runtime/tools/loop_output.py,sha256=U4hO9PCQgWlXwOq6jdmCGbegtAxGAPXObSxZQ3z38uk,8069
 alita_sdk/runtime/tools/mcp_server_tool.py,sha256=MhLxZJ44LYrB_0GrojmkyqKoDRaqIHkEQAsg718ipog,4277
 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=0OjCNsDVO1N0cFNEFVr6GVICSaqGWesUzF6LcYg-Hn0,11349
+alita_sdk/runtime/tools/sandbox.py,sha256=CBPaHwGv74FiHbELuwLBEvB2C-HhbptUnSMipzJUSZA,14282
 alita_sdk/runtime/tools/tool.py,sha256=lE1hGi6qOAXG7qxtqxarD_XMQqTghdywf261DZawwno,5631
 alita_sdk/runtime/tools/vectorstore.py,sha256=FsnxdnvMK5bUEFxz0eeSHeNpVOk2gxOeXjoSlvCo8rs,34327
 alita_sdk/runtime/tools/vectorstore_base.py,sha256=lNz6bOMpHOY8JiHT7BkoDbyj3kLykcKlCx4zOu_IgPE,28252
@@ -135,7 +135,7 @@ alita_sdk/runtime/utils/streamlit.py,sha256=GQ69CsjfRMcGXcCrslL0Uoj24Cl07Jeji0rZ
 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=PJK8A-JVIzY1IowOjGG8DIqsIiEFe65qDKvFcjJCKWA,1041
-alita_sdk/tools/__init__.py,sha256=jUj1ztC2FbkIUB-YYmiqaz_rqW7Il5kWzDPn1mJmj5w,10545
+alita_sdk/tools/__init__.py,sha256=NrZyTEdEhmO1NnAR9RFMQ05Mb-kgu68mAQz3n5r0HYs,10692
 alita_sdk/tools/base_indexer_toolkit.py,sha256=i0S3tIdXrWoRx5B5v0cQMArnmOTsinC9SMLihlEcdxM,26801
 alita_sdk/tools/code_indexer_toolkit.py,sha256=p3zVnCnQTUf7JUGra9Rl6GEK2W1-hvvz0Xsgz0v0muM,7292
 alita_sdk/tools/elitea_base.py,sha256=34fmVdYgd2YXifU5LFNjMQysr4OOIZ6AOZjq4GxLgSw,34417
@@ -353,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.378.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.378.dist-info/METADATA,sha256=JZZ0qoXsRM2PriFKAUs4xSabkZkxQm6oX4ZBT57V3OU,19071
-alita_sdk-0.3.378.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.378.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.378.dist-info/RECORD,,
+alita_sdk-0.3.380.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.380.dist-info/METADATA,sha256=81aR6cJaFL6Ez549W3wrMAlKIKG7veu3PsTcEs5rw18,19071
+alita_sdk-0.3.380.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.380.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.380.dist-info/RECORD,,