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

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

@@ -0,0 +1,309 @@
+from typing import Any, AsyncGenerator, Dict, List, Optional, Union
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Request
+from httpx import HTTPStatusError
+from starlette.responses import StreamingResponse
+
+from letta.functions.mcp_client.types import SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig
+from letta.log import get_logger
+from letta.schemas.letta_message import ToolReturnMessage
+from letta.schemas.mcp_server import (
+    CreateMCPServerUnion,
+    MCPServerUnion,
+    MCPToolExecuteRequest,
+    UpdateMCPServerUnion,
+    convert_generic_to_union,
+    convert_update_to_internal,
+)
+from letta.schemas.tool import Tool
+from letta.schemas.tool_execution_result import ToolExecutionResult
+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 drill_down_exception, oauth_stream_event
+from letta.services.mcp.stdio_client import AsyncStdioMCPClient
+from letta.services.mcp.types import OauthStreamEvent
+from letta.settings import tool_settings
+
+router = APIRouter(prefix="/mcp-servers", tags=["mcp-servers"])
+
+logger = get_logger(__name__)
+
+
+@router.post(
+    "/",
+    response_model=MCPServerUnion,
+    operation_id="mcp_create_mcp_server",
+)
+async def create_mcp_server(
+    request: CreateMCPServerUnion = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Add a new MCP server to the Letta MCP server config
+    """
+    # TODO: add the tools to the MCP server table we made.
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    new_server = await server.mcp_server_manager.create_mcp_server_from_config_with_tools(request, actor=actor)
+    return convert_generic_to_union(new_server)
+
+
+@router.get(
+    "/",
+    response_model=List[MCPServerUnion],
+    operation_id="mcp_list_mcp_servers",
+)
+async def list_mcp_servers(
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Get a list of all configured MCP servers
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    mcp_servers = await server.mcp_server_manager.list_mcp_servers(actor=actor)
+    return [convert_generic_to_union(mcp_server) for mcp_server in mcp_servers]
+
+
+@router.get(
+    "/{mcp_server_id}",
+    response_model=MCPServerUnion,
+    operation_id="mcp_get_mcp_server",
+)
+async def get_mcp_server(
+    mcp_server_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Get a specific MCP server
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    current_server = await server.mcp_server_manager.get_mcp_server_by_id_async(mcp_server_id=mcp_server_id, actor=actor)
+    return convert_generic_to_union(current_server)
+
+
+@router.delete(
+    "/{mcp_server_id}",
+    status_code=204,
+    operation_id="mcp_delete_mcp_server",
+)
+async def delete_mcp_server(
+    mcp_server_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Delete an MCP server by its ID
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    await server.mcp_server_manager.delete_mcp_server_by_id(mcp_server_id, actor=actor)
+
+
+@router.patch(
+    "/{mcp_server_id}",
+    response_model=MCPServerUnion,
+    operation_id="mcp_update_mcp_server",
+)
+async def update_mcp_server(
+    mcp_server_id: str,
+    request: UpdateMCPServerUnion = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Update an existing MCP server configuration
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    # Convert external update payload to internal manager union
+    internal_update = convert_update_to_internal(request)
+    updated_server = await server.mcp_server_manager.update_mcp_server_by_id(
+        mcp_server_id=mcp_server_id, mcp_server_update=internal_update, actor=actor
+    )
+    return convert_generic_to_union(updated_server)
+
+
+@router.get("/{mcp_server_id}/tools", response_model=List[Tool], operation_id="mcp_list_mcp_tools_by_server")
+async def list_mcp_tools_by_server(
+    mcp_server_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Get a list of all tools for a specific MCP server
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    # Use the new efficient method that queries from the database using MCPTools mapping
+    tools = await server.mcp_server_manager.list_tools_by_mcp_server_from_db(mcp_server_id, actor=actor)
+    return tools
+
+
+@router.get("/{mcp_server_id}/tools/{tool_id}", response_model=Tool, operation_id="mcp_get_mcp_tool")
+async def get_mcp_tool(
+    mcp_server_id: str,
+    tool_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Get a specific MCP tool by its ID
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    tool = await server.mcp_server_manager.get_tool_by_mcp_server(mcp_server_id, tool_id, actor=actor)
+    return tool
+
+
+@router.post("/{mcp_server_id}/tools/{tool_id}/run", response_model=ToolExecutionResult, operation_id="mcp_run_tool")
+async def run_mcp_tool(
+    mcp_server_id: str,
+    tool_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+    request: MCPToolExecuteRequest = Body(default=MCPToolExecuteRequest()),
+):
+    """
+    Execute a specific MCP tool
+
+    The request body should contain the tool arguments in the MCPToolExecuteRequest format.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+
+    # Execute the tool
+    result, success = await server.mcp_server_manager.execute_mcp_server_tool(
+        mcp_server_id=mcp_server_id,
+        tool_id=tool_id,
+        tool_args=request.args,
+        environment_variables={},  # TODO: Get environment variables from somewhere if needed
+        actor=actor,
+    )
+
+    # Create a ToolExecutionResult
+    return ToolExecutionResult(
+        status="success" if success else "error",
+        func_return=result,
+    )
+
+
+@router.patch("/{mcp_server_id}/refresh", operation_id="mcp_refresh_mcp_server_tools")
+async def refresh_mcp_server_tools(
+    mcp_server_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+    agent_id: Optional[str] = None,
+):
+    """
+    Refresh tools for an MCP server by:
+    1. Fetching current tools from the MCP server
+    2. Deleting tools that no longer exist on the server
+    3. Updating schemas for existing tools
+    4. Adding new tools from the server
+
+    Returns a summary of changes made.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    result = await server.mcp_server_manager.resync_mcp_server_tools(mcp_server_id, actor=actor, agent_id=agent_id)
+    return result
+
+
+@router.get(
+    "/connect/{mcp_server_id}",
+    response_model=None,
+    # TODO: make this into a model?
+    responses={
+        200: {
+            "description": "Successful response",
+            "content": {
+                "text/event-stream": {"description": "Server-Sent Events stream"},
+            },
+        }
+    },
+    operation_id="mcp_connect_mcp_server",
+)
+async def connect_mcp_server(
+    mcp_server_id: str,
+    request: Request,
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+) -> StreamingResponse:
+    """
+    Connect to an MCP server with support for OAuth via SSE.
+    Returns a stream of events handling authorization state and exchange if OAuth is required.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    mcp_server = await server.mcp_server_manager.get_mcp_server_by_id_async(mcp_server_id=mcp_server_id, actor=actor)
+
+    # Convert the MCP server to the appropriate config type
+    config = mcp_server.to_config(resolve_variables=False)
+
+    async def oauth_stream_generator(
+        mcp_config: Union[StdioServerConfig, SSEServerConfig, StreamableHTTPServerConfig],
+        http_request: Request,
+    ) -> AsyncGenerator[str, None]:
+        client = None
+
+        oauth_flow_attempted = False
+        try:
+            # Acknowledge connection attempt
+            yield oauth_stream_event(OauthStreamEvent.CONNECTION_ATTEMPT, server_name=mcp_config.server_name)
+
+            # Create MCP client with respective transport type
+            try:
+                mcp_config.resolve_environment_variables()
+                client = await server.mcp_server_manager.get_mcp_client(mcp_config, actor)
+            except ValueError as e:
+                yield oauth_stream_event(OauthStreamEvent.ERROR, message=str(e))
+                return
+
+            # Try normal connection first for flows that don't require OAuth
+            try:
+                await client.connect_to_server()
+                tools = await client.list_tools(serialize=True)
+                yield oauth_stream_event(OauthStreamEvent.SUCCESS, tools=tools)
+                return
+            except ConnectionError:
+                # TODO: jnjpng make this connection error check more specific to the 401 unauthorized error
+                if isinstance(client, AsyncStdioMCPClient):
+                    logger.warning("OAuth not supported for stdio")
+                    yield oauth_stream_event(OauthStreamEvent.ERROR, message="OAuth not supported for stdio")
+                    return
+                # Continue to OAuth flow
+                logger.info(f"Attempting OAuth flow for {mcp_config}...")
+            except Exception as e:
+                yield oauth_stream_event(OauthStreamEvent.ERROR, message=f"Connection failed: {str(e)}")
+                return
+            finally:
+                if client:
+                    try:
+                        await client.cleanup()
+                    # This is a workaround to catch the expected 401 Unauthorized from the official MCP SDK, see their streamable_http.py
+                    # For SSE transport types, we catch the ConnectionError above, but Streamable HTTP doesn't bubble up the exception
+                    except HTTPStatusError:
+                        oauth_flow_attempted = True
+                        async for event in server.mcp_server_manager.handle_oauth_flow(
+                            request=mcp_config, actor=actor, http_request=http_request
+                        ):
+                            yield event
+
+            # Failsafe to make sure we don't try to handle OAuth flow twice
+            if not oauth_flow_attempted:
+                async for event in server.mcp_server_manager.handle_oauth_flow(request=mcp_config, actor=actor, http_request=http_request):
+                    yield event
+            return
+        except Exception as e:
+            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}")
+
+        finally:
+            if client:
+                try:
+                    await client.cleanup()
+                except Exception as cleanup_error:
+                    logger.warning(f"Error during temp MCP client cleanup: {cleanup_error}")
+
+    return StreamingResponseWithStatusCode(oauth_stream_generator(config, request), media_type="text/event-stream")

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

