letta-nightly 0.11.3.dev20250820104219__py3-none-any.whl → 0.11.4.dev20250820213507__py3-none-any.whl

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

@@ -8,13 +8,14 @@ from fastapi import APIRouter, Body, Depends, File, Form, Header, HTTPException,
 from fastapi.responses import JSONResponse
 from marshmallow import ValidationError
 from orjson import orjson
-from pydantic import Field
+from pydantic import BaseModel, Field
 from sqlalchemy.exc import IntegrityError, OperationalError
 from starlette.responses import Response, StreamingResponse
 
 from letta.agents.letta_agent import LettaAgent
-from letta.constants import DEFAULT_MAX_STEPS, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, REDIS_RUN_ID_PREFIX
+from letta.constants import AGENT_ID_PATTERN, DEFAULT_MAX_STEPS, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, REDIS_RUN_ID_PREFIX
 from letta.data_sources.redis_client import get_redis_client
+from letta.errors import AgentExportIdMappingError, AgentExportProcessingError, AgentFileImportError, AgentNotFoundForExportError
 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
@@ -22,7 +23,9 @@ from letta.orm.errors import NoResultFound
 from letta.otel.context import get_ctx_attributes
 from letta.otel.metric_registry import MetricRegistry
 from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgent
+from letta.schemas.agent_file import AgentFileSchema
 from letta.schemas.block import Block, BlockUpdate
+from letta.schemas.enums import JobType
 from letta.schemas.group import Group
 from letta.schemas.job import JobStatus, JobUpdate, LettaRequestConfig
 from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUnion, MessageType
@@ -144,29 +147,143 @@ class IndentedORJSONResponse(Response):
 
 
 @router.get("/{agent_id}/export", response_class=IndentedORJSONResponse, operation_id="export_agent_serialized")
