letta-nightly 0.7.3.dev20250424104224__py3-none-any.whl → 0.7.4.dev20250424184820__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.7.3"
+__version__ = "0.7.4"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/groups/sleeptime_multi_agent.py

@@ -43,24 +43,21 @@ class SleeptimeMultiAgent(Agent):
 
     def _run_async_in_new_thread(self, coro):
         """Run an async coroutine in a new thread with its own event loop"""
-        result = None
 
         def run_async():
-            nonlocal result
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
             try:
-                result = loop.run_until_complete(coro)
+                loop.run_until_complete(coro)
             finally:
                 loop.close()
                 asyncio.set_event_loop(None)
 
         thread = threading.Thread(target=run_async)
+        thread.daemon = True
         thread.start()
-        thread.join()
-        return result
 
-    async def _issue_background_task(
+    def _issue_background_task(
         self,
         participant_agent_id: str,
         messages: List[Message],
@@ -81,7 +78,7 @@ class SleeptimeMultiAgent(Agent):
         )
         run = self.job_manager.create_job(pydantic_job=run, actor=self.user)
 
-        asyncio.create_task(
+        self._run_async_in_new_thread(
             self._perform_background_agent_step(
                 participant_agent_id=participant_agent_id,
                 messages=messages,
@@ -239,17 +236,15 @@ class SleeptimeMultiAgent(Agent):
                 )
                 for participant_agent_id in self.agent_ids:
                     try:
-                        run_id = self._run_async_in_new_thread(
-                            self._issue_background_task(
-                                participant_agent_id,
-                                last_response_messages,
-                                chaining,
-                                max_chaining_steps,
-                                token_streaming,
-                                metadata,
-                                put_inner_thoughts_first,
-                                last_processed_message_id,
-                            )
+                        run_id = self._issue_background_task(
+                            participant_agent_id,
+                            last_response_messages,
+                            chaining,
+                            max_chaining_steps,
+                            token_streaming,
+                            metadata,
+                            put_inner_thoughts_first,
+                            last_processed_message_id,
                         )
                         run_ids.append(run_id)
 

letta/schemas/message.py

@@ -699,6 +699,10 @@ class Message(BaseMessage):
         else:
             raise ValueError(self.role)
 
+        # Optional field, do not include if null
+        if self.name is not None:
+            openai_message["name"] = self.name
+
         if parse_content_parts:
             for content in self.content:
                 if isinstance(content, ReasoningContent):

letta/schemas/sandbox_config.py

@@ -47,14 +47,14 @@ class PipRequirement(BaseModel):
 
 class LocalSandboxConfig(BaseModel):
     sandbox_dir: Optional[str] = Field(None, description="Directory for the sandbox environment.")
-    use_venv: bool = Field(False, description="Whether or not to use the venv, or run directly in the same run loop.")
+    force_create_venv: bool = Field(False, description="Whether or not to use the venv, or run directly in the same run loop.")
     venv_name: str = Field(
         "venv",
         description="The name for the venv in the sandbox directory. We first search for an existing venv with this name, otherwise, we make it from the requirements.txt.",
     )
     pip_requirements: List[PipRequirement] = Field(
         default_factory=list,
-        description="List of pip packages to install with mandatory name and optional version following semantic versioning. This only is considered when use_venv is True.",
+        description="List of pip packages to install with mandatory name and optional version following semantic versioning. This only is considered when force_create_venv is True.",
     )
 
     @property

letta/server/server.py

@@ -1308,12 +1308,14 @@ class SyncServer(Server):
             tool_execution_result = ToolExecutionSandbox(tool.name, tool_args, actor, tool_object=tool).run(
                 agent_state=agent_state, additional_env_vars=tool_env_vars
             )
+            status = "error" if tool_execution_result.stderr else "success"
+            tool_return = str(tool_execution_result.stderr) if tool_execution_result.stderr else str(tool_execution_result.func_return)
             return ToolReturnMessage(
                 id="null",
                 tool_call_id="null",
                 date=get_utc_time(),
-                status=tool_execution_result.status,
-                tool_return=str(tool_execution_result.func_return),
+                status=status,
+                tool_return=tool_return,
                 stdout=tool_execution_result.stdout,
                 stderr=tool_execution_result.stderr,
             )

letta/services/helpers/tool_execution_helper.py

@@ -24,7 +24,7 @@ def find_python_executable(local_configs: LocalSandboxConfig) -> str:
     """
     sandbox_dir = os.path.expanduser(local_configs.sandbox_dir)  # Expand tilde
 
-    if not local_configs.use_venv:
+    if not local_configs.force_create_venv:
         return "python.exe" if platform.system().lower().startswith("win") else "python3"
 
     venv_path = os.path.join(sandbox_dir, local_configs.venv_name)
@@ -96,7 +96,7 @@ def install_pip_requirements_for_sandbox(
     python_exec = find_python_executable(local_configs)
 
     # If using a virtual environment, upgrade pip before installing dependencies.
-    if local_configs.use_venv:
+    if local_configs.force_create_venv:
         ensure_pip_is_up_to_date(python_exec, env=env)
 
     # Construct package list
@@ -108,7 +108,7 @@ def install_pip_requirements_for_sandbox(
         pip_cmd.append("--upgrade")
     pip_cmd += packages
 
-    if user_install_if_no_venv and not local_configs.use_venv:
+    if user_install_if_no_venv and not local_configs.force_create_venv:
         pip_cmd.append("--user")
 
     run_subprocess(pip_cmd, env=env, fail_msg=f"Failed to install packages: {', '.join(packages)}")

letta/services/tool_executor/tool_execution_sandbox.py

@@ -1,12 +1,10 @@
 import ast
 import base64
-import io
 import os
 import pickle
 import subprocess
 import sys
 import tempfile
-import traceback
 import uuid
 from typing import Any, Dict, Optional
 
@@ -119,89 +117,74 @@ class ToolExecutionSandbox:
 
     @trace_method
     def run_local_dir_sandbox(
-        self, agent_state: Optional[AgentState] = None, additional_env_vars: Optional[Dict] = None
+        self,
+        agent_state: Optional[AgentState] = None,
+        additional_env_vars: Optional[Dict] = None,
     ) -> ToolExecutionResult:
-        sbx_config = self.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=self.user)
+        sbx_config = self.sandbox_config_manager.get_or_create_default_sandbox_config(
+            sandbox_type=SandboxType.LOCAL,
+            actor=self.user,
+        )
         local_configs = sbx_config.get_local_config()
+        sandbox_dir = os.path.expanduser(local_configs.sandbox_dir)
+        venv_path = os.path.join(sandbox_dir, local_configs.venv_name)
 
-        # Get environment variables for the sandbox
+        # Aggregate environment variables
         env = os.environ.copy()
-        env_vars = self.sandbox_config_manager.get_sandbox_env_vars_as_dict(sandbox_config_id=sbx_config.id, actor=self.user, limit=100)
-        env.update(env_vars)
-
-        # Get environment variables for this agent specifically
+        env.update(self.sandbox_config_manager.get_sandbox_env_vars_as_dict(sandbox_config_id=sbx_config.id, actor=self.user, limit=100))
         if agent_state:
             env.update(agent_state.get_agent_env_vars_as_dict())
-
-        # Finally, get any that are passed explicitly into the `run` function call
         if additional_env_vars:
             env.update(additional_env_vars)
 
-        # Safety checks
-        if not os.path.exists(local_configs.sandbox_dir) or not os.path.isdir(local_configs.sandbox_dir):
-            logger.warning(f"Sandbox directory does not exist, creating: {local_configs.sandbox_dir}")
-            os.makedirs(local_configs.sandbox_dir)
-
-        # Write the code to a temp file in the sandbox_dir
-        with tempfile.NamedTemporaryFile(mode="w", dir=local_configs.sandbox_dir, suffix=".py", delete=False) as temp_file:
-            if local_configs.use_venv:
-                # If using venv, we need to wrap with special string markers to separate out the output and the stdout (since it is all in stdout)
-                code = self.generate_execution_script(agent_state=agent_state, wrap_print_with_markers=True)
-            else:
-                code = self.generate_execution_script(agent_state=agent_state)
+        # Ensure sandbox dir exists
+        if not os.path.exists(sandbox_dir):
+            logger.warning(f"Sandbox directory does not exist, creating: {sandbox_dir}")
+            os.makedirs(sandbox_dir)
 
+        # Write the code to a temp file
+        with tempfile.NamedTemporaryFile(mode="w", dir=sandbox_dir, suffix=".py", delete=False) as temp_file:
+            code = self.generate_execution_script(agent_state=agent_state, wrap_print_with_markers=True)
             temp_file.write(code)
             temp_file.flush()
             temp_file_path = temp_file.name
+
         try:
-            if local_configs.use_venv:
-                return self.run_local_dir_sandbox_venv(sbx_config, env, temp_file_path)
+            # Decide whether to use venv
+            use_venv = os.path.isdir(venv_path)
+
+            if self.force_recreate_venv or (not use_venv and local_configs.force_create_venv):
+                logger.warning(f"Virtual environment not found at {venv_path}. Creating one...")
+                log_event(name="start create_venv_for_local_sandbox", attributes={"venv_path": venv_path})
+                create_venv_for_local_sandbox(
+                    sandbox_dir_path=sandbox_dir,
+                    venv_path=venv_path,
+                    env=env,
+                    force_recreate=self.force_recreate_venv,
+                )
+                log_event(name="finish create_venv_for_local_sandbox")
+                use_venv = True
+
+            if use_venv:
+                log_event(name="start install_pip_requirements_for_sandbox", attributes={"local_configs": local_configs.model_dump_json()})
+                install_pip_requirements_for_sandbox(local_configs, env=env)
+                log_event(name="finish install_pip_requirements_for_sandbox", attributes={"local_configs": local_configs.model_dump_json()})
+
+                python_executable = find_python_executable(local_configs)
+                if not os.path.isfile(python_executable):
+                    logger.warning(
+                        f"Python executable not found at expected venv path: {python_executable}. Falling back to system Python."
+                    )
+                    python_executable = sys.executable
+                else:
+                    env = dict(env)
+                    env["VIRTUAL_ENV"] = venv_path
+                    env["PATH"] = os.path.join(venv_path, "bin") + ":" + env.get("PATH", "")
             else:
-                return self.run_local_dir_sandbox_directly(sbx_config, env, temp_file_path)
-        except Exception as e:
-            logger.error(f"Executing tool {self.tool_name} has an unexpected error: {e}")
-            logger.error(f"Logging out tool {self.tool_name} auto-generated code for debugging: \n\n{code}")
-            raise e
-        finally:
-            # Clean up the temp file
-            os.remove(temp_file_path)
-
-    @trace_method
-    def run_local_dir_sandbox_venv(
-        self,
-        sbx_config: SandboxConfig,
-        env: Dict[str, str],
-        temp_file_path: str,
-    ) -> ToolExecutionResult:
-        local_configs = sbx_config.get_local_config()
-        sandbox_dir = os.path.expanduser(local_configs.sandbox_dir)  # Expand tilde
-        venv_path = os.path.join(sandbox_dir, local_configs.venv_name)
-
-        # Recreate venv if required
-        if self.force_recreate_venv or not os.path.isdir(venv_path):
-            logger.warning(f"Virtual environment directory does not exist at: {venv_path}, creating one now...")
-            log_event(name="start create_venv_for_local_sandbox", attributes={"venv_path": venv_path})
-            create_venv_for_local_sandbox(
-                sandbox_dir_path=sandbox_dir, venv_path=venv_path, env=env, force_recreate=self.force_recreate_venv
-            )
-            log_event(name="finish create_venv_for_local_sandbox")
-
-        log_event(name="start install_pip_requirements_for_sandbox", attributes={"local_configs": local_configs.model_dump_json()})
-        install_pip_requirements_for_sandbox(local_configs, env=env)
-        log_event(name="finish install_pip_requirements_for_sandbox", attributes={"local_configs": local_configs.model_dump_json()})
-
-        # Ensure Python executable exists
-        python_executable = find_python_executable(local_configs)
-        if not os.path.isfile(python_executable):
-            raise FileNotFoundError(f"Python executable not found in virtual environment: {python_executable}")
+                python_executable = sys.executable
 
-        # Set up environment variables
-        env["VIRTUAL_ENV"] = venv_path
-        env["PATH"] = os.path.join(venv_path, "bin") + ":" + env["PATH"]
-        env["PYTHONWARNINGS"] = "ignore"
+            env["PYTHONWARNINGS"] = "ignore"
 
-        # Execute the code
-        try:
             log_event(name="start subprocess")
             result = subprocess.run(
                 [python_executable, temp_file_path],
@@ -213,19 +196,19 @@ class ToolExecutionSandbox:
             )
             log_event(name="finish subprocess")
             func_result, stdout = self.parse_out_function_results_markers(result.stdout)
-            func_return, agent_state = self.parse_best_effort(func_result)
+            func_return, parsed_agent_state = self.parse_best_effort(func_result)
 
             return ToolExecutionResult(
                 status="success",
                 func_return=func_return,
-                agent_state=agent_state,
+                agent_state=parsed_agent_state,
                 stdout=[stdout] if stdout else [],
                 stderr=[result.stderr] if result.stderr else [],
                 sandbox_config_fingerprint=sbx_config.fingerprint(),
             )
 
         except subprocess.CalledProcessError as e:
-            logger.error(f"Executing tool {self.tool_name} has process error: {e}")
+            logger.error(f"Tool execution failed: {e}")
             func_return = get_friendly_error_msg(
                 function_name=self.tool_name,
                 exception_name=type(e).__name__,
@@ -245,72 +228,11 @@ class ToolExecutionSandbox:
 
         except Exception as e:
             logger.error(f"Executing tool {self.tool_name} has an unexpected error: {e}")
+            logger.error(f"Generated script:\n{code}")
             raise e
 
-    @trace_method
-    def run_local_dir_sandbox_directly(
-        self,
-        sbx_config: SandboxConfig,
-        env: Dict[str, str],
-        temp_file_path: str,
-    ) -> ToolExecutionResult:
-        status = "success"
-        func_return, agent_state, stderr = None, None, None
-
-        old_stdout = sys.stdout
-        old_stderr = sys.stderr
-        captured_stdout, captured_stderr = io.StringIO(), io.StringIO()
-
-        sys.stdout = captured_stdout
-        sys.stderr = captured_stderr
-
-        try:
-            with self.temporary_env_vars(env):
-
-                # Read and compile the Python script
-                with open(temp_file_path, "r", encoding="utf-8") as f:
-                    source = f.read()
-                code_obj = compile(source, temp_file_path, "exec")
-
-                # Provide a dict for globals
-                globals_dict = dict(env)  # or {}
-                # If you need to mimic `__main__` behavior:
-                globals_dict["__name__"] = "__main__"
-                globals_dict["__file__"] = temp_file_path
-
-                # Execute the compiled code
-                log_event(name="start exec", attributes={"temp_file_path": temp_file_path})
-                exec(code_obj, globals_dict)
-                log_event(name="finish exec", attributes={"temp_file_path": temp_file_path})
-
-                # Get result from the global dict
-                func_result = globals_dict.get(self.LOCAL_SANDBOX_RESULT_VAR_NAME)
-                func_return, agent_state = self.parse_best_effort(func_result)
-
-        except Exception as e:
-            func_return = get_friendly_error_msg(
-                function_name=self.tool_name,
-                exception_name=type(e).__name__,
-                exception_message=str(e),
-            )
-            traceback.print_exc(file=sys.stderr)
-            status = "error"
-
-        # Restore stdout/stderr
-        sys.stdout = old_stdout
-        sys.stderr = old_stderr
-
-        stdout_output = [captured_stdout.getvalue()] if captured_stdout.getvalue() else []
-        stderr_output = [captured_stderr.getvalue()] if captured_stderr.getvalue() else []
-
-        return ToolExecutionResult(
-            status=status,
-            func_return=func_return,
-            agent_state=agent_state,
-            stdout=stdout_output,
-            stderr=stderr_output,
-            sandbox_config_fingerprint=sbx_config.fingerprint(),
-        )
+        finally:
+            os.remove(temp_file_path)
 
     def parse_out_function_results_markers(self, text: str):
         if self.LOCAL_SANDBOX_RESULT_START_MARKER not in text:

letta/services/tool_sandbox/local_sandbox.py

@@ -69,7 +69,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
         else:
             sbx_config = self.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=self.user)
         local_configs = sbx_config.get_local_config()
-        use_venv = local_configs.use_venv
+        force_create_venv = local_configs.force_create_venv
 
         # Prepare environment variables
         env = os.environ.copy()
@@ -92,7 +92,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
 
         # If using a virtual environment, ensure it's prepared in parallel
         venv_preparation_task = None
-        if use_venv:
+        if force_create_venv:
             venv_path = str(os.path.join(sandbox_dir, local_configs.venv_name))
             venv_preparation_task = asyncio.create_task(self._prepare_venv(local_configs, venv_path, env))
 
@@ -110,7 +110,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
 
             # Determine the python executable and environment for the subprocess
             exec_env = env.copy()
-            if use_venv:
+            if force_create_venv:
                 venv_path = str(os.path.join(sandbox_dir, local_configs.venv_name))
                 python_executable = find_python_executable(local_configs)
                 exec_env["VIRTUAL_ENV"] = venv_path

{letta_nightly-0.7.3.dev20250424104224.dist-info → letta_nightly-0.7.4.dev20250424184820.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.3.dev20250424104224
+Version: 0.7.4.dev20250424184820
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.7.3.dev20250424104224.dist-info → letta_nightly-0.7.4.dev20250424184820.dist-info}/RECORD

@@ -1,4 +1,4 @@
-letta/__init__.py,sha256=ShZtnPIM0QOgxGGKrq6VfF4qXaE6_ZDoAQ6zXI0RepM,917
+letta/__init__.py,sha256=syDK9U6HGmZVN3Corz6hxHnV1EA-JVL--ta6nFa6z5s,917
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
 letta/agent.py,sha256=YmAkpFXHwZ0UhoatyIE-ZrV-kQDwg7f4A1o4cymoI-Y,72170
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -42,7 +42,7 @@ letta/functions/schema_generator.py,sha256=OoXDHd5oZMNjljZJplEIMOMmKvxO_rfDFtAi-
 letta/groups/dynamic_multi_agent.py,sha256=OLCxhICFLYyx8wjKGPr1INc6pniEuk4YGZyZhq2vkiY,12230
 letta/groups/helpers.py,sha256=Cof7vfZMOT2gApYpROpiAyKSKrofP1UPJxZQWFcZaqA,4336
 letta/groups/round_robin_multi_agent.py,sha256=uUJff0bO68udOREiKFWeS7eEQlk3bF7hcfLSFXMScqI,6999
-letta/groups/sleeptime_multi_agent.py,sha256=sBVcTHKDu5kKG2W3iXib9uSY2T1e_ngmwcVA207Phiw,10245
+letta/groups/sleeptime_multi_agent.py,sha256=aGtL7YiCcy1pjEXHNf85to8Wa2AT4m47Su4qXSmP3Pg,10054
 letta/groups/supervisor_multi_agent.py,sha256=ml8Gi9gyVjPuVZjAJAkpGZDjnM7GOS50NkKf5SIutvQ,4455
 letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
 letta/helpers/composio_helpers.py,sha256=5SznD1Y0Y1rV4_wu-uCaZdDU2tNedk-RIX0M9-0r6yo,947
@@ -213,7 +213,7 @@ letta/schemas/llm_batch_job.py,sha256=n9ZbWINBECRrZW6vslm-f2pk_rI_gpuxcZsqAphl9b
 letta/schemas/llm_config.py,sha256=DIJrjHUYohOd0yz3rNK8TAABbFZsLd8EpdscQErjobU,7927
 letta/schemas/llm_config_overrides.py,sha256=-oRglCTcajF6UAK3RAa0FLWVuKODPI1v403fDIWMAtA,1815
 letta/schemas/memory.py,sha256=GOYDfPKzbWftUWO9Hv4KW7xAi1EIQmC8zpP7qvEkVHw,10245
-letta/schemas/message.py,sha256=oA6vvsqlsXKA42-LsEqwv-UcTPrFEf5z6rjRWvxNSF0,49545
+letta/schemas/message.py,sha256=Is9K5-J-V07-EiyLezsY4JBuENQTogZ_6FraOoLd_mc,49676
 letta/schemas/openai/chat_completion_request.py,sha256=PZHzx--ooqJLsHTo1NpHwfywm5L8Id-CUXaKR6eXuko,4171
 letta/schemas/openai/chat_completion_response.py,sha256=7SsfVNsWq_EUajmckU5KjFClkK0iXZF2jHWZZ0nr6T4,6701
 letta/schemas/openai/chat_completions.py,sha256=l0e9sT9boTD5VBU5YtJ0s7qUtCfFGB2K-gQLeEZ2LHU,3599
@@ -224,7 +224,7 @@ letta/schemas/passage.py,sha256=RG0vkaewEu4a_NAZM-FVyMammHjqpPP0RDYAdu27g6A,3723
 letta/schemas/providers.py,sha256=lUz9QvMm_-wUUJZ5OGRsefsora0Y_55s3xQwnzL8gOw,51643
 letta/schemas/response_format.py,sha256=pXNsjbtpA3Tf8HsDyIa40CSmoUbVR_7n2WOfQaX4aFs,2204
 letta/schemas/run.py,sha256=SRqPRziINIiPunjOhE_NlbnQYgxTvqmbauni_yfBQRA,2085
-letta/schemas/sandbox_config.py,sha256=SZCo3FSMz-DIBMKGu0atT4tsVFXGsqMFPaJnjrxpkX4,5993
+letta/schemas/sandbox_config.py,sha256=Uu_GDofZasycarUVjXB1tL5-X1pLXSsrCB_7XycRIuM,6011
 letta/schemas/source.py,sha256=IuenIFs7B8uOuYJIHXqR1E28wVSa-pUX6NkLZH7cukg,3141
 letta/schemas/step.py,sha256=WkcVnruUUOWLKwiWPn2Gfal4EQZPNLqlsd9859xhgsw,2224
 letta/schemas/tool.py,sha256=n1gYBORUwT4pH5NYLLfT8v97JcoI3W6mpnUsa-GzcNg,13063
@@ -278,7 +278,7 @@ letta/server/rest_api/routers/v1/users.py,sha256=G5DBHSkPfBgVHN2Wkm-rVYiLQAudwQc
 letta/server/rest_api/routers/v1/voice.py,sha256=0lerWjrKLkt4gXLhZl1cIcgstOz9Q2HZwc67L58BCXE,2451
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=OKUWg7u4vmROVweqRrs83bQvS958bZAoR_bUFDwwqsc,14861
-letta/server/server.py,sha256=XcZ_vrQkG2CVr_mgCKVAV6EMVjuR4lQVtU3FTAUJIIc,79726
+letta/server/server.py,sha256=lEoFawsNHHa2VI-ipFuYqToi7OgJrVYOLUlNd_CYHqA,79889
 letta/server/startup.sh,sha256=MRXh1RKbS5lyA7XAsk7O6Q4LEKOqnv5B-dwe0SnTHeQ,2514
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
@@ -296,7 +296,7 @@ letta/services/agent_manager.py,sha256=I893THGSJrwQt-NynuY2rUJxTOGVCetIlXdkEZALc
 letta/services/block_manager.py,sha256=rphbpGBIEDFvCJ5GJt6A1OfbURGFQZ3WardljELQyAc,15225
 letta/services/group_manager.py,sha256=z1woWRRnjkWrGG_auSicXr2bJaJ653JV6PYl2N_AUfw,12224
 letta/services/helpers/agent_manager_helper.py,sha256=57ARg5TcmE_JdrWmhz5uaNHAt1NGlJ3wQH1tP2XOiAs,17825
-letta/services/helpers/tool_execution_helper.py,sha256=lLoebs1kZKjw62y1PxHbIDkHq_heJN2ZT0gKje-R8oo,6941
+letta/services/helpers/tool_execution_helper.py,sha256=E8knHJUP_EKmAzwKx-z-rd5EKjU-oroyPzyElUmq83o,6968
 letta/services/identity_manager.py,sha256=PqnUnM3OGCRnd5NPjGonwYBnYAQK8rpiissdNYUouGU,9389
 letta/services/job_manager.py,sha256=Z9cSD-IqpiOIWE_UOTBUEIxGITrJ10JT1G3ske-0yIY,17166
 letta/services/llm_batch_manager.py,sha256=jm6MY91hrZdcPOsimSd7Ns3mf0J4SwKV2_ShWXhD02k,16819
@@ -313,13 +313,13 @@ letta/services/summarizer/enums.py,sha256=szzPX2OBRRJEZsBTGYQThrNz02ELFqhuLwvOR7
 letta/services/summarizer/summarizer.py,sha256=4rbbzcB_lY4-3ybT8HMxM8OskLC38YCs9n5h0NhWRcY,4988
 letta/services/tool_executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/tool_executor/tool_execution_manager.py,sha256=RcmnwPougb8AxIwKdC4N9ZxTvOQqJyjI6CaVHF2HBi4,4505
-letta/services/tool_executor/tool_execution_sandbox.py,sha256=nEd36843hY_u076RtR2Wl-1HsnIq5XzMun8iGe1kwdU,24754
+letta/services/tool_executor/tool_execution_sandbox.py,sha256=EMQC25mYf7OxsUNPHFNkbcUZHZvf4QaeO94xenQJv4Y,21450
 letta/services/tool_executor/tool_executor.py,sha256=keWIzQuwqSzcC6kWcbTY_SfclhKtOT5CZNE-r3OBWNk,27372
 letta/services/tool_manager.py,sha256=a5PyLqYDd1H3snWdQGxl-dscMrBHlXcwg6U4T-tc_IM,10276
 letta/services/tool_sandbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/tool_sandbox/base.py,sha256=pUnPFkEg9I5ktMuT4AOOxbTnTmZTGcTA2phLe1H1EdY,8306
 letta/services/tool_sandbox/e2b_sandbox.py,sha256=umsXfolzM_j67izswECDdVfnlcm03wLpMoZtS6SZ0sc,6147
-letta/services/tool_sandbox/local_sandbox.py,sha256=TdtUkzT6lsKqUWvL9iw0CyL3el9r6fqfavLly8jnux4,10475
+letta/services/tool_sandbox/local_sandbox.py,sha256=3TC8bVZerhmVD6T-PxPN-QeQGOKzKjHNG7zhhU1o2ME,10511
 letta/services/user_manager.py,sha256=ScHbdJK9kNF8QXjsd3ZWGEL87n_Uyp3YwfKetOJmpHs,4304
 letta/settings.py,sha256=CN48IzOHJ2mUUDvYR1qlh-n9ukXJxNuVDlj_v74UJmg,8046
 letta/streaming_interface.py,sha256=kDSc5bnodgGzAuLcnq4Zf7p-uS6cdyxSIZ5U_JA_8FU,16300
@@ -327,8 +327,8 @@ letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,1194
 letta/system.py,sha256=dnOrS2FlRMwijQnOvfrky0Lg8wEw-FUq2zzfAJOUSKA,8477
 letta/tracing.py,sha256=RstWXpfWVF77nmb_ISORVWd9IQw2Ky3de40k_S70yKI,8258
 letta/utils.py,sha256=IZFvtj9WYcrxUbkoUUYGDxMYQYdn5SgfqsvnARGsAzc,32245
-letta_nightly-0.7.3.dev20250424104224.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.7.3.dev20250424104224.dist-info/METADATA,sha256=vkA4D8fksUdoGVsggydzQnSg3UiVVS2AoTdSuUz5CdI,22282
-letta_nightly-0.7.3.dev20250424104224.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.7.3.dev20250424104224.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.7.3.dev20250424104224.dist-info/RECORD,,
+letta_nightly-0.7.4.dev20250424184820.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.7.4.dev20250424184820.dist-info/METADATA,sha256=VuX6foyFknSyK3rzhVvx8iY8IY4yHwnfo_yIpjEFi8I,22282
+letta_nightly-0.7.4.dev20250424184820.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.7.4.dev20250424184820.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.7.4.dev20250424184820.dist-info/RECORD,,