letta-nightly 0.6.49.dev20250408030511__py3-none-any.whl → 0.6.50.dev20250409043626__py3-none-any.whl

letta/server/rest_api/app.py

@@ -16,6 +16,7 @@ from starlette.middleware.cors import CORSMiddleware
 from letta.__init__ import __version__
 from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
 from letta.errors import BedrockPermissionError, LettaAgentNotFoundError, LettaUserNotFoundError
+from letta.jobs.scheduler import shutdown_cron_scheduler, start_cron_jobs
 from letta.log import get_logger
 from letta.orm.errors import DatabaseTimeoutError, ForeignKeyConstraintViolationError, NoResultFound, UniqueConstraintViolationError
 from letta.schemas.letta_message import create_letta_message_union_schema
@@ -144,6 +145,12 @@ def create_application() -> "FastAPI":
         executor = concurrent.futures.ThreadPoolExecutor(max_workers=settings.event_loop_threadpool_max_workers)
         loop.set_default_executor(executor)
 
+    @app.on_event("startup")
+    def on_startup():
+        global server
+
+        start_cron_jobs(server)
+
     @app.on_event("shutdown")
     def shutdown_mcp_clients():
         global server
@@ -159,6 +166,10 @@ def create_application() -> "FastAPI":
         t.start()
         t.join()
 
+    @app.on_event("shutdown")
+    def shutdown_scheduler():
+        shutdown_cron_scheduler()
+
     @app.exception_handler(Exception)
     async def generic_error_handler(request: Request, exc: Exception):
         # Log the actual error for debugging

letta/server/rest_api/chat_completions_interface.py

@@ -160,6 +160,7 @@ class ChatCompletionsStreamingInterface(AgentChunkStreamingInterface):
         message_id: str,
         message_date: datetime,
         expect_reasoning_content: bool = False,
