letta-nightly 0.11.7.dev20250911104039__py3-none-any.whl → 0.11.7.dev20250913103940__py3-none-any.whl

letta/llm_api/openai_client.py

@@ -99,7 +99,7 @@ def supports_structured_output(llm_config: LLMConfig) -> bool:
 
     # FIXME pretty hacky - turn off for providers we know users will use,
     #       but also don't support structured output
-    if "nebius.com" in llm_config.model_endpoint:
+    if llm_config.model_endpoint and "nebius.com" in llm_config.model_endpoint:
         return False
     else:
         return True
@@ -108,7 +108,7 @@ def supports_structured_output(llm_config: LLMConfig) -> bool:
 # TODO move into LLMConfig as a field?
 def requires_auto_tool_choice(llm_config: LLMConfig) -> bool:
     """Certain providers require the tool choice to be set to 'auto'."""
-    if "nebius.com" in llm_config.model_endpoint:
+    if llm_config.model_endpoint and "nebius.com" in llm_config.model_endpoint:
         return True
     if llm_config.handle and "vllm" in llm_config.handle:
         return True
@@ -168,7 +168,9 @@ class OpenAIClient(LLMClientBase):
             # Special case for LM Studio backend since it needs extra guidance to force out the thoughts first
             # TODO(fix)
             inner_thoughts_desc = (
-                INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST if ":1234" in llm_config.model_endpoint else INNER_THOUGHTS_KWARG_DESCRIPTION
+                INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST
+                if llm_config.model_endpoint and ":1234" in llm_config.model_endpoint
+                else INNER_THOUGHTS_KWARG_DESCRIPTION
             )
             tools = add_inner_thoughts_to_functions(
                 functions=tools,
@@ -198,14 +200,15 @@ class OpenAIClient(LLMClientBase):
         # TODO(matt) move into LLMConfig
         # TODO: This vllm checking is very brittle and is a patch at most
         tool_choice = None
-        if self.requires_auto_tool_choice(llm_config):
-            tool_choice = "auto"
-        elif tools:
-            # only set if tools is non-Null
-            tool_choice = "required"
-
-        if force_tool_call is not None:
-            tool_choice = ToolFunctionChoice(type="function", function=ToolFunctionChoiceFunctionCall(name=force_tool_call))
+        if tools:  # only set tool_choice if tools exist
+            if self.requires_auto_tool_choice(llm_config):
+                tool_choice = "auto"
+            else:
+                # only set if tools is non-Null
+                tool_choice = "required"
+
+            if force_tool_call is not None:
+                tool_choice = ToolFunctionChoice(type="function", function=ToolFunctionChoiceFunctionCall(name=force_tool_call))
 
         data = ChatCompletionRequest(
             model=model,

letta/orm/job.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import TYPE_CHECKING, List, Optional
 
-from sqlalchemy import JSON, BigInteger, Index, String
+from sqlalchemy import JSON, BigInteger, ForeignKey, Index, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import UserMixin
@@ -12,6 +12,7 @@ from letta.schemas.job import Job as PydanticJob, LettaRequestConfig
 if TYPE_CHECKING:
     from letta.orm.job_messages import JobMessage
     from letta.orm.message import Message
+    from letta.orm.organization import Organization
     from letta.orm.step import Step
     from letta.orm.user import User
 
@@ -36,6 +37,7 @@ class Job(SqlalchemyBase, UserMixin):
     request_config: Mapped[Optional[LettaRequestConfig]] = mapped_column(
         JSON, nullable=True, doc="The request configuration for the job, stored as JSON."
     )
+    organization_id: Mapped[Optional[str]] = mapped_column(String, ForeignKey("organizations.id"))
 
     # callback related columns
     callback_url: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="When set, POST to this URL after job completion.")
@@ -53,6 +55,8 @@ class Job(SqlalchemyBase, UserMixin):
     user: Mapped["User"] = relationship("User", back_populates="jobs")
     job_messages: Mapped[List["JobMessage"]] = relationship("JobMessage", back_populates="job", cascade="all, delete-orphan")
     steps: Mapped[List["Step"]] = relationship("Step", back_populates="job", cascade="save-update")
+    # organization relationship (nullable for backward compatibility)
+    organization: Mapped[Optional["Organization"]] = relationship("Organization", back_populates="jobs")
 
     @property
     def messages(self) -> List["Message"]:

letta/orm/organization.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from letta.orm.block import Block
     from letta.orm.group import Group
     from letta.orm.identity import Identity
+    from letta.orm.job import Job
     from letta.orm.llm_batch_items import LLMBatchItem
     from letta.orm.llm_batch_job import LLMBatchJob
     from letta.orm.message import Message
@@ -66,3 +67,4 @@ class Organization(SqlalchemyBase):
     llm_batch_items: Mapped[List["LLMBatchItem"]] = relationship(
         "LLMBatchItem", back_populates="organization", cascade="all, delete-orphan"
     )
+    jobs: Mapped[List["Job"]] = relationship("Job", back_populates="organization", cascade="all, delete-orphan")

letta/otel/sqlalchemy_instrumentation.py

@@ -146,11 +146,16 @@ def _instrument_engine_events(engine: Engine) -> None:
             span.end()
             context._sync_instrumentation_span = None
 
-    def handle_cursor_error(conn, cursor, statement, parameters, context, executemany):
+    def handle_cursor_error(exception_context):
         """Handle cursor execution errors."""
         if not _config["enabled"]:
             return
 
+        # Extract context from exception_context
+        context = getattr(exception_context, "execution_context", None)
+        if not context:
+            return
+
         span = getattr(context, "_sync_instrumentation_span", None)
         if span:
             span.set_status(Status(StatusCode.ERROR, "Database operation failed"))

letta/schemas/letta_stop_reason.py

@@ -9,6 +9,7 @@ from letta.schemas.enums import JobStatus
 class StopReasonType(str, Enum):
     end_turn = "end_turn"
     error = "error"
+    llm_api_error = "llm_api_error"
     invalid_llm_response = "invalid_llm_response"
     invalid_tool_call = "invalid_tool_call"
     max_steps = "max_steps"
@@ -31,6 +32,7 @@ class StopReasonType(str, Enum):
             StopReasonType.invalid_tool_call,
             StopReasonType.no_tool_call,
             StopReasonType.invalid_llm_response,
+            StopReasonType.llm_api_error,
         ):
             return JobStatus.failed
         elif self == StopReasonType.cancelled:

letta/server/rest_api/app.py

@@ -17,7 +17,15 @@ from starlette.middleware.cors import CORSMiddleware
 from letta.__init__ import __version__ as letta_version
 from letta.agents.exceptions import IncompatibleAgentType
 from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
-from letta.errors import BedrockPermissionError, LettaAgentNotFoundError, LettaUserNotFoundError
+from letta.errors import (
+    BedrockPermissionError,
+    LettaAgentNotFoundError,
+    LettaUserNotFoundError,
+    LLMAuthenticationError,
+    LLMError,
+    LLMRateLimitError,
+    LLMTimeoutError,
+)
 from letta.helpers.pinecone_utils import get_pinecone_indices, should_use_pinecone, upsert_pinecone_indices
 from letta.jobs.scheduler import start_scheduler_with_leader_election
 from letta.log import get_logger
@@ -276,6 +284,58 @@ def create_application() -> "FastAPI":
             },
         )
 
+    @app.exception_handler(LLMTimeoutError)
+    async def llm_timeout_error_handler(request: Request, exc: LLMTimeoutError):
+        return JSONResponse(
+            status_code=504,
+            content={
+                "error": {
+                    "type": "llm_timeout",
+                    "message": "The LLM request timed out. Please try again.",
+                    "detail": str(exc),
+                }
+            },
+        )
+
+    @app.exception_handler(LLMRateLimitError)
+    async def llm_rate_limit_error_handler(request: Request, exc: LLMRateLimitError):
+        return JSONResponse(
+            status_code=429,
+            content={
+                "error": {
+                    "type": "llm_rate_limit",
+                    "message": "Rate limit exceeded for LLM model provider. Please wait before making another request.",
+                    "detail": str(exc),
+                }
+            },
+        )
+
+    @app.exception_handler(LLMAuthenticationError)
+    async def llm_auth_error_handler(request: Request, exc: LLMAuthenticationError):
+        return JSONResponse(
+            status_code=401,
+            content={
+                "error": {
+                    "type": "llm_authentication",
+                    "message": "Authentication failed with the LLM model provider.",
+                    "detail": str(exc),
+                }
+            },
+        )
+
+    @app.exception_handler(LLMError)
+    async def llm_error_handler(request: Request, exc: LLMError):
+        return JSONResponse(
+            status_code=502,
+            content={
+                "error": {
+                    "type": "llm_error",
+                    "message": "An error occurred with the LLM request.",
+                    "detail": str(exc),
+                }
+            },
+        )
+
     settings.cors_origins.append("https://app.letta.com")
 
     if (os.getenv("LETTA_SERVER_SECURE") == "true") or "--secure" in sys.argv:

letta/server/rest_api/redis_stream_manager.py

@@ -8,6 +8,9 @@ from typing import AsyncIterator, Dict, List, Optional
 
 from letta.data_sources.redis_client import AsyncRedisClient
 from letta.log import get_logger
+from letta.schemas.enums import JobStatus
+from letta.schemas.user import User
+from letta.services.job_manager import JobManager
 from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
@@ -133,9 +136,9 @@ class RedisSSEStreamWriter:
 
             async with client.pipeline(transaction=False) as pipe:
                 for chunk in chunks:
-                    pipe.xadd(stream_key, chunk, maxlen=self.max_stream_length, approximate=True)
+                    await pipe.xadd(stream_key, chunk, maxlen=self.max_stream_length, approximate=True)
 
-                pipe.expire(stream_key, self.stream_ttl)
+                await pipe.expire(stream_key, self.stream_ttl)
 
                 await pipe.execute()
 
@@ -191,6 +194,8 @@ async def create_background_stream_processor(
     redis_client: AsyncRedisClient,
     run_id: str,
     writer: Optional[RedisSSEStreamWriter] = None,
+    job_manager: Optional[JobManager] = None,
+    actor: Optional[User] = None,
 ) -> None:
     """
     Process a stream in the background and store chunks to Redis.
@@ -203,6 +208,8 @@ async def create_background_stream_processor(
         redis_client: Redis client instance
         run_id: The run ID to store chunks under
         writer: Optional pre-configured writer (creates new if not provided)
+        job_manager: Optional job manager for updating job status
+        actor: Optional actor for job status updates
     """
     if writer is None:
         writer = RedisSSEStreamWriter(redis_client)
@@ -227,6 +234,12 @@ async def create_background_stream_processor(
         logger.error(f"Error processing stream for run {run_id}: {e}")
         # Write error chunk
         # error_chunk = {"error": {"message": str(e)}}
+        # Mark run_id terminal state
+        if job_manager and actor:
+            await job_manager.safe_update_job_status_async(
+                job_id=run_id, new_status=JobStatus.failed, actor=actor, metadata={"error": str(e)}
+            )
+
         error_chunk = {"error": str(e), "code": "INTERNAL_SERVER_ERROR"}
         await writer.write_chunk(run_id=run_id, data=f"event: error\ndata: {json.dumps(error_chunk)}\n\n", is_complete=True)
     finally:

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

@@ -536,9 +536,7 @@ async def attach_source(
 
     if agent_state.enable_sleeptime:
         source = await server.source_manager.get_source_by_id(source_id=source_id)
-        safe_create_task(
-            server.sleeptime_document_ingest_async(agent_state, source, actor), logger=logger, label="sleeptime_document_ingest_async"
-        )
+        safe_create_task(server.sleeptime_document_ingest_async(agent_state, source, actor), label="sleeptime_document_ingest_async")
 
     return agent_state
 
@@ -565,9 +563,7 @@ async def attach_folder_to_agent(
 
     if agent_state.enable_sleeptime:
         source = await server.source_manager.get_source_by_id(source_id=folder_id)
-        safe_create_task(
-            server.sleeptime_document_ingest_async(agent_state, source, actor), logger=logger, label="sleeptime_document_ingest_async"
-        )
+        safe_create_task(server.sleeptime_document_ingest_async(agent_state, source, actor), label="sleeptime_document_ingest_async")
 
     return agent_state
 
@@ -1320,15 +1316,55 @@ async def send_message_streaming(
     try:
         if agent_eligible and model_compatible:
             agent_loop = AgentLoop.load(agent_state=agent, actor=actor)
-            raw_stream = agent_loop.stream(
-                input_messages=request.messages,
-                max_steps=request.max_steps,
-                stream_tokens=request.stream_tokens and model_compatible_token_streaming,
-                run_id=run.id if run else None,
-                use_assistant_message=request.use_assistant_message,
-                request_start_timestamp_ns=request_start_timestamp_ns,
-                include_return_message_types=request.include_return_message_types,
-            )
+
+            async def error_aware_stream():
+                """Stream that handles early LLM errors gracefully in streaming format."""
+                from letta.errors import LLMAuthenticationError, LLMError, LLMRateLimitError, LLMTimeoutError
+
+                try:
+                    stream = agent_loop.stream(
+                        input_messages=request.messages,
+                        max_steps=request.max_steps,
+                        stream_tokens=request.stream_tokens and model_compatible_token_streaming,
+                        run_id=run.id if run else None,
+                        use_assistant_message=request.use_assistant_message,
+                        request_start_timestamp_ns=request_start_timestamp_ns,
+                        include_return_message_types=request.include_return_message_types,
+                    )
+                    async for chunk in stream:
+                        yield chunk
+
+                except LLMTimeoutError as e:
+                    error_data = {
+                        "error": {"type": "llm_timeout", "message": "The LLM request timed out. Please try again.", "detail": str(e)}
+                    }
+                    yield (f"data: {json.dumps(error_data)}\n\n", 504)
+                except LLMRateLimitError as e:
+                    error_data = {
+                        "error": {
+                            "type": "llm_rate_limit",
+                            "message": "Rate limit exceeded for LLM model provider. Please wait before making another request.",
+                            "detail": str(e),
+                        }
+                    }
+                    yield (f"data: {json.dumps(error_data)}\n\n", 429)
+                except LLMAuthenticationError as e:
+                    error_data = {
+                        "error": {
+                            "type": "llm_authentication",
+                            "message": "Authentication failed with the LLM model provider.",
+                            "detail": str(e),
+                        }
+                    }
+                    yield (f"data: {json.dumps(error_data)}\n\n", 401)
+                except LLMError as e:
+                    error_data = {"error": {"type": "llm_error", "message": "An error occurred with the LLM request.", "detail": str(e)}}
+                    yield (f"data: {json.dumps(error_data)}\n\n", 502)
+                except Exception as e:
+                    error_data = {"error": {"type": "internal_error", "message": "An internal server error occurred.", "detail": str(e)}}
+                    yield (f"data: {json.dumps(error_data)}\n\n", 500)
+
+            raw_stream = error_aware_stream()
 
             from letta.server.rest_api.streaming_response import StreamingResponseWithStatusCode, add_keepalive_to_stream
 
@@ -1348,6 +1384,8 @@ async def send_message_streaming(
                         stream_generator=raw_stream,
                         redis_client=redis_client,
                         run_id=run.id,
+                        job_manager=server.job_manager,
+                        actor=actor,
                     ),
                     label=f"background_stream_processor_{run.id}",
                 )

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

@@ -12,7 +12,7 @@ from composio.exceptions import (
     EnumStringNotFound,
 )
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, Request
-from httpx import HTTPStatusError
+from httpx import ConnectError, HTTPStatusError
 from pydantic import BaseModel, Field
 from starlette.responses import StreamingResponse
 
@@ -151,7 +151,6 @@ async def count_tools(
             exclude_letta_tools=exclude_letta_tools,
         )
     except Exception as e:
-        print(f"Error occurred: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
@@ -265,8 +264,6 @@ async def list_tools(
             return_only_letta_tools=return_only_letta_tools,
         )
     except Exception as e:
-        # Log or print the full exception here for debugging
-        print(f"Error occurred: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
@@ -284,21 +281,13 @@ async def create_tool(
         tool = Tool(**request.model_dump(exclude_unset=True))
         return await server.tool_manager.create_tool_async(pydantic_tool=tool, actor=actor)
     except UniqueConstraintViolationError as e:
-        # Log or print the full exception here for debugging
-        print(f"Error occurred: {e}")
         clean_error_message = "Tool with this name already exists."
         raise HTTPException(status_code=409, detail=clean_error_message)
     except LettaToolCreateError as e:
         # HTTP 400 == Bad Request
-        print(f"Error occurred during tool creation: {e}")
-        # print the full stack trace
-        import traceback
-
-        print(traceback.format_exc())
         raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
         # Catch other unexpected errors and raise an internal server error
-        print(f"Unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
@@ -319,15 +308,12 @@ async def upsert_tool(
         return tool
     except UniqueConstraintViolationError as e:
         # Log the error and raise a conflict exception
-        print(f"Unique constraint violation occurred: {e}")
         raise HTTPException(status_code=409, detail=str(e))
     except LettaToolCreateError as e:
         # HTTP 400 == Bad Request
-        print(f"Error occurred during tool upsert: {e}")
         raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
         # Catch other unexpected errors and raise an internal server error
-        print(f"Unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
@@ -344,7 +330,6 @@ async def modify_tool(
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
         tool = await server.tool_manager.update_tool_by_id_async(tool_id=tool_id, tool_update=request, actor=actor)
-        print("FINAL TOOL", tool)
         return tool
     except LettaToolNameConflictError as e:
         # HTTP 409 == Conflict
@@ -394,16 +379,10 @@ async def run_tool_from_source(
         )
     except LettaToolCreateError as e:
         # HTTP 400 == Bad Request
-        print(f"Error occurred during tool creation: {e}")
-        # print the full stack trace
-        import traceback
-
-        print(traceback.format_exc())
         raise HTTPException(status_code=400, detail=str(e))
 
     except Exception as e:
         # Catch other unexpected errors and raise an internal server error
-        print(f"Unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
@@ -559,32 +538,38 @@ async def list_mcp_tools_by_server(
     """
     Get a list of all tools for a specific MCP server
     """
-    if tool_settings.mcp_read_from_config:
-        try:
-            return await server.get_tools_from_mcp_server(mcp_server_name=mcp_server_name)
-        except ValueError as e:
-            # ValueError means that the MCP server name doesn't exist
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        mcp_tools = await server.mcp_manager.list_mcp_server_tools(mcp_server_name=mcp_server_name, actor=actor)
+        return mcp_tools
+    except Exception as e:
+        if isinstance(e, ConnectError) or isinstance(e, ConnectionError):
             raise HTTPException(
-                status_code=400,  # Bad Request
+                status_code=404,
                 detail={
-                    "code": "MCPServerNotFoundError",
+                    "code": "MCPListToolsError",
                     "message": str(e),
                     "mcp_server_name": mcp_server_name,
                 },
             )
-        except MCPTimeoutError as e:
+        if isinstance(e, HTTPStatusError):
             raise HTTPException(
-                status_code=408,  # Timeout
+                status_code=401,
                 detail={
-                    "code": "MCPTimeoutError",
+                    "code": "MCPListToolsError",
+                    "message": str(e),
+                    "mcp_server_name": mcp_server_name,
+                },
+            )
+        else:
+            raise HTTPException(
+                status_code=500,
+                detail={
+                    "code": "MCPListToolsError",
                     "message": str(e),
                     "mcp_server_name": mcp_server_name,
                 },
             )
-    else:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-        mcp_tools = await server.mcp_manager.list_mcp_server_tools(mcp_server_name=mcp_server_name, actor=actor)
-        return mcp_tools
 
 
 @router.post("/mcp/servers/{mcp_server_name}/resync", operation_id="resync_mcp_server_tools")
@@ -753,7 +738,8 @@ async def add_mcp_server_to_config(
                     custom_headers=request.custom_headers,
                 )
 
-            await server.mcp_manager.create_mcp_server(mapped_request, actor=actor)
+            # Create MCP server and optimistically sync tools
+            await server.mcp_manager.create_mcp_server_with_tools(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)
@@ -769,7 +755,6 @@ async def add_mcp_server_to_config(
             },
         )
     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)}")
 
 
@@ -801,7 +786,6 @@ async def update_mcp_server(
         # 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)}")
 
 

letta/services/job_manager.py

@@ -43,6 +43,7 @@ class JobManager:
             pydantic_job.user_id = actor.id
             job_data = pydantic_job.model_dump(to_orm=True)
             job = JobModel(**job_data)
+            job.organization_id = actor.organization_id
             job.create(session, actor=actor)  # Save job in the database
         return job.to_pydantic()
 
@@ -57,6 +58,7 @@ class JobManager:
             pydantic_job.user_id = actor.id
             job_data = pydantic_job.model_dump(to_orm=True)
             job = JobModel(**job_data)
+            job.organization_id = actor.organization_id
             job = await job.create_async(session, actor=actor, no_commit=True, no_refresh=True)  # Save job in the database
             result = job.to_pydantic()
             await session.commit()
@@ -150,8 +152,9 @@ class JobManager:
                     logger.error(f"Invalid job status transition from {current_status} to {job_update.status} for job {job_id}")
                     raise ValueError(f"Invalid job status transition from {current_status} to {job_update.status}")
 
-            # Check if we'll need to dispatch callback
-            if job_update.status in {JobStatus.completed, JobStatus.failed} and job.callback_url:
+            # Check if we'll need to dispatch callback (only if not already completed)
+            not_completed_before = not bool(job.completed_at)
+            if job_update.status in {JobStatus.completed, JobStatus.failed} and not_completed_before and job.callback_url:
                 needs_callback = True
                 callback_url = job.callback_url
 
@@ -215,8 +218,17 @@ class JobManager:
         """
         try:
             job_update_builder = partial(JobUpdate, status=new_status)
+
+            # If metadata is provided, merge it with existing metadata
             if metadata:
-                job_update_builder = partial(job_update_builder, metadata=metadata)
+                # Get the current job to access existing metadata
+                current_job = await self.get_job_by_id_async(job_id=job_id, actor=actor)
+                merged_metadata = {}
+                if current_job.metadata:
+                    merged_metadata.update(current_job.metadata)
+                merged_metadata.update(metadata)
+                job_update_builder = partial(job_update_builder, metadata=merged_metadata)
+
             if new_status.is_terminal:
                 job_update_builder = partial(job_update_builder, completed_at=get_utc_time())
 

letta/services/mcp_manager.py

@@ -79,11 +79,16 @@ class MCPManager:
         except Exception as e:
             # MCP tool listing errors are often due to connection/configuration issues, not system errors
             # Log at info level to avoid triggering Sentry alerts for expected failures
-            logger.info(f"Error listing tools for MCP server {mcp_server_name}: {e}")
-            return []
+            logger.warning(f"Error listing tools for MCP server {mcp_server_name}: {e}")
+            raise e
         finally:
             if mcp_client:
-                await mcp_client.cleanup()
+                try:
+                    await mcp_client.cleanup()
+                except* Exception as eg:
+                    for e in eg.exceptions:
+                        logger.warning(f"Error listing tools for MCP server {mcp_server_name}: {e}")
+                        raise e
 
     @enforce_types
     async def execute_mcp_server_tool(
@@ -349,6 +354,62 @@ class MCPManager:
                 logger.error(f"Failed to create MCP server: {e}")
                 raise
 
+    @enforce_types
+    async def create_mcp_server_with_tools(self, pydantic_mcp_server: MCPServer, actor: PydanticUser) -> MCPServer:
+        """
+        Create a new MCP server and optimistically sync its tools.
+
+        This method:
+        1. Creates the MCP server record
+        2. Attempts to connect and fetch tools
+        3. Persists valid tools in parallel (best-effort)
+        """
+        import asyncio
+
+        # First, create the MCP server
+        created_server = await self.create_mcp_server(pydantic_mcp_server, actor)
+
+        # Optimistically try to sync tools
+        try:
+            logger.info(f"Attempting to auto-sync tools from MCP server: {created_server.server_name}")
+
+            # List all tools from the MCP server
+            mcp_tools = await self.list_mcp_server_tools(mcp_server_name=created_server.server_name, actor=actor)
+
+            # Filter out invalid tools
+            valid_tools = [tool for tool in mcp_tools if not (tool.health and tool.health.status == "INVALID")]
+
+            # Register in parallel
+            if valid_tools:
+                tool_tasks = []
+                for mcp_tool in valid_tools:
+                    tool_create = ToolCreate.from_mcp(mcp_server_name=created_server.server_name, mcp_tool=mcp_tool)
+                    task = self.tool_manager.create_mcp_tool_async(
+                        tool_create=tool_create, mcp_server_name=created_server.server_name, mcp_server_id=created_server.id, actor=actor
+                    )
+                    tool_tasks.append(task)
+
+                results = await asyncio.gather(*tool_tasks, return_exceptions=True)
+
+                successful = sum(1 for r in results if not isinstance(r, Exception))
+                failed = len(results) - successful
+                logger.info(
+                    f"Auto-sync completed for MCP server {created_server.server_name}: "
+                    f"{successful} tools persisted, {failed} failed, "
+                    f"{len(mcp_tools) - len(valid_tools)} invalid tools skipped"
+                )
+            else:
+                logger.info(f"No valid tools found to sync from MCP server {created_server.server_name}")
+
+        except Exception as e:
+            # Log the error but don't fail the server creation
+            logger.warning(
+                f"Failed to auto-sync tools from MCP server {created_server.server_name}: {e}. "
+                f"Server was created successfully but tools were not persisted."
+            )
+
+        return created_server
+
     @enforce_types
     async def update_mcp_server_by_id(self, mcp_server_id: str, mcp_server_update: UpdateMCPServer, actor: PydanticUser) -> MCPServer:
         """Update a tool by its ID with the given ToolUpdate object."""