letta-nightly 0.6.5.dev20241218213641__tar.gz → 0.6.5.dev20241219104153__tar.gz

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/PKG-INFO

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

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/agent.py

@@ -20,7 +20,7 @@ from letta.constants import (
     REQ_HEARTBEAT_MESSAGE,
     STRUCTURED_OUTPUT_MODELS,
 )
-from letta.errors import LLMError
+from letta.errors import ContextWindowExceededError
 from letta.helpers import ToolRulesSolver
 from letta.interface import AgentInterface
 from letta.llm_api.helpers import is_context_overflow_error
@@ -1094,6 +1094,7 @@ class Agent(BaseAgent):
 
             # If we got a context alert, try trimming the messages length, then try again
             if is_context_overflow_error(e):
+                printd(f"context window exceeded with limit {self.agent_state.llm_config.context_window}, running summarizer to trim messages")
                 # A separate API call to run a summarizer
                 self.summarize_messages_inplace()
 
@@ -1169,8 +1170,13 @@ class Agent(BaseAgent):
 
         # If at this point there's nothing to summarize, throw an error
         if len(candidate_messages_to_summarize) == 0:
-            raise LLMError(
-                f"Summarize error: tried to run summarize, but couldn't find enough messages to compress [len={len(self.messages)}, preserve_N={MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST}]"
+            raise ContextWindowExceededError(
+                "Not enough messages to compress for summarization",
+                details={
+                    "num_candidate_messages": len(candidate_messages_to_summarize),
+                    "num_total_messages": len(self.messages),
+                    "preserve_N": MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST,
+                },
             )
 
         # Walk down the message buffer (front-to-back) until we hit the target token count
@@ -1204,8 +1210,13 @@ class Agent(BaseAgent):
         message_sequence_to_summarize = self._messages[1:cutoff]  # do NOT get rid of the system message
         if len(message_sequence_to_summarize) <= 1:
             # This prevents a potential infinite loop of summarizing the same message over and over
-            raise LLMError(
-                f"Summarize error: tried to run summarize, but couldn't find enough messages to compress [len={len(message_sequence_to_summarize)} <= 1]"
+            raise ContextWindowExceededError(
+                "Not enough messages to compress for summarization after determining cutoff",
+                details={
+                    "num_candidate_messages": len(message_sequence_to_summarize),
+                    "num_total_messages": len(self.messages),
+                    "preserve_N": MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST,
+                },
             )
         else:
             printd(f"Attempting to summarize {len(message_sequence_to_summarize)} messages [1:{cutoff}] of {len(self._messages)}")
@@ -1218,6 +1229,7 @@ class Agent(BaseAgent):
             self.agent_state.llm_config.context_window = (
                 LLM_MAX_TOKENS[self.model] if (self.model is not None and self.model in LLM_MAX_TOKENS) else LLM_MAX_TOKENS["DEFAULT"]
             )
+
         summary = summarize_messages(agent_state=self.agent_state, message_sequence_to_summarize=message_sequence_to_summarize)
         printd(f"Got summary: {summary}")
 

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/client/client.py

@@ -233,7 +233,7 @@ class AbstractClient(object):
     def get_tool_id(self, name: str) -> Optional[str]:
         raise NotImplementedError
 
-    def add_base_tools(self) -> List[Tool]:
+    def upsert_base_tools(self) -> List[Tool]:
         raise NotImplementedError
 
     def load_data(self, connector: DataConnector, source_name: str):
@@ -1466,7 +1466,7 @@ class RESTClient(AbstractClient):
             raise ValueError(f"Failed to get tool: {response.text}")
         return response.json()
 
-    def add_base_tools(self) -> List[Tool]:
+    def upsert_base_tools(self) -> List[Tool]:
         response = requests.post(f"{self.base_url}/{self.api_prefix}/tools/add-base-tools/", headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to add base tools: {response.text}")

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/errors.py

@@ -1,4 +1,5 @@
 import json
+from enum import Enum
 from typing import TYPE_CHECKING, List, Optional, Union
 
 # Avoid circular imports
@@ -6,9 +7,31 @@ if TYPE_CHECKING:
     from letta.schemas.message import Message
 
 
+class ErrorCode(Enum):
+    """Enum for error codes used by client."""
+
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
+    CONTEXT_WINDOW_EXCEEDED = "CONTEXT_WINDOW_EXCEEDED"
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED"
+
+
 class LettaError(Exception):
     """Base class for all Letta related errors."""
 
+    def __init__(self, message: str, code: Optional[ErrorCode] = None, details: dict = {}):
+        self.message = message
+        self.code = code
+        self.details = details
+        super().__init__(message)
+
+    def __str__(self) -> str:
+        if self.code:
+            return f"{self.code.value}: {self.message}"
+        return self.message
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(message='{self.message}', code='{self.code}', details={self.details})"
+
 
 class LettaToolCreateError(LettaError):
     """Error raised when a tool cannot be created."""
@@ -16,10 +39,7 @@ class LettaToolCreateError(LettaError):
     default_error_message = "Error creating tool."
 
     def __init__(self, message=None):
-        if message is None:
-            message = self.default_error_message
-        self.message = message
-        super().__init__(self.message)
+        super().__init__(message=message or self.default_error_message)
 
 
 class LettaConfigurationError(LettaError):
@@ -27,23 +47,17 @@ class LettaConfigurationError(LettaError):
 
     def __init__(self, message: str, missing_fields: Optional[List[str]] = None):
         self.missing_fields = missing_fields or []
-        super().__init__(message)
+        super().__init__(message=message, details={"missing_fields": self.missing_fields})
 
 
 class LettaAgentNotFoundError(LettaError):
     """Error raised when an agent is not found."""
-
-    def __init__(self, message: str):
-        self.message = message
-        super().__init__(self.message)
+    pass
 
 
 class LettaUserNotFoundError(LettaError):
     """Error raised when a user is not found."""
-
-    def __init__(self, message: str):
-        self.message = message
-        super().__init__(self.message)
+    pass
 
 
 class LLMError(LettaError):
@@ -54,24 +68,45 @@ class LLMJSONParsingError(LettaError):
     """Exception raised for errors in the JSON parsing process."""
 
     def __init__(self, message="Error parsing JSON generated by LLM"):
-        self.message = message
-        super().__init__(self.message)
+        super().__init__(message=message)
 
 
 class LocalLLMError(LettaError):
     """Generic catch-all error for local LLM problems"""
 
     def __init__(self, message="Encountered an error while running local LLM"):
-        self.message = message
-        super().__init__(self.message)
+        super().__init__(message=message)
 
 
 class LocalLLMConnectionError(LettaError):
     """Error for when local LLM cannot be reached with provided IP/port"""
 
     def __init__(self, message="Could not connect to local LLM"):
-        self.message = message
-        super().__init__(self.message)
+        super().__init__(message=message)
+
+
+class ContextWindowExceededError(LettaError):
+    """Error raised when the context window is exceeded but further summarization fails."""
+
+    def __init__(self, message: str, details: dict = {}):
+        error_message = f"{message} ({details})"
+        super().__init__(
+            message=error_message,
+            code=ErrorCode.CONTEXT_WINDOW_EXCEEDED,
+            details=details,
+        )
+
+
+class RateLimitExceededError(LettaError):
+    """Error raised when the llm rate limiter throttles api requests."""
+
+    def __init__(self, message: str, max_retries: int):
+        error_message = f"{message} ({max_retries})"
+        super().__init__(
+            message=error_message,
+            code=ErrorCode.RATE_LIMIT_EXCEEDED,
+            details={"max_retries": max_retries},
+        )
 
 
 class LettaMessageError(LettaError):

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/functions/function_sets/base.py

@@ -61,60 +61,6 @@ def conversation_search(self: "Agent", query: str, page: Optional[int] = 0) -> O
     return results_str
 
 
-def conversation_search_date(self: "Agent", start_date: str, end_date: str, page: Optional[int] = 0) -> Optional[str]:
-    """
-    Search prior conversation history using a date range.
-
-    Args:
-        start_date (str): The start of the date range to search, in the format 'YYYY-MM-DD'.
-        end_date (str): The end of the date range to search, in the format 'YYYY-MM-DD'.
-        page (int): Allows you to page through results. Only use on a follow-up query. Defaults to 0 (first page).
-
-    Returns:
-        str: Query result string
-    """
-    import math
-    from datetime import datetime
-
-    from letta.constants import RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    from letta.utils import json_dumps
-
-    if page is None or (isinstance(page, str) and page.lower().strip() == "none"):
-        page = 0
-    try:
-        page = int(page)
-        if page < 0:
-            raise ValueError
-    except:
-        raise ValueError(f"'page' argument must be an integer")
-
-    # Convert date strings to datetime objects
-    try:
-        start_datetime = datetime.strptime(start_date, "%Y-%m-%d").replace(hour=0, minute=0, second=0, microsecond=0)
-        end_datetime = datetime.strptime(end_date, "%Y-%m-%d").replace(hour=23, minute=59, second=59, microsecond=999999)
-    except ValueError:
-        raise ValueError("Dates must be in the format 'YYYY-MM-DD'")
-
-    count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    results = self.message_manager.list_user_messages_for_agent(
-        # TODO: add paging by page number. currently cursor only works with strings.
-        agent_id=self.agent_state.id,
-        actor=self.user,
-        start_date=start_datetime,
-        end_date=end_datetime,
-        limit=count,
-    )
-    total = len(results)
-    num_pages = math.ceil(total / count) - 1  # 0 index
-    if len(results) == 0:
-        results_str = f"No results found."
-    else:
-        results_pref = f"Showing {len(results)} of {total} results (page {page}/{num_pages}):"
-        results_formatted = [f"timestamp: {d['timestamp']}, {d['message']['role']} - {d['message']['content']}" for d in results]
-        results_str = f"{results_pref} {json_dumps(results_formatted)}"
-    return results_str
-
-
 def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
     """
     Add to archival memory. Make sure to phrase the memory contents such that it can be easily queried later.

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/llm_api/llm_api_tools.py

@@ -5,7 +5,7 @@ from typing import List, Optional, Union
 import requests
 
 from letta.constants import CLI_WARNING_PREFIX
-from letta.errors import LettaConfigurationError
+from letta.errors import LettaConfigurationError, RateLimitExceededError
 from letta.llm_api.anthropic import anthropic_chat_completions_request
 from letta.llm_api.azure_openai import azure_openai_chat_completions_request
 from letta.llm_api.google_ai import (
@@ -80,7 +80,7 @@ def retry_with_exponential_backoff(
 
                     # Check if max retries has been reached
                     if num_retries > max_retries:
-                        raise Exception(f"Maximum number of retries ({max_retries}) exceeded.")
+                        raise RateLimitExceededError("Maximum number of retries exceeded", max_retries=max_retries)
 
                     # Increment the delay
                     delay *= exponential_base * (1 + jitter * random.random())

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/orm/message.py

@@ -1,5 +1,6 @@
 from typing import Optional
 
+from sqlalchemy import Index
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.custom_columns import ToolCallColumn
@@ -13,7 +14,7 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     """Defines data model for storing Message objects"""
 
     __tablename__ = "messages"
-    __table_args__ = {"extend_existing": True}
+    __table_args__ = (Index("ix_messages_agent_created_at", "agent_id", "created_at"),)
     __pydantic_model__ = PydanticMessage
 
     id: Mapped[str] = mapped_column(primary_key=True, doc="Unique message identifier")

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/orm/passage.py

@@ -1,26 +1,26 @@
 from typing import TYPE_CHECKING
-from sqlalchemy import Column, JSON, Index
-from sqlalchemy.orm import Mapped, mapped_column, relationship, declared_attr
 
-from letta.orm.mixins import FileMixin, OrganizationMixin
+from sqlalchemy import JSON, Column, Index
+from sqlalchemy.orm import Mapped, declared_attr, mapped_column, relationship
+
+from letta.config import LettaConfig
+from letta.constants import MAX_EMBEDDING_DIM
 from letta.orm.custom_columns import CommonVector, EmbeddingConfigColumn
-from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.orm.mixins import AgentMixin, FileMixin, OrganizationMixin, SourceMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.settings import settings
 
-from letta.config import LettaConfig
-from letta.constants import MAX_EMBEDDING_DIM
-
 config = LettaConfig()
 
 if TYPE_CHECKING:
-    from letta.orm.organization import Organization
     from letta.orm.agent import Agent
+    from letta.orm.organization import Organization
 
 
 class BasePassage(SqlalchemyBase, OrganizationMixin):
     """Base class for all passage types with common fields"""
+
     __abstract__ = True
     __pydantic_model__ = PydanticPassage
 
@@ -45,17 +45,15 @@ class BasePassage(SqlalchemyBase, OrganizationMixin):
     @declared_attr
     def __table_args__(cls):
         if settings.letta_pg_uri_no_default:
-            return (
-                Index(f'{cls.__tablename__}_org_idx', 'organization_id'),
-                {"extend_existing": True}
-            )
+            return (Index(f"{cls.__tablename__}_org_idx", "organization_id"), {"extend_existing": True})
         return ({"extend_existing": True},)
 
 
 class SourcePassage(BasePassage, FileMixin, SourceMixin):
     """Passages derived from external files/sources"""
+
     __tablename__ = "source_passages"
-    
+
     @declared_attr
     def file(cls) -> Mapped["FileMetadata"]:
         """Relationship to file"""
@@ -64,7 +62,7 @@ class SourcePassage(BasePassage, FileMixin, SourceMixin):
     @declared_attr
     def organization(cls) -> Mapped["Organization"]:
         return relationship("Organization", back_populates="source_passages", lazy="selectin")
-        
+
     @declared_attr
     def source(cls) -> Mapped["Source"]:
         """Relationship to source"""
@@ -73,8 +71,9 @@ class SourcePassage(BasePassage, FileMixin, SourceMixin):
 
 class AgentPassage(BasePassage, AgentMixin):
     """Passages created by agents as archival memories"""
+
     __tablename__ = "agent_passages"
-    
+
     @declared_attr
     def organization(cls) -> Mapped["Organization"]:
         return relationship("Organization", back_populates="agent_passages", lazy="selectin")

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/server/rest_api/routers/v1/agents.py

@@ -17,6 +17,7 @@ from fastapi.responses import JSONResponse, StreamingResponse
 from pydantic import Field
 
 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.block import (  # , BlockLabelUpdate, BlockLimitUpdate
@@ -54,6 +55,8 @@ from letta.server.server import SyncServer
 
 router = APIRouter(prefix="/agents", tags=["agents"])
 
+logger = get_logger(__name__)
+
 
 # TODO: This should be paginated
 @router.get("/", response_model=List[AgentState], operation_id="list_agents")
@@ -453,6 +456,13 @@ def get_agent_messages(
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
 
+    # TODO: Temporary debugging logs for debugging very slow endpoint
+    import uuid
+
+    temp_rand_uuid = uuid.uuid4()
+
+    logger.info(f"[{temp_rand_uuid}] RECEIVED GET /messages for agent_id={agent_id} before={before} limit={limit}")
+
     return server.get_agent_recall_cursor(
         user_id=actor.id,
         agent_id=agent_id,
@@ -462,6 +472,7 @@ def get_agent_messages(
         return_message_object=msg_object,
         assistant_message_tool_name=assistant_message_tool_name,
         assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+        temp_rand_uuid=temp_rand_uuid,
     )
 
 

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/server/rest_api/routers/v1/tools.py

@@ -152,30 +152,15 @@ def update_tool(
 
 
 @router.post("/add-base-tools", response_model=List[Tool], operation_id="add_base_tools")
-def add_base_tools(
+def upsert_base_tools(
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
-    Add base tools
+    Upsert base tools
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
-    return server.tool_manager.add_base_tools(actor=actor)
-
-
-# NOTE: can re-enable if needed
-# @router.post("/{tool_id}/run", response_model=FunctionReturn, operation_id="run_tool")
-# def run_tool(
-#     server: SyncServer = Depends(get_letta_server),
-#     request: ToolRun = Body(...),
-#     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-# ):
-#     """
-#     Run an existing tool on provided arguments
-#     """
-#     actor = server.user_manager.get_user_or_default(user_id=user_id)
-
-#     return server.run_tool(tool_id=request.tool_id, tool_args=request.tool_args, user_id=actor.id)
+    return server.tool_manager.upsert_base_tools(actor=actor)
 
 
 @router.post("/run", response_model=FunctionReturn, operation_id="run_tool_from_source")

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/server/rest_api/utils.py

@@ -8,6 +8,7 @@ from typing import AsyncGenerator, Optional, Union
 from fastapi import Header
 from pydantic import BaseModel
 
+from letta.errors import ContextWindowExceededError, RateLimitExceededError
 from letta.schemas.usage import LettaUsageStatistics
 from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.server import SyncServer
@@ -61,34 +62,21 @@ async def sse_async_generator(
                 if not isinstance(usage, LettaUsageStatistics):
                     raise ValueError(f"Expected LettaUsageStatistics, got {type(usage)}")
                 yield sse_formatter({"usage": usage.model_dump()})
-            except Exception as e:
-                import traceback
-
-                traceback.print_exc()
-                warnings.warn(f"SSE stream generator failed: {e}")
 
-                # Log the error, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response
-                # Print the stack trace
-                if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
-                    import sentry_sdk
+            except ContextWindowExceededError as e:
+                log_error_to_sentry(e)
+                yield sse_formatter({"error": f"Stream failed: {e}", "code": str(e.code.value) if e.code else None})
 
-                    sentry_sdk.capture_exception(e)
+            except RateLimitExceededError as e:
+                log_error_to_sentry(e)
+                yield sse_formatter({"error": f"Stream failed: {e}", "code": str(e.code.value) if e.code else None})
 
+            except Exception as e:
+                log_error_to_sentry(e)
                 yield sse_formatter({"error": f"Stream failed (internal error occured)"})
 
     except Exception as e:
-        import traceback
-
-        traceback.print_exc()
-        warnings.warn(f"SSE stream generator failed: {e}")
-
-        # Log the error, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response
-        # Print the stack trace
-        if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
-            import sentry_sdk
-
-            sentry_sdk.capture_exception(e)
-
+        log_error_to_sentry(e)
         yield sse_formatter({"error": "Stream failed (decoder encountered an error)"})
 
     finally:
@@ -113,3 +101,16 @@ def get_user_id(user_id: Optional[str] = Header(None, alias="user_id")) -> Optio
 
 def get_current_interface() -> StreamingServerInterface:
     return StreamingServerInterface
+
+def log_error_to_sentry(e):
+    import traceback
+
+    traceback.print_exc()
+    warnings.warn(f"SSE stream generator failed: {e}")
+
+    # Log the error, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response
+    # Print the stack trace
+    if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
+        import sentry_sdk
+
+        sentry_sdk.capture_exception(e)

{letta_nightly-0.6.5.dev20241218213641 → letta_nightly-0.6.5.dev20241219104153}/letta/server/server.py

@@ -301,7 +301,7 @@ class SyncServer(Server):
             self.default_org = self.organization_manager.create_default_organization()
             self.default_user = self.user_manager.create_default_user()
             self.block_manager.add_default_blocks(actor=self.default_user)
-            self.tool_manager.add_base_tools(actor=self.default_user)
+            self.tool_manager.upsert_base_tools(actor=self.default_user)
 
             # If there is a default org/user
             # This logic may have to change in the future
@@ -979,16 +979,32 @@ class SyncServer(Server):
         return_message_object: bool = True,
         assistant_message_tool_name: str = constants.DEFAULT_MESSAGE_TOOL,
         assistant_message_tool_kwarg: str = constants.DEFAULT_MESSAGE_TOOL_KWARG,
+        temp_rand_uuid: Optional[str] = None,
     ) -> Union[List[Message], List[LettaMessage]]:
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
+        import datetime
+
+        start_time = datetime.datetime.utcnow()
+
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Fetching actor for user_id={user_id} (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         actor = self.user_manager.get_user_or_default(user_id=user_id)
 
-        # Get the agent object (loaded in memory)
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Loading agent object for agent_id={agent_id} (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
 
-        # iterate over records
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Resolving start_date and end_date for filtering messages (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         start_date = self.message_manager.get_message_by_id(after, actor=actor).created_at if after else None
         end_date = self.message_manager.get_message_by_id(before, actor=actor).created_at if before else None
+
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Fetching messages for agent_id={agent_id}, start_date={start_date}, end_date={end_date}, limit={limit}, reverse={reverse} (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         records = letta_agent.message_manager.list_messages_for_agent(
             agent_id=agent_id,
             actor=actor,
@@ -998,10 +1014,15 @@ class SyncServer(Server):
             ascending=not reverse,
         )
 
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Validating message types (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         assert all(isinstance(m, Message) for m in records)
 
         if not return_message_object:
-            # If we're GETing messages in reverse, we need to reverse the inner list (generated by to_letta_message)
+            logger.info(
+                f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Converting messages to LettaMessage objects (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+            )
             records = [
                 msg
                 for m in records
@@ -1012,8 +1033,14 @@ class SyncServer(Server):
             ]
 
         if reverse:
+            logger.info(
+                f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Reversing message order (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+            )
             records = records[::-1]
 
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Returning {len(records)} messages (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         return records
 
     def get_server_config(self, include_defaults: bool = False) -> dict: