letta-nightly 0.8.4.dev20250618104304__py3-none-any.whl → 0.8.5.dev20250619180801__py3-none-any.whl

letta/schemas/agent.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from enum import Enum
 from typing import Dict, List, Optional
 
@@ -105,6 +106,10 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
 
     multi_agent_group: Optional[Group] = Field(None, description="The multi-agent group that this agent manages")
 
+    # Run metrics
+    last_run_completion: Optional[datetime] = Field(None, description="The timestamp when the agent last completed a run.")
+    last_run_duration_ms: Optional[int] = Field(None, description="The duration in milliseconds of the agent's last run.")
+
     def get_agent_env_vars_as_dict(self) -> Dict[str, str]:
         # Get environment variables for this agent specifically
         per_agent_env_vars = {}
@@ -279,6 +284,8 @@ class UpdateAgent(BaseModel):
     )
     enable_sleeptime: Optional[bool] = Field(None, description="If set to True, memory management will move to a background agent thread.")
     response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the agent.")
+    last_run_completion: Optional[datetime] = Field(None, description="The timestamp when the agent last completed a run.")
+    last_run_duration_ms: Optional[int] = Field(None, description="The duration in milliseconds of the agent's last run.")
 
     class Config:
         extra = "ignore"  # Ignores extra fields

letta/schemas/embedding_config.py

@@ -63,6 +63,14 @@ class EmbeddingConfig(BaseModel):
                 embedding_dim=1536,
                 embedding_chunk_size=300,
             )
