letta-nightly 0.12.1.dev20251024104217__py3-none-any.whl → 0.13.0.dev20251025104015__py3-none-any.whl

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

@@ -5,8 +5,8 @@ from fastapi import APIRouter, Body, Depends, HTTPException, Query
 from pydantic import Field
 
 from letta.data_sources.redis_client import NoopAsyncRedisClient, get_redis_client
+from letta.errors import LettaExpiredError, LettaInvalidArgumentError
 from letta.helpers.datetime_helpers import get_utc_time
-from letta.orm.errors import NoResultFound
 from letta.schemas.enums import RunStatus
 from letta.schemas.letta_message import LettaMessageUnion
 from letta.schemas.letta_request import RetrieveStreamRequest
@@ -151,28 +151,25 @@ async def retrieve_run(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
 
-    try:
-        run = await runs_manager.get_run_by_id(run_id=run_id, actor=actor)
-
-        use_lettuce = run.metadata and run.metadata.get("lettuce")
-        if use_lettuce and run.status not in [RunStatus.completed, RunStatus.failed, RunStatus.cancelled]:
-            lettuce_client = await LettuceClient.create()
-            status = await lettuce_client.get_status()
-
-            # Map the status to our enum
-            run_status = run.status
-            if status == "RUNNING":
-                run_status = RunStatus.running
-            elif status == "COMPLETED":
-                run_status = RunStatus.completed
-            elif status == "FAILED":
-                run_status = RunStatus.failed
-            elif status == "CANCELLED":
-                run_status = RunStatus.cancelled
-            run.status = run_status
-        return run
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Run not found")
+    run = await runs_manager.get_run_by_id(run_id=run_id, actor=actor)
+
+    use_lettuce = run.metadata and run.metadata.get("lettuce")
+    if use_lettuce and run.status not in [RunStatus.completed, RunStatus.failed, RunStatus.cancelled]:
+        lettuce_client = await LettuceClient.create()
+        status = await lettuce_client.get_status(run_id=run_id)
+
+        # Map the status to our enum
+        run_status = run.status
+        if status == "RUNNING":
+            run_status = RunStatus.running
+        elif status == "COMPLETED":
+            run_status = RunStatus.completed
+        elif status == "FAILED":
+            run_status = RunStatus.failed
+        elif status == "CANCELLED":
+            run_status = RunStatus.cancelled
+        run.status = run_status
+    return run
 
 
 RunMessagesResponse = Annotated[
@@ -218,11 +215,7 @@ async def retrieve_run_usage(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
 
-    try:
-        usage = await runs_manager.get_run_usage(run_id=run_id, actor=actor)
-        return usage
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail=f"Run '{run_id}' not found")
+    return await runs_manager.get_run_usage(run_id=run_id, actor=actor)
 
 
 @router.get("/{run_id}/metrics", response_model=RunMetrics, operation_id="retrieve_metrics_for_run")
@@ -234,12 +227,9 @@ async def retrieve_metrics_for_run(
     """
     Get run metrics by run ID.
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        runs_manager = RunManager()
-        return await runs_manager.get_run_metrics_async(run_id=run_id, actor=actor)
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Run metrics not found")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    runs_manager = RunManager()
+    return await runs_manager.get_run_metrics_async(run_id=run_id, actor=actor)
 
 
 @router.get(
@@ -275,7 +265,7 @@ async def list_run_steps(
     )
 
 
-@router.delete("/{run_id}", response_model=Run, operation_id="delete_run")
+@router.delete("/{run_id}", response_model=None, operation_id="delete_run")
 async def delete_run(
     run_id: str,
     headers: HeaderParams = Depends(get_headers),
@@ -286,7 +276,7 @@ async def delete_run(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
-    return await runs_manager.delete_run(run_id=run_id, actor=actor)
+    return await runs_manager.delete_run_by_id(run_id=run_id, actor=actor)
 
 
 @router.post(
@@ -330,16 +320,13 @@ async def retrieve_stream(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
 
-    try:
-        run = await runs_manager.get_run_by_id(run_id=run_id, actor=actor)
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Run not found")
+    run = await runs_manager.get_run_by_id(run_id=run_id, actor=actor)
 
     if not run.background:
-        raise HTTPException(status_code=400, detail="Run was not created in background mode, so it cannot be retrieved.")
+        raise LettaInvalidArgumentError("Run was not created in background mode, so it cannot be retrieved.")
 
     if run.created_at < get_utc_time() - timedelta(hours=3):
-        raise HTTPException(status_code=410, detail="Run was created more than 3 hours ago, and is now expired.")
+        raise LettaExpiredError("Run was created more than 3 hours ago, and is now expired.")
 
     redis_client = await get_redis_client()
 
@@ -370,7 +357,7 @@ async def retrieve_stream(
         )
 
     if request.include_pings and settings.enable_keepalive:
-        stream = add_keepalive_to_stream(stream, keepalive_interval=settings.keepalive_interval)
+        stream = add_keepalive_to_stream(stream, keepalive_interval=settings.keepalive_interval, run_id=run_id)
 
     return StreamingResponseWithStatusCode(
         stream,

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

@@ -15,12 +15,14 @@ from letta.schemas.environment_variables import (
 from letta.schemas.sandbox_config import (
     LocalSandboxConfig,
     SandboxConfig as PydanticSandboxConfig,
+    SandboxConfigBase,
     SandboxConfigCreate,
     SandboxConfigUpdate,
 )
 from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
 from letta.server.server import SyncServer
 from letta.services.helpers.tool_execution_helper import create_venv_for_local_sandbox, install_pip_requirements_for_sandbox
+from letta.validators import SandboxConfigId
 
 router = APIRouter(prefix="/sandbox-config", tags=["sandbox-config"])
 
@@ -87,8 +89,8 @@ async def create_custom_local_sandbox_config(
 
 @router.patch("/{sandbox_config_id}", response_model=PydanticSandboxConfig)
 async def update_sandbox_config(
-    sandbox_config_id: str,
     config_update: SandboxConfigUpdate,
+    sandbox_config_id: SandboxConfigId,
     server: SyncServer = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -98,7 +100,7 @@ async def update_sandbox_config(
 
 @router.delete("/{sandbox_config_id}", status_code=204)
 async def delete_sandbox_config(
-    sandbox_config_id: str,
+    sandbox_config_id: SandboxConfigId,
     server: SyncServer = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -157,8 +159,8 @@ async def force_recreate_local_sandbox_venv(
 
 @router.post("/{sandbox_config_id}/environment-variable", response_model=PydanticEnvVar)
 async def create_sandbox_env_var(
-    sandbox_config_id: str,
     env_var_create: SandboxEnvironmentVariableCreate,
+    sandbox_config_id: SandboxConfigId,
     server: SyncServer = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -189,7 +191,7 @@ async def delete_sandbox_env_var(
 
 @router.get("/{sandbox_config_id}/environment-variable", response_model=List[PydanticEnvVar])
 async def list_sandbox_env_vars(
-    sandbox_config_id: str,
+    sandbox_config_id: SandboxConfigId,
     limit: int = Query(1000, description="Number of results to return"),
     after: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
     server: SyncServer = Depends(get_letta_server),

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

@@ -9,6 +9,7 @@ from starlette import status
 from starlette.responses import Response
 
 import letta.constants as constants
+from letta.errors import LettaInvalidArgumentError, LettaUnsupportedFileUploadError
 from letta.helpers.pinecone_utils import (
     delete_file_records_from_pinecone_index,
     delete_source_records_from_pinecone_index,
@@ -20,9 +21,9 @@ from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import DuplicateFileHandling, FileProcessingStatus
-from letta.schemas.file import FileMetadata
+from letta.schemas.file import FileMetadata, FileMetadataBase
 from letta.schemas.passage import Passage
-from letta.schemas.source import Source, SourceCreate, SourceUpdate
+from letta.schemas.source import BaseSource, Source, SourceCreate, SourceUpdate
 from letta.schemas.source_metadata import OrganizationSourcesStats
 from letta.schemas.user import User
 from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
@@ -35,6 +36,7 @@ from letta.services.file_processor.parser.markitdown_parser import MarkitdownFil
 from letta.services.file_processor.parser.mistral_parser import MistralFileParser
 from letta.settings import settings
 from letta.utils import safe_create_file_processing_task, safe_create_task, sanitize_filename
+from letta.validators import FileId, SourceId
 
 logger = get_logger(__name__)
 
@@ -58,7 +60,7 @@ async def count_sources(
 
 @router.get("/{source_id}", response_model=Source, operation_id="retrieve_source", deprecated=True)
 async def retrieve_source(
-    source_id: str,
+    source_id: SourceId,
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -66,10 +68,7 @@ async def retrieve_source(
     Get all sources
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-
     source = await server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
-    if not source:
-        raise HTTPException(status_code=404, detail=f"Source with id={source_id} not found.")
     return source
 
 
@@ -85,8 +84,6 @@ async def get_source_id_by_name(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
     source = await server.source_manager.get_source_by_name(source_name=source_name, actor=actor)
-    if not source:
-        raise HTTPException(status_code=404, detail=f"Source with name={source_name} not found.")
     return source.id
 
 
@@ -138,8 +135,9 @@ async def create_source(
     if not source_create.embedding_config:
         if not source_create.embedding:
             if settings.default_embedding_handle is None:
-                # TODO: modify error type
-                raise ValueError("Must specify either embedding or embedding_config in request")
+                raise LettaInvalidArgumentError(
+                    "Must specify either embedding or embedding_config in request", argument_name="default_embedding_handle"
+                )
             else:
                 source_create.embedding = settings.default_embedding_handle
         source_create.embedding_config = await server.get_embedding_config_from_handle_async(
@@ -159,8 +157,8 @@ async def create_source(
 
 @router.patch("/{source_id}", response_model=Source, operation_id="modify_source", deprecated=True)
 async def modify_source(
-    source_id: str,
     source: SourceUpdate,
+    source_id: SourceId,
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -169,14 +167,13 @@ async def modify_source(
     """
     # TODO: allow updating the handle/embedding config
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-    if not await server.source_manager.get_source_by_id(source_id=source_id, actor=actor):
-        raise HTTPException(status_code=404, detail=f"Source with id={source_id} does not exist.")
+    await server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
     return await server.source_manager.update_source(source_id=source_id, source_update=source, actor=actor)
 
 
 @router.delete("/{source_id}", response_model=None, operation_id="delete_source", deprecated=True)
 async def delete_source(
-    source_id: str,
+    source_id: SourceId,
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -203,18 +200,16 @@ async def delete_source(
         await server.remove_files_from_context_window(agent_state=agent_state, file_ids=file_ids, actor=actor)
 
         if agent_state.enable_sleeptime:
-            try:
-                block = await server.agent_manager.get_block_with_label_async(agent_id=agent_state.id, block_label=source.name, actor=actor)
+            block = await server.agent_manager.get_block_with_label_async(agent_id=agent_state.id, block_label=source.name, actor=actor)
+            if block:
                 await server.block_manager.delete_block_async(block.id, actor)
-            except:
-                pass
     await server.delete_source(source_id=source_id, actor=actor)
 
 
 @router.post("/{source_id}/upload", response_model=FileMetadata, operation_id="upload_file_to_source", deprecated=True)
 async def upload_file_to_source(
     file: UploadFile,
-    source_id: str,
+    source_id: SourceId,
     duplicate_handling: DuplicateFileHandling = Query(DuplicateFileHandling.SUFFIX, description="How to handle duplicate filenames"),
     name: Optional[str] = Query(None, description="Optional custom name to override the uploaded file's name"),
     server: "SyncServer" = Depends(get_letta_server),
@@ -246,9 +241,8 @@ async def upload_file_to_source(
 
     # If still not allowed, reject with 415.
     if media_type not in allowed_media_types:
-        raise HTTPException(
-            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
-            detail=(
+        raise LettaUnsupportedFileUploadError(
+            message=(
                 f"Unsupported file type: {media_type or 'unknown'} "
                 f"(filename: {file.filename}). "
                 f"Supported types: PDF, text files (.txt, .md), JSON, and code files (.py, .js, .java, etc.)."
@@ -258,8 +252,6 @@ async def upload_file_to_source(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
     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()
 
@@ -278,8 +270,9 @@ async def upload_file_to_source(
     if existing_file:
         # Duplicate found, handle based on strategy
         if duplicate_handling == DuplicateFileHandling.ERROR:
-            raise HTTPException(
-                status_code=status.HTTP_409_CONFLICT, detail=f"File '{original_filename}' already exists in source '{source.name}'"
+            raise LettaInvalidArgumentError(
+                message=f"File '{original_filename}' already exists in source '{source.name}'",
+                argument_name="duplicate_handling",
             )
         elif duplicate_handling == DuplicateFileHandling.SKIP:
             # Return existing file metadata with custom header to indicate it was skipped
@@ -331,7 +324,7 @@ async def upload_file_to_source(
 
 @router.get("/{source_id}/agents", response_model=List[str], operation_id="get_agents_for_source", deprecated=True)
 async def get_agents_for_source(
-    source_id: str,
+    source_id: SourceId,
     server: SyncServer = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -344,7 +337,7 @@ async def get_agents_for_source(
 
 @router.get("/{source_id}/passages", response_model=List[Passage], operation_id="list_source_passages", deprecated=True)
 async def list_source_passages(
-    source_id: str,
+    source_id: SourceId,
     after: Optional[str] = Query(None, description="Message after which to retrieve the returned messages."),
     before: Optional[str] = Query(None, description="Message before which to retrieve the returned messages."),
     limit: int = Query(100, description="Maximum number of messages to retrieve."),
@@ -366,7 +359,7 @@ async def list_source_passages(
 
 @router.get("/{source_id}/files", response_model=List[FileMetadata], operation_id="list_source_files", deprecated=True)
 async def list_source_files(
-    source_id: str,
+    source_id: SourceId,
     limit: int = Query(1000, description="Number of files to return"),
     after: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
     include_content: bool = Query(False, description="Whether to include full file content"),
@@ -394,8 +387,8 @@ async def list_source_files(
 
 @router.get("/{source_id}/files/{file_id}", response_model=FileMetadata, operation_id="get_file_metadata", deprecated=True)
 async def get_file_metadata(
-    source_id: str,
-    file_id: str,
+    source_id: SourceId,
+    file_id: FileId,
     include_content: bool = Query(False, description="Whether to include full file content"),
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
@@ -410,13 +403,6 @@ async def get_file_metadata(
         file_id=file_id, actor=actor, include_content=include_content, strip_directory_prefix=True
     )
 
-    if not file_metadata:
-        raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
-
-    # Verify the file belongs to the specified source
-    if file_metadata.source_id != source_id:
-        raise HTTPException(status_code=404, detail=f"File with id={file_id} not found in source {source_id}.")
-
     # Check and update file status (timeout check and pinecone embedding sync)
     file_metadata = await server.file_manager.check_and_update_file_status(file_metadata, actor)
 
@@ -427,8 +413,8 @@ async def get_file_metadata(
 # it's still good practice to return a status indicating the success or failure of the deletion
 @router.delete("/{source_id}/{file_id}", status_code=204, operation_id="delete_file_from_source", deprecated=True)
 async def delete_file_from_source(
-    source_id: str,
-    file_id: str,
+    source_id: SourceId,
+    file_id: FileId,
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -452,8 +438,6 @@ async def delete_file_from_source(
         await delete_file_records_from_pinecone_index(file_id=file_id, actor=actor)
 
     safe_create_task(sleeptime_document_ingest_async(server, source_id, actor, clear_history=True), label="document_ingest_after_delete")
-    if deleted_file is None:
-        raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
 
 
 async def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, filename: str, bytes: bytes, actor: User):

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

@@ -1,19 +1,19 @@
 from datetime import datetime
 from typing import List, Literal, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+from fastapi import APIRouter, Body, Depends, Header, Query
 from pydantic import BaseModel, Field
 
-from letta.orm.errors import NoResultFound
 from letta.schemas.letta_message import LettaMessageUnion
 from letta.schemas.message import Message
 from letta.schemas.provider_trace import ProviderTrace
-from letta.schemas.step import Step
+from letta.schemas.step import Step, StepBase
 from letta.schemas.step_metrics import StepMetrics
 from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
 from letta.server.server import SyncServer
 from letta.services.step_manager import FeedbackType
 from letta.settings import settings
+from letta.validators import StepId
 
 router = APIRouter(prefix="/steps", tags=["steps"])
 
@@ -70,39 +70,33 @@ async def list_steps(
 
 @router.get("/{step_id}", response_model=Step, operation_id="retrieve_step")
 async def retrieve_step(
-    step_id: str,
+    step_id: StepId,
     headers: HeaderParams = Depends(get_headers),
     server: SyncServer = Depends(get_letta_server),
 ):
     """
     Get a step by ID.
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        return await server.step_manager.get_step_async(step_id=step_id, actor=actor)
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Step not found")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.step_manager.get_step_async(step_id=step_id, actor=actor)
 
 
 @router.get("/{step_id}/metrics", response_model=StepMetrics, operation_id="retrieve_metrics_for_step")
 async def retrieve_metrics_for_step(
-    step_id: str,
+    step_id: StepId,
     headers: HeaderParams = Depends(get_headers),
     server: SyncServer = Depends(get_letta_server),
 ):
     """
     Get step metrics by step ID.
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        return await server.step_manager.get_step_metrics_async(step_id=step_id, actor=actor)
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Step metrics not found")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.step_manager.get_step_metrics_async(step_id=step_id, actor=actor)
 
 
 @router.get("/{step_id}/trace", response_model=Optional[ProviderTrace], operation_id="retrieve_trace_for_step")
 async def retrieve_trace_for_step(
-    step_id: str,
+    step_id: StepId,
     server: SyncServer = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -125,7 +119,7 @@ class ModifyFeedbackRequest(BaseModel):
 
 @router.patch("/{step_id}/feedback", response_model=Step, operation_id="modify_feedback_for_step")
 async def modify_feedback_for_step(
-    step_id: str,
+    step_id: StepId,
     request: ModifyFeedbackRequest = Body(...),
     headers: HeaderParams = Depends(get_headers),
     server: SyncServer = Depends(get_letta_server),
@@ -133,16 +127,13 @@ async def modify_feedback_for_step(
     """
     Modify feedback for a given step.
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        return await server.step_manager.add_feedback_async(step_id=step_id, feedback=request.feedback, tags=request.tags, actor=actor)
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Step not found")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.step_manager.add_feedback_async(step_id=step_id, feedback=request.feedback, tags=request.tags, actor=actor)
 
 
 @router.get("/{step_id}/messages", response_model=List[LettaMessageUnion], operation_id="list_messages_for_step")
 async def list_messages_for_step(
-    step_id: str,
+    step_id: StepId,
     headers: HeaderParams = Depends(get_headers),
     server: SyncServer = Depends(get_letta_server),
     before: Optional[str] = Query(
@@ -169,8 +160,8 @@ async def list_messages_for_step(
 
 @router.patch("/{step_id}/transaction/{transaction_id}", response_model=Step, operation_id="update_step_transaction_id")
 async def update_step_transaction_id(
-    step_id: str,
     transaction_id: str,
+    step_id: StepId,
     headers: HeaderParams = Depends(get_headers),
     server: SyncServer = Depends(get_letta_server),
 ):
@@ -178,8 +169,4 @@ async def update_step_transaction_id(
     Update the transaction ID for a step.
     """
     actor = server.user_manager.get_user_or_default(user_id=headers.actor_id)
-
-    try:
-        return await server.step_manager.update_step_transaction_id(actor=actor, step_id=step_id, transaction_id=transaction_id)
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Step not found")
+    return await server.step_manager.update_step_transaction_id(actor=actor, step_id=step_id, transaction_id=transaction_id)

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

@@ -30,14 +30,17 @@ from letta.schemas.letta_message_content import TextContent
 from letta.schemas.mcp import UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateStreamableHTTPMCPServer
 from letta.schemas.message import Message
 from letta.schemas.pip_requirement import PipRequirement
-from letta.schemas.tool import Tool, ToolCreate, ToolRunFromSource, ToolUpdate
+from letta.schemas.tool import BaseTool, Tool, ToolCreate, ToolRunFromSource, ToolUpdate
 from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
 from letta.server.rest_api.streaming_response import StreamingResponseWithStatusCode
 from letta.server.server import SyncServer
 from letta.services.mcp.oauth_utils import MCPOAuthSession, drill_down_exception, oauth_stream_event
 from letta.services.mcp.stdio_client import AsyncStdioMCPClient
 from letta.services.mcp.types import OauthStreamEvent
+from letta.services.summarizer.summarizer import traceback
 from letta.settings import tool_settings
+from letta.utils import asyncio
+from letta.validators import ToolId
 
 router = APIRouter(prefix="/tools", tags=["tools"])
 
@@ -46,7 +49,7 @@ logger = get_logger(__name__)
 
 @router.delete("/{tool_id}", operation_id="delete_tool")
 async def delete_tool(
-    tool_id: str,
+    tool_id: ToolId,
     server: SyncServer = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -149,7 +152,7 @@ async def count_tools(
 
 @router.get("/{tool_id}", response_model=Tool, operation_id="retrieve_tool")
 async def retrieve_tool(
-    tool_id: str,
+    tool_id: ToolId,
     server: SyncServer = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
@@ -297,7 +300,7 @@ async def upsert_tool(
 
 @router.patch("/{tool_id}", response_model=Tool, operation_id="modify_tool")
 async def modify_tool(
-    tool_id: str,
+    tool_id: ToolId,
     request: ToolUpdate = Body(...),
     server: SyncServer = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
@@ -443,14 +446,11 @@ async def add_mcp_tool(
                 argument_name="mcp_tool_name",
             )
 
-        # Check tool health - reject only INVALID tools
-        if mcp_tool.health:
-            if mcp_tool.health.status == "INVALID":
-                raise LettaInvalidMCPSchemaError(
-                    server_name=mcp_server_name,
-                    mcp_tool_name=mcp_tool_name,
-                    reasons=mcp_tool.health.reasons,
-                )
+        # Log warning if tool has invalid schema but allow attachment
+        if mcp_tool.health and mcp_tool.health.status == "INVALID":
+            logger.warning(
+                f"Attaching MCP tool {mcp_tool_name} from server {mcp_server_name} with invalid schema. Reasons: {mcp_tool.health.reasons}"
+            )
 
         tool_create = ToolCreate.from_mcp(mcp_server_name=mcp_server_name, mcp_tool=mcp_tool)
         # For config-based servers, use the server name as ID since they don't have database IDs
@@ -666,7 +666,11 @@ async def connect_mcp_server(
             detailed_error = drill_down_exception(e)
             logger.error(f"Error in OAuth stream:\n{detailed_error}")
             yield oauth_stream_event(OauthStreamEvent.ERROR, message=f"Internal error: {detailed_error}")
-
+        # TODO: investigate cancelled by cancel scope errors here during oauth exchange flow
+        except asyncio.CancelledError as e:
+            logger.error(f"CancelledError: {e!r}")
+            tb = "".join(traceback.format_stack())
+            logger.error(f"Stack trace at cancellation:\n{tb}")
         finally:
             if client:
                 try:

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

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, List, Optional
 
-from fastapi import APIRouter, Body, Depends, HTTPException, Query
+from fastapi import APIRouter, Body, Depends, Query
 
 from letta.schemas.user import User, UserCreate, UserUpdate
 from letta.server.rest_api.dependencies import get_letta_server
@@ -22,13 +22,7 @@ async def list_users(
     """
     Get a list of all users in the database
     """
-    try:
-        users = await server.user_manager.list_actors_async(after=after, limit=limit)
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
-    return users
+    return await server.user_manager.list_actors_async(after=after, limit=limit)
 
 
 @router.post("/", tags=["admin"], response_model=User, operation_id="create_user")
@@ -62,13 +56,7 @@ async def delete_user(
     server: "SyncServer" = Depends(get_letta_server),
 ):
     # TODO make a soft deletion, instead of a hard deletion
-    try:
-        user = await server.user_manager.get_actor_by_id_async(actor_id=user_id)
-        if user is None:
-            raise HTTPException(status_code=404, detail="User does not exist")
-        await server.user_manager.delete_actor_by_id_async(user_id=user_id)
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    # Get the user first so we can return it after deletion
+    user = await server.user_manager.get_actor_by_id_async(actor_id=user_id)
+    await server.user_manager.delete_actor_by_id_async(user_id=user_id)
     return user