letta-nightly 0.8.8.dev20250703104323__py3-none-any.whl → 0.8.8.dev20250703174903__py3-none-any.whl

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

@@ -73,7 +73,9 @@ def create_group(
     group: GroupCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
-    x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
+    x_project: Optional[str] = Header(
+        None, alias="X-Project", description="The project slug to associate with the group (cloud only)."
+    ),  # Only handled by next js middleware
 ):
     """
     Create a new multi-agent group with the specified configuration.
@@ -91,7 +93,9 @@ async def modify_group(
     group: GroupUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
-    x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
+    x_project: Optional[str] = Header(
+        None, alias="X-Project", description="The project slug to associate with the group (cloud only)."
+    ),  # Only handled by next js middleware
 ):
     """
     Create a new multi-agent group with the specified configuration.

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

@@ -86,7 +86,9 @@ async def create_identity(
     identity: IdentityCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-    x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
+    x_project: Optional[str] = Header(
+        None, alias="X-Project", description="The project slug to associate with the identity (cloud only)."
+    ),  # Only handled by next js middleware
 ):
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
@@ -110,7 +112,9 @@ async def upsert_identity(
     identity: IdentityUpsert = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-    x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
+    x_project: Optional[str] = Header(
+        None, alias="X-Project", description="The project slug to associate with the identity (cloud only)."
+    ),  # Only handled by next js middleware
 ):
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)

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