+        name: Optional[str] = None,
         message_index: int = 0,
     ) -> None:
         """

letta/server/rest_api/routers/v1/agents.py

@@ -14,7 +14,7 @@ from letta.agents.letta_agent import LettaAgent
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
-from letta.schemas.agent import AgentState, CreateAgent, UpdateAgent
+from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgent
 from letta.schemas.block import Block, BlockUpdate
 from letta.schemas.job import JobStatus, JobUpdate, LettaRequestConfig
 from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUnion
@@ -31,6 +31,7 @@ from letta.schemas.user import User
 from letta.serialize_schemas.pydantic_agent_schema import AgentSchema
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
+from letta.settings import settings
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
 
@@ -593,7 +594,13 @@ async def send_message(
     # TODO: This is redundant, remove soon
     agent = server.agent_manager.get_agent_by_id(agent_id, actor)
 
-    if agent.llm_config.model_endpoint_type == "anthropic" and not agent.enable_sleeptime and not agent.multi_agent_group:
+    if (
+        agent.llm_config.model_endpoint_type == "anthropic"
+        and not agent.enable_sleeptime
+        and not agent.multi_agent_group
+        and not agent.agent_type == AgentType.sleeptime_agent
+        and settings.use_experimental
+    ):
         experimental_agent = LettaAgent(
             agent_id=agent_id,
             message_manager=server.message_manager,
@@ -649,7 +656,13 @@ async def send_message_streaming(
     # TODO: This is redundant, remove soon
     agent = server.agent_manager.get_agent_by_id(agent_id, actor)
 
-    if agent.llm_config.model_endpoint_type == "anthropic" and not agent.enable_sleeptime and not agent.multi_agent_group:
+    if (
+        agent.llm_config.model_endpoint_type == "anthropic"
+        and not agent.enable_sleeptime
+        and not agent.multi_agent_group
+        and not agent.agent_type == AgentType.sleeptime_agent
+        and settings.use_experimental
+    ):
         experimental_agent = LettaAgent(
             agent_id=agent_id,
             message_manager=server.message_manager,

letta/server/server.py

@@ -8,6 +8,7 @@ from abc import abstractmethod
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
+from anthropic import AsyncAnthropic
 from composio.client import Composio
 from composio.client.collections import ActionModel, AppModel
 from fastapi import HTTPException
@@ -352,6 +353,9 @@ class SyncServer(Server):
         self._llm_config_cache = {}
         self._embedding_config_cache = {}
 
+        # TODO: Replace this with the Anthropic client we have in house
+        self.anthropic_async_client = AsyncAnthropic()
+
     def load_agent(self, agent_id: str, actor: User, interface: Union[AgentInterface, None] = None) -> Agent:
         """Updated method to load agents from persisted storage"""
         agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
@@ -775,7 +779,7 @@ class SyncServer(Server):
 
     def create_sleeptime_agent(self, main_agent: AgentState, actor: User) -> AgentState:
         request = CreateAgent(
-            name=main_agent.name,
+            name=main_agent.name + "-sleeptime",
             agent_type=AgentType.sleeptime_agent,
             block_ids=[block.id for block in main_agent.memory.blocks],
             memory_blocks=[

letta/services/agent_manager.py

@@ -38,7 +38,7 @@ from letta.schemas.group import ManagerType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message as PydanticMessage
-from letta.schemas.message import MessageCreate
+from letta.schemas.message import MessageCreate, MessageUpdate
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.tool import Tool as PydanticTool
@@ -115,9 +115,10 @@ class AgentManager:
                 block = self.block_manager.create_or_update_block(PydanticBlock(**create_block.model_dump(to_orm=True)), actor=actor)
                 block_ids.append(block.id)
 
-        # TODO: Remove this block once we deprecate the legacy `tools` field
-        # create passed in `tools`
-        tool_names = []
+        # add passed in `tools`
+        tool_names = agent_create.tools or []
+
+        # add base tools
         if agent_create.include_base_tools:
             if agent_create.agent_type == AgentType.sleeptime_agent:
                 tool_names.extend(BASE_SLEEPTIME_TOOLS)
@@ -128,42 +129,45 @@ class AgentManager:
                     tool_names.extend(BASE_TOOLS + BASE_MEMORY_TOOLS)
         if agent_create.include_multi_agent_tools:
             tool_names.extend(MULTI_AGENT_TOOLS)
-        if agent_create.tools:
-            tool_names.extend(agent_create.tools)
-        # Remove duplicates
+
+        # remove duplicates
         tool_names = list(set(tool_names))
 
+        # convert tool names to ids
+        tool_ids = []
+        for tool_name in tool_names:
+            tool = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
+            if not tool:
+                raise ValueError(f"Tool {tool_name} not found")
+            tool_ids.append(tool.id)
+
+        # add passed in `tool_ids`
+        for tool_id in agent_create.tool_ids or []:
+            if tool_id not in tool_ids:
+                tool = self.tool_manager.get_tool_by_id(tool_id=tool_id, actor=actor)
+                if tool:
+                    tool_ids.append(tool.id)
+                    tool_names.append(tool.name)
+                else:
+                    raise ValueError(f"Tool {tool_id} not found")
+
         # add default tool rules
+        tool_rules = agent_create.tool_rules or []
         if agent_create.include_base_tool_rules:
-            if not agent_create.tool_rules:
-                tool_rules = []
-            else:
-                tool_rules = agent_create.tool_rules
-
             # apply default tool rules
             for tool_name in tool_names:
                 if tool_name == "send_message" or tool_name == "send_message_to_agent_async" or tool_name == "finish_rethinking_memory":
                     tool_rules.append(PydanticTerminalToolRule(tool_name=tool_name))
-                elif tool_name in BASE_TOOLS:
+                elif tool_name in BASE_TOOLS + BASE_MEMORY_TOOLS + BASE_SLEEPTIME_TOOLS:
                     tool_rules.append(PydanticContinueToolRule(tool_name=tool_name))
 
             if agent_create.agent_type == AgentType.sleeptime_agent:
                 tool_rules.append(PydanticChildToolRule(tool_name="view_core_memory_with_line_numbers", children=["core_memory_insert"]))
 
-        else:
-            tool_rules = agent_create.tool_rules
-        # Check tool rules are valid
+        # if custom rules, check tool rules are valid
         if agent_create.tool_rules:
             check_supports_structured_output(model=agent_create.llm_config.model, tool_rules=agent_create.tool_rules)
 
-        tool_ids = agent_create.tool_ids or []
-        for tool_name in tool_names:
-            tool = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
-            if tool:
-                tool_ids.append(tool.id)
-        # Remove duplicates
-        tool_ids = list(set(tool_ids))
-
         # Create the agent
         agent_state = self._create_agent(
             name=agent_create.name,
@@ -714,10 +718,12 @@ class AgentManager:
                 model=agent_state.llm_config.model,
                 openai_message_dict={"role": "system", "content": new_system_message_str},
             )
-            # TODO: This seems kind of silly, why not just update the message?
-            message = self.message_manager.create_message(message, actor=actor)
-            message_ids = [message.id] + agent_state.message_ids[1:]  # swap index 0 (system)
-            return self.set_in_context_messages(agent_id=agent_id, message_ids=message_ids, actor=actor)
+            message = self.message_manager.update_message_by_id(
+                message_id=curr_system_message.id,
+                message_update=MessageUpdate(**message.model_dump()),
+                actor=actor,
+            )
+            return self.set_in_context_messages(agent_id=agent_id, message_ids=agent_state.message_ids, actor=actor)
         else:
             return agent_state
 

letta/services/helpers/agent_manager_helper.py

@@ -238,7 +238,9 @@ def initialize_message_sequence(
     first_user_message = get_login_event()  # event letting Letta know the user just logged in
 
     if include_initial_boot_message:
-        if agent_state.llm_config.model is not None and "gpt-3.5" in agent_state.llm_config.model:
+        if agent_state.agent_type == AgentType.sleeptime_agent:
+            initial_boot_messages = []
+        elif agent_state.llm_config.model is not None and "gpt-3.5" in agent_state.llm_config.model:
             initial_boot_messages = get_initial_boot_messages("startup_with_send_message_gpt35")
         else:
             initial_boot_messages = get_initial_boot_messages("startup_with_send_message")

letta/services/llm_batch_manager.py

@@ -1,13 +1,15 @@
 import datetime
-from typing import Optional
+from typing import List, Optional
 
 from anthropic.types.beta.messages import BetaMessageBatch, BetaMessageBatchIndividualResponse
+from sqlalchemy import tuple_
 
+from letta.jobs.types import BatchPollingResult, ItemUpdateInfo
 from letta.log import get_logger
 from letta.orm.llm_batch_items import LLMBatchItem
 from letta.orm.llm_batch_job import LLMBatchJob
 from letta.schemas.agent import AgentStepState
-from letta.schemas.enums import AgentStepStatus, JobStatus
+from letta.schemas.enums import AgentStepStatus, JobStatus, ProviderType
 from letta.schemas.llm_batch_job import LLMBatchItem as PydanticLLMBatchItem
 from letta.schemas.llm_batch_job import LLMBatchJob as PydanticLLMBatchJob
 from letta.schemas.llm_config import LLMConfig
@@ -28,7 +30,7 @@ class LLMBatchManager:
     @enforce_types
     def create_batch_request(
         self,
-        llm_provider: str,
+        llm_provider: ProviderType,
         create_batch_response: BetaMessageBatch,
         actor: PydanticUser,
         status: JobStatus = JobStatus.created,
@@ -45,7 +47,7 @@ class LLMBatchManager:
             return batch.to_pydantic()
 
     @enforce_types
-    def get_batch_request_by_id(self, batch_id: str, actor: PydanticUser) -> PydanticLLMBatchJob:
+    def get_batch_job_by_id(self, batch_id: str, actor: Optional[PydanticUser] = None) -> PydanticLLMBatchJob:
         """Retrieve a single batch job by ID."""
         with self.session_maker() as session:
             batch = LLMBatchJob.read(db_session=session, identifier=batch_id, actor=actor)
@@ -56,7 +58,7 @@ class LLMBatchManager:
         self,
         batch_id: str,
         status: JobStatus,
-        actor: PydanticUser,
+        actor: Optional[PydanticUser] = None,
         latest_polling_response: Optional[BetaMessageBatch] = None,
     ) -> PydanticLLMBatchJob:
         """Update a batch job’s status and optionally its polling response."""
@@ -65,7 +67,34 @@ class LLMBatchManager:
             batch.status = status
             batch.latest_polling_response = latest_polling_response
             batch.last_polled_at = datetime.datetime.now(datetime.timezone.utc)
-            return batch.update(db_session=session, actor=actor).to_pydantic()
+            batch = batch.update(db_session=session, actor=actor)
+            return batch.to_pydantic()
+
+    def bulk_update_batch_statuses(
+        self,
+        updates: List[BatchPollingResult],
+    ) -> None:
+        """
+        Efficiently update many LLMBatchJob rows. This is used by the cron jobs.
+
+        `updates` = [(batch_id, new_status, polling_response_or_None), …]
+        """
+        now = datetime.datetime.now(datetime.timezone.utc)
+
+        with self.session_maker() as session:
+            mappings = []
+            for batch_id, status, response in updates:
+                mappings.append(
+                    {
+                        "id": batch_id,
+                        "status": status,
+                        "latest_polling_response": response,
+                        "last_polled_at": now,
+                    }
+                )
+
+            session.bulk_update_mappings(LLMBatchJob, mappings)
+            session.commit()
 
     @enforce_types
     def delete_batch_request(self, batch_id: str, actor: PydanticUser) -> None:
@@ -74,6 +103,18 @@ class LLMBatchManager:
             batch = LLMBatchJob.read(db_session=session, identifier=batch_id, actor=actor)
             batch.hard_delete(db_session=session, actor=actor)
 
+    @enforce_types
+    def list_running_batches(self, actor: Optional[PydanticUser] = None) -> List[PydanticLLMBatchJob]:
+        """Return all running LLM batch jobs, optionally filtered by actor's organization."""
+        with self.session_maker() as session:
+            query = session.query(LLMBatchJob).filter(LLMBatchJob.status == JobStatus.running)
+
+            if actor is not None:
+                query = query.filter(LLMBatchJob.organization_id == actor.organization_id)
+
+            results = query.all()
+            return [batch.to_pydantic() for batch in results]
+
     @enforce_types
     def create_batch_item(
         self,
@@ -131,6 +172,56 @@ class LLMBatchManager:
 
             return item.update(db_session=session, actor=actor).to_pydantic()
 
+    def bulk_update_batch_items_by_agent(
+        self,
+        updates: List[ItemUpdateInfo],
+    ) -> None:
+        """
+        Efficiently update LLMBatchItem rows by (batch_id, agent_id).
+
+        Args:
+            updates: List of tuples:
+              (batch_id, agent_id, new_request_status, batch_request_result)
+        """
+        with self.session_maker() as session:
+            # For bulk_update_mappings, we need the primary key of each row
+            # So we must map (batch_id, agent_id) → actual PK (id)
+            # We'll do it in one DB query using the (batch_id, agent_id) sets
+
+            # 1. Gather the pairs
+            key_pairs = [(b_id, a_id) for (b_id, a_id, *_rest) in updates]
+
+            # 2. Query items in a single step
+            items = (
+                session.query(LLMBatchItem.id, LLMBatchItem.batch_id, LLMBatchItem.agent_id)
+                .filter(tuple_(LLMBatchItem.batch_id, LLMBatchItem.agent_id).in_(key_pairs))
+                .all()
+            )
+
+            # Build a map from (batch_id, agent_id) → PK id
+            pair_to_pk = {}
+            for row_id, row_batch_id, row_agent_id in items:
+                pair_to_pk[(row_batch_id, row_agent_id)] = row_id
+
+            # 3. Construct mappings for the PK-based bulk update
+            mappings = []
+            for batch_id, agent_id, new_status, new_result in updates:
+                pk_id = pair_to_pk.get((batch_id, agent_id))
+                if not pk_id:
+                    # Nonexistent or mismatch → skip
+                    continue
+                mappings.append(
+                    {
+                        "id": pk_id,
+                        "request_status": new_status,
+                        "batch_request_result": new_result,
+                    }
+                )
+
+            if mappings:
+                session.bulk_update_mappings(LLMBatchItem, mappings)
+                session.commit()
+
     @enforce_types
     def delete_batch_item(self, item_id: str, actor: PydanticUser) -> None:
         """Hard delete a batch item by ID."""

letta/services/tool_sandbox/local_sandbox.py

@@ -12,6 +12,7 @@ from letta.services.helpers.tool_execution_helper import (
     install_pip_requirements_for_sandbox,
 )
 from letta.services.tool_sandbox.base import AsyncToolSandboxBase
+from letta.settings import tool_settings
 from letta.tracing import log_event, trace_method
 from letta.utils import get_friendly_error_msg
 
@@ -152,7 +153,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
             )
 
             try:
