letta-nightly 0.7.8.dev20250502104219__py3-none-any.whl → 0.7.9.dev20250503104103__py3-none-any.whl

letta/schemas/message.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import copy
 import json
+import re
 import uuid
 import warnings
 from collections import OrderedDict
@@ -84,6 +85,7 @@ class MessageCreate(BaseModel):
     name: Optional[str] = Field(None, description="The name of the participant.")
     otid: Optional[str] = Field(None, description="The offline threading id associated with this message")
     sender_id: Optional[str] = Field(None, description="The id of the sender of the message, can be an identity id or agent id")
+    batch_item_id: Optional[str] = Field(None, description="The id of the LLMBatchItem that this message is associated with")
     group_id: Optional[str] = Field(None, description="The multi-agent group that the message was sent in")
 
     def model_dump(self, to_orm: bool = False, **kwargs) -> Dict[str, Any]:
@@ -137,6 +139,11 @@ class Message(BaseMessage):
         created_at (datetime): The time the message was created.
         tool_calls (List[OpenAIToolCall,]): The list of tool calls requested.
         tool_call_id (str): The id of the tool call.
+        step_id (str): The id of the step that this message was created in.
+        otid (str): The offline threading id associated with this message.
+        tool_returns (List[ToolReturn]): The list of tool returns requested.
+        group_id (str): The multi-agent group that the message was sent in.
+        sender_id (str): The id of the sender of the message, can be an identity id or agent id.
 
     """
 
@@ -162,6 +169,7 @@ class Message(BaseMessage):
     tool_returns: Optional[List[ToolReturn]] = Field(None, description="Tool execution return information for prior tool calls")
     group_id: Optional[str] = Field(None, description="The multi-agent group that the message was sent in")
     sender_id: Optional[str] = Field(None, description="The id of the sender of the message, can be an identity id or agent id")
+    batch_item_id: Optional[str] = Field(None, description="The id of the LLMBatchItem that this message is associated with")
     # This overrides the optional base orm schema, created_at MUST exist on all messages objects
     created_at: datetime = Field(default_factory=get_utc_time, description="The timestamp when the object was created.")
 
@@ -252,6 +260,7 @@ class Message(BaseMessage):
                             name=self.name,
                             otid=otid,
                             sender_id=self.sender_id,
+                            step_id=self.step_id,
                         )
                     )
                 # Otherwise, we may have a list of multiple types
@@ -269,6 +278,7 @@ class Message(BaseMessage):
                                     name=self.name,
                                     otid=otid,
                                     sender_id=self.sender_id,
+                                    step_id=self.step_id,
                                 )
                             )
                         elif isinstance(content_part, ReasoningContent):
@@ -282,6 +292,7 @@ class Message(BaseMessage):
                                     signature=content_part.signature,
                                     name=self.name,
                                     otid=otid,
+                                    step_id=self.step_id,
                                 )
                             )
                         elif isinstance(content_part, RedactedReasoningContent):
@@ -295,6 +306,7 @@ class Message(BaseMessage):
                                     name=self.name,
                                     otid=otid,
                                     sender_id=self.sender_id,
+                                    step_id=self.step_id,
                                 )
                             )
                         elif isinstance(content_part, OmittedReasoningContent):
@@ -307,6 +319,7 @@ class Message(BaseMessage):
                                     state="omitted",
                                     name=self.name,
                                     otid=otid,
+                                    step_id=self.step_id,
                                 )
                             )
                         else:
@@ -333,6 +346,7 @@ class Message(BaseMessage):
                                 name=self.name,
                                 otid=otid,
                                 sender_id=self.sender_id,
+                                step_id=self.step_id,
                             )
                         )
                     else:
@@ -348,6 +362,7 @@ class Message(BaseMessage):
                                 name=self.name,
                                 otid=otid,
                                 sender_id=self.sender_id,
+                                step_id=self.step_id,
                             )
                         )
         elif self.role == MessageRole.tool:
@@ -391,6 +406,7 @@ class Message(BaseMessage):
                     name=self.name,
                     otid=self.id.replace("message-", ""),
                     sender_id=self.sender_id,
+                    step_id=self.step_id,
                 )
             )
         elif self.role == MessageRole.user:
@@ -409,6 +425,7 @@ class Message(BaseMessage):
                     name=self.name,
                     otid=self.otid,
                     sender_id=self.sender_id,
+                    step_id=self.step_id,
                 )
             )
         elif self.role == MessageRole.system:
@@ -426,6 +443,7 @@ class Message(BaseMessage):
                     name=self.name,
                     otid=self.otid,
                     sender_id=self.sender_id,
+                    step_id=self.step_id,
                 )
             )
         else:
@@ -700,9 +718,12 @@ class Message(BaseMessage):
         else:
             raise ValueError(self.role)
 
-        # Optional field, do not include if null
+        # Optional field, do not include if null or invalid
         if self.name is not None:
-            openai_message["name"] = self.name
+            if bool(re.match(r"^[^\s<|\\/>]+$", self.name)):
+                openai_message["name"] = self.name
+            else:
+                warnings.warn(f"Using OpenAI with invalid 'name' field (name={self.name} role={self.role}).")
 
         if parse_content_parts:
             for content in self.content:

letta/schemas/providers.py

@@ -201,7 +201,9 @@ class OpenAIProvider(Provider):
             # for openai, filter models
             if self.base_url == "https://api.openai.com/v1":
                 allowed_types = ["gpt-4", "o1", "o3"]
-                disallowed_types = ["transcribe", "search", "realtime", "tts", "audio", "computer"]
+                # NOTE: o1-mini and o1-preview do not support tool calling
+                # NOTE: o1-pro is only available in Responses API
+                disallowed_types = ["transcribe", "search", "realtime", "tts", "audio", "computer", "o1-mini", "o1-preview", "o1-pro"]
                 skip = True
                 for model_type in allowed_types:
                     if model_name.startswith(model_type):

letta/server/rest_api/app.py

@@ -17,7 +17,7 @@ from letta.__init__ import __version__
 from letta.agents.exceptions import IncompatibleAgentType
 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.jobs.scheduler import shutdown_scheduler_and_release_lock, start_scheduler_with_leader_election
 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
@@ -150,10 +150,10 @@ def create_application() -> "FastAPI":
         loop.set_default_executor(executor)
 
     @app.on_event("startup")
-    def on_startup():
+    async def on_startup():
         global server
 
-        start_cron_jobs(server)
+        await start_scheduler_with_leader_election(server)
 
     @app.on_event("shutdown")
     def shutdown_mcp_clients():
@@ -170,9 +170,16 @@ def create_application() -> "FastAPI":
         t.start()
         t.join()
 
-    @app.on_event("shutdown")
-    def shutdown_scheduler():
-        shutdown_cron_scheduler()
+    @app.exception_handler(IncompatibleAgentType)
+    async def handle_incompatible_agent_type(request: Request, exc: IncompatibleAgentType):
+        return JSONResponse(
+            status_code=400,
+            content={
+                "detail": str(exc),
+                "expected_type": exc.expected_type,
+                "actual_type": exc.actual_type,
+            },
+        )
 
     @app.exception_handler(IncompatibleAgentType)
     async def handle_incompatible_agent_type(request: Request, exc: IncompatibleAgentType):
@@ -322,9 +329,10 @@ def create_application() -> "FastAPI":
     generate_openapi_schema(app)
 
     @app.on_event("shutdown")
-    def on_shutdown():
+    async def on_shutdown():
         global server
         # server = None
+        await shutdown_scheduler_and_release_lock()
 
     return app
 

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

@@ -13,6 +13,7 @@ from starlette.responses import Response, StreamingResponse
 
 from letta.agents.letta_agent import LettaAgent
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
+from letta.helpers.datetime_helpers import get_utc_timestamp_ns
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgent
@@ -684,6 +685,7 @@ async def send_message_streaming(
     This endpoint accepts a message from a user and processes it through the agent.
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
+    request_start_timestamp_ns = get_utc_timestamp_ns()
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     # TODO: This is redundant, remove soon
     agent = server.agent_manager.get_agent_by_id(agent_id, actor)
@@ -719,6 +721,7 @@ async def send_message_streaming(
             use_assistant_message=request.use_assistant_message,
             assistant_message_tool_name=request.assistant_message_tool_name,
             assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+            request_start_timestamp_ns=request_start_timestamp_ns,
         )
 
     return result

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

@@ -1,6 +1,6 @@
 from typing import List, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, status
+from fastapi import APIRouter, Body, Depends, Header, Query, status
 from fastapi.exceptions import HTTPException
 from starlette.requests import Request
 
@@ -9,6 +9,7 @@ from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.schemas.job import BatchJob, JobStatus, JobType, JobUpdate
 from letta.schemas.letta_request import CreateBatch
+from letta.schemas.letta_response import LettaBatchMessages
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 from letta.settings import settings
@@ -123,6 +124,50 @@ async def list_batch_runs(
     return [BatchJob.from_job(job) for job in jobs]
 
 
+@router.get(
+    "/batches/{batch_id}/messages",
+    response_model=LettaBatchMessages,
+    operation_id="list_batch_messages",
+)
+async def list_batch_messages(
+    batch_id: str,
+    limit: int = Query(100, description="Maximum number of messages to return"),
+    cursor: Optional[str] = Query(
+        None, description="Message ID to use as pagination cursor (get messages before/after this ID) depending on sort_descending."
+    ),
+    agent_id: Optional[str] = Query(None, description="Filter messages by agent ID"),
+    sort_descending: bool = Query(True, description="Sort messages by creation time (true=newest first)"),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    Get messages for a specific batch job.
+
+    Returns messages associated with the batch in chronological order.
+
+    Pagination:
+    - For the first page, omit the cursor parameter
+    - For subsequent pages, use the ID of the last message from the previous response as the cursor
+    - Results will include messages before/after the cursor based on sort_descending
+    """
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+
+    # First, verify the batch job exists and the user has access to it
+    try:
+        job = server.job_manager.get_job_by_id(job_id=batch_id, actor=actor)
+        BatchJob.from_job(job)
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Batch not found")
+
+    # Get messages directly using our efficient method
+    # We'll need to update the underlying implementation to use message_id as cursor
+    messages = server.batch_manager.get_messages_for_letta_batch(
+        letta_batch_job_id=batch_id, limit=limit, actor=actor, agent_id=agent_id, sort_descending=sort_descending, cursor=cursor
+    )
+
+    return LettaBatchMessages(messages=messages)
+
+
 @router.patch("/batches/{batch_id}/cancel", operation_id="cancel_batch_run")
 async def cancel_batch_run(
     batch_id: str,

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

@@ -11,7 +11,7 @@ from letta.server.server import SyncServer
 router = APIRouter(prefix="/steps", tags=["steps"])
 
 
-@router.get("", response_model=List[Step], operation_id="list_steps")
+@router.get("/", response_model=List[Step], operation_id="list_steps")
 def list_steps(
     before: Optional[str] = Query(None, description="Return steps before this step ID"),
     after: Optional[str] = Query(None, description="Return steps after this step ID"),

letta/server/rest_api/utils.py

@@ -15,7 +15,7 @@ from pydantic import BaseModel
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, FUNC_FAILED_HEARTBEAT_MESSAGE, REQ_HEARTBEAT_MESSAGE
 from letta.errors import ContextWindowExceededError, RateLimitExceededError
-from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.datetime_helpers import get_utc_time, get_utc_timestamp_ns
 from letta.helpers.message_helper import convert_message_creates_to_messages
 from letta.log import get_logger
 from letta.schemas.enums import MessageRole
@@ -25,6 +25,7 @@ from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.server.rest_api.interface import StreamingServerInterface
 from letta.system import get_heartbeat, package_function_response
+from letta.tracing import tracer
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
@@ -51,18 +52,35 @@ async def sse_async_generator(
     generator: AsyncGenerator,
     usage_task: Optional[asyncio.Task] = None,
     finish_message=True,
+    request_start_timestamp_ns: Optional[int] = None,
 ):
     """
     Wraps a generator for use in Server-Sent Events (SSE), handling errors and ensuring a completion message.
 
     Args:
     - generator: An asynchronous generator yielding data chunks.
+    - usage_task: Optional task that will return usage statistics.
+    - finish_message: Whether to send a completion message.
+    - request_start_timestamp_ns: Optional ns timestamp when the request started, used to measure time to first token.
 
     Yields:
     - Formatted Server-Sent Event strings.
     """
+    first_chunk = True
+    ttft_span = None
+    if request_start_timestamp_ns is not None:
+        ttft_span = tracer.start_span("time_to_first_token", start_time=request_start_timestamp_ns)
+
     try:
         async for chunk in generator:
+            # Measure time to first token
+            if first_chunk and ttft_span is not None:
+                now = get_utc_timestamp_ns()
+                ttft_ns = now - request_start_timestamp_ns
+                ttft_span.add_event(name="time_to_first_token_ms", attributes={"ttft_ms": ttft_ns // 1_000_000})
+                ttft_span.end()
+                first_chunk = False
+
             # yield f"data: {json.dumps(chunk)}\n\n"
             if isinstance(chunk, BaseModel):
                 chunk = chunk.model_dump()
@@ -168,6 +186,7 @@ def create_letta_messages_from_llm_response(
     reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
     pre_computed_assistant_message_id: Optional[str] = None,
     pre_computed_tool_message_id: Optional[str] = None,
+    llm_batch_item_id: Optional[str] = None,
 ) -> List[Message]:
     messages = []
 
@@ -192,6 +211,7 @@ def create_letta_messages_from_llm_response(
         tool_calls=[tool_call],
         tool_call_id=tool_call_id,
         created_at=get_utc_time(),
+        batch_item_id=llm_batch_item_id,
     )
     if pre_computed_assistant_message_id:
         assistant_message.id = pre_computed_assistant_message_id
@@ -209,6 +229,7 @@ def create_letta_messages_from_llm_response(
         tool_call_id=tool_call_id,
         created_at=get_utc_time(),
         name=function_name,
+        batch_item_id=llm_batch_item_id,
     )
     if pre_computed_tool_message_id:
         tool_message.id = pre_computed_tool_message_id
@@ -216,7 +237,7 @@ def create_letta_messages_from_llm_response(
 
     if add_heartbeat_request_system_message:
         heartbeat_system_message = create_heartbeat_system_message(
-            agent_id=agent_id, model=model, function_call_success=function_call_success, actor=actor
+            agent_id=agent_id, model=model, function_call_success=function_call_success, actor=actor, llm_batch_item_id=llm_batch_item_id
         )
         messages.append(heartbeat_system_message)
 
@@ -224,10 +245,7 @@ def create_letta_messages_from_llm_response(
 
 
 def create_heartbeat_system_message(
-    agent_id: str,
-    model: str,
-    function_call_success: bool,
-    actor: User,
+    agent_id: str, model: str, function_call_success: bool, actor: User, llm_batch_item_id: Optional[str] = None
 ) -> Message:
     text_content = REQ_HEARTBEAT_MESSAGE if function_call_success else FUNC_FAILED_HEARTBEAT_MESSAGE
     heartbeat_system_message = Message(
@@ -239,6 +257,7 @@ def create_heartbeat_system_message(
         tool_calls=[],
         tool_call_id=None,
         created_at=get_utc_time(),
+        batch_item_id=llm_batch_item_id,
     )
     return heartbeat_system_message
 

letta/server/server.py

@@ -244,9 +244,15 @@ class SyncServer(Server):
             tool_dir = tool_settings.tool_exec_dir or LETTA_TOOL_EXECUTION_DIR
 
             venv_dir = Path(tool_dir) / venv_name
-            if not Path(tool_dir).is_dir():
-                logger.error(f"Provided LETTA_TOOL_SANDBOX_DIR is not a valid directory: {tool_dir}")
+            tool_path = Path(tool_dir)
+
+            if tool_path.exists() and not tool_path.is_dir():
+                logger.error(f"LETTA_TOOL_SANDBOX_DIR exists but is not a directory: {tool_dir}")
             else:
+                if not tool_path.exists():
+                    logger.warning(f"LETTA_TOOL_SANDBOX_DIR does not exist, creating now: {tool_dir}")
+                    tool_path.mkdir(parents=True, exist_ok=True)
+
                 if tool_settings.tool_exec_venv_name and not venv_dir.is_dir():
                     logger.warning(
                         f"Provided LETTA_TOOL_SANDBOX_VENV_NAME is not a valid venv ({venv_dir}), one will be created for you during tool execution."
@@ -859,7 +865,7 @@ class SyncServer(Server):
                     value=get_persona_text("voice_memory_persona"),
                 ),
             ],
-            llm_config=main_agent.llm_config,
+            llm_config=LLMConfig.default_config("gpt-4.1"),
             embedding_config=main_agent.embedding_config,
             project_id=main_agent.project_id,
         )
@@ -1633,6 +1639,7 @@ class SyncServer(Server):
         assistant_message_tool_name: str = constants.DEFAULT_MESSAGE_TOOL,
         assistant_message_tool_kwarg: str = constants.DEFAULT_MESSAGE_TOOL_KWARG,
         metadata: Optional[dict] = None,
+        request_start_timestamp_ns: Optional[int] = None,
     ) -> Union[StreamingResponse, LettaResponse]:
         """Split off into a separate function so that it can be imported in the /chat/completion proxy."""
         # TODO: @charles is this the correct way to handle?
@@ -1717,6 +1724,7 @@ class SyncServer(Server):
                         streaming_interface.get_generator(),
                         usage_task=task,
                         finish_message=include_final_message,
+                        request_start_timestamp_ns=request_start_timestamp_ns,
                     ),
                     media_type="text/event-stream",
                 )

letta/services/llm_batch_manager.py

@@ -2,10 +2,11 @@ import datetime
 from typing import Any, Dict, List, Optional, Tuple
 
 from anthropic.types.beta.messages import BetaMessageBatch, BetaMessageBatchIndividualResponse
-from sqlalchemy import func, tuple_
+from sqlalchemy import desc, func, tuple_
 
 from letta.jobs.types import BatchPollingResult, ItemUpdateInfo, RequestStatusUpdateInfo, StepStatusUpdateInfo
 from letta.log import get_logger
+from letta.orm import Message as MessageModel
 from letta.orm.llm_batch_items import LLMBatchItem
 from letta.orm.llm_batch_job import LLMBatchJob
 from letta.schemas.agent import AgentStepState
@@ -13,6 +14,7 @@ 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
+from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types
 
@@ -142,6 +144,62 @@ class LLMBatchManager:
             batch = LLMBatchJob.read(db_session=session, identifier=llm_batch_id, actor=actor)
             batch.hard_delete(db_session=session, actor=actor)
 
+    @enforce_types
+    def get_messages_for_letta_batch(
+        self,
+        letta_batch_job_id: str,
+        limit: int = 100,
+        actor: Optional[PydanticUser] = None,
+        agent_id: Optional[str] = None,
+        sort_descending: bool = True,
+        cursor: Optional[str] = None,  # Message ID as cursor
+    ) -> List[PydanticMessage]:
+        """
+        Retrieve messages across all LLM batch jobs associated with a Letta batch job.
+        Optimized for PostgreSQL performance using ID-based keyset pagination.
+        """
+        with self.session_maker() as session:
+            # If cursor is provided, get sequence_id for that message
+            cursor_sequence_id = None
+            if cursor:
+                cursor_query = session.query(MessageModel.sequence_id).filter(MessageModel.id == cursor).limit(1)
+                cursor_result = cursor_query.first()
+                if cursor_result:
+                    cursor_sequence_id = cursor_result[0]
+                else:
+                    # If cursor message doesn't exist, ignore it
+                    pass
+
+            query = (
+                session.query(MessageModel)
+                .join(LLMBatchItem, MessageModel.batch_item_id == LLMBatchItem.id)
+                .join(LLMBatchJob, LLMBatchItem.llm_batch_id == LLMBatchJob.id)
+                .filter(LLMBatchJob.letta_batch_job_id == letta_batch_job_id)
+            )
+
+            if actor is not None:
+                query = query.filter(MessageModel.organization_id == actor.organization_id)
+
+            if agent_id is not None:
+                query = query.filter(MessageModel.agent_id == agent_id)
+
+            # Apply cursor-based pagination if cursor exists
+            if cursor_sequence_id is not None:
+                if sort_descending:
+                    query = query.filter(MessageModel.sequence_id < cursor_sequence_id)
+                else:
+                    query = query.filter(MessageModel.sequence_id > cursor_sequence_id)
+
+            if sort_descending:
+                query = query.order_by(desc(MessageModel.sequence_id))
+            else:
+                query = query.order_by(MessageModel.sequence_id)
+
+            query = query.limit(limit)
+
+            results = query.all()
+            return [message.to_pydantic() for message in results]
+
     @enforce_types
     def list_running_llm_batches(self, actor: Optional[PydanticUser] = None) -> List[PydanticLLMBatchJob]:
         """Return all running LLM batch jobs, optionally filtered by actor's organization."""
@@ -196,6 +254,7 @@ class LLMBatchManager:
             orm_items = []
             for item in llm_batch_items:
                 orm_item = LLMBatchItem(
+                    id=item.id,
                     llm_batch_id=item.llm_batch_id,
                     agent_id=item.agent_id,
                     llm_config=item.llm_config,

letta/services/message_manager.py

@@ -73,6 +73,7 @@ class MessageManager:
         Returns:
             List of created Pydantic message models
         """
+
         if not pydantic_msgs:
             return []
 

letta/services/summarizer/summarizer.py

@@ -1,9 +1,8 @@
 import asyncio
 import json
 import traceback
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
-from letta.agents.voice_sleeptime_agent import VoiceSleeptimeAgent
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.log import get_logger
 from letta.schemas.enums import MessageRole
@@ -22,7 +21,11 @@ class Summarizer:
     """
 
     def __init__(
-        self, mode: SummarizationMode, summarizer_agent: VoiceSleeptimeAgent, message_buffer_limit: int = 10, message_buffer_min: int = 3
+        self,
+        mode: SummarizationMode,
+        summarizer_agent: Optional["VoiceSleeptimeAgent"] = None,
+        message_buffer_limit: int = 10,
+        message_buffer_min: int = 3,
     ):
         self.mode = mode
 
@@ -90,39 +93,42 @@ class Summarizer:
             logger.info("Nothing to evict, returning in context messages as is.")
             return all_in_context_messages, False
 
-        evicted_messages = all_in_context_messages[1:target_trim_index]
-
-        # Format
-        formatted_evicted_messages = format_transcript(evicted_messages)
-        formatted_in_context_messages = format_transcript(updated_in_context_messages)
-
-        # Update the message transcript of the memory agent
-        self.summarizer_agent.update_message_transcript(message_transcripts=formatted_evicted_messages + formatted_in_context_messages)
-
-        # Add line numbers to the formatted messages
-        line_number = 0
-        for i in range(len(formatted_evicted_messages)):
-            formatted_evicted_messages[i] = f"{line_number}. " + formatted_evicted_messages[i]
-            line_number += 1
-        for i in range(len(formatted_in_context_messages)):
-            formatted_in_context_messages[i] = f"{line_number}. " + formatted_in_context_messages[i]
-            line_number += 1
-
-        evicted_messages_str = "\n".join(formatted_evicted_messages)
-        in_context_messages_str = "\n".join(formatted_in_context_messages)
-        summary_request_text = f"""You’re a memory-recall helper for an AI that can only keep the last {self.message_buffer_min} messages. Scan the conversation history, focusing on messages about to drop out of that window, and write crisp notes that capture any important facts or insights about the human so they aren’t lost.
-
-(Older) Evicted Messages:\n
-{evicted_messages_str}\n
-
-(Newer) In-Context Messages:\n
-{in_context_messages_str}
-"""
-        print(summary_request_text)
-        # Fire-and-forget the summarization task
-        self.fire_and_forget(
-            self.summarizer_agent.step([MessageCreate(role=MessageRole.user, content=[TextContent(text=summary_request_text)])])
-        )
+        if self.summarizer_agent:
+            # Only invoke if summarizer agent is passed in
+
+            evicted_messages = all_in_context_messages[1:target_trim_index]
+
+            # Format
+            formatted_evicted_messages = format_transcript(evicted_messages)
+            formatted_in_context_messages = format_transcript(updated_in_context_messages)
+
+            # TODO: This is hyperspecific to voice, generalize!
+            # Update the message transcript of the memory agent
+            self.summarizer_agent.update_message_transcript(message_transcripts=formatted_evicted_messages + formatted_in_context_messages)
+
+            # Add line numbers to the formatted messages
+            line_number = 0
+            for i in range(len(formatted_evicted_messages)):
+                formatted_evicted_messages[i] = f"{line_number}. " + formatted_evicted_messages[i]
+                line_number += 1
+            for i in range(len(formatted_in_context_messages)):
+                formatted_in_context_messages[i] = f"{line_number}. " + formatted_in_context_messages[i]
+                line_number += 1
+
+            evicted_messages_str = "\n".join(formatted_evicted_messages)
+            in_context_messages_str = "\n".join(formatted_in_context_messages)
+            summary_request_text = f"""You’re a memory-recall helper for an AI that can only keep the last {self.message_buffer_min} messages. Scan the conversation history, focusing on messages about to drop out of that window, and write crisp notes that capture any important facts or insights about the human so they aren’t lost.
+
+    (Older) Evicted Messages:\n
+    {evicted_messages_str}\n
+
+    (Newer) In-Context Messages:\n
+    {in_context_messages_str}
+    """
+            # Fire-and-forget the summarization task
+            self.fire_and_forget(
+                self.summarizer_agent.step([MessageCreate(role=MessageRole.user, content=[TextContent(text=summary_request_text)])])
+            )
 
         return [all_in_context_messages[0]] + updated_in_context_messages, True
 

letta/settings.py

@@ -209,6 +209,7 @@ class Settings(BaseSettings):
     # cron job parameters
     enable_batch_job_polling: bool = False
     poll_running_llm_batches_interval_seconds: int = 5 * 60
+    poll_lock_retry_interval_seconds: int = 5 * 60
 
     @property
     def letta_pg_uri(self) -> str:

letta/tracing.py

@@ -75,6 +75,11 @@ async def update_trace_attributes(request: Request):
     for key, value in request.path_params.items():
         span.set_attribute(f"http.{key}", value)
 
+    # Add user ID if available
+    user_id = request.headers.get("user_id")
+    if user_id:
+        span.set_attribute("user.id", user_id)
+
     # Add request body if available
     try:
         body = await request.json()