letta-nightly 0.8.5.dev20250625104328__py3-none-any.whl → 0.8.6.dev20250626104326__py3-none-any.whl

letta/services/tool_executor/multi_agent_tool_executor.py

@@ -10,7 +10,6 @@ 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 logger
 from letta.services.tool_executor.tool_executor_base import ToolExecutor
 
 
@@ -30,7 +29,6 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
         assert agent_state is not None, "Agent state is required for multi-agent tools"
         function_map = {
             "send_message_to_agent_and_wait_for_reply": self.send_message_to_agent_and_wait_for_reply,
-            "send_message_to_agent_async": self.send_message_to_agent_async,
             "send_message_to_agents_matching_tags": self.send_message_to_agents_matching_tags_async,
         }
 
@@ -54,21 +52,6 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
 
         return str(await self._process_agent(agent_id=other_agent_id, message=augmented_message))
 
-    async def send_message_to_agent_async(self, agent_state: AgentState, message: str, other_agent_id: str) -> str:
-        # 1) Build the prefixed system‐message
-        prefixed = (
-            f"[Incoming message from agent with ID '{agent_state.id}' - "
-            f"to reply to this message, make sure to use the "
-            f"'send_message_to_agent_async' tool, or the agent will not receive your message] "
-            f"{message}"
-        )
-
-        task = asyncio.create_task(self._process_agent(agent_id=other_agent_id, message=prefixed))
-
-        task.add_done_callback(lambda t: (logger.error(f"Async send_message task failed: {t.exception()}") if t.exception() else None))
-
-        return "Successfully sent message"
-
     async def send_message_to_agents_matching_tags_async(
         self, agent_state: AgentState, message: str, match_all: List[str], match_some: List[str]
     ) -> str:
@@ -101,6 +84,7 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
                 message_manager=self.message_manager,
                 agent_manager=self.agent_manager,
                 block_manager=self.block_manager,
+                job_manager=self.job_manager,
                 passage_manager=self.passage_manager,
                 actor=self.actor,
             )

letta/services/tool_executor/tool_execution_manager.py

@@ -15,6 +15,7 @@ from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
+from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.tool_executor.builtin_tool_executor import LettaBuiltinToolExecutor
@@ -49,6 +50,7 @@ class ToolExecutorFactory:
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
+        job_manager: JobManager,
         passage_manager: PassageManager,
         actor: User,
     ) -> ToolExecutor:
@@ -58,6 +60,7 @@ class ToolExecutorFactory:
             message_manager=message_manager,
             agent_manager=agent_manager,
             block_manager=block_manager,
+            job_manager=job_manager,
             passage_manager=passage_manager,
             actor=actor,
         )
@@ -71,6 +74,7 @@ class ToolExecutionManager:
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
+        job_manager: JobManager,
         passage_manager: PassageManager,
         actor: User,
         agent_state: Optional[AgentState] = None,
@@ -80,6 +84,7 @@ class ToolExecutionManager:
         self.message_manager = message_manager
         self.agent_manager = agent_manager
         self.block_manager = block_manager
+        self.job_manager = job_manager
         self.passage_manager = passage_manager
         self.agent_state = agent_state
         self.logger = get_logger(__name__)
@@ -101,6 +106,7 @@ class ToolExecutionManager:
                 message_manager=self.message_manager,
                 agent_manager=self.agent_manager,
                 block_manager=self.block_manager,
+                job_manager=self.job_manager,
                 passage_manager=self.passage_manager,
                 actor=self.actor,
             )

letta/services/tool_executor/tool_executor_base.py

@@ -8,6 +8,7 @@ from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
+from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 
@@ -20,12 +21,14 @@ class ToolExecutor(ABC):
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
+        job_manager: JobManager,
         passage_manager: PassageManager,
         actor: User,
     ):
         self.message_manager = message_manager
         self.agent_manager = agent_manager
         self.block_manager = block_manager
+        self.job_manager = job_manager
         self.passage_manager = passage_manager
         self.actor = actor
 

letta/services/tool_sandbox/base.py

@@ -52,6 +52,9 @@ class AsyncToolSandboxBase(ABC):
         else:
             self.inject_agent_state = False
 
+        # Detect if the tool function is async
+        self.is_async_function = self._detect_async_function()
+
     # Lazily initialize the manager only when needed
     @property
     def sandbox_config_manager(self):