-                stdout_bytes, stderr_bytes = await asyncio.wait_for(process.communicate(), timeout=60)
+                stdout_bytes, stderr_bytes = await asyncio.wait_for(process.communicate(), timeout=tool_settings.local_sandbox_timeout)
             except asyncio.TimeoutError:
                 # Terminate the process on timeout
                 if process.returncode is None:

letta/settings.py

@@ -17,6 +17,7 @@ class ToolSettings(BaseSettings):
 
     # Local Sandbox configurations
     local_sandbox_dir: Optional[str] = None
+    local_sandbox_timeout: float = 180
 
     # MCP settings
     mcp_connect_to_server_timeout: float = 30.0
@@ -203,6 +204,9 @@ class Settings(BaseSettings):
     httpx_max_keepalive_connections: int = 500
     httpx_keepalive_expiry: float = 120.0
 
+    # cron job parameters
+    poll_running_llm_batches_interval_seconds: int = 5 * 60
+
     @property
     def letta_pg_uri(self) -> str:
         if self.pg_uri:

letta/streaming_interface.py

@@ -54,6 +54,7 @@ class AgentChunkStreamingInterface(ABC):
         message_id: str,
         message_date: datetime,
         expect_reasoning_content: bool = False,
+        name: Optional[str] = None,
         message_index: int = 0,
     ):
         """Process a streaming chunk from an OpenAI-compatible server"""