@@ -1,12 +1,11 @@
 from typing import List, Literal, Optional
 
 from fastapi import APIRouter, Body, Depends, Query
-from fastapi.exceptions import HTTPException
 from starlette.requests import Request
 
 from letta.agents.letta_agent_batch import LettaAgentBatch
+from letta.errors import LettaInvalidArgumentError
 from letta.log import get_logger
-from letta.orm.errors import NoResultFound
 from letta.schemas.job import BatchJob, JobStatus, JobType, JobUpdate
 from letta.schemas.letta_request import CreateBatch
 from letta.schemas.letta_response import LettaBatchMessages
@@ -42,7 +41,9 @@ async def create_batch(
     if content_length:
         length = int(content_length)
         if length > max_bytes:
-            raise HTTPException(status_code=413, detail=f"Request too large ({length} bytes). Max is {max_bytes} bytes.")
+            raise LettaInvalidArgumentError(
+                message=f"Request too large ({length} bytes). Max is {max_bytes} bytes.", argument_name="content-length"
+            )
 
     if not settings.enable_batch_job_polling:
         logger.warning("Batch job polling is disabled. Enable batch processing by setting LETTA_ENABLE_BATCH_JOB_POLLING to True.")
@@ -93,12 +94,8 @@ async def retrieve_batch(
     Retrieve the status and details of a batch run.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-
-    try:
-        job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
-        return BatchJob.from_job(job)
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Batch not found")
+    job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
+    return BatchJob.from_job(job)
 
 
 @router.get("/batches", response_model=List[BatchJob], operation_id="list_batches")
@@ -162,11 +159,8 @@ async def list_messages_for_batch(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
     # Verify the batch job exists and the user has access to it
-    try:
-        job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
-        BatchJob.from_job(job)
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Batch not found")
+    job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
+    BatchJob.from_job(job)
 
     # Get messages directly using our efficient method
     messages = await server.batch_manager.get_messages_for_letta_batch_async(
@@ -187,23 +181,18 @@ async def cancel_batch(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
-    try:
-        job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
-        job = await server.job_manager.update_job_by_id_async(job_id=job.id, job_update=JobUpdate(status=JobStatus.cancelled), actor=actor)
-
-        # Get related llm batch jobs
-        llm_batch_jobs = await server.batch_manager.list_llm_batch_jobs_async(letta_batch_id=job.id, actor=actor)
-        for llm_batch_job in llm_batch_jobs:
-            if llm_batch_job.status in {JobStatus.running, JobStatus.created}:
-                # TODO: Extend to providers beyond anthropic
-                # TODO: For now, we only support anthropic
-                # Cancel the job
-                anthropic_batch_id = llm_batch_job.create_batch_response.id
-                await server.anthropic_async_client.messages.batches.cancel(anthropic_batch_id)
-
-                # Update all the batch_job statuses
-                await server.batch_manager.update_llm_batch_status_async(
-                    llm_batch_id=llm_batch_job.id, status=JobStatus.cancelled, actor=actor
-                )
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Run not found")
+    job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
+    job = await server.job_manager.update_job_by_id_async(job_id=job.id, job_update=JobUpdate(status=JobStatus.cancelled), actor=actor)
+
+    # Get related llm batch jobs
+    llm_batch_jobs = await server.batch_manager.list_llm_batch_jobs_async(letta_batch_id=job.id, actor=actor)
+    for llm_batch_job in llm_batch_jobs:
+        if llm_batch_job.status in {JobStatus.running, JobStatus.created}:
+            # TODO: Extend to providers beyond anthropic
+            # TODO: For now, we only support anthropic
+            # Cancel the job
+            anthropic_batch_id = llm_batch_job.create_batch_response.id
+            await server.anthropic_async_client.messages.batches.cancel(anthropic_batch_id)
+
+            # Update all the batch_job statuses
+            await server.batch_manager.update_llm_batch_status_async(llm_batch_id=llm_batch_job.id, status=JobStatus.cancelled, actor=actor)

letta/server/rest_api/routers/v1/organizations.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.organization import Organization, OrganizationCreate, OrganizationUpdate
 from letta.server.rest_api.dependencies import get_letta_server
@@ -21,13 +21,7 @@ async def get_all_orgs(
     """
     Get a list of all orgs in the database
     """
-    try:
-        orgs = await server.organization_manager.list_organizations_async(after=after, limit=limit)
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
-    return orgs
+    return await server.organization_manager.list_organizations_async(after=after, limit=limit)
 
 
 @router.post("/", tags=["admin"], response_model=Organization, operation_id="create_organization")
@@ -49,15 +43,9 @@ async def delete_org(
     server: "SyncServer" = Depends(get_letta_server),
 ):
     # TODO make a soft deletion, instead of a hard deletion
-    try:
-        org = await server.organization_manager.get_organization_by_id_async(org_id=org_id)
-        if org is None:
-            raise HTTPException(status_code=404, detail="Organization does not exist")
-        await server.organization_manager.delete_organization_by_id_async(org_id=org_id)
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    # Get the org first so we can return it after deletion
+    org = await server.organization_manager.get_organization_by_id_async(org_id=org_id)
+    await server.organization_manager.delete_organization_by_id_async(org_id=org_id)
     return org
 
 
@@ -67,13 +55,4 @@ async def update_org(
     request: OrganizationUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
-    try:
-        org = await server.organization_manager.get_organization_by_id_async(org_id=org_id)
-        if org is None:
-            raise HTTPException(status_code=404, detail="Organization does not exist")
-        org = await server.organization_manager.update_organization_async(org_id=org_id, name=request.name)
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
-    return org
+    return await server.organization_manager.update_organization_async(org_id=org_id, org_update=request)

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

@@ -1,13 +1,12 @@
 from typing import TYPE_CHECKING, List, Literal, Optional
 
-from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
+from fastapi import APIRouter, Body, Depends, Query, status
 from fastapi.responses import JSONResponse
 
-from letta.errors import LLMAuthenticationError
-from letta.orm.errors import NoResultFound
 from letta.schemas.enums import ProviderType
-from letta.schemas.providers import Provider, ProviderCheck, ProviderCreate, ProviderUpdate
+from letta.schemas.providers import Provider, ProviderBase, ProviderCheck, ProviderCreate, ProviderUpdate
 from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
+from letta.validators import ProviderId
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
@@ -38,21 +37,16 @@ async def list_providers(
     """
     Get a list of all custom providers.
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        providers = await server.provider_manager.list_providers_async(
-            before=before, after=after, limit=limit, actor=actor, name=name, provider_type=provider_type, ascending=(order == "asc")
-        )
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    providers = await server.provider_manager.list_providers_async(
+        before=before, after=after, limit=limit, actor=actor, name=name, provider_type=provider_type, ascending=(order == "asc")
+    )
     return providers
 
 
 @router.get("/{provider_id}", response_model=Provider, operation_id="retrieve_provider")
 async def retrieve_provider(
-    provider_id: str,
+    provider_id: ProviderId,
     headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
@@ -86,7 +80,7 @@ async def create_provider(
 
 @router.patch("/{provider_id}", response_model=Provider, operation_id="modify_provider")
 async def modify_provider(
-    provider_id: str,
+    provider_id: ProviderId,
     request: ProviderUpdate = Body(...),
     headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
@@ -106,70 +100,49 @@ async def check_provider(
     """
     Verify the API key and additional parameters for a provider.
     """
-    try:
-        if request.base_url and len(request.base_url) == 0:
-            # set to null if empty string
-            request.base_url = None
-        await 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:
-        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"{e}")
+    if request.base_url and len(request.base_url) == 0:
+        # set to null if empty string
+        request.base_url = None
+    await 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}"}
+    )
 
 
 @router.post("/{provider_id}/check", response_model=None, operation_id="check_existing_provider")
 async def check_existing_provider(
-    provider_id: str,
+    provider_id: ProviderId,
     headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Verify the API key and additional parameters for an existing provider.
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        provider = await server.provider_manager.get_provider_async(provider_id=provider_id, actor=actor)
-
-        # Create a ProviderCheck from the existing provider
-        provider_check = ProviderCheck(
-            provider_type=provider.provider_type,
-            api_key=provider.api_key,
-            base_url=provider.base_url,
-        )
-
-        await 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.provider_type.value}"}
-        )
-    except LLMAuthenticationError as e:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=f"{e.message}")
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail=f"Provider provider_id={provider_id} not found for user_id={actor.id}.")
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    provider = await server.provider_manager.get_provider_async(provider_id=provider_id, actor=actor)
+
+    # Create a ProviderCheck from the existing provider
+    provider_check = ProviderCheck(
+        provider_type=provider.provider_type,
+        api_key=provider.api_key,
+        base_url=provider.base_url,
+    )
+
+    await 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.provider_type.value}"}
+    )
 
 
 @router.delete("/{provider_id}", response_model=None, operation_id="delete_provider")
 async def delete_provider(
-    provider_id: str,
+    provider_id: ProviderId,
     headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Delete an existing custom provider.
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        await server.provider_manager.delete_provider_by_id_async(provider_id=provider_id, actor=actor)
-        return JSONResponse(status_code=status.HTTP_200_OK, content={"message": f"Provider id={provider_id} successfully deleted"})
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail=f"Provider provider_id={provider_id} not found for user_id={actor.id}.")
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    await server.provider_manager.delete_provider_by_id_async(provider_id=provider_id, actor=actor)
+    return JSONResponse(status_code=status.HTTP_200_OK, content={"message": f"Provider id={provider_id} successfully deleted"})