letta-nightly 0.7.30.dev20250603104343__py3-none-any.whl → 0.8.0.dev20250604201135__py3-none-any.whl

letta/schemas/tool_execution_result.py

@@ -6,9 +6,14 @@ from letta.schemas.agent import AgentState
 
 
 class ToolExecutionResult(BaseModel):
+
     status: Literal["success", "error"] = Field(..., description="The status of the tool execution and return object")
     func_return: Optional[Any] = Field(None, description="The function return object")
     agent_state: Optional[AgentState] = Field(None, description="The agent state")
     stdout: Optional[List[str]] = Field(None, description="Captured stdout (prints, logs) from function invocation")
     stderr: Optional[List[str]] = Field(None, description="Captured stderr from the function invocation")
     sandbox_config_fingerprint: Optional[str] = Field(None, description="The fingerprint of the config for the sandbox")
+
+    @property
+    def success_flag(self) -> bool:
+        return self.status == "success"

letta/server/db.py

@@ -1,5 +1,6 @@
 import os
 import threading
+import uuid
 from contextlib import asynccontextmanager, contextmanager
 from typing import Any, AsyncGenerator, Generator
 
@@ -118,13 +119,11 @@ class DatabaseRegistry:
                 else:
                     async_pg_uri = f"postgresql+asyncpg://{pg_uri.split('://', 1)[1]}" if "://" in pg_uri else pg_uri
                 async_pg_uri = async_pg_uri.replace("sslmode=", "ssl=")
-
                 async_engine = create_async_engine(async_pg_uri, **self._build_sqlalchemy_engine_args(is_async=True))
-                self._initialized["async"] = True
             else:
-                self.logger.warning("Async SQLite is currently not supported. Please use PostgreSQL for async database operations.")
-                # TODO (cliandy): unclear around async sqlite support in sqlalchemy, we will not currently support this
-                self._initialized["async"] = True
+                # create sqlite async engine
+                self._initialized["async"] = False
+                # TODO: remove self.config
                 engine_path = "sqlite+aiosqlite:///" + os.path.join(self.config.recall_storage_path, "sqlite.db")
                 self.logger.info("Creating sqlite engine " + engine_path)
                 async_engine = create_async_engine(engine_path, **self._build_sqlalchemy_engine_args(is_async=True))
@@ -132,7 +131,7 @@ class DatabaseRegistry:
             # Create async session factory
             self._async_engines["default"] = async_engine
             self._async_session_factories["default"] = async_sessionmaker(
-                autocommit=False, autoflush=False, bind=self._async_engines["default"], class_=AsyncSession
+                close_resets_only=False, autocommit=False, autoflush=False, bind=self._async_engines["default"], class_=AsyncSession
             )
             self._initialized["async"] = True
 
@@ -165,8 +164,24 @@ class DatabaseRegistry:
                 }
             )
             if not is_async:
-                base_args["pool_use_lifo"] = settings.pool_use_lifo
-
+                base_args.update(
+                    {
+                        "pool_use_lifo": settings.pool_use_lifo,
+                    }
+                )
+
+        elif is_async:
+            # For asyncpg, statement_cache_size should be in connect_args
+            base_args.update(
+                {
+                    "connect_args": {
+                        "timeout": settings.pg_pool_timeout,
+                        "prepared_statement_name_func": lambda: f"__asyncpg_{uuid.uuid4()}__",
+                        "statement_cache_size": 0,
+                        "prepared_statement_cache_size": 0,
+                    },
+                }
+            )
         return base_args
 
     def _wrap_sqlite_engine(self, engine: Engine) -> None:

letta/server/rest_api/app.py

@@ -1,5 +1,4 @@
-import asyncio
-import concurrent.futures
+import importlib.util
 import json
 import logging
 import os
@@ -17,7 +16,6 @@ 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_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
@@ -100,7 +98,7 @@ class CheckPasswordMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request, call_next):
 
         # Exclude health check endpoint from password protection
-        if request.url.path == "/v1/health/" or request.url.path == "/latest/health/":
+        if request.url.path in {"/v1/health", "/v1/health/", "/latest/health/"}:
             return await call_next(request)
 
         if (
@@ -142,34 +140,6 @@ def create_application() -> "FastAPI":
         debug=debug_mode,  # if True, the stack trace will be printed in the response
     )
 