-def export_agent_serialized(
+async def export_agent_serialized(
     agent_id: str,
     max_steps: int = 100,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: str | None = Header(None, alias="user_id"),
+    use_legacy_format: bool = Query(
+        True,
+        description="If true, exports using the legacy single-agent format. If false, exports using the new multi-entity format.",
+    ),
     # do not remove, used to autogeneration of spec
-    # TODO: Think of a better way to export AgentSchema
-    spec: AgentSchema | None = None,
+    # TODO: Think of a better way to export AgentFileSchema
+    spec: AgentFileSchema | None = None,
+    legacy_spec: AgentSchema | None = None,
 ) -> JSONResponse:
     """
     Export the serialized JSON representation of an agent, formatted with indentation.
+
+    Supports two export formats:
+    - Legacy format (use_legacy_format=true): Single agent with inline tools/blocks
+    - New format (default): Multi-entity format with separate agents, tools, blocks, files, etc.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
+    if use_legacy_format:
+        # Use the legacy serialization method
+        try:
+            agent = server.agent_manager.serialize(agent_id=agent_id, actor=actor, max_steps=max_steps)
+            return agent.model_dump()
+        except NoResultFound:
+            raise HTTPException(status_code=404, detail=f"Agent with id={agent_id} not found for user_id={actor.id}.")
+    else:
+        # Use the new multi-entity export format
+        try:
+            agent_file_schema = await server.agent_serialization_manager.export(agent_ids=[agent_id], actor=actor)
+            return agent_file_schema.model_dump()
+        except AgentNotFoundForExportError:
+            raise HTTPException(status_code=404, detail=f"Agent with id={agent_id} not found for user_id={actor.id}.")
+        except AgentExportIdMappingError as e:
+            raise HTTPException(
+                status_code=500, detail=f"Internal error during export: ID mapping failed for {e.entity_type} ID '{e.db_id}'"
+            )
+        except AgentExportProcessingError as e:
+            raise HTTPException(status_code=500, detail=f"Export processing failed: {str(e.original_error)}")
+
+
+class ImportedAgentsResponse(BaseModel):
+    """Response model for imported agents"""
+
+    agent_ids: List[str] = Field(..., description="List of IDs of the imported agents")
+
+
+def import_agent_legacy(
+    agent_json: dict,
+    server: "SyncServer",
+    actor: User,
+    append_copy_suffix: bool = True,
+    override_existing_tools: bool = True,
+    project_id: str | None = None,
+    strip_messages: bool = False,
+    env_vars: Optional[dict[str, Any]] = None,
+) -> List[str]:
+    """
+    Import an agent using the legacy AgentSchema format.
+    """
     try:
-        agent = server.agent_manager.serialize(agent_id=agent_id, actor=actor, max_steps=max_steps)
-        return agent.model_dump()
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail=f"Agent with id={agent_id} not found for user_id={actor.id}.")
+        # Validate the JSON against AgentSchema before passing it to deserialize
+        agent_schema = AgentSchema.model_validate(agent_json)
+
+        new_agent = server.agent_manager.deserialize(
+            serialized_agent=agent_schema,  # Ensure we're passing a validated AgentSchema
+            actor=actor,
+            append_copy_suffix=append_copy_suffix,
+            override_existing_tools=override_existing_tools,
+            project_id=project_id,
+            strip_messages=strip_messages,
+            env_vars=env_vars,
+        )
+        return [new_agent.id]
+
+    except ValidationError as e:
+        raise HTTPException(status_code=422, detail=f"Invalid agent schema: {e!s}")
+
+    except IntegrityError as e:
+        raise HTTPException(status_code=409, detail=f"Database integrity error: {e!s}")
+
+    except OperationalError as e:
+        raise HTTPException(status_code=503, detail=f"Database connection error. Please try again later: {e!s}")
+
+    except Exception as e:
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred while uploading the agent: {e!s}")
+
+
+async def import_agent(
+    agent_file_json: dict,
+    server: "SyncServer",
+    actor: User,
+    # TODO: Support these fields for new agent file
+    append_copy_suffix: bool = True,
+    override_existing_tools: bool = True,
+    project_id: str | None = None,
+    strip_messages: bool = False,
+) -> List[str]:
+    """
+    Import an agent using the new AgentFileSchema format.
+    """
+    try:
+        agent_schema = AgentFileSchema.model_validate(agent_file_json)
+    except ValidationError as e:
+        raise HTTPException(status_code=422, detail=f"Invalid agent file schema: {e!s}")
+
+    try:
+        import_result = await server.agent_serialization_manager.import_file(schema=agent_schema, actor=actor)
+
+        if not import_result.success:
+            raise HTTPException(
+                status_code=500, detail=f"Import failed: {import_result.message}. Errors: {', '.join(import_result.errors)}"
+            )
 
+        return import_result.imported_agent_ids
 
-@router.post("/import", response_model=AgentState, operation_id="import_agent_serialized")
-def import_agent_serialized(
+    except AgentFileImportError as e:
+        raise HTTPException(status_code=400, detail=f"Agent file import error: {str(e)}")
+
+    except IntegrityError as e:
+        raise HTTPException(status_code=409, detail=f"Database integrity error: {e!s}")
+
+    except OperationalError as e:
+        raise HTTPException(status_code=503, detail=f"Database connection error. Please try again later: {e!s}")
+
+    except Exception as e:
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred while importing agents: {e!s}")
+
+
+@router.post("/import", response_model=ImportedAgentsResponse, operation_id="import_agent_serialized")
+async def import_agent_serialized(
     file: UploadFile = File(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: str | None = Header(None, alias="user_id"),
@@ -183,19 +300,35 @@ def import_agent_serialized(
     env_vars: Optional[Dict[str, Any]] = Form(None, description="Environment variables to pass to the agent for tool execution."),
 ):
     """
-    Import a serialized agent file and recreate the agent in the system.
+    Import a serialized agent file and recreate the agent(s) in the system.
+    Returns the IDs of all imported agents.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
     try:
         serialized_data = file.file.read()
         agent_json = json.loads(serialized_data)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Corrupted agent file format.")
 
-        # Validate the JSON against AgentSchema before passing it to deserialize
-        agent_schema = AgentSchema.model_validate(agent_json)
-
-        new_agent = server.agent_manager.deserialize(
-            serialized_agent=agent_schema,  # Ensure we're passing a validated AgentSchema
+    # Check if the JSON is AgentFileSchema or AgentSchema
+    # TODO: This is kind of hacky, but should work as long as dont' change the schema
+    if "agents" in agent_json and isinstance(agent_json.get("agents"), list):
+        # This is an AgentFileSchema
+        agent_ids = await import_agent(
+            agent_file_json=agent_json,
+            server=server,
+            actor=actor,
+            append_copy_suffix=append_copy_suffix,
+            override_existing_tools=override_existing_tools,
+            project_id=project_id,
+            strip_messages=strip_messages,
+        )
+    else:
+        # This is a legacy AgentSchema
+        agent_ids = import_agent_legacy(
+            agent_json=agent_json,
+            server=server,
             actor=actor,
             append_copy_suffix=append_copy_suffix,
             override_existing_tools=override_existing_tools,
@@ -203,23 +336,8 @@ def import_agent_serialized(
             strip_messages=strip_messages,
             env_vars=env_vars,
         )
-        return new_agent
 
-    except json.JSONDecodeError:
-        raise HTTPException(status_code=400, detail="Corrupted agent file format.")
-
-    except ValidationError as e:
-        raise HTTPException(status_code=422, detail=f"Invalid agent schema: {e!s}")
-
-    except IntegrityError as e:
-        raise HTTPException(status_code=409, detail=f"Database integrity error: {e!s}")
-
-    except OperationalError as e:
-        raise HTTPException(status_code=503, detail=f"Database connection error. Please try again later: {e!s}")
-
-    except Exception as e:
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"An unexpected error occurred while uploading the agent: {e!s}")
+    return ImportedAgentsResponse(agent_ids=agent_ids)
 
 
 @router.get("/{agent_id}/context", response_model=ContextWindowOverview, operation_id="retrieve_agent_context_window")
@@ -555,6 +673,10 @@ async def retrieve_agent(
     """
     Get the state of the agent.
     """
+    # Check if agent_id matches uuid4 format
+    if not AGENT_ID_PATTERN.match(agent_id):
+        raise HTTPException(status_code=400, detail=f"agent_id {agent_id} is not in the valid format 'agent-<uuid4>'")
+
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
@@ -876,6 +998,8 @@ async def send_message(
         "google_vertex",
         "bedrock",
         "ollama",
+        "azure",
+        "together",
     ]
 
     # Create a new run for execution tracking
@@ -1018,6 +1142,8 @@ async def send_message_streaming(
         "google_vertex",
         "bedrock",
         "ollama",
+        "azure",
+        "together",
     ]
     model_compatible_token_streaming = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "bedrock"]
 
@@ -1153,10 +1279,14 @@ async def send_message_streaming(
             )
 
 
+class CancelAgentRunRequest(BaseModel):
+    run_ids: list[str] | None = Field(None, description="Optional list of run IDs to cancel")
+
+
 @router.post("/{agent_id}/messages/cancel", operation_id="cancel_agent_run")
 async def cancel_agent_run(
     agent_id: str,
-    run_ids: list[str] | None = None,
+    request: CancelAgentRunRequest = Body(None),
     server: SyncServer = Depends(get_letta_server),
     actor_id: str | None = Header(None, alias="user_id"),
 ) -> dict:
@@ -1165,17 +1295,24 @@ async def cancel_agent_run(
 
     Note to cancel active runs associated with an agent, redis is required.
     """
-
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     if not settings.track_agent_run:
         raise HTTPException(status_code=400, detail="Agent run tracking is disabled")
+    run_ids = request.run_ids if request else None
     if not run_ids:
         redis_client = await get_redis_client()
         run_id = await redis_client.get(f"{REDIS_RUN_ID_PREFIX}:{agent_id}")
         if run_id is None:
-            logger.warning("Cannot find run associated with agent to cancel.")
-            return {}
-        run_ids = [run_id]
+            logger.warning("Cannot find run associated with agent to cancel in redis, fetching from db.")
+            job_ids = await server.job_manager.list_jobs_async(
+                actor=actor,
+                statuses=[JobStatus.created, JobStatus.running],
+                job_type=JobType.RUN,
+                ascending=False,
+            )
+            run_ids = [Run.from_job(job).id for job in job_ids]
+        else:
+            run_ids = [run_id]
 
     results = {}
     for run_id in run_ids:
@@ -1400,6 +1537,8 @@ async def preview_raw_payload(
         "google_vertex",
         "bedrock",
         "ollama",
+        "azure",
+        "together",
     ]
 
     if agent_eligible and model_compatible:
@@ -1468,6 +1607,8 @@ async def summarize_agent_conversation(
         "google_vertex",
         "bedrock",
         "ollama",
+        "azure",
+        "together",
     ]
 
     if agent_eligible and model_compatible:

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

@@ -208,6 +208,7 @@ async def upload_file_to_folder(
     file: UploadFile,
     folder_id: str,
     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),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
@@ -255,7 +256,8 @@ async def upload_file_to_folder(
     content = await file.read()
 
     # Store original filename and handle duplicate logic
-    original_filename = sanitize_filename(file.filename)  # Basic sanitization only
+    # Use custom name if provided, otherwise use the uploaded file's name
+    original_filename = sanitize_filename(name if name else file.filename)  # Basic sanitization only
 
     # Check if duplicate exists
     existing_file = await server.file_manager.get_file_by_original_name_and_source(
@@ -270,18 +272,21 @@ async def upload_file_to_folder(
             )
         elif duplicate_handling == DuplicateFileHandling.SKIP:
             # Return existing file metadata with custom header to indicate it was skipped
-            from fastapi import Response
-
             response = Response(
                 content=existing_file.model_dump_json(), media_type="application/json", headers={"X-Upload-Result": "skipped"}
             )
             return response
-        # For SUFFIX, continue to generate unique filename
+        elif duplicate_handling == DuplicateFileHandling.REPLACE:
+            # delete the file
+            deleted_file = await server.file_manager.delete_file(file_id=existing_file.id, actor=actor)
+            unique_filename = original_filename
 
-    # Generate unique filename (adds suffix if needed)
-    unique_filename = await server.file_manager.generate_unique_filename(
-        original_filename=original_filename, source=folder, organization_id=actor.organization_id
-    )
+    if not unique_filename:
+        # For SUFFIX, continue to generate unique filename
+        # Generate unique filename (adds suffix if needed)
+        unique_filename = await server.file_manager.generate_unique_filename(
+            original_filename=original_filename, source=folder, organization_id=actor.organization_id
+        )
 
     # create file metadata
     file_metadata = FileMetadata(

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

@@ -49,9 +49,13 @@ async def create_provider(
     Create a new custom provider
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    for field_name in request.model_fields:
+        value = getattr(request, field_name, None)
+        if isinstance(value, str) and value == "":
+            setattr(request, field_name, None)
 
-    provider = ProviderCreate(**request.model_dump())
-
+    request_data = request.model_dump(exclude_unset=True, exclude_none=True)
+    provider = ProviderCreate(**request_data)
     provider = await server.provider_manager.create_provider_async(provider, actor=actor)
     return provider
 
@@ -70,12 +74,15 @@ async def modify_provider(
     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")
+@router.post("/check", response_model=None, operation_id="check_provider")
 async def check_provider(
     request: ProviderCheck = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     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}"}

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

@@ -209,6 +209,7 @@ async def upload_file_to_source(
     file: UploadFile,
     source_id: str,
     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),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
@@ -256,13 +257,15 @@ async def upload_file_to_source(
     content = await file.read()
 
     # Store original filename and handle duplicate logic
-    original_filename = sanitize_filename(file.filename)  # Basic sanitization only
+    # Use custom name if provided, otherwise use the uploaded file's name
+    original_filename = sanitize_filename(name if name else file.filename)  # Basic sanitization only
 
     # Check if duplicate exists
     existing_file = await server.file_manager.get_file_by_original_name_and_source(
         original_filename=original_filename, source_id=source_id, actor=actor
     )
 
+    unique_filename = None
     if existing_file:
         # Duplicate found, handle based on strategy
         if duplicate_handling == DuplicateFileHandling.ERROR:
@@ -271,18 +274,21 @@ async def upload_file_to_source(
             )
         elif duplicate_handling == DuplicateFileHandling.SKIP:
             # Return existing file metadata with custom header to indicate it was skipped
-            from fastapi import Response
-
             response = Response(
                 content=existing_file.model_dump_json(), media_type="application/json", headers={"X-Upload-Result": "skipped"}
             )
             return response
-        # For SUFFIX, continue to generate unique filename
+        elif duplicate_handling == DuplicateFileHandling.REPLACE:
+            # delete the file
+            deleted_file = await server.file_manager.delete_file(file_id=existing_file.id, actor=actor)
+            unique_filename = original_filename
 
-    # Generate unique filename (adds suffix if needed)
-    unique_filename = await server.file_manager.generate_unique_filename(
-        original_filename=original_filename, source=source, organization_id=actor.organization_id
-    )
+    if not unique_filename:
+        # For SUFFIX, continue to generate unique filename
+        # Generate unique filename (adds suffix if needed)
+        unique_filename = await server.file_manager.generate_unique_filename(
+            original_filename=original_filename, source=source, organization_id=actor.organization_id
+        )
 
     # create file metadata
     file_metadata = FileMetadata(

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

@@ -5,6 +5,7 @@ from fastapi import APIRouter, Depends, Header, HTTPException, Query
 
 from letta.orm.errors import NoResultFound
 from letta.schemas.step import Step
+from letta.schemas.step_metrics import StepMetrics
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 from letta.services.step_manager import FeedbackType
@@ -56,7 +57,6 @@ async def list_steps(
         trace_ids=trace_ids,
         feedback=feedback,
         has_feedback=has_feedback,
-        tags=tags,
         project_id=project_id,
     )
 
@@ -77,6 +77,22 @@ async def retrieve_step(
         raise HTTPException(status_code=404, detail="Step not found")
 
 
+@router.get("/{step_id}/metrics", response_model=StepMetrics, operation_id="retrieve_step_metrics")
+async def retrieve_step_metrics(
+    step_id: str,
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    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=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")
+
+
 @router.patch("/{step_id}/feedback", response_model=Step, operation_id="add_feedback")
 async def add_feedback(
     step_id: str,

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

@@ -486,6 +486,20 @@ async def add_mcp_tool(
                 },
             )
 
+        # Check tool health - reject only INVALID tools
+        if mcp_tool.health:
+            if mcp_tool.health.status == "INVALID":
+                raise HTTPException(
+                    status_code=400,
+                    detail={
+                        "code": "MCPToolSchemaInvalid",
+                        "message": f"Tool {mcp_tool_name} has an invalid schema and cannot be attached",
+                        "mcp_tool_name": mcp_tool_name,
+                        "health_status": mcp_tool.health.status,
+                        "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
         mcp_server_id = mcp_server_name
@@ -608,7 +622,7 @@ async def delete_mcp_server_from_config(
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
-    Add a new MCP server to the Letta MCP server config
+    Delete a MCP server configuration
     """
     if tool_settings.mcp_read_from_config:
         # write to config file
@@ -774,7 +788,8 @@ async def connect_mcp_server(
 
 
 class CodeInput(BaseModel):
-    code: str = Field(..., description="Python source code to parse for JSON schema")
+    code: str = Field(..., description="Source code to parse for JSON schema")
+    source_type: Optional[str] = Field("python", description="The source type of the code (python or typescript)")
 
 
 @router.post("/generate-schema", response_model=Dict[str, Any], operation_id="generate_json_schema")
@@ -784,16 +799,90 @@ async def generate_json_schema(
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
-    Generate a JSON schema from the given Python source code defining a function or class.
+    Generate a JSON schema from the given source code defining a function or class.
+    Supports both Python and TypeScript source code.
     """
     try:
-        schema = derive_openai_json_schema(source_code=request.code)
+        if request.source_type == "typescript":
+            from letta.functions.typescript_parser import derive_typescript_json_schema
+
+            schema = derive_typescript_json_schema(source_code=request.code)
+        else:
+            # Default to Python for backwards compatibility
+            schema = derive_openai_json_schema(source_code=request.code)
         return schema
 
     except Exception as e:
         raise HTTPException(status_code=400, detail=f"Failed to generate schema: {str(e)}")
 
 
+# TODO: @jnjpng move this and other models above to appropriate file for schemas
+class MCPToolExecuteRequest(BaseModel):
+    args: Dict[str, Any] = Field(default_factory=dict, description="Arguments to pass to the MCP tool")
+
+
+@router.post("/mcp/servers/{mcp_server_name}/tools/{tool_name}/execute", operation_id="execute_mcp_tool")
+async def execute_mcp_tool(
+    mcp_server_name: str,
+    tool_name: str,
+    request: MCPToolExecuteRequest = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Execute a specific MCP tool from a configured server.
+    Returns the tool execution result.
+    """
+    client = None
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+
+        # Get the MCP server by name
+        mcp_server = await server.mcp_manager.get_mcp_server(mcp_server_name, actor)
+        if not mcp_server:
+            raise HTTPException(
+                status_code=404,
+                detail={
+                    "code": "MCPServerNotFound",
+                    "message": f"MCP server '{mcp_server_name}' not found",
+                    "server_name": mcp_server_name,
+                },
+            )
+
+        # Create client and connect
+        server_config = mcp_server.to_config()
+        server_config.resolve_environment_variables()
+        client = await server.mcp_manager.get_mcp_client(server_config, actor)
+        await client.connect_to_server()
+
+        # Execute the tool
+        result, success = await client.execute_tool(tool_name, request.args)
+
+        return {
+            "result": result,
+            "success": success,
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.warning(f"Error executing MCP tool: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "code": "MCPToolExecutionError",
+                "message": f"Failed to execute MCP tool: {str(e)}",
+                "server_name": mcp_server_name,
+                "tool_name": tool_name,
+            },
+        )
+    finally:
+        if client:
+            try:
+                await client.cleanup()
+            except Exception as cleanup_error:
+                logger.warning(f"Error during MCP client cleanup: {cleanup_error}")
+
+
 # TODO: @jnjpng need to route this through cloud API for production
 @router.get("/mcp/oauth/callback/{session_id}", operation_id="mcp_oauth_callback")
 async def mcp_oauth_callback(
@@ -855,6 +944,8 @@ async def generate_tool_from_prompt(
     """
     Generate a tool from the given user prompt.
     """
+    response_data = None
+
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
         llm_config = await server.get_cached_llm_config_async(actor=actor, handle=request.handle or "anthropic/claude-3-5-sonnet-20240620")
@@ -917,5 +1008,5 @@ async def generate_tool_from_prompt(
             response=response.choices[0].message.content,
         )
     except Exception as e:
-        logger.error(f"Failed to generate tool: {str(e)}")
+        logger.error(f"Failed to generate tool: {str(e)}. Raw response: {response_data}")
         raise HTTPException(status_code=500, detail=f"Failed to generate tool: {str(e)}")