letta-nightly 0.7.30.dev20250603104343__py3-none-any.whl → 0.8.0.dev20250604201135__py3-none-any.whl

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

@@ -9,7 +9,7 @@ router = APIRouter(prefix="/embeddings", tags=["embeddings"])
 
 
 @router.get("/total_storage_size", response_model=float, operation_id="get_total_storage_size")
-def get_embeddings_total_storage_size(
+async def get_embeddings_total_storage_size(
     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
     storage_unit: Optional[str] = Header("GB", alias="storage_unit"),  # Extract storage unit from header, default to GB
@@ -17,5 +17,5 @@ def get_embeddings_total_storage_size(
     """
     Get the total size of all embeddings in the database for a user in the storage unit given.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.passage_manager.estimate_embeddings_size(actor=actor, storage_unit=storage_unit)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.passage_manager.estimate_embeddings_size_async(actor=actor, storage_unit=storage_unit)

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

@@ -52,7 +52,7 @@ def count_groups(
 
 
 @router.get("/{group_id}", response_model=Group, operation_id="retrieve_group")
-def retrieve_group(
+async def retrieve_group(
     group_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
@@ -60,10 +60,10 @@ def retrieve_group(
     """
     Retrieve the group by id.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
-        return server.group_manager.retrieve_group(group_id=group_id, actor=actor)
+        return await server.group_manager.retrieve_group_async(group_id=group_id, actor=actor)
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
 

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

@@ -12,7 +12,7 @@ router = APIRouter(prefix="/jobs", tags=["jobs"])
 
 
 @router.get("/", response_model=List[Job], operation_id="list_jobs")
-def list_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."),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -20,33 +20,30 @@ def list_jobs(
     """
     List all jobs.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     # TODO: add filtering by status
-    jobs = server.job_manager.list_jobs(actor=actor)
-
-    if source_id:
-        # can't be in the ORM since we have source_id stored in the metadata
-        # TODO: Probably change this
-        jobs = [job for job in jobs if job.metadata.get("source_id") == source_id]
-    return jobs
+    return await server.job_manager.list_jobs_async(
+        actor=actor,
+        source_id=source_id,
+    )
 
 
 @router.get("/active", response_model=List[Job], operation_id="list_active_jobs")
 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."),
 ):
     """
     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])
+    return await server.job_manager.list_jobs_async(actor=actor, statuses=[JobStatus.created, JobStatus.running], source_id=source_id)
 
 
 @router.get("/{job_id}", response_model=Job, operation_id="retrieve_job")
-def retrieve_job(
+async def retrieve_job(
     job_id: str,
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
@@ -54,16 +51,16 @@ def retrieve_job(
     """
     Get the status of a job.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
-        return server.job_manager.get_job_by_id(job_id=job_id, actor=actor)
+        return await server.job_manager.get_job_by_id_async(job_id=job_id, actor=actor)
     except NoResultFound:
         raise HTTPException(status_code=404, detail="Job not found")
 
 
 @router.delete("/{job_id}", response_model=Job, operation_id="delete_job")
-def delete_job(
+async def delete_job(
     job_id: str,
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
@@ -71,10 +68,10 @@ def delete_job(
     """
     Delete a job by its job_id.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
-        job = server.job_manager.delete_job_by_id(job_id=job_id, actor=actor)
+        job = await server.job_manager.delete_job_by_id_async(job_id=job_id, actor=actor)
         return job
     except NoResultFound:
         raise HTTPException(status_code=404, detail="Job not found")

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

@@ -13,7 +13,7 @@ router = APIRouter(prefix="/orgs", tags=["organization", "admin"])
 
 
 @router.get("/", tags=["admin"], response_model=List[Organization], operation_id="list_orgs")
-def get_all_orgs(
+async def get_all_orgs(
     after: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
     server: "SyncServer" = Depends(get_letta_server),
@@ -22,7 +22,7 @@ def get_all_orgs(
     Get a list of all orgs in the database
     """
     try:
-        orgs = server.organization_manager.list_organizations(after=after, limit=limit)
+        orgs = await server.organization_manager.list_organizations_async(after=after, limit=limit)
     except HTTPException:
         raise
     except Exception as e:
@@ -31,7 +31,7 @@ def get_all_orgs(
 
 
 @router.post("/", tags=["admin"], response_model=Organization, operation_id="create_organization")
-def create_org(
+async def create_org(
     request: OrganizationCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
@@ -39,21 +39,21 @@ def create_org(
     Create a new org in the database
     """
     org = Organization(**request.model_dump())
-    org = server.organization_manager.create_organization(pydantic_org=org)
+    org = await server.organization_manager.create_organization_async(pydantic_org=org)
     return org
 
 
 @router.delete("/", tags=["admin"], response_model=Organization, operation_id="delete_organization_by_id")
-def delete_org(
+async def delete_org(
     org_id: str = Query(..., description="The org_id key to be deleted."),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     # TODO make a soft deletion, instead of a hard deletion
     try:
-        org = server.organization_manager.get_organization_by_id(org_id=org_id)
+        org = await server.organization_manager.get_organization_by_id_async(org_id=org_id)
         if org is None:
             raise HTTPException(status_code=404, detail=f"Organization does not exist")
-        server.organization_manager.delete_organization_by_id(org_id=org_id)
+        await server.organization_manager.delete_organization_by_id_async(org_id=org_id)
     except HTTPException:
         raise
     except Exception as e:
@@ -62,16 +62,16 @@ def delete_org(
 
 
 @router.patch("/", tags=["admin"], response_model=Organization, operation_id="update_organization")
-def update_org(
+async def update_org(
     org_id: str = Query(..., description="The org_id key to be updated."),
     request: OrganizationUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     try:
-        org = server.organization_manager.get_organization_by_id(org_id=org_id)
+        org = await server.organization_manager.get_organization_by_id_async(org_id=org_id)
         if org is None:
             raise HTTPException(status_code=404, detail=f"Organization does not exist")
-        org = server.organization_manager.update_organization(org_id=org_id, name=request.name)
+        org = await server.organization_manager.update_organization_async(org_id=org_id, name=request.name)
     except HTTPException:
         raise
     except Exception as e:

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

@@ -16,7 +16,7 @@ router = APIRouter(prefix="/providers", tags=["providers"])
 
 
 @router.get("/", response_model=List[Provider], operation_id="list_providers")
-def list_providers(
+async def list_providers(
     name: Optional[str] = Query(None),
     provider_type: Optional[ProviderType] = Query(None),
     after: Optional[str] = Query(None),
@@ -28,8 +28,10 @@ def list_providers(
     Get a list of all custom providers in the database
     """
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        providers = server.provider_manager.list_providers(after=after, limit=limit, actor=actor, name=name, provider_type=provider_type)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        providers = await server.provider_manager.list_providers_async(
+            after=after, limit=limit, actor=actor, name=name, provider_type=provider_type
+        )
     except HTTPException:
         raise
     except Exception as e:
@@ -38,7 +40,7 @@ def list_providers(
 
 
 @router.post("/", response_model=Provider, operation_id="create_provider")
-def create_provider(
+async def create_provider(
     request: ProviderCreate = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
     server: "SyncServer" = Depends(get_letta_server),
@@ -46,16 +48,16 @@ def create_provider(
     """
     Create a new custom provider
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     provider = ProviderCreate(**request.model_dump())
 
-    provider = server.provider_manager.create_provider(provider, actor=actor)
+    provider = await server.provider_manager.create_provider_async(provider, actor=actor)
     return provider
 
 
 @router.patch("/{provider_id}", response_model=Provider, operation_id="modify_provider")
-def modify_provider(
+async def modify_provider(
     provider_id: str,
     request: ProviderUpdate = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -85,7 +87,7 @@ def check_provider(
 
 
 @router.delete("/{provider_id}", response_model=None, operation_id="delete_provider")
-def delete_provider(
+async def delete_provider(
     provider_id: str,
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
@@ -94,8 +96,8 @@ def delete_provider(
     Delete an existing custom provider
     """
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        server.provider_manager.delete_provider_by_id(provider_id=provider_id, actor=actor)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=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}.")

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

@@ -199,7 +199,7 @@ async def list_run_steps(
 
 
 @router.delete("/{run_id}", response_model=Run, operation_id="delete_run")
-def delete_run(
+async def delete_run(
     run_id: str,
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
@@ -207,10 +207,10 @@ def delete_run(
     """
     Delete a run by its run_id.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
-        job = server.job_manager.delete_job_by_id(job_id=run_id, actor=actor)
+        job = await server.job_manager.delete_job_by_id_async(job_id=run_id, actor=actor)
         return Run.from_job(job)
     except NoResultFound:
         raise HTTPException(status_code=404, detail="Run not found")

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

@@ -90,13 +90,13 @@ async def update_sandbox_config(
 
 
 @router.delete("/{sandbox_config_id}", status_code=204)
-def delete_sandbox_config(
+async def delete_sandbox_config(
     sandbox_config_id: str,
     server: SyncServer = Depends(get_letta_server),
     actor_id: str = Depends(get_user_id),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    server.sandbox_config_manager.delete_sandbox_config(sandbox_config_id, actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    await server.sandbox_config_manager.delete_sandbox_config_async(sandbox_config_id, actor)
 
 
 @router.get("/", response_model=List[PydanticSandboxConfig])
@@ -158,35 +158,35 @@ async def force_recreate_local_sandbox_venv(
 
 
 @router.post("/{sandbox_config_id}/environment-variable", response_model=PydanticEnvVar)
-def create_sandbox_env_var(
+async def create_sandbox_env_var(
     sandbox_config_id: str,
     env_var_create: SandboxEnvironmentVariableCreate,
     server: SyncServer = Depends(get_letta_server),
     actor_id: str = Depends(get_user_id),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.sandbox_config_manager.create_sandbox_env_var(env_var_create, sandbox_config_id, actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.sandbox_config_manager.create_sandbox_env_var_async(env_var_create, sandbox_config_id, actor)
 
 
 @router.patch("/environment-variable/{env_var_id}", response_model=PydanticEnvVar)
-def update_sandbox_env_var(
+async def update_sandbox_env_var(
     env_var_id: str,
     env_var_update: SandboxEnvironmentVariableUpdate,
     server: SyncServer = Depends(get_letta_server),
     actor_id: str = Depends(get_user_id),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.sandbox_config_manager.update_sandbox_env_var(env_var_id, env_var_update, actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.sandbox_config_manager.update_sandbox_env_var_async(env_var_id, env_var_update, actor)
 
 
 @router.delete("/environment-variable/{env_var_id}", status_code=204)
-def delete_sandbox_env_var(
+async def delete_sandbox_env_var(
     env_var_id: str,
     server: SyncServer = Depends(get_letta_server),
     actor_id: str = Depends(get_user_id),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    server.sandbox_config_manager.delete_sandbox_env_var(env_var_id, actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    await server.sandbox_config_manager.delete_sandbox_env_var_async(env_var_id, actor)
 
 
 @router.get("/{sandbox_config_id}/environment-variable", response_model=List[PydanticEnvVar])

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

@@ -1,11 +1,16 @@
 import asyncio
+import mimetypes
 import os
 import tempfile
+from pathlib import Path
 from typing import List, Optional
 
-from fastapi import APIRouter, BackgroundTasks, Depends, Header, HTTPException, Query, UploadFile
+from fastapi import APIRouter, Depends, Header, HTTPException, Query, UploadFile
+from starlette import status
 
 import letta.constants as constants
+from letta.log import get_logger
+from letta.schemas.agent import AgentState
 from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.passage import Passage
@@ -13,9 +18,14 @@ from letta.schemas.source import Source, SourceCreate, SourceUpdate
 from letta.schemas.user import User
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
-from letta.utils import sanitize_filename
+from letta.services.file_processor.chunker.llama_index_chunker import LlamaIndexChunker
+from letta.services.file_processor.embedder.openai_embedder import OpenAIEmbedder
+from letta.services.file_processor.file_processor import FileProcessor
+from letta.services.file_processor.parser.mistral_parser import MistralFileParser
+from letta.settings import model_settings, settings
+from letta.utils import safe_create_task, sanitize_filename
 
-# These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
+logger = get_logger(__name__)
 
 
 router = APIRouter(prefix="/sources", tags=["sources"])
@@ -29,7 +39,8 @@ async def count_sources(
     """
     Count all data sources created by a user.
     """
-    return await server.source_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.source_manager.size_async(actor=actor)
 
 
 @router.get("/{source_id}", response_model=Source, operation_id="retrieve_source")
@@ -41,7 +52,7 @@ async def retrieve_source(
     """
     Get all sources
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     source = await server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
     if not source:
@@ -58,7 +69,7 @@ async def get_source_id_by_name(
     """
     Get a source by name
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     source = await server.source_manager.get_source_by_name(source_name=source_name, actor=actor)
     if not source:
@@ -74,7 +85,7 @@ async def list_sources(
     """
     List all data sources created by a user.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     return await server.source_manager.list_sources(actor=actor)
 
 
@@ -87,14 +98,14 @@ async def create_source(
     """
     Create a new data source.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     # TODO: need to asyncify this
     if not source_create.embedding_config:
         if not source_create.embedding:
             # TODO: modify error type
             raise ValueError("Must specify either embedding or embedding_config in request")
-        source_create.embedding_config = server.get_embedding_config_from_handle(
+        source_create.embedding_config = await server.get_embedding_config_from_handle_async(
             handle=source_create.embedding,
             embedding_chunk_size=source_create.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE,
             actor=actor,
@@ -120,7 +131,7 @@ async def modify_source(
     Update the name or documentation of an existing data source.
     """
     # TODO: allow updating the handle/embedding config
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     if not await server.source_manager.get_source_by_id(source_id=source_id, actor=actor):
         raise HTTPException(status_code=404, detail=f"Source with id={source_id} does not exist.")
     return await server.source_manager.update_source(source_id=source_id, source_update=source, actor=actor)
@@ -135,15 +146,19 @@ async def delete_source(
     """
     Delete a data source.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    source = await server.source_manager.get_source_by_id(source_id=source_id)
-    agents = await server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
-    for agent in agents:
-        if agent.enable_sleeptime:
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    source = await server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
+    agent_states = await server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
+    files = await server.source_manager.list_files(source_id, actor)
+    file_ids = [f.id for f in files]
+
+    for agent_state in agent_states:
+        await server.remove_files_from_context_window(agent_state=agent_state, file_ids=file_ids, actor=actor)
+
+        if agent_state.enable_sleeptime:
             try:
-                # TODO: make async
-                block = server.agent_manager.get_block_with_label(agent_id=agent.id, block_label=source.name, actor=actor)
-                server.block_manager.delete_block(block.id, actor)
+                block = await server.agent_manager.get_block_with_label_async(agent_id=agent_state.id, block_label=source.name, actor=actor)
+                await server.block_manager.delete_block_async(block.id, actor)
             except:
                 pass
     await server.delete_source(source_id=source_id, actor=actor)
@@ -153,18 +168,49 @@ async def delete_source(
 async def upload_file_to_source(
     file: UploadFile,
     source_id: str,
-    background_tasks: BackgroundTasks,
     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
+    actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Upload a file to a data source.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    allowed_media_types = {"application/pdf", "text/plain", "application/json"}
+
+    # Normalize incoming Content-Type header (strip charset or any parameters).
+    raw_ct = file.content_type or ""
+    media_type = raw_ct.split(";", 1)[0].strip().lower()
+
+    # If client didn’t supply a Content-Type or it’s not one of the allowed types,
+    #    attempt to infer from filename extension.
+    if media_type not in allowed_media_types and file.filename:
+        guessed, _ = mimetypes.guess_type(file.filename)
+        media_type = (guessed or "").lower()
+
+        if media_type not in allowed_media_types:
+            ext = Path(file.filename).suffix.lower()
+            ext_map = {
+                ".pdf": "application/pdf",
+                ".txt": "text/plain",
+                ".json": "application/json",
+            }
+            media_type = ext_map.get(ext, media_type)
+
+    # If still not allowed, reject with 415.
+    if media_type not in allowed_media_types:
+        raise HTTPException(
+            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            detail=(f"Unsupported file type: {media_type or 'unknown'} " f"(filename: {file.filename}). Only PDF, .txt, or .json allowed."),
+        )
+
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     source = await server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
-    assert source is not None, f"Source with id={source_id} not found."
-    bytes = file.file.read()
+    if source is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Source with id={source_id} not found.")
+    content = await file.read()
+
+    # sanitize filename
+    file.filename = sanitize_filename(file.filename)
 
     # create job
     job = Job(
@@ -172,17 +218,28 @@ async def upload_file_to_source(
         metadata={"type": "embedding", "filename": file.filename, "source_id": source_id},
         completed_at=None,
     )
-    job_id = job.id
-    server.job_manager.create_job(job, actor=actor)
-
-    # create background tasks
-    asyncio.create_task(load_file_to_source_async(server, source_id=source.id, file=file, job_id=job.id, bytes=bytes, actor=actor))
-    asyncio.create_task(sleeptime_document_ingest_async(server, source_id, actor))
+    job = await server.job_manager.create_job_async(job, actor=actor)
+
+    # 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
+    if settings.mistral_api_key and model_settings.openai_api_key:
+        logger.info("Running experimental cloud based file processing...")
+        safe_create_task(
+            load_file_to_source_cloud(server, agent_states, content, file, job, source_id, actor),
+            logger=logger,
+            label="file_processor.process",
+        )
+    else:
+        # create background tasks
+        safe_create_task(
+            load_file_to_source_async(server, source_id=source.id, filename=file.filename, job_id=job.id, bytes=content, actor=actor),
+            logger=logger,
+            label="load_file_to_source_async",
+        )
+    safe_create_task(sleeptime_document_ingest_async(server, source_id, actor), logger=logger, label="sleeptime_document_ingest_async")
 
-    # return job information
-    # Is this necessary? Can we just return the job from create_job?
-    job = server.job_manager.get_job_by_id(job_id=job_id, actor=actor)
-    assert job is not None, "Job not found"
     return job
 
 
@@ -198,7 +255,7 @@ async def list_source_passages(
     """
     List all passages associated with a data source.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     return await server.agent_manager.list_passages_async(
         actor=actor,
         source_id=source_id,
@@ -219,7 +276,7 @@ async def list_source_files(
     """
     List paginated files associated with a data source.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     return await server.source_manager.list_files(source_id=source_id, limit=limit, after=after, actor=actor)
 
 
@@ -229,29 +286,27 @@ async def list_source_files(
 async def delete_file_from_source(
     source_id: str,
     file_id: str,
-    background_tasks: BackgroundTasks,
     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
 ):
     """
     Delete a data source.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     deleted_file = await server.source_manager.delete_file(file_id=file_id, actor=actor)
 
-    # TODO: make async
+    await server.remove_file_from_context_windows(source_id=source_id, file_id=deleted_file.id, actor=actor)
+
     asyncio.create_task(sleeptime_document_ingest_async(server, source_id, actor, clear_history=True))
     if deleted_file is None:
         raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
 
 
-async def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, file: UploadFile, bytes: bytes, actor: User):
+async def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, filename: str, bytes: bytes, actor: User):
     # Create a temporary directory (deleted after the context manager exits)
     with tempfile.TemporaryDirectory() as tmpdirname:
-        # Sanitize the filename
-        sanitized_filename = sanitize_filename(file.filename)
-        file_path = os.path.join(tmpdirname, sanitized_filename)
+        file_path = os.path.join(tmpdirname, filename)
 
         # Write the file to the sanitized path
         with open(file_path, "wb") as buffer:
@@ -266,4 +321,14 @@ async def sleeptime_document_ingest_async(server: SyncServer, source_id: str, ac
     agents = await server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
     for agent in agents:
         if agent.enable_sleeptime:
-            server.sleeptime_document_ingest(agent, source, actor, clear_history)  # TODO: make async
+            await server.sleeptime_document_ingest_async(agent, source, actor, clear_history)
+
+
+async def load_file_to_source_cloud(
+    server: SyncServer, agent_states: List[AgentState], content: bytes, file: UploadFile, job: Job, source_id: str, actor: User
+):
+    file_processor = MistralFileParser()
+    text_chunker = LlamaIndexChunker()
+    embedder = OpenAIEmbedder()
+    file_processor = FileProcessor(file_parser=file_processor, text_chunker=text_chunker, embedder=embedder, actor=actor)
+    await file_processor.process(server=server, agent_states=agent_states, source_id=source_id, content=content, file=file, job=job)