letta-nightly 0.7.0.dev20250423003112__py3-none-any.whl → 0.7.2.dev20250423222439__py3-none-any.whl

letta/services/llm_batch_manager.py

@@ -291,9 +291,7 @@ class LLMBatchManager:
             return [item.to_pydantic() for item in results]
 
     def bulk_update_llm_batch_items(
-        self,
-        llm_batch_id_agent_id_pairs: List[Tuple[str, str]],
-        field_updates: List[Dict[str, Any]],
+        self, llm_batch_id_agent_id_pairs: List[Tuple[str, str]], field_updates: List[Dict[str, Any]], strict: bool = True
     ) -> None:
         """
         Efficiently update multiple LLMBatchItem rows by (llm_batch_id, agent_id) pairs.
@@ -301,30 +299,43 @@ class LLMBatchManager:
         Args:
             llm_batch_id_agent_id_pairs: List of (llm_batch_id, agent_id) tuples identifying items to update
             field_updates: List of dictionaries containing the fields to update for each item
+            strict: Whether to error if any of the requested keys don't exist (default True).
+                    If False, missing pairs are skipped.
         """
         if not llm_batch_id_agent_id_pairs or not field_updates:
             return
 
         if len(llm_batch_id_agent_id_pairs) != len(field_updates):
-            raise ValueError("batch_id_agent_id_pairs and field_updates must have the same length")
+            raise ValueError("llm_batch_id_agent_id_pairs and field_updates must have the same length")
 
         with self.session_maker() as session:
-            # Lookup primary keys
+            # Lookup primary keys for all requested (batch_id, agent_id) pairs
             items = (
                 session.query(LLMBatchItem.id, LLMBatchItem.llm_batch_id, LLMBatchItem.agent_id)
                 .filter(tuple_(LLMBatchItem.llm_batch_id, LLMBatchItem.agent_id).in_(llm_batch_id_agent_id_pairs))
                 .all()
             )
-            pair_to_pk = {(b, a): id for id, b, a in items}
-
+            pair_to_pk = {(batch_id, agent_id): pk for pk, batch_id, agent_id in items}
+
+            if strict:
+                requested = set(llm_batch_id_agent_id_pairs)
+                found = set(pair_to_pk.keys())
+                missing = requested - found
+                if missing:
+                    raise ValueError(
+                        f"Cannot bulk-update batch items: no records for the following " f"(llm_batch_id, agent_id) pairs: {missing}"
+                    )
+
+            # Build mappings, skipping any missing when strict=False
             mappings = []
-            for (llm_batch_id, agent_id), fields in zip(llm_batch_id_agent_id_pairs, field_updates):
-                pk_id = pair_to_pk.get((llm_batch_id, agent_id))
-                if not pk_id:
+            for (batch_id, agent_id), fields in zip(llm_batch_id_agent_id_pairs, field_updates):
+                pk = pair_to_pk.get((batch_id, agent_id))
+                if pk is None:
+                    # skip missing in non-strict mode
                     continue
 
                 update_fields = fields.copy()
-                update_fields["id"] = pk_id
+                update_fields["id"] = pk
                 mappings.append(update_fields)
 
             if mappings:
@@ -332,10 +343,7 @@ class LLMBatchManager:
                 session.commit()
 
     @enforce_types
-    def bulk_update_batch_llm_items_results_by_agent(
-        self,
-        updates: List[ItemUpdateInfo],
-    ) -> None:
+    def bulk_update_batch_llm_items_results_by_agent(self, updates: List[ItemUpdateInfo], strict: bool = True) -> None:
         """Update request status and batch results for multiple batch items."""
         batch_id_agent_id_pairs = [(update.llm_batch_id, update.agent_id) for update in updates]
         field_updates = [
@@ -346,29 +354,23 @@ class LLMBatchManager:
             for update in updates
         ]
 
-        self.bulk_update_llm_batch_items(batch_id_agent_id_pairs, field_updates)
+        self.bulk_update_llm_batch_items(batch_id_agent_id_pairs, field_updates, strict=strict)
 
     @enforce_types