@@ -78,7 +81,8 @@ class AsyncToolSandboxBase(ABC):
         """
         from letta.templates.template_helper import render_template
 
-        TEMPLATE_NAME = "sandbox_code_file.py.j2"
+        # Select the appropriate template based on whether the function is async
+        TEMPLATE_NAME = "sandbox_code_file_async.py.j2" if self.is_async_function else "sandbox_code_file.py.j2"
 
         future_import = False
         schema_code = None
@@ -114,6 +118,7 @@ class AsyncToolSandboxBase(ABC):
             invoke_function_call=self.invoke_function_call(),
             wrap_print_with_markers=wrap_print_with_markers,
             start_marker=self.LOCAL_SANDBOX_RESULT_START_MARKER,
+            use_top_level_await=self.use_top_level_await(),
         )
 
     def initialize_param(self, name: str, raw_value: JsonValue) -> str:
@@ -150,5 +155,38 @@ class AsyncToolSandboxBase(ABC):
         func_call_str = self.tool.name + "(" + params + ")"
         return func_call_str
 
+    def _detect_async_function(self) -> bool:
+        """
+        Detect if the tool function is an async function by examining its source code.
+        Uses AST parsing to reliably detect 'async def' declarations.
+        """
+        import ast
+
+        try:
+            # Parse the source code to AST
+            tree = ast.parse(self.tool.source_code)
+
+            # Look for function definitions
+            for node in ast.walk(tree):
+                if isinstance(node, ast.AsyncFunctionDef) and node.name == self.tool.name:
+                    return True
+                elif isinstance(node, ast.FunctionDef) and node.name == self.tool.name:
+                    return False
+
+            # If we couldn't find the function definition, fall back to string matching
+            return "async def " + self.tool.name in self.tool.source_code
+
+        except SyntaxError:
+            # If source code can't be parsed, fall back to string matching
+            return "async def " + self.tool.name in self.tool.source_code
+
+    def use_top_level_await(self) -> bool:
+        """
+        Determine if this sandbox environment supports top-level await.
+        Should be overridden by subclasses to return True for environments
+        with running event loops (like E2B), False for local execution.
+        """
+        return False  # Default to False for local execution
+
     def _update_env_vars(self):
         pass  # TODO

letta/services/tool_sandbox/e2b_sandbox.py

@@ -250,6 +250,13 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
 
         return sbx
 
+    def use_top_level_await(self) -> bool:
+        """
+        E2B sandboxes run in a Jupyter-like environment with an active event loop,
+        so they support top-level await.
+        """
+        return True
+
     @staticmethod
     async def list_running_e2b_sandboxes():
         # List running sandboxes and access metadata.

letta/services/user_manager.py

@@ -8,6 +8,7 @@ from letta.helpers.decorators import async_redis_cache
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
+from letta.orm.sqlalchemy_base import is_postgresql_session
 from letta.orm.user import User as UserModel
 from letta.otel.tracing import trace_method
 from letta.schemas.user import User as PydanticUser
@@ -158,14 +159,14 @@ class UserManager:
         """Fetch a user by ID asynchronously."""
         async with db_registry.async_session() as session:
             # Turn off seqscan to force use pk index
-            if settings.letta_pg_uri_no_default:
+            if is_postgresql_session(session):
                 await session.execute(text("SET LOCAL enable_seqscan = OFF"))
             try:
                 stmt = select(UserModel).where(UserModel.id == actor_id)
                 result = await session.execute(stmt)
                 user = result.scalar_one_or_none()
             finally:
-                if settings.letta_pg_uri_no_default:
+                if is_postgresql_session(session):
                     await session.execute(text("SET LOCAL enable_seqscan = ON"))
 
             if not user:

letta/settings.py

@@ -95,9 +95,9 @@ class ModelSettings(BaseSettings):
     groq_api_key: Optional[str] = None
 
     # Bedrock
-    aws_access_key: Optional[str] = None
+    aws_access_key_id: Optional[str] = None
     aws_secret_access_key: Optional[str] = None
-    aws_region: Optional[str] = None
+    aws_default_region: Optional[str] = None
     bedrock_anthropic_version: Optional[str] = "bedrock-2023-05-31"
 
     # anthropic
@@ -196,8 +196,8 @@ class Settings(BaseSettings):
     pool_use_lifo: bool = True
     disable_sqlalchemy_pooling: bool = False
 
-    redis_host: Optional[str] = None
-    redis_port: Optional[int] = None
+    redis_host: Optional[str] = Field(default=None, description="Host for Redis instance")
+    redis_port: Optional[int] = Field(default=6379, description="Port for Redis instance")
 
     plugin_register: Optional[str] = None
 
@@ -230,16 +230,6 @@ class Settings(BaseSettings):
     use_experimental: bool = False
     use_vertex_structured_outputs_experimental: bool = False
 
-    # LLM provider client settings
-    httpx_max_retries: int = 5
-    httpx_timeout_connect: float = 10.0
-    httpx_timeout_read: float = 60.0
-    httpx_timeout_write: float = 30.0
-    httpx_timeout_pool: float = 10.0
-    httpx_max_connections: int = 500
-    httpx_max_keepalive_connections: int = 500
-    httpx_keepalive_expiry: float = 120.0
-
     # cron job parameters
     enable_batch_job_polling: bool = False
     poll_running_llm_batches_interval_seconds: int = 5 * 60
@@ -250,6 +240,10 @@ class Settings(BaseSettings):
     # for OCR
     mistral_api_key: Optional[str] = None
 
+    # LLM request timeout settings (model + embedding model)
+    llm_request_timeout_seconds: float = Field(default=60.0, ge=10.0, le=1800.0, description="Timeout for LLM requests in seconds")
+    llm_stream_timeout_seconds: float = Field(default=60.0, ge=10.0, le=1800.0, description="Timeout for LLM streaming requests in seconds")
+
     @property
     def letta_pg_uri(self) -> str:
         if self.pg_uri:

letta/system.py

@@ -13,7 +13,7 @@ from .helpers.datetime_helpers import get_local_time
 from .helpers.json_helpers import json_dumps
 
 
-def get_initial_boot_messages(version="startup"):
+def get_initial_boot_messages(version, timezone):
     if version == "startup":
         initial_boot_message = INITIAL_BOOT_MESSAGE
         messages = [
@@ -47,7 +47,7 @@ def get_initial_boot_messages(version="startup"):
                 # "role": "function",
                 "role": "tool",
                 "name": "send_message",  # NOTE: technically not up to spec, this is old functions style
-                "content": package_function_response(True, None),
+                "content": package_function_response(True, None, timezone),
                 "tool_call_id": tool_call_id,
             },
         ]
@@ -76,7 +76,7 @@ def get_initial_boot_messages(version="startup"):
                 # "role": "function",
                 "role": "tool",
                 "name": "send_message",
-                "content": package_function_response(True, None),
+                "content": package_function_response(True, None, timezone),
                 "tool_call_id": tool_call_id,
             },
         ]
@@ -87,9 +87,9 @@ def get_initial_boot_messages(version="startup"):
     return messages
 
 
-def get_heartbeat(reason="Automated timer", include_location=False, location_name="San Francisco, CA, USA"):
+def get_heartbeat(timezone, reason: str = "Automated timer", include_location: bool = False, location_name: str = "San Francisco, CA, USA"):
     # Package the message with time and location
-    formatted_time = get_local_time()
+    formatted_time = get_local_time(timezone=timezone)
     packaged_message = {
         "type": "heartbeat",
         "reason": reason,
@@ -102,9 +102,9 @@ def get_heartbeat(reason="Automated timer", include_location=False, location_nam
     return json_dumps(packaged_message)
 
 
-def get_login_event(last_login="Never (first login)", include_location=False, location_name="San Francisco, CA, USA"):
+def get_login_event(timezone, last_login="Never (first login)", include_location=False, location_name="San Francisco, CA, USA"):
     # Package the message with time and location
-    formatted_time = get_local_time()
+    formatted_time = get_local_time(timezone=timezone)
     packaged_message = {
         "type": "login",
         "last_login": last_login,
@@ -119,13 +119,13 @@ def get_login_event(last_login="Never (first login)", include_location=False, lo
 
 def package_user_message(
     user_message: str,
-    time: Optional[str] = None,
+    timezone: str,
     include_location: bool = False,
     location_name: Optional[str] = "San Francisco, CA, USA",
     name: Optional[str] = None,
 ):
     # Package the message with time and location
-    formatted_time = time if time else get_local_time()
+    formatted_time = get_local_time(timezone=timezone)
     packaged_message = {
         "type": "user_message",
         "message": user_message,
@@ -141,8 +141,8 @@ def package_user_message(
     return json_dumps(packaged_message)
 
 
-def package_function_response(was_success, response_string, timestamp=None):
-    formatted_time = get_local_time() if timestamp is None else timestamp
+def package_function_response(was_success, response_string, timezone):
+    formatted_time = get_local_time(timezone=timezone)
     packaged_message = {
         "status": "OK" if was_success else "Failed",
         "message": response_string,
@@ -152,7 +152,7 @@ def package_function_response(was_success, response_string, timestamp=None):
     return json_dumps(packaged_message)
 
 
-def package_system_message(system_message, message_type="system_alert", time=None):
+def package_system_message(system_message, timezone, message_type="system_alert"):
     # error handling for recursive packaging
     try:
         message_json = json.loads(system_message)
@@ -162,7 +162,7 @@ def package_system_message(system_message, message_type="system_alert", time=Non
     except:
         pass  # do nothing, expected behavior that the message is not JSON
 
-    formatted_time = time if time else get_local_time()
+    formatted_time = get_local_time(timezone=timezone)
     packaged_message = {
         "type": message_type,
         "message": system_message,
@@ -172,13 +172,13 @@ def package_system_message(system_message, message_type="system_alert", time=Non
     return json.dumps(packaged_message)
 
 
-def package_summarize_message(summary, summary_message_count, hidden_message_count, total_message_count, timestamp=None):
+def package_summarize_message(summary, summary_message_count, hidden_message_count, total_message_count, timezone):
     context_message = (
         f"Note: prior messages ({hidden_message_count} of {total_message_count} total messages) have been hidden from view due to conversation memory constraints.\n"
         + f"The following is a summary of the previous {summary_message_count} messages:\n {summary}"
     )
 
-    formatted_time = get_local_time() if timestamp is None else timestamp
+    formatted_time = get_local_time(timezone=timezone)
     packaged_message = {
         "type": "system_alert",
         "message": context_message,
@@ -188,11 +188,11 @@ def package_summarize_message(summary, summary_message_count, hidden_message_cou
     return json_dumps(packaged_message)
 
 
-def package_summarize_message_no_summary(hidden_message_count, timestamp=None, message=None):
+def package_summarize_message_no_summary(hidden_message_count, message=None, timezone=None):
     """Add useful metadata to the summary message"""
 
     # Package the message with time and location
-    formatted_time = get_local_time() if timestamp is None else timestamp
+    formatted_time = get_local_time(timezone=timezone)
     context_message = (
         message
         if message

letta/templates/sandbox_code_file_async.py.j2

@@ -0,0 +1,59 @@
+{{ 'from __future__ import annotations' if future_import else '' }}
+from typing import *
+import pickle
+import sys
+import base64
+import struct
+import hashlib
+import asyncio
+
+{# Additional imports to support agent state #}
+{% if inject_agent_state %}
+import letta
+from letta import *
+{% endif %}
+
+{# Add schema code if available #}
+{{ schema_imports or '' }}
+
+{# Load agent state #}
+agent_state = {{ 'pickle.loads(' ~ agent_state_pickle ~ ')' if agent_state_pickle else 'None' }}
+
+{{ tool_args }}
+
+{# The tool's source code #}
+{{ tool_source_code }}
+
+{# Async wrapper to handle the function call and store the result #}
+async def _async_wrapper():
+    result = await {{ invoke_function_call }}
+    return {
+        "results": result,
+        "agent_state": agent_state
+    }
+
+{# Run the async function - method depends on environment #}
+{% if use_top_level_await %}
+{# Environment with running event loop (like E2B) - use top-level await #}
+{{ local_sandbox_result_var_name }} = await _async_wrapper()
+{% else %}
+{# Local execution environment - use asyncio.run #}
+{{ local_sandbox_result_var_name }} = asyncio.run(_async_wrapper())
+{% endif %}
+
+{{ local_sandbox_result_var_name }}_pkl = pickle.dumps({{ local_sandbox_result_var_name }})
+
+{% if wrap_print_with_markers %}
+{# Combine everything to flush and write at once. #}
+data_checksum = hashlib.md5({{ local_sandbox_result_var_name }}_pkl).hexdigest().encode('ascii')
+{{ local_sandbox_result_var_name }}_msg = (
+  {{ start_marker }} +
+  struct.pack('>I', len({{ local_sandbox_result_var_name }}_pkl)) +
+  data_checksum +
+  {{ local_sandbox_result_var_name }}_pkl
+)
+sys.stdout.buffer.write({{ local_sandbox_result_var_name }}_msg)
+sys.stdout.buffer.flush()
+{% else %}
+base64.b64encode({{ local_sandbox_result_var_name }}_pkl).decode('utf-8')
+{% endif %}

{letta_nightly-0.8.5.dev20250625104328.dist-info → letta_nightly-0.8.6.dev20250626104326.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.8.5.dev20250625104328
+Version: 0.8.6.dev20250626104326
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -23,6 +23,7 @@ Provides-Extra: postgres
 Provides-Extra: redis
 Provides-Extra: server
 Provides-Extra: tests
+Requires-Dist: aioboto3 (>=14.3.0,<15.0.0) ; extra == "bedrock"
 Requires-Dist: aiomultiprocess (>=0.9.1,<0.10.0)
 Requires-Dist: aiosqlite (>=0.21.0,<0.22.0)
 Requires-Dist: alembic (>=1.13.3,<2.0.0)
@@ -56,7 +57,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.160,<0.2.0)
+Requires-Dist: letta_client (>=0.1.169,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"