@@ -105,6 +106,7 @@ class StreamingCLIInterface(AgentChunkStreamingInterface):
         message_id: str,
         message_date: datetime,
         expect_reasoning_content: bool = False,
+        name: Optional[str] = None,
         message_index: int = 0,
     ):
         assert len(chunk.choices) == 1, chunk

{letta_nightly-0.6.49.dev20250408030511.dist-info → letta_nightly-0.6.50.dev20250409043626.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.49.dev20250408030511
+Version: 0.6.50.dev20250409043626
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -24,6 +24,7 @@ Provides-Extra: server
 Provides-Extra: tests
 Requires-Dist: alembic (>=1.13.3,<2.0.0)
 Requires-Dist: anthropic (>=0.49.0,<0.50.0)
+Requires-Dist: apscheduler (>=3.11.0,<4.0.0)
 Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: boto3 (>=1.36.24,<2.0.0) ; extra == "bedrock"
@@ -31,7 +32,7 @@ Requires-Dist: brotli (>=1.1.0,<2.0.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: composio-core (>=0.7.7,<0.8.0)
 Requires-Dist: composio-langchain (>=0.7.7,<0.8.0)
-Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0) ; extra == "desktop" or extra == "all"
+Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0)
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)
 Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: docstring-parser (>=0.16,<0.17)
@@ -49,12 +50,12 @@ 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.97,<0.2.0) ; extra == "desktop"
+Requires-Dist: letta_client (>=0.1.97,<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"
 Requires-Dist: marshmallow-sqlalchemy (>=1.4.1,<2.0.0)
-Requires-Dist: mcp (>=1.3.0,<2.0.0) ; extra == "desktop"
+Requires-Dist: mcp (>=1.3.0,<2.0.0)
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numpy (>=1.26.2,<2.0.0)
 Requires-Dist: openai (>=1.60.0,<2.0.0)