-    def bulk_update_llm_batch_items_step_status_by_agent(
-        self,
-        updates: List[StepStatusUpdateInfo],
-    ) -> None:
+    def bulk_update_llm_batch_items_step_status_by_agent(self, updates: List[StepStatusUpdateInfo], strict: bool = True) -> None:
         """Update step status for multiple batch items."""
         batch_id_agent_id_pairs = [(update.llm_batch_id, update.agent_id) for update in updates]
         field_updates = [{"step_status": update.step_status} for update in updates]
 
-        self.bulk_update_llm_batch_items(batch_id_agent_id_pairs, field_updates)
+        self.bulk_update_llm_batch_items(batch_id_agent_id_pairs, field_updates, strict=strict)
 
     @enforce_types
-    def bulk_update_llm_batch_items_request_status_by_agent(
-        self,
-        updates: List[RequestStatusUpdateInfo],
-    ) -> None:
+    def bulk_update_llm_batch_items_request_status_by_agent(self, updates: List[RequestStatusUpdateInfo], strict: bool = True) -> None:
         """Update request status for multiple batch items."""
         batch_id_agent_id_pairs = [(update.llm_batch_id, update.agent_id) for update in updates]
         field_updates = [{"request_status": update.request_status} for update in updates]
 
-        self.bulk_update_llm_batch_items(batch_id_agent_id_pairs, field_updates)
+        self.bulk_update_llm_batch_items(batch_id_agent_id_pairs, field_updates, strict=strict)
 
     @enforce_types
     def delete_llm_batch_item(self, item_id: str, actor: PydanticUser) -> None:

letta/services/tool_executor/tool_execution_manager.py

@@ -1,16 +1,17 @@
-from typing import Any, Dict, Optional, Tuple, Type
+import traceback
+from typing import Any, Dict, Optional, Type
 
 from letta.log import get_logger
 from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState
-from letta.schemas.sandbox_config import SandboxConfig, SandboxRunResult
+from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
+from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.services.tool_executor.tool_executor import (
     ExternalComposioToolExecutor,
     ExternalMCPToolExecutor,
     LettaCoreToolExecutor,
-    LettaMemoryToolExecutor,
     LettaMultiAgentToolExecutor,
     SandboxToolExecutor,
     ToolExecutor,
@@ -24,8 +25,9 @@ class ToolExecutorFactory:
 
     _executor_map: Dict[ToolType, Type[ToolExecutor]] = {
         ToolType.LETTA_CORE: LettaCoreToolExecutor,
+        ToolType.LETTA_MEMORY_CORE: LettaCoreToolExecutor,
+        ToolType.LETTA_SLEEPTIME_CORE: LettaCoreToolExecutor,
         ToolType.LETTA_MULTI_AGENT_CORE: LettaMultiAgentToolExecutor,
-        ToolType.LETTA_MEMORY_CORE: LettaMemoryToolExecutor,
         ToolType.EXTERNAL_COMPOSIO: ExternalComposioToolExecutor,
         ToolType.EXTERNAL_MCP: ExternalMCPToolExecutor,
     }
@@ -33,13 +35,8 @@ class ToolExecutorFactory:
     @classmethod
     def get_executor(cls, tool_type: ToolType) -> ToolExecutor:
         """Get the appropriate executor for the given tool type."""
-        executor_class = cls._executor_map.get(tool_type)
-
-        if executor_class:
-            return executor_class()
-
-        # Default to sandbox executor for unknown types
-        return SandboxToolExecutor()
+        executor_class = cls._executor_map.get(tool_type, SandboxToolExecutor)
+        return executor_class()
 
 
 class ToolExecutionManager:
@@ -58,7 +55,7 @@ class ToolExecutionManager:
         self.sandbox_config = sandbox_config
         self.sandbox_env_vars = sandbox_env_vars
 
-    def execute_tool(self, function_name: str, function_args: dict, tool: Tool) -> Tuple[Any, Optional[SandboxRunResult]]:
+    def execute_tool(self, function_name: str, function_args: dict, tool: Tool) -> ToolExecutionResult:
         """
         Execute a tool and persist any state changes.
 
@@ -71,35 +68,43 @@ class ToolExecutionManager:
             Tuple containing the function response and sandbox run result (if applicable)
         """
         try:
-            # Get the appropriate executor for this tool type
             executor = ToolExecutorFactory.get_executor(tool.tool_type)
-
-            # Execute the tool
             return executor.execute(
-                function_name, function_args, self.agent_state, tool, self.actor, self.sandbox_config, self.sandbox_env_vars
+                function_name,
+                function_args,
+                self.agent_state,
+                tool,
+                self.actor,
+                self.sandbox_config,
+                self.sandbox_env_vars,
             )
 
         except Exception as e:
             self.logger.error(f"Error executing tool {function_name}: {str(e)}")
-            error_message = get_friendly_error_msg(function_name=function_name, exception_name=type(e).__name__, exception_message=str(e))
-            return error_message, SandboxRunResult(status="error")
+            error_message = get_friendly_error_msg(
+                function_name=function_name,
+                exception_name=type(e).__name__,
+                exception_message=str(e),
+            )
+            return ToolExecutionResult(
+                status="error",
+                func_return=error_message,
+                stderr=[traceback.format_exc()],
+            )
 
     @trace_method
-    async def execute_tool_async(self, function_name: str, function_args: dict, tool: Tool) -> Tuple[Any, Optional[SandboxRunResult]]:
+    async def execute_tool_async(self, function_name: str, function_args: dict, tool: Tool) -> ToolExecutionResult:
         """
         Execute a tool asynchronously and persist any state changes.
         """
         try:
-            # Get the appropriate executor for this tool type
+            executor = ToolExecutorFactory.get_executor(tool.tool_type)
             # TODO: Extend this async model to composio
-
-            if tool.tool_type == ToolType.CUSTOM:
-                executor = SandboxToolExecutor()
-                result_tuple = await executor.execute(function_name, function_args, self.agent_state, tool, self.actor)
+            if isinstance(executor, SandboxToolExecutor):
+                result = await executor.execute(function_name, function_args, self.agent_state, tool, self.actor)
             else:
-                executor = ToolExecutorFactory.get_executor(tool.tool_type)
-                result_tuple = executor.execute(function_name, function_args, self.agent_state, tool, self.actor)
-            return result_tuple
+                result = executor.execute(function_name, function_args, self.agent_state, tool, self.actor)
+            return result
 
         except Exception as e:
             self.logger.error(f"Error executing tool {function_name}: {str(e)}")
@@ -108,4 +113,8 @@ class ToolExecutionManager:
                 exception_name=type(e).__name__,
                 exception_message=str(e),
             )
-            return error_message, SandboxRunResult(status="error")
+            return ToolExecutionResult(
+                status="error",
+                func_return=error_message,
+                stderr=[traceback.format_exc()],
+            )

letta/services/tool_executor/tool_execution_sandbox.py

@@ -13,8 +13,9 @@ from typing import Any, Dict, Optional
 from letta.functions.helpers import generate_model_from_args_json_schema
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
-from letta.schemas.sandbox_config import SandboxConfig, SandboxRunResult, SandboxType
+from letta.schemas.sandbox_config import SandboxConfig, SandboxType
 from letta.schemas.tool import Tool
+from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.services.helpers.tool_execution_helper import (
     add_imports_and_pydantic_schemas_for_args,
@@ -72,7 +73,11 @@ class ToolExecutionSandbox:
         self.force_recreate = force_recreate
         self.force_recreate_venv = force_recreate_venv
 
-    def run(self, agent_state: Optional[AgentState] = None, additional_env_vars: Optional[Dict] = None) -> SandboxRunResult:
+    def run(
+        self,
+        agent_state: Optional[AgentState] = None,
+        additional_env_vars: Optional[Dict] = None,
+    ) -> ToolExecutionResult:
         """
         Run the tool in a sandbox environment.
 
@@ -81,7 +86,7 @@ class ToolExecutionSandbox:
             additional_env_vars (Optional[Dict]): Environment variables to inject into the sandbox
 
         Returns:
-            Tuple[Any, Optional[AgentState]]: Tuple containing (tool_result, agent_state)
+            ToolExecutionResult: Object containing tool execution outcome (e.g. status, response)
         """
         if tool_settings.e2b_api_key and not self.privileged_tools:
             logger.debug(f"Using e2b sandbox to execute {self.tool_name}")
@@ -115,7 +120,7 @@ class ToolExecutionSandbox:
     @trace_method
     def run_local_dir_sandbox(
         self, agent_state: Optional[AgentState] = None, additional_env_vars: Optional[Dict] = None
-    ) -> SandboxRunResult:
+    ) -> ToolExecutionResult:
         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()
 