-    @app.on_event("startup")
-    async def configure_executor():
-        print(f"INFO:     Configured event loop executor with {settings.event_loop_threadpool_max_workers} workers.")
-        loop = asyncio.get_running_loop()
-        executor = concurrent.futures.ThreadPoolExecutor(max_workers=settings.event_loop_threadpool_max_workers)
-        loop.set_default_executor(executor)
-
-    @app.on_event("startup")
-    async def on_startup():
-        global server
-
-        await start_scheduler_with_leader_election(server)
-
-    @app.on_event("shutdown")
-    def shutdown_mcp_clients():
-        global server
-        import threading
-
-        def cleanup_clients():
-            if hasattr(server, "mcp_clients"):
-                for client in server.mcp_clients.values():
-                    client.cleanup()
-                server.mcp_clients.clear()
-
-        t = threading.Thread(target=cleanup_clients)
-        t.start()
-        t.join()
-
     @app.exception_handler(IncompatibleAgentType)
     async def handle_incompatible_agent_type(request: Request, exc: IncompatibleAgentType):
         return JSONResponse(
@@ -320,12 +290,6 @@ def create_application() -> "FastAPI":
     # Generate OpenAPI schema after all routes are mounted
     generate_openapi_schema(app)
 
-    @app.on_event("shutdown")
-    async def on_shutdown():
-        global server
-        # server = None
-        await shutdown_scheduler_and_release_lock()
-
     return app
 
 
@@ -352,19 +316,53 @@ def start_server(
         # Add the handler to the logger
         server_logger.addHandler(stream_handler)
 
+    # Experimental UV Loop Support
+    try:
+        if importlib.util.find_spec("uvloop") is not None and settings.use_uvloop:
+            print("Running server on uvloop...")
+            import asyncio
+
+            import uvloop
+
+            asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+    except:
+        pass
+
     if (os.getenv("LOCAL_HTTPS") == "true") or "--localhttps" in sys.argv:
         print(f"▶ Server running at: https://{host or 'localhost'}:{port or REST_DEFAULT_PORT}")
         print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard\n")
-        uvicorn.run(
-            "letta.server.rest_api.app:app",
-            host=host or "localhost",
-            port=port or REST_DEFAULT_PORT,
-            workers=settings.uvicorn_workers,
-            reload=reload or settings.uvicorn_reload,
-            timeout_keep_alive=settings.uvicorn_timeout_keep_alive,
-            ssl_keyfile="certs/localhost-key.pem",
-            ssl_certfile="certs/localhost.pem",
-        )
+        if importlib.util.find_spec("granian") is not None and settings.use_uvloop:
+            from granian import Granian
+
+            # Experimental Granian engine
+            Granian(
+                target="letta.server.rest_api.app:app",
+                # factory=True,
+                interface="asgi",
+                address=host or "localhost",
+                port=port or REST_DEFAULT_PORT,
+                workers=settings.uvicorn_workers,
+                # threads=
+                reload=reload or settings.uvicorn_reload,
+                reload_ignore_patterns=["openapi_letta.json"],
+                reload_ignore_worker_failure=True,
+                reload_tick=100,
+                # log_level="info"
+                ssl_keyfile="certs/localhost-key.pem",
+                ssl_cert="certs/localhost.pem",
+            ).serve()
+        else:
+            uvicorn.run(
+                "letta.server.rest_api.app:app",
+                host=host or "localhost",
+                port=port or REST_DEFAULT_PORT,
+                workers=settings.uvicorn_workers,
+                reload=reload or settings.uvicorn_reload,
+                timeout_keep_alive=settings.uvicorn_timeout_keep_alive,
+                ssl_keyfile="certs/localhost-key.pem",
+                ssl_certfile="certs/localhost.pem",
+            )
+
     else:
         if is_windows:
             # Windows doesn't those the fancy unicode characters
@@ -374,11 +372,30 @@ def start_server(
             print(f"▶ Server running at: http://{host or 'localhost'}:{port or REST_DEFAULT_PORT}")
             print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard\n")
 
-        uvicorn.run(
-            "letta.server.rest_api.app:app",
-            host=host or "localhost",
-            port=port or REST_DEFAULT_PORT,
-            workers=settings.uvicorn_workers,
-            reload=reload or settings.uvicorn_reload,
-            timeout_keep_alive=settings.uvicorn_timeout_keep_alive,
-        )
+        if importlib.util.find_spec("granian") is not None and settings.use_granian:
+            # Experimental Granian engine
+            from granian import Granian
+
+            Granian(
+                target="letta.server.rest_api.app:app",
+                # factory=True,
+                interface="asgi",
+                address=host or "localhost",
+                port=port or REST_DEFAULT_PORT,
+                workers=settings.uvicorn_workers,
+                # threads=
+                reload=reload or settings.uvicorn_reload,
+                reload_ignore_patterns=["openapi_letta.json"],
+                reload_ignore_worker_failure=True,
+                reload_tick=100,
+                # log_level="info"
+            ).serve()
+        else:
+            uvicorn.run(
+                "letta.server.rest_api.app:app",
+                host=host or "localhost",
+                port=port or REST_DEFAULT_PORT,
+                workers=settings.uvicorn_workers,
+                reload=reload or settings.uvicorn_reload,
+                timeout_keep_alive=settings.uvicorn_timeout_keep_alive,
+            )

letta/server/rest_api/interface.py

@@ -1338,8 +1338,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     tool_return=msg,
                     status=msg_obj.tool_returns[0].status if msg_obj.tool_returns else "success",
                     tool_call_id=msg_obj.tool_call_id,
-                    stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else None,
-                    stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else None,
+                    stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else [],
+                    stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else [],
                     name=msg_obj.name,
                     otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,
                 )
@@ -1354,8 +1354,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 tool_return=msg,
                 status=msg_obj.tool_returns[0].status if msg_obj.tool_returns else "error",
                 tool_call_id=msg_obj.tool_call_id,
-                stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else None,
-                stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else None,
+                stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else [],
+                stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else [],
                 name=msg_obj.name,
                 otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,
             )

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

@@ -12,12 +12,12 @@ from sqlalchemy.exc import IntegrityError, OperationalError
 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.constants import CORE_MEMORY_SOURCE_CHAR_LIMIT, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.groups.sleeptime_multi_agent_v2 import SleeptimeMultiAgentV2
 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, CreateAgent, UpdateAgent
+from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgent
 from letta.schemas.block import Block, BlockUpdate
 from letta.schemas.group import Group
 from letta.schemas.job import JobStatus, JobUpdate, LettaRequestConfig
@@ -36,6 +36,7 @@ from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 from letta.services.telemetry_manager import NoopTelemetryManager
 from letta.settings import settings
+from letta.utils import safe_create_task
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
 
@@ -127,7 +128,7 @@ class IndentedORJSONResponse(Response):
 
 
 @router.get("/{agent_id}/export", response_class=IndentedORJSONResponse, operation_id="export_agent_serialized")
-async def export_agent_serialized(
+def export_agent_serialized(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
@@ -138,7 +139,7 @@ async def export_agent_serialized(
     """
     Export the serialized JSON representation of an agent, formatted with indentation.
     """
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
     try:
         agent = server.agent_manager.serialize(agent_id=agent_id, actor=actor)
@@ -270,7 +271,7 @@ def list_agent_tools(
 
 
 @router.patch("/{agent_id}/tools/attach/{tool_id}", response_model=AgentState, operation_id="attach_tool")
-def attach_tool(
+async def attach_tool(
     agent_id: str,
     tool_id: str,
     server: "SyncServer" = Depends(get_letta_server),
@@ -279,12 +280,12 @@ def attach_tool(
     """
     Attach a tool to an agent.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.agent_manager.attach_tool(agent_id=agent_id, tool_id=tool_id, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.agent_manager.attach_tool_async(agent_id=agent_id, tool_id=tool_id, actor=actor)
 
 
 @router.patch("/{agent_id}/tools/detach/{tool_id}", response_model=AgentState, operation_id="detach_tool")
-def detach_tool(
+async def detach_tool(
     agent_id: str,
     tool_id: str,
     server: "SyncServer" = Depends(get_letta_server),
@@ -293,31 +294,49 @@ def detach_tool(
     """
     Detach a tool from an agent.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.agent_manager.detach_tool(agent_id=agent_id, tool_id=tool_id, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.agent_manager.detach_tool_async(agent_id=agent_id, tool_id=tool_id, actor=actor)
 
 
 @router.patch("/{agent_id}/sources/attach/{source_id}", response_model=AgentState, operation_id="attach_source_to_agent")
 async def attach_source(
     agent_id: str,
     source_id: str,
-    background_tasks: BackgroundTasks,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Attach a source to an agent.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    agent = server.agent_manager.attach_source(agent_id=agent_id, source_id=source_id, actor=actor)
-    if agent.enable_sleeptime:
-        source = await server.source_manager.get_source_by_id_async(source_id=source_id)
-        background_tasks.add_task(server.sleeptime_document_ingest, agent, source, actor)
-    return agent
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    agent_state = await server.agent_manager.attach_source_async(agent_id=agent_id, source_id=source_id, actor=actor)
+
+    files = await server.source_manager.list_files(source_id, actor)
+    texts = []
+    file_ids = []
+    for f in files:
+        passages = await server.passage_manager.list_passages_by_file_id_async(file_id=f.id, actor=actor)
+        passage_text = ""
+        for p in passages:
+            if len(passage_text) <= CORE_MEMORY_SOURCE_CHAR_LIMIT:
+                passage_text += p.text
+
+        texts.append(passage_text)
+        file_ids.append(f.id)
+
+    await server.insert_files_into_context_window(agent_state=agent_state, texts=texts, file_ids=file_ids, actor=actor)
+
+    if agent_state.enable_sleeptime:
+        source = await server.source_manager.get_source_by_id(source_id=source_id)
+        safe_create_task(
+            server.sleeptime_document_ingest_async(agent_state, source, actor), logger=logger, label="sleeptime_document_ingest_async"
+        )
+
+    return agent_state
 
 
 @router.patch("/{agent_id}/sources/detach/{source_id}", response_model=AgentState, operation_id="detach_source_from_agent")
-def detach_source(
+async def detach_source(
     agent_id: str,
     source_id: str,
     server: "SyncServer" = Depends(get_letta_server),
@@ -326,16 +345,20 @@ def detach_source(
     """
     Detach a source from an agent.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    agent = server.agent_manager.detach_source(agent_id=agent_id, source_id=source_id, actor=actor)
-    if agent.enable_sleeptime:
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    agent_state = await server.agent_manager.detach_source_async(agent_id=agent_id, source_id=source_id, actor=actor)
+    files = await server.source_manager.list_files(source_id, actor)
+    file_ids = [f.id for f in files]
+    await server.remove_files_from_context_window(agent_state=agent_state, file_ids=file_ids, actor=actor)
+
+    if agent_state.enable_sleeptime:
         try:
-            source = server.source_manager.get_source_by_id(source_id=source_id)
-            block = server.agent_manager.get_block_with_label(agent_id=agent.id, block_label=source.name, actor=actor)
-            server.block_manager.delete_block(block.id, actor)
+            source = await server.source_manager.get_source_by_id(source_id=source_id)
+            block = await server.agent_manager.get_block_with_label_async(agent_id=agent_state.id, block_label=source.name, actor=actor)
+            await server.block_manager.delete_block_async(block.id, actor)
         except:
             pass
-    return agent
+    return agent_state
 
 
 @router.get("/{agent_id}", response_model=AgentState, operation_id="retrieve_agent")
@@ -517,18 +540,18 @@ async def list_passages(
 
 
 @router.post("/{agent_id}/archival-memory", response_model=List[Passage], operation_id="create_passage")
-def create_passage(
+async def create_passage(
     agent_id: str,
     request: CreateArchivalMemory = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+    actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Insert a memory into an agent's archival memory store.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
-    return server.insert_archival_memory(agent_id=agent_id, memory_contents=request.text, actor=actor)
+    return await server.insert_archival_memory_async(agent_id=agent_id, memory_contents=request.text, actor=actor)
 
 
 @router.patch("/{agent_id}/archival-memory/{memory_id}", response_model=List[Passage], operation_id="modify_passage")
@@ -549,7 +572,7 @@ def modify_passage(
 # TODO(ethan): query or path parameter for memory_id?
 # @router.delete("/{agent_id}/archival")
 @router.delete("/{agent_id}/archival-memory/{memory_id}", response_model=None, operation_id="delete_passage")
-def delete_passage(
+async def delete_passage(
     agent_id: str,
     memory_id: str,
     # memory_id: str = Query(..., description="Unique ID of the memory to be deleted."),
@@ -559,9 +582,9 @@ def delete_passage(
     """
     Delete a memory from an agent's archival memory store.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
-    server.delete_archival_memory(memory_id=memory_id, actor=actor)
+    await server.delete_archival_memory_async(memory_id=memory_id, actor=actor)
     return JSONResponse(status_code=status.HTTP_200_OK, content={"message": f"Memory id={memory_id} successfully deleted"})
 
 
@@ -636,15 +659,17 @@ async def send_message(
     This endpoint accepts a message from a user and processes it through the agent.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    request_start_timestamp_ns = get_utc_timestamp_ns()
+    user_eligible = True
     # TODO: This is redundant, remove soon
-    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor)
-    agent_eligible = agent.enable_sleeptime or not agent.multi_agent_group
+    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+    agent_eligible = agent.enable_sleeptime or agent.agent_type == AgentType.sleeptime_agent or not agent.multi_agent_group
     experimental_header = request_obj.headers.get("X-EXPERIMENTAL") or "false"
     feature_enabled = settings.use_experimental or experimental_header.lower() == "true"
     model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
 
-    if agent_eligible and feature_enabled and model_compatible:
-        if agent.enable_sleeptime:
+    if user_eligible and agent_eligible and feature_enabled and model_compatible:
+        if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
             experimental_agent = SleeptimeMultiAgentV2(
                 agent_id=agent_id,
                 message_manager=server.message_manager,
@@ -668,7 +693,12 @@ async def send_message(
                 telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
             )
 
-        result = await experimental_agent.step(request.messages, max_steps=10, use_assistant_message=request.use_assistant_message)
+        result = await experimental_agent.step(
+            request.messages,
+            max_steps=10,
+            use_assistant_message=request.use_assistant_message,
+            request_start_timestamp_ns=request_start_timestamp_ns,
+        )
     else:
         result = await server.send_message_to_agent(
             agent_id=agent_id,
@@ -691,7 +721,9 @@ async def send_message(
     responses={
         200: {
             "description": "Successful response",
-            "content": {"text/event-stream": {}},
+            "content": {
+                "text/event-stream": {"description": "Server-Sent Events stream"},
+            },
         }
     },
 )
@@ -709,17 +741,19 @@ async def send_message_streaming(
     """
     request_start_timestamp_ns = get_utc_timestamp_ns()
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    user_eligible = actor.organization_id not in ["org-4a3af5dd-4c6a-48cb-ac13-3f73ecaaa4bf", "org-4ab3f6e8-9a44-4bee-aeb6-c681cbbc7bf6"]
     # TODO: This is redundant, remove soon
-    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor)
-    agent_eligible = agent.enable_sleeptime or not agent.multi_agent_group
+    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+    agent_eligible = agent.enable_sleeptime or agent.agent_type == AgentType.sleeptime_agent or not agent.multi_agent_group
     experimental_header = request_obj.headers.get("X-EXPERIMENTAL") or "false"
     feature_enabled = settings.use_experimental or experimental_header.lower() == "true"
     model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
     model_compatible_token_streaming = agent.llm_config.model_endpoint_type in ["anthropic", "openai"]
-    not_letta_endpoint = not ("letta" in agent.llm_config.model_endpoint)
+    not_letta_endpoint = not ("inference.letta.com" in agent.llm_config.model_endpoint)
+    request_start_timestamp_ns = get_utc_timestamp_ns()
 
-    if agent_eligible and feature_enabled and model_compatible:
-        if agent.enable_sleeptime:
+    if user_eligible and agent_eligible and feature_enabled and model_compatible:
+        if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
             experimental_agent = SleeptimeMultiAgentV2(
                 agent_id=agent_id,
                 message_manager=server.message_manager,
@@ -759,7 +793,10 @@ async def send_message_streaming(
         else:
             result = StreamingResponseWithStatusCode(
                 experimental_agent.step_stream_no_tokens(
-                    request.messages, max_steps=10, use_assistant_message=request.use_assistant_message
+                    request.messages,
+                    max_steps=10,
+                    use_assistant_message=request.use_assistant_message,
+                    request_start_timestamp_ns=request_start_timestamp_ns,
                 ),
                 media_type="text/event-stream",
             )
@@ -792,6 +829,7 @@ async def process_message_background(
 ) -> None:
     """Background task to process the message and update job status."""
     try:
+        request_start_timestamp_ns = get_utc_timestamp_ns()
         result = await server.send_message_to_agent(
             agent_id=agent_id,
             actor=actor,
@@ -802,6 +840,7 @@ async def process_message_background(
             assistant_message_tool_name=assistant_message_tool_name,
             assistant_message_tool_kwarg=assistant_message_tool_kwarg,
             metadata={"job_id": job_id},  # Pass job_id through metadata
+            request_start_timestamp_ns=request_start_timestamp_ns,
         )
 
         # Update job status to completed
@@ -874,15 +913,17 @@ async def send_message_async(
 
 
 @router.patch("/{agent_id}/reset-messages", response_model=AgentState, operation_id="reset_messages")
-def reset_messages(
+async def reset_messages(
     agent_id: str,
     add_default_initial_messages: bool = Query(default=False, description="If true, adds the default initial messages after resetting."),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """Resets the messages for an agent"""
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.agent_manager.reset_messages(agent_id=agent_id, actor=actor, add_default_initial_messages=add_default_initial_messages)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.agent_manager.reset_messages_async(
+        agent_id=agent_id, actor=actor, add_default_initial_messages=add_default_initial_messages
+    )
 
 
 @router.get("/{agent_id}/groups", response_model=List[Group], operation_id="list_agent_groups")
@@ -896,3 +937,47 @@ async def list_agent_groups(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     print("in list agents with manager_type", manager_type)
     return server.agent_manager.list_groups(agent_id=agent_id, manager_type=manager_type, actor=actor)
+
+
+@router.post("/{agent_id}/summarize", response_model=AgentState, operation_id="summarize_agent_conversation")
+async def summarize_agent_conversation(
+    agent_id: str,
+    request_obj: Request,  # FastAPI Request
+    max_message_length: int = Query(..., description="Maximum number of messages to retain after summarization."),
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Summarize an agent's conversation history to a target message length.
+
+    This endpoint summarizes the current message history for a given agent,
+    truncating and compressing it down to the specified `max_message_length`.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+
+    # user_eligible = actor.organization_id not in ["org-4a3af5dd-4c6a-48cb-ac13-3f73ecaaa4bf", "org-4ab3f6e8-9a44-4bee-aeb6-c681cbbc7bf6"]
+    # TODO: This is redundant, remove soon
+    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+    agent_eligible = agent.enable_sleeptime or agent.agent_type == AgentType.sleeptime_agent or not agent.multi_agent_group
+    experimental_header = request_obj.headers.get("X-EXPERIMENTAL") or "false"
+    feature_enabled = settings.use_experimental or experimental_header.lower() == "true"
+    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
+
+    if agent_eligible and feature_enabled and model_compatible:
+        agent = LettaAgent(
+            agent_id=agent_id,
+            message_manager=server.message_manager,
+            agent_manager=server.agent_manager,
+            block_manager=server.block_manager,
+            passage_manager=server.passage_manager,
+            actor=actor,
+            step_manager=server.step_manager,
+            telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
+            message_buffer_min=max_message_length,
+        )
+        return await agent.summarize_conversation_history()
+
+    raise HTTPException(
+        status_code=status.HTTP_403_FORBIDDEN,
+        detail="Summarization is not currently supported for this agent configuration. Please contact Letta support.",
+    )

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

@@ -39,14 +39,15 @@ async def list_blocks(
 
 
 @router.get("/count", response_model=int, operation_id="count_blocks")
-def count_blocks(
+async def count_blocks(
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Count all blocks created by a user.
     """
-    return server.block_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.block_manager.size_async(actor=actor)
 
 
 @router.post("/", response_model=Block, operation_id="create_block")