+        if model_name == "text-embedding-3-small" and provider == "openai":
+            return cls(
+                embedding_model="text-embedding-3-small",
+                embedding_endpoint_type="openai",
+                embedding_endpoint="https://api.openai.com/v1",
+                embedding_dim=2000,
+                embedding_chunk_size=300,
+            )
         elif model_name == "letta":
             return cls(
                 embedding_endpoint="https://embeddings.memgpt.ai",

letta/schemas/enums.py

@@ -3,7 +3,6 @@ from enum import Enum
 
 class ProviderType(str, Enum):
     anthropic = "anthropic"
-    anthropic_bedrock = "bedrock"
     google_ai = "google_ai"
     google_vertex = "google_vertex"
     openai = "openai"

letta/schemas/job.py

@@ -19,6 +19,7 @@ class JobBase(OrmMetadataBase):
     callback_url: Optional[str] = Field(None, description="If set, POST to this URL when the job completes.")
     callback_sent_at: Optional[datetime] = Field(None, description="Timestamp when the callback was last attempted.")
     callback_status_code: Optional[int] = Field(None, description="HTTP status code returned by the callback endpoint.")
+    callback_error: Optional[str] = Field(None, description="Optional error message from attempting to POST the callback endpoint.")
 
 
 class Job(JobBase):

letta/schemas/providers.py

@@ -27,8 +27,10 @@ class Provider(ProviderBase):
     name: str = Field(..., description="The name of the provider")
     provider_type: ProviderType = Field(..., description="The type of the provider")
     provider_category: ProviderCategory = Field(..., description="The category of the provider (base or byok)")
-    api_key: Optional[str] = Field(None, description="API key used for requests to the provider.")
+    api_key: Optional[str] = Field(None, description="API key or secret key used for requests to the provider.")
     base_url: Optional[str] = Field(None, description="Base URL for the provider.")
+    access_key: Optional[str] = Field(None, description="Access key used for requests to the provider.")
+    region: Optional[str] = Field(None, description="Region used for requests to the provider.")
     organization_id: Optional[str] = Field(None, description="The organization id of the user")
     updated_at: Optional[datetime] = Field(None, description="The last update timestamp of the provider.")
 
@@ -95,7 +97,7 @@ class Provider(ProviderBase):
                 return OpenAIProvider(**self.model_dump(exclude_none=True))
             case ProviderType.anthropic:
                 return AnthropicProvider(**self.model_dump(exclude_none=True))
-            case ProviderType.anthropic_bedrock:
+            case ProviderType.bedrock:
                 return AnthropicBedrockProvider(**self.model_dump(exclude_none=True))
             case ProviderType.ollama:
                 return OllamaProvider(**self.model_dump(exclude_none=True))
@@ -122,16 +124,22 @@ class Provider(ProviderBase):
 class ProviderCreate(ProviderBase):
     name: str = Field(..., description="The name of the provider.")
     provider_type: ProviderType = Field(..., description="The type of the provider.")
-    api_key: str = Field(..., description="API key used for requests to the provider.")
+    api_key: str = Field(..., description="API key or secret key used for requests to the provider.")
+    access_key: Optional[str] = Field(None, description="Access key used for requests to the provider.")
+    region: Optional[str] = Field(None, description="Region used for requests to the provider.")
 
 
 class ProviderUpdate(ProviderBase):
-    api_key: str = Field(..., description="API key used for requests to the provider.")
+    api_key: str = Field(..., description="API key or secret key used for requests to the provider.")
+    access_key: Optional[str] = Field(None, description="Access key used for requests to the provider.")
+    region: Optional[str] = Field(None, description="Region used for requests to the provider.")
 
 
 class ProviderCheck(BaseModel):
     provider_type: ProviderType = Field(..., description="The type of the provider.")
-    api_key: str = Field(..., description="API key used for requests to the provider.")
+    api_key: str = Field(..., description="API key or secret key used for requests to the provider.")
+    access_key: Optional[str] = Field(None, description="Access key used for requests to the provider.")
+    region: Optional[str] = Field(None, description="Region used for requests to the provider.")
 
 
 class LettaProvider(Provider):

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

@@ -1,9 +1,10 @@
+import asyncio
 import json
 import traceback
 from datetime import datetime, timezone
 from typing import Annotated, Any, List, Optional
 
-from fastapi import APIRouter, BackgroundTasks, Body, Depends, File, Header, HTTPException, Query, Request, UploadFile, status
+from fastapi import APIRouter, Body, Depends, File, Header, HTTPException, Query, Request, UploadFile, status
 from fastapi.responses import JSONResponse
 from marshmallow import ValidationError
 from orjson import orjson
@@ -79,6 +80,10 @@ async def list_agents(
         False,
         description="Whether to sort agents oldest to newest (True) or newest to oldest (False, default)",
     ),
+    sort_by: Optional[str] = Query(
+        "created_at",
+        description="Field to sort by. Options: 'created_at' (default), 'last_run_completion'",
+    ),
 ):
     """
     List all agents associated with a given user.
@@ -107,6 +112,7 @@ async def list_agents(
         identifier_keys=identifier_keys,
         include_relationships=include_relationships,
         ascending=ascending,
+        sort_by=sort_by,
     )
 
 
@@ -847,29 +853,63 @@ async def process_message_background(
     include_return_message_types: Optional[List[MessageType]] = None,
 ) -> None:
     """Background task to process the message and update job status."""
+    request_start_timestamp_ns = get_utc_timestamp_ns()
     try:
-        request_start_timestamp_ns = get_utc_timestamp_ns()
-        result = await server.send_message_to_agent(
-            agent_id=agent_id,
-            actor=actor,
-            input_messages=messages,
-            stream_steps=False,  # NOTE(matt)
-            stream_tokens=False,
-            use_assistant_message=use_assistant_message,
-            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,
-            include_return_message_types=include_return_message_types,
-        )
+        agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+        agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
+        model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
+        if agent_eligible and model_compatible:
+            if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
+                agent_loop = SleeptimeMultiAgentV2(
+                    agent_id=agent_id,
+                    message_manager=server.message_manager,
+                    agent_manager=server.agent_manager,
+                    block_manager=server.block_manager,
+                    passage_manager=server.passage_manager,
+                    group_manager=server.group_manager,
+                    job_manager=server.job_manager,
+                    actor=actor,
+                    group=agent.multi_agent_group,
+                )
+            else:
+                agent_loop = 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(),
+                )
+
+            result = await agent_loop.step(
+                messages,
+                max_steps=max_steps,
+                use_assistant_message=use_assistant_message,
+                request_start_timestamp_ns=request_start_timestamp_ns,
+                include_return_message_types=include_return_message_types,
+            )
+        else:
+            result = await server.send_message_to_agent(
+                agent_id=agent_id,
+                actor=actor,
+                input_messages=messages,
+                stream_steps=False,
+                stream_tokens=False,
+                # Support for AssistantMessage
+                use_assistant_message=use_assistant_message,
+                assistant_message_tool_name=assistant_message_tool_name,
+                assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+                include_return_message_types=include_return_message_types,
+            )
 
-        # Update job status to completed
         job_update = JobUpdate(
             status=JobStatus.completed,
             completed_at=datetime.now(timezone.utc),
-            metadata={"result": result.model_dump(mode="json")},  # Store the result in metadata
+            metadata={"result": result.model_dump(mode="json")},
         )
-        server.job_manager.update_job_by_id(job_id=job_id, job_update=job_update, actor=actor)
+        await server.job_manager.update_job_by_id_async(job_id=job_id, job_update=job_update, actor=actor)
 
     except Exception as e:
         # Update job status to failed
@@ -878,8 +918,7 @@ async def process_message_background(
             completed_at=datetime.now(timezone.utc),
             metadata={"error": str(e)},
         )
-        server.job_manager.update_job_by_id(job_id=job_id, job_update=job_update, actor=actor)
-        raise
+        await server.job_manager.update_job_by_id_async(job_id=job_id, job_update=job_update, actor=actor)
 
 
 @router.post(
@@ -889,10 +928,10 @@ async def process_message_background(
 )
 async def send_message_async(
     agent_id: str,
-    background_tasks: BackgroundTasks,
     server: SyncServer = Depends(get_letta_server),
     request: LettaRequest = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),
+    callback_url: Optional[str] = Query(None, description="Optional callback URL to POST to when the job completes"),
 ):
     """
     Asynchronously process a user message and return a run object.