@@ -162,7 +167,12 @@ class ToolExecutionSandbox:
             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) -> SandboxRunResult:
+    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)
@@ -205,12 +215,12 @@ class ToolExecutionSandbox:
             func_result, stdout = self.parse_out_function_results_markers(result.stdout)
             func_return, agent_state = self.parse_best_effort(func_result)
 
-            return SandboxRunResult(
+            return ToolExecutionResult(
+                status="success",
                 func_return=func_return,
                 agent_state=agent_state,
                 stdout=[stdout] if stdout else [],
                 stderr=[result.stderr] if result.stderr else [],
-                status="success",
                 sandbox_config_fingerprint=sbx_config.fingerprint(),
             )
 
@@ -221,12 +231,12 @@ class ToolExecutionSandbox:
                 exception_name=type(e).__name__,
                 exception_message=str(e),
             )
-            return SandboxRunResult(
+            return ToolExecutionResult(
+                status="error",
                 func_return=func_return,
                 agent_state=None,
                 stdout=[e.stdout] if e.stdout else [],
                 stderr=[e.stderr] if e.stderr else [],
-                status="error",
                 sandbox_config_fingerprint=sbx_config.fingerprint(),
             )
 
@@ -238,7 +248,12 @@ class ToolExecutionSandbox:
             raise e
 
     @trace_method
-    def run_local_dir_sandbox_directly(self, sbx_config: SandboxConfig, env: Dict[str, str], temp_file_path: str) -> SandboxRunResult:
+    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
 
@@ -288,12 +303,12 @@ class ToolExecutionSandbox:
         stdout_output = [captured_stdout.getvalue()] if captured_stdout.getvalue() else []
         stderr_output = [captured_stderr.getvalue()] if captured_stderr.getvalue() else []
 
-        return SandboxRunResult(
+        return ToolExecutionResult(
+            status=status,
             func_return=func_return,
             agent_state=agent_state,
             stdout=stdout_output,
             stderr=stderr_output,
-            status=status,
             sandbox_config_fingerprint=sbx_config.fingerprint(),
         )
 
@@ -307,7 +322,11 @@ class ToolExecutionSandbox:
 
     # e2b sandbox specific functions
 
-    def run_e2b_sandbox(self, agent_state: Optional[AgentState] = None, additional_env_vars: Optional[Dict] = None) -> SandboxRunResult:
+    def run_e2b_sandbox(
+        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.E2B, actor=self.user)
         sbx = self.get_running_e2b_sandbox_with_same_state(sbx_config)
         if not sbx or self.force_recreate:
@@ -348,12 +367,12 @@ class ToolExecutionSandbox:
         else:
             raise ValueError(f"Tool {self.tool_name} returned execution with None")
 
-        return SandboxRunResult(
+        return ToolExecutionResult(
+            status="error" if execution.error else "success",
             func_return=func_return,
             agent_state=agent_state,
             stdout=execution.logs.stdout,
             stderr=execution.logs.stderr,
-            status="error" if execution.error else "success",
             sandbox_config_fingerprint=sbx_config.fingerprint(),
         )
 
@@ -535,7 +554,7 @@ class ToolExecutionSandbox:
         Generate the code string to call the function.
 
         Args:
-            inject_agent_state (bool): Whether to inject the axgent's state as an input into the tool
+            inject_agent_state (bool): Whether to inject the agent's state as an input into the tool
 
         Returns:
             str: Generated code string for calling the tool