@@ -15,10 +15,15 @@ router = APIRouter(prefix="/jobs", tags=["jobs"])
 async def list_jobs(
     server: "SyncServer" = Depends(get_letta_server),
     source_id: Optional[str] = Query(None, description="Only list jobs associated with the source."),
+    before: Optional[str] = Query(None, description="Cursor for pagination"),
+    after: Optional[str] = Query(None, description="Cursor for pagination"),
+    limit: Optional[int] = Query(50, description="Limit for pagination"),
+    ascending: bool = Query(True, description="Whether to sort jobs oldest to newest (True, default) or newest to oldest (False)"),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     List all jobs.
+    TODO (cliandy): implementation for pagination
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
@@ -26,6 +31,10 @@ async def list_jobs(
     return await server.job_manager.list_jobs_async(
         actor=actor,
         source_id=source_id,
+        before=before,
+        after=after,
+        limit=limit,
+        ascending=ascending,
     )
 
 
@@ -34,12 +43,24 @@ async def list_active_jobs(
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
     source_id: Optional[str] = Query(None, description="Only list jobs associated with the source."),
+    before: Optional[str] = Query(None, description="Cursor for pagination"),
+    after: Optional[str] = Query(None, description="Cursor for pagination"),
+    limit: Optional[int] = Query(50, description="Limit for pagination"),
+    ascending: bool = Query(True, description="Whether to sort jobs oldest to newest (True, default) or newest to oldest (False)"),
 ):
     """
     List all active jobs.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-    return await server.job_manager.list_jobs_async(actor=actor, statuses=[JobStatus.created, JobStatus.running], source_id=source_id)
+    return await server.job_manager.list_jobs_async(
+        actor=actor,
+        statuses=[JobStatus.created, JobStatus.running],
+        source_id=source_id,
+        before=before,
+        after=after,
+        limit=limit,
+        ascending=ascending,
+    )
 
 
 @router.get("/{job_id}", response_model=Job, operation_id="retrieve_job")
@@ -59,6 +80,33 @@ async def retrieve_job(
         raise HTTPException(status_code=404, detail="Job not found")
 
 
+@router.patch("/{job_id}/cancel", response_model=Job, operation_id="cancel_job")
+async def cancel_job(
+    job_id: str,
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Cancel a job by its job_id.
+
+    This endpoint marks a job as cancelled, which will cause any associated
+    agent execution to terminate as soon as possible.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+
+    try:
+        # First check if the job exists and is in a cancellable state
+        existing_job = await server.job_manager.get_job_by_id_async(job_id=job_id, actor=actor)
+
+        if existing_job.status.is_terminal:
+            return False
+
+        return await server.job_manager.safe_update_job_status_async(job_id=job_id, new_status=JobStatus.cancelled, actor=actor)
+
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Job not found")
+
+
 @router.delete("/{job_id}", response_model=Job, operation_id="delete_job")
 async def delete_job(
     job_id: str,

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

@@ -10,6 +10,7 @@ from starlette import status
 
 import letta.constants as constants
 from letta.log import get_logger
+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 FileProcessingStatus
@@ -184,6 +185,20 @@ async def upload_file_to_source(
     """
     Upload a file to a data source.
     """
+    # NEW: Cloud based file processing
+    # Determine file's MIME type
+    file_mime_type = mimetypes.guess_type(file.filename)[0] or "application/octet-stream"
+
+    # Check if it's a simple text file
+    is_simple_file = is_simple_text_mime_type(file_mime_type)
+
+    # For complex files, require Mistral API key
+    if not is_simple_file and not settings.mistral_api_key:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Mistral API key is required to process this file type {file_mime_type}. Please configure your Mistral API key to upload complex file formats.",
+        )
+
     allowed_media_types = get_allowed_media_types()
 
     # Normalize incoming Content-Type header (strip charset or any parameters).
@@ -220,15 +235,19 @@ async def upload_file_to_source(
 
     content = await file.read()
 
-    # sanitize filename
-    file.filename = sanitize_filename(file.filename)
+    # Store original filename and generate unique filename
+    original_filename = sanitize_filename(file.filename)  # Basic sanitization only
+    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(
         source_id=source_id,
-        file_name=file.filename,
+        file_name=unique_filename,
+        original_file_name=original_filename,
         file_path=None,
-        file_type=mimetypes.guess_type(file.filename)[0] or file.content_type or "unknown",
+        file_type=mimetypes.guess_type(original_filename)[0] or file.content_type or "unknown",
         file_size=file.size if file.size is not None else None,
         processing_status=FileProcessingStatus.PARSING,
     )
@@ -237,20 +256,6 @@ async def upload_file_to_source(
     # TODO: Do we need to pull in the full agent_states? Can probably simplify here right?
     agent_states = await server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
 
-    # NEW: Cloud based file processing
-    # Determine file's MIME type
-    file_mime_type = mimetypes.guess_type(file.filename)[0] or "application/octet-stream"
-
-    # Check if it's a simple text file
-    is_simple_file = is_simple_text_mime_type(file_mime_type)
-
-    # For complex files, require Mistral API key
-    if not is_simple_file and not settings.mistral_api_key:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Mistral API key is required to process this file type {file_mime_type}. Please configure your Mistral API key to upload complex file formats.",
-        )
-
     # Use cloud processing for all files (simple files always, complex files with Mistral key)
     logger.info("Running experimental cloud based file processing...")
     safe_create_task(
@@ -304,6 +309,7 @@ async def list_source_files(
         after=after,
         actor=actor,
         include_content=include_content,
+        strip_directory_prefix=True,  # TODO: Reconsider this. This is purely for aesthetics.
     )
 
 
@@ -326,7 +332,9 @@ async def get_file_metadata(
         raise HTTPException(status_code=404, detail=f"Source with id={source_id} not found.")
 
     # Get file metadata using the file manager
-    file_metadata = await server.file_manager.get_file_by_id(file_id=file_id, actor=actor, include_content=include_content)
+    file_metadata = await server.file_manager.get_file_by_id(
+        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.")
@@ -382,6 +390,7 @@ async def sleeptime_document_ingest_async(server: SyncServer, source_id: str, ac
             await server.sleeptime_document_ingest_async(agent, source, actor, clear_history)
 
 
+@trace_method
 async def load_file_to_source_cloud(
     server: SyncServer,
     agent_states: List[AgentState],

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

@@ -26,8 +26,12 @@ async def list_steps(
     feedback: Optional[Literal["positive", "negative"]] = Query(None, description="Filter by feedback"),
     has_feedback: Optional[bool] = Query(None, description="Filter by whether steps have feedback (true) or not (false)"),
     tags: Optional[list[str]] = Query(None, description="Filter by tags"),
+    project_id: Optional[str] = Query(None, description="Filter by the project ID that is associated with the step (cloud only)."),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
+    x_project: Optional[str] = Header(
+        None, alias="X-Project", description="Filter by project slug to associate with the group (cloud only)."
+    ),  # Only handled by next js middleware
 ):
     """
     List steps with optional pagination and date filters.
@@ -53,6 +57,7 @@ async def list_steps(
         feedback=feedback,
         has_feedback=has_feedback,
         tags=tags,
+        project_id=project_id,
     )
 
 
@@ -90,7 +95,7 @@ async def add_feedback(
 
 
 @router.patch("/{step_id}/transaction/{transaction_id}", response_model=Step, operation_id="update_step_transaction_id")
-def update_step_transaction_id(
+async def update_step_transaction_id(
     step_id: str,
     transaction_id: str,
     actor_id: Optional[str] = Header(None, alias="user_id"),
@@ -102,6 +107,6 @@ def update_step_transaction_id(
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
     try:
-        return server.step_manager.update_step_transaction_id(actor=actor, step_id=step_id, transaction_id=transaction_id)
+        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")

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

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from composio.client import ComposioClientError, HTTPError, NoItemsFound
 from composio.client.collections import ActionModel, AppModel
@@ -10,8 +10,10 @@ from composio.exceptions import (
     EnumStringNotFound,
 )
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+from pydantic import BaseModel, Field
 
 from letta.errors import LettaToolCreateError
+from letta.functions.functions import derive_openai_json_schema
 from letta.functions.mcp_client.exceptions import MCPTimeoutError
 from letta.functions.mcp_client.types import MCPServerType, MCPTool, SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig
 from letta.helpers.composio_helpers import get_composio_api_key
@@ -521,11 +523,19 @@ async def add_mcp_server_to_config(
                     )
             elif isinstance(request, SSEServerConfig):
                 mapped_request = MCPServer(
-                    server_name=request.server_name, server_type=request.type, server_url=request.server_url, token=request.resolve_token()
+                    server_name=request.server_name,
+                    server_type=request.type,
+                    server_url=request.server_url,
+                    token=request.resolve_token() if not request.custom_headers else None,
+                    custom_headers=request.custom_headers,
                 )
             elif isinstance(request, StreamableHTTPServerConfig):
                 mapped_request = MCPServer(
-                    server_name=request.server_name, server_type=request.type, server_url=request.server_url, token=request.resolve_token()
+                    server_name=request.server_name,
+                    server_type=request.type,
+                    server_url=request.server_url,
+                    token=request.resolve_token() if not request.custom_headers else None,
+                    custom_headers=request.custom_headers,
                 )
 
             await server.mcp_manager.create_mcp_server(mapped_request, actor=actor)
@@ -637,7 +647,6 @@ async def test_mcp_server(
 
         await client.connect_to_server()
         tools = await client.list_tools()
-        await client.cleanup()
         return tools
     except ConnectionError as e:
         raise HTTPException(
@@ -658,11 +667,6 @@ async def test_mcp_server(
             },
         )
     except Exception as e:
-        if client:
-            try:
-                await client.cleanup()
-            except:
-                pass
         raise HTTPException(
             status_code=500,
             detail={
@@ -671,3 +675,30 @@ async def test_mcp_server(
                 "server_name": request.server_name,
             },
         )
+    finally:
+        if client:
+            try:
+                await client.cleanup()
+            except Exception as cleanup_error:
+                logger.warning(f"Error during MCP client cleanup: {cleanup_error}")
+
+
+class CodeInput(BaseModel):
+    code: str = Field(..., description="Python source code to parse for JSON schema")
+
+
+@router.post("/generate-schema", response_model=Dict[str, Any], operation_id="generate_json_schema")
+async def generate_json_schema(
+    request: CodeInput = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Generate a JSON schema from the given Python source code defining a function or class.
+    """
+    try:
+        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)}")

letta/server/rest_api/streaming_response.py

@@ -2,6 +2,7 @@
 # stremaing HTTP trailers, as we cannot set codes after the initial response.
 # Taken from: https://github.com/fastapi/fastapi/discussions/10138#discussioncomment-10377361
 
+import asyncio
 import json
 from collections.abc import AsyncIterator
 
@@ -9,10 +10,73 @@ from fastapi.responses import StreamingResponse
 from starlette.types import Send
 
 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
 
 logger = get_logger(__name__)
 
 
+# TODO (cliandy) wrap this and handle types
+async def cancellation_aware_stream_wrapper(
+    stream_generator: AsyncIterator[str | bytes],
+    job_manager: JobManager,
+    job_id: str,
+    actor: User,
+    cancellation_check_interval: float = 0.5,
+) -> AsyncIterator[str | bytes]:
+    """
+    Wraps a stream generator to provide real-time job cancellation checking.
+
+    This wrapper periodically checks for job cancellation while streaming and
+    can interrupt the stream at any point, not just at step boundaries.
+
+    Args:
+        stream_generator: The original stream generator to wrap
+        job_manager: Job manager instance for checking job status
+        job_id: ID of the job to monitor for cancellation
+        actor: User/actor making the request
+        cancellation_check_interval: How often to check for cancellation (seconds)
+
+    Yields:
+        Stream chunks from the original generator until cancelled
+
+    Raises:
+        asyncio.CancelledError: If the job is cancelled during streaming
+    """
+    last_cancellation_check = asyncio.get_event_loop().time()
+
+    try:
+        async for chunk in stream_generator:
+            # Check for cancellation periodically (not on every chunk for performance)
+            current_time = asyncio.get_event_loop().time()
+            if current_time - last_cancellation_check >= cancellation_check_interval:
+                try:
+                    job = await job_manager.get_job_by_id_async(job_id=job_id, actor=actor)
+                    if job.status == JobStatus.cancelled:
+                        logger.info(f"Stream cancelled for job {job_id}, interrupting stream")
+                        # Send cancellation event to client
+                        cancellation_event = {"message_type": "stop_reason", "stop_reason": "cancelled"}
+                        yield f"data: {json.dumps(cancellation_event)}\n\n"
+                        # Raise CancelledError to interrupt the stream
+                        raise asyncio.CancelledError(f"Job {job_id} was cancelled")
+                except Exception as e:
+                    # Log warning but don't fail the stream if cancellation check fails
+                    logger.warning(f"Failed to check job cancellation for job {job_id}: {e}")
+
+                last_cancellation_check = current_time
+
+            yield chunk
+
+    except asyncio.CancelledError:
+        # Re-raise CancelledError to ensure proper cleanup
+        logger.info(f"Stream for job {job_id} was cancelled and cleaned up")
+        raise
+    except Exception as e:
+        logger.error(f"Error in cancellation-aware stream wrapper for job {job_id}: {e}")
+        raise
+
+
 class StreamingResponseWithStatusCode(StreamingResponse):
     """
     Variation of StreamingResponse that can dynamically decide the HTTP status code,
@@ -81,6 +145,30 @@ class StreamingResponseWithStatusCode(StreamingResponse):
                     }
                 )
 
+        # This should be handled properly upstream?
+        except asyncio.CancelledError:
+            logger.info("Stream was cancelled by client or job cancellation")
+            # Handle cancellation gracefully
+            more_body = False
+            cancellation_resp = {"error": {"message": "Stream cancelled"}}
+            cancellation_event = f"event: cancelled\ndata: {json.dumps(cancellation_resp)}\n\n".encode(self.charset)
+            if not self.response_started:
+                await send(
+                    {
+                        "type": "http.response.start",
+                        "status": 200,  # Use 200 for graceful cancellation
+                        "headers": self.raw_headers,
+                    }
+                )
+            await send(
+                {
+                    "type": "http.response.body",
+                    "body": cancellation_event,
+                    "more_body": more_body,
+                }
+            )
+            return
+
         except Exception:
             logger.exception("unhandled_streaming_error")
             more_body = False

letta/server/server.py

@@ -19,7 +19,6 @@ import letta.constants as constants
 import letta.server.utils as server_utils
 import letta.system as system
 from letta.agent import Agent, save_agent
-from letta.agents.letta_agent import LettaAgent
 from letta.config import LettaConfig
 from letta.constants import LETTA_TOOL_EXECUTION_DIR
 from letta.data_sources.connectors import DataConnector, load_data
@@ -101,7 +100,7 @@ from letta.services.provider_manager import ProviderManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.source_manager import SourceManager
 from letta.services.step_manager import StepManager
-from letta.services.telemetry_manager import NoopTelemetryManager, TelemetryManager
+from letta.services.telemetry_manager import TelemetryManager
 from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
@@ -1360,46 +1359,28 @@ class SyncServer(Server):
     async def sleeptime_document_ingest_async(
         self, main_agent: AgentState, source: Source, actor: User, clear_history: bool = False
     ) -> None:
-        sleeptime_agent_state = await self.create_document_sleeptime_agent_async(main_agent, source, actor, clear_history)
-        sleeptime_agent = LettaAgent(
-            agent_id=sleeptime_agent_state.id,
-            message_manager=self.message_manager,
-            agent_manager=self.agent_manager,
-            block_manager=self.block_manager,
-            job_manager=self.job_manager,
-            passage_manager=self.passage_manager,
-            actor=actor,
-            step_manager=self.step_manager,
-            telemetry_manager=self.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-        )
-        passages = await self.agent_manager.list_passages_async(actor=actor, source_id=source.id)
-        for passage in passages:
-            await sleeptime_agent.step(
-                input_messages=[
-                    MessageCreate(role="user", content=passage.text),
-                ]
-            )
-        await self.agent_manager.delete_agent_async(agent_id=sleeptime_agent_state.id, actor=actor)
-
-    async def _upsert_file_to_agent(self, agent_id: str, file_metadata_with_content: FileMetadata, actor: User) -> List[str]:
-        """
-        Internal method to create or update a file <-> agent association
-
-        Returns:
-            List of file names that were closed due to LRU eviction
-        """
-        # TODO: Maybe have LineChunker object be on the server level?
-        content_lines = LineChunker().chunk_text(file_metadata=file_metadata_with_content)
-        visible_content = "\n".join(content_lines)
-
-        file_agent, closed_files = await self.file_agent_manager.attach_file(
-            agent_id=agent_id,
-            file_id=file_metadata_with_content.id,
-            file_name=file_metadata_with_content.file_name,
-            actor=actor,
-            visible_content=visible_content,
-        )
-        return closed_files
+        # TEMPORARILY DISABLE UNTIL V2
+        # sleeptime_agent_state = await self.create_document_sleeptime_agent_async(main_agent, source, actor, clear_history)
+        # sleeptime_agent = LettaAgent(
+        #     agent_id=sleeptime_agent_state.id,
+        #     message_manager=self.message_manager,
+        #     agent_manager=self.agent_manager,
+        #     block_manager=self.block_manager,
+        #     job_manager=self.job_manager,
+        #     passage_manager=self.passage_manager,
+        #     actor=actor,
+        #     step_manager=self.step_manager,
+        #     telemetry_manager=self.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
+        # )
+        # passages = await self.agent_manager.list_passages_async(actor=actor, source_id=source.id)
+        # for passage in passages:
+        #     await sleeptime_agent.step(
+        #         input_messages=[
+        #             MessageCreate(role="user", content=passage.text),
+        #         ]
+        #     )
+        # await self.agent_manager.delete_agent_async(agent_id=sleeptime_agent_state.id, actor=actor)
+        pass
 
     async def _remove_file_from_agent(self, agent_id: str, file_id: str, actor: User) -> None:
         """
@@ -1430,9 +1411,23 @@ class SyncServer(Server):
         logger.info(f"Inserting document into context window for source: {source_id}")
         logger.info(f"Attached agents: {[a.id for a in agent_states]}")
 
-        # Collect any files that were closed due to LRU eviction during bulk attach
+        # Generate visible content for the file
+        line_chunker = LineChunker()
+        content_lines = line_chunker.chunk_text(file_metadata=file_metadata_with_content)
+        visible_content = "\n".join(content_lines)
+        visible_content_map = {file_metadata_with_content.file_name: visible_content}
+
+        # Attach file to each agent using bulk method (one file per agent, but atomic per agent)
         all_closed_files = await asyncio.gather(
-            *(self._upsert_file_to_agent(agent_state.id, file_metadata_with_content, actor) for agent_state in agent_states)
+            *(
+                self.file_agent_manager.attach_files_bulk(
+                    agent_id=agent_state.id,
+                    files_metadata=[file_metadata_with_content],
+                    visible_content_map=visible_content_map,
+                    actor=actor,
+                )
+                for agent_state in agent_states
+            )
         )
         # Flatten and log if any files were closed
         closed_files = [file for closed_list in all_closed_files for file in closed_list]
@@ -1448,14 +1443,23 @@ class SyncServer(Server):
         Insert the uploaded documents into the context window of an agent
         attached to the given source.
         """
-        logger.info(f"Inserting documents into context window for agent_state: {agent_state.id}")
-
-        # Collect any files that were closed due to LRU eviction during bulk insert
-        all_closed_files = await asyncio.gather(
-            *(self._upsert_file_to_agent(agent_state.id, file_metadata, actor) for file_metadata in file_metadata_with_content)
+        logger.info(f"Inserting {len(file_metadata_with_content)} documents into context window for agent_state: {agent_state.id}")
+
+        # Generate visible content for each file
+        line_chunker = LineChunker()
+        visible_content_map = {}
+        for file_metadata in file_metadata_with_content:
+            content_lines = line_chunker.chunk_text(file_metadata=file_metadata)
+            visible_content_map[file_metadata.file_name] = "\n".join(content_lines)
+
+        # Use bulk attach to avoid race conditions and duplicate LRU eviction decisions
+        closed_files = await self.file_agent_manager.attach_files_bulk(
+            agent_id=agent_state.id,
+            files_metadata=file_metadata_with_content,
+            visible_content_map=visible_content_map,
+            actor=actor,
         )
-        # Flatten and log if any files were closed
-        closed_files = [file for closed_list in all_closed_files for file in closed_list]
+
         if closed_files:
             logger.info(f"LRU eviction closed {len(closed_files)} files during bulk insert: {closed_files}")
 
@@ -1634,12 +1638,14 @@ class SyncServer(Server):
 
         async def get_provider_models(provider: Provider) -> list[LLMConfig]:
             try:
-                return await provider.list_llm_models_async()
+                async with asyncio.timeout(constants.GET_PROVIDERS_TIMEOUT_SECONDS):
+                    return await provider.list_llm_models_async()
+            except asyncio.TimeoutError:
+                warnings.warn(f"Timeout while listing LLM models for provider {provider}")
+                return []
             except Exception as e:
-                import traceback
-
                 traceback.print_exc()
-                warnings.warn(f"An error occurred while listing LLM models for provider {provider}: {e}")
+                warnings.warn(f"Error while listing LLM models for provider {provider}: {e}")
                 return []
 
         # Execute all provider model listing tasks concurrently