@@ -905,6 +944,7 @@ async def send_message_async(
     run = Run(
         user_id=actor.id,
         status=JobStatus.created,
+        callback_url=callback_url,
         metadata={
             "job_type": "send_message_async",
             "agent_id": agent_id,
@@ -915,21 +955,22 @@ async def send_message_async(
             assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
         ),
     )
-    run = server.job_manager.create_job(pydantic_job=run, actor=actor)
+    run = await server.job_manager.create_job_async(pydantic_job=run, actor=actor)
 
-    # Add the background task
-    background_tasks.add_task(
-        process_message_background,
-        job_id=run.id,
-        server=server,
-        actor=actor,
-        agent_id=agent_id,
-        messages=request.messages,
-        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,
-        max_steps=request.max_steps,
-        include_return_message_types=request.include_return_message_types,
+    # Create asyncio task for background processing
+    asyncio.create_task(
+        process_message_background(
+            job_id=run.id,
+            server=server,
+            actor=actor,
+            agent_id=agent_id,
+            messages=request.messages,
+            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,
+            max_steps=request.max_steps,
+            include_return_message_types=request.include_return_message_types,
+        )
     )
 
     return run

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

@@ -66,20 +66,20 @@ async def modify_provider(
     """
     Update an existing custom provider
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.provider_manager.update_provider(provider_id=provider_id, provider_update=request, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.provider_manager.update_provider_async(provider_id=provider_id, provider_update=request, actor=actor)
 
 
 @router.get("/check", response_model=None, operation_id="check_provider")
 def check_provider(
-    provider_type: ProviderType = Query(...),
-    api_key: str = Header(..., alias="x-api-key"),
+    request: ProviderCheck = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     try:
-        provider_check = ProviderCheck(provider_type=provider_type, api_key=api_key)
-        server.provider_manager.check_provider_api_key(provider_check=provider_check)
-        return JSONResponse(status_code=status.HTTP_200_OK, content={"message": f"Valid api key for provider_type={provider_type.value}"})
+        server.provider_manager.check_provider_api_key(provider_check=request)
+        return JSONResponse(
+            status_code=status.HTTP_200_OK, content={"message": f"Valid api key for provider_type={request.provider_type.value}"}
+        )
     except LLMAuthenticationError as e:
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=f"{e.message}")
     except Exception as e:

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

@@ -11,6 +11,7 @@ from starlette import status
 import letta.constants as constants
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
+from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.passage import Passage
@@ -21,9 +22,14 @@ from letta.server.server import SyncServer
 from letta.services.file_processor.chunker.llama_index_chunker import LlamaIndexChunker
 from letta.services.file_processor.embedder.openai_embedder import OpenAIEmbedder
 from letta.services.file_processor.file_processor import FileProcessor
-from letta.services.file_processor.file_types import get_allowed_media_types, get_extension_to_mime_type_map, register_mime_types
+from letta.services.file_processor.file_types import (
+    get_allowed_media_types,
+    get_extension_to_mime_type_map,
+    is_simple_text_mime_type,
+    register_mime_types,
+)
 from letta.services.file_processor.parser.mistral_parser import MistralFileParser
-from letta.settings import model_settings, settings
+from letta.settings import settings
 from letta.utils import safe_create_task, sanitize_filename
 
 logger = get_logger(__name__)
@@ -184,7 +190,7 @@ async def upload_file_to_source(
     raw_ct = file.content_type or ""
     media_type = raw_ct.split(";", 1)[0].strip().lower()
 
-    # If client didn’t supply a Content-Type or it’s not one of the allowed types,
+    # If client didn't supply a Content-Type or it's not one of the allowed types,
     #    attempt to infer from filename extension.
     if media_type not in allowed_media_types and file.filename:
         guessed, _ = mimetypes.guess_type(file.filename)
@@ -211,6 +217,7 @@ async def upload_file_to_source(
     source = await server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
     if source is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Source with id={source_id} not found.")
+
     content = await file.read()
 
     # sanitize filename
@@ -228,20 +235,26 @@ async def upload_file_to_source(
     agent_states = await server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
 
     # NEW: Cloud based file processing
-    if settings.mistral_api_key and model_settings.openai_api_key:
-        logger.info("Running experimental cloud based file processing...")
-        safe_create_task(
-            load_file_to_source_cloud(server, agent_states, content, file, job, source_id, actor),
-            logger=logger,
-            label="file_processor.process",
-        )
-    else:
-        # create background tasks
-        safe_create_task(
-            load_file_to_source_async(server, source_id=source.id, filename=file.filename, job_id=job.id, bytes=content, actor=actor),
-            logger=logger,
-            label="load_file_to_source_async",
+    # Determine file's MIME type
+    file_mime_type = mimetypes.guess_type(file.filename)[0] or "application/octet-stream"
+
+    # Check if it's a simple text file
+    is_simple_file = is_simple_text_mime_type(file_mime_type)
+
+    # For complex files, require Mistral API key
+    if not is_simple_file and not settings.mistral_api_key:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Mistral API key is required to process this file type {file_mime_type}. Please configure your Mistral API key to upload complex file formats.",
         )
+
+    # Use cloud processing for all files (simple files always, complex files with Mistral key)
+    logger.info("Running experimental cloud based file processing...")
+    safe_create_task(
+        load_file_to_source_cloud(server, agent_states, content, file, job, source_id, actor, source.embedding_config),
+        logger=logger,
+        label="file_processor.process",
+    )
     safe_create_task(sleeptime_document_ingest_async(server, source_id, actor), logger=logger, label="sleeptime_document_ingest_async")
 
     return job
@@ -336,10 +349,17 @@ async def sleeptime_document_ingest_async(server: SyncServer, source_id: str, ac
 
 
 async def load_file_to_source_cloud(
-    server: SyncServer, agent_states: List[AgentState], content: bytes, file: UploadFile, job: Job, source_id: str, actor: User
+    server: SyncServer,
+    agent_states: List[AgentState],
+    content: bytes,
+    file: UploadFile,
+    job: Job,
+    source_id: str,
+    actor: User,
+    embedding_config: EmbeddingConfig,
 ):
     file_processor = MistralFileParser()
-    text_chunker = LlamaIndexChunker()
-    embedder = OpenAIEmbedder()
+    text_chunker = LlamaIndexChunker(chunk_size=embedding_config.embedding_chunk_size)
+    embedder = OpenAIEmbedder(embedding_config=embedding_config)
     file_processor = FileProcessor(file_parser=file_processor, text_chunker=text_chunker, embedder=embedder, actor=actor)
     await file_processor.process(server=server, agent_states=agent_states, source_id=source_id, content=content, file=file, job=job)

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

@@ -13,11 +13,12 @@ from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 
 from letta.errors import LettaToolCreateError
 from letta.functions.mcp_client.exceptions import MCPTimeoutError
-from letta.functions.mcp_client.types import MCPTool, SSEServerConfig, StdioServerConfig
+from letta.functions.mcp_client.types import MCPTool, SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig
 from letta.helpers.composio_helpers import get_composio_api_key
 from letta.log import get_logger
 from letta.orm.errors import UniqueConstraintViolationError
 from letta.schemas.letta_message import ToolReturnMessage
+from letta.schemas.mcp import UpdateSSEMCPServer, UpdateStreamableHTTPMCPServer
 from letta.schemas.tool import Tool, ToolCreate, ToolRunFromSource, ToolUpdate
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
@@ -91,6 +92,8 @@ async def list_tools(
         if name is not None:
             tool = await server.tool_manager.get_tool_by_name_async(tool_name=name, actor=actor)
             return [tool] if tool else []
+
+        # Get the list of tools
         return await server.tool_manager.list_tools_async(actor=actor, after=after, limit=limit)
     except Exception as e:
         # Log or print the full exception here for debugging
@@ -338,20 +341,20 @@ async def add_composio_tool(
                 "composio_action_name": composio_action_name,
             },
         )
-    except ComposioClientError as e:
+    except ApiKeyNotProvidedError as e:
         raise HTTPException(
             status_code=400,  # Bad Request
             detail={
-                "code": "ComposioClientError",
+                "code": "ApiKeyNotProvidedError",
                 "message": str(e),
                 "composio_action_name": composio_action_name,
             },
         )
-    except ApiKeyNotProvidedError as e:
+    except ComposioClientError as e:
         raise HTTPException(
             status_code=400,  # Bad Request
             detail={
-                "code": "ApiKeyNotProvidedError",
+                "code": "ComposioClientError",
                 "message": str(e),
                 "composio_action_name": composio_action_name,
             },
@@ -368,7 +371,11 @@ async def add_composio_tool(
 
 
 # Specific routes for MCP
-@router.get("/mcp/servers", response_model=dict[str, Union[SSEServerConfig, StdioServerConfig]], operation_id="list_mcp_servers")
+@router.get(
+    "/mcp/servers",
+    response_model=dict[str, Union[SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig]],
+    operation_id="list_mcp_servers",
+)
 async def list_mcp_servers(server: SyncServer = Depends(get_letta_server), user_id: Optional[str] = Header(None, alias="user_id")):
     """
     Get a list of all configured MCP servers
@@ -479,44 +486,102 @@ async def add_mcp_tool(
         return await server.mcp_manager.add_tool_from_mcp_server(mcp_server_name=mcp_server_name, mcp_tool_name=mcp_tool_name, actor=actor)
 
 
-@router.put("/mcp/servers", response_model=List[Union[StdioServerConfig, SSEServerConfig]], operation_id="add_mcp_server")
+@router.put(
+    "/mcp/servers",
+    response_model=List[Union[StdioServerConfig, SSEServerConfig, StreamableHTTPServerConfig]],
+    operation_id="add_mcp_server",
+)
 async def add_mcp_server_to_config(
-    request: Union[StdioServerConfig, SSEServerConfig] = Body(...),
+    request: Union[StdioServerConfig, SSEServerConfig, StreamableHTTPServerConfig] = Body(...),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Add a new MCP server to the Letta MCP server config
     """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        if tool_settings.mcp_read_from_config:
+            # write to config file
+            return await server.add_mcp_server_to_config(server_config=request, allow_upsert=True)
+        else:
+            # log to DB
+            from letta.schemas.mcp import MCPServer
+
+            if isinstance(request, StdioServerConfig):
+                mapped_request = MCPServer(server_name=request.server_name, server_type=request.type, stdio_config=request)
+                # don't allow stdio servers
+                if tool_settings.mcp_disable_stdio:  # protected server
+                    raise HTTPException(
+                        status_code=400,
+                        detail="stdio is not supported in the current environment, please use a self-hosted Letta server in order to add a stdio MCP server",
+                    )
+            elif isinstance(request, SSEServerConfig):
+                mapped_request = MCPServer(
+                    server_name=request.server_name, server_type=request.type, server_url=request.server_url, token=request.resolve_token()
+                )
+            elif isinstance(request, StreamableHTTPServerConfig):
+                mapped_request = MCPServer(
+                    server_name=request.server_name, server_type=request.type, server_url=request.server_url, token=request.resolve_token()
+                )
+
+            await server.mcp_manager.create_mcp_server(mapped_request, actor=actor)
+
+            # TODO: don't do this in the future (just return MCPServer)
+            all_servers = await server.mcp_manager.list_mcp_servers(actor=actor)
+            return [server.to_config() for server in all_servers]
+    except UniqueConstraintViolationError:
+        # If server name already exists, throw 409 conflict error
+        raise HTTPException(
+            status_code=409,
+            detail={
+                "code": "MCPServerNameAlreadyExistsError",
+                "message": f"MCP server with name '{request.server_name}' already exists",
+                "server_name": request.server_name,
+            },
+        )
+    except Exception as e:
+        print(f"Unexpected error occurred while adding MCP server: {e}")
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
-    if tool_settings.mcp_read_from_config:
-        # write to config file
-        return await server.add_mcp_server_to_config(server_config=request, allow_upsert=True)
-    else:
-        # log to DB
-        from letta.schemas.mcp import MCPServer
-
-        if isinstance(request, StdioServerConfig):
-            mapped_request = MCPServer(server_name=request.server_name, server_type=request.type, stdio_config=request)
-            # don't allow stdio servers
-            if tool_settings.mcp_disable_stdio:  # protected server
-                raise HTTPException(status_code=400, detail="StdioServerConfig is not supported")
-        elif isinstance(request, SSEServerConfig):
-            mapped_request = MCPServer(
-                server_name=request.server_name, server_type=request.type, server_url=request.server_url, token=request.resolve_token()
-            )
-        # TODO: add HTTP streaming
-        mcp_server = await server.mcp_manager.create_or_update_mcp_server(mapped_request, actor=actor)
 
-        # TODO: don't do this in the future (just return MCPServer)
-        all_servers = await server.mcp_manager.list_mcp_servers(actor=actor)
-        return [server.to_config() for server in all_servers]
+@router.patch(
+    "/mcp/servers/{mcp_server_name}",
+    response_model=Union[StdioServerConfig, SSEServerConfig, StreamableHTTPServerConfig],
+    operation_id="update_mcp_server",
+)
+async def update_mcp_server(
+    mcp_server_name: str,
+    request: Union[UpdateSSEMCPServer, UpdateStreamableHTTPMCPServer] = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Update an existing MCP server configuration
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+
+        if tool_settings.mcp_read_from_config:
+            raise HTTPException(status_code=501, detail="Update not implemented for config file mode, config files to be deprecated.")
+        else:
+            updated_server = await server.mcp_manager.update_mcp_server_by_name(
+                mcp_server_name=mcp_server_name, mcp_server_update=request, actor=actor
+            )
+            return updated_server.to_config()
+    except HTTPException:
+        # Re-raise HTTP exceptions (like 404)
+        raise
+    except Exception as e:
+        print(f"Unexpected error occurred while updating MCP server: {e}")
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
 @router.delete(
-    "/mcp/servers/{mcp_server_name}", response_model=List[Union[StdioServerConfig, SSEServerConfig]], operation_id="delete_mcp_server"
+    "/mcp/servers/{mcp_server_name}",
+    response_model=List[Union[StdioServerConfig, SSEServerConfig, StreamableHTTPServerConfig]],
+    operation_id="delete_mcp_server",
 )
 async def delete_mcp_server_from_config(
     mcp_server_name: str,

letta/services/agent_manager.py

@@ -622,6 +622,8 @@ class AgentManager:
                 "message_buffer_autoclear": agent_update.message_buffer_autoclear,
                 "enable_sleeptime": agent_update.enable_sleeptime,
                 "response_format": agent_update.response_format,
+                "last_run_completion": agent_update.last_run_completion,
+                "last_run_duration_ms": agent_update.last_run_duration_ms,
             }
             for col, val in scalar_updates.items():
                 if val is not None:
@@ -742,6 +744,8 @@ class AgentManager:
                 "message_buffer_autoclear": agent_update.message_buffer_autoclear,
                 "enable_sleeptime": agent_update.enable_sleeptime,
                 "response_format": agent_update.response_format,
+                "last_run_completion": agent_update.last_run_completion,
+                "last_run_duration_ms": agent_update.last_run_duration_ms,
             }
             for col, val in scalar_updates.items():
                 if val is not None:
@@ -844,6 +848,7 @@ class AgentManager:
         identifier_keys: Optional[List[str]] = None,
         include_relationships: Optional[List[str]] = None,
         ascending: bool = True,
+        sort_by: Optional[str] = "created_at",
     ) -> List[PydanticAgentState]:
         """
         Retrieves agents with optimized filtering and optional field selection.
@@ -876,7 +881,7 @@ class AgentManager:
             query = _apply_filters(query, name, query_text, project_id, template_id, base_template_id)
             query = _apply_identity_filters(query, identity_id, identifier_keys)
             query = _apply_tag_filter(query, tags, match_all_tags)
-            query = _apply_pagination(query, before, after, session, ascending=ascending)
+            query = _apply_pagination(query, before, after, session, ascending=ascending, sort_by=sort_by)
 
             if limit:
                 query = query.limit(limit)
@@ -903,6 +908,7 @@ class AgentManager:
         identifier_keys: Optional[List[str]] = None,
         include_relationships: Optional[List[str]] = None,
         ascending: bool = True,
+        sort_by: Optional[str] = "created_at",
     ) -> List[PydanticAgentState]:
         """
         Retrieves agents with optimized filtering and optional field selection.
@@ -935,7 +941,7 @@ class AgentManager:
             query = _apply_filters(query, name, query_text, project_id, template_id, base_template_id)
             query = _apply_identity_filters(query, identity_id, identifier_keys)
             query = _apply_tag_filter(query, tags, match_all_tags)
-            query = await _apply_pagination_async(query, before, after, session, ascending=ascending)
+            query = await _apply_pagination_async(query, before, after, session, ascending=ascending, sort_by=sort_by)
 
             if limit:
                 query = query.limit(limit)