letta-nightly 0.7.21.dev20250522104246__py3-none-any.whl → 0.7.22.dev20250523104244__py3-none-any.whl

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

@@ -161,7 +161,7 @@ async def list_batch_messages(
 
     # Get messages directly using our efficient method
     # We'll need to update the underlying implementation to use message_id as cursor
-    messages = server.batch_manager.get_messages_for_letta_batch(
+    messages = await server.batch_manager.get_messages_for_letta_batch_async(
         letta_batch_job_id=batch_id, limit=limit, actor=actor, agent_id=agent_id, sort_descending=sort_descending, cursor=cursor
     )
 
@@ -184,7 +184,7 @@ async def cancel_batch_run(
         job = await server.job_manager.update_job_by_id_async(job_id=job.id, job_update=JobUpdate(status=JobStatus.cancelled), actor=actor)
 
         # Get related llm batch jobs
-        llm_batch_jobs = server.batch_manager.list_llm_batch_jobs(letta_batch_id=job.id, actor=actor)
+        llm_batch_jobs = await server.batch_manager.list_llm_batch_jobs_async(letta_batch_id=job.id, actor=actor)
         for llm_batch_job in llm_batch_jobs:
             if llm_batch_job.status in {JobStatus.running, JobStatus.created}:
                 # TODO: Extend to providers beyond anthropic
@@ -194,6 +194,8 @@ async def cancel_batch_run(
                 await server.anthropic_async_client.messages.batches.cancel(anthropic_batch_id)
 
                 # Update all the batch_job statuses
-                server.batch_manager.update_llm_batch_status(llm_batch_id=llm_batch_job.id, status=JobStatus.cancelled, actor=actor)
+                await server.batch_manager.update_llm_batch_status_async(
+                    llm_batch_id=llm_batch_job.id, status=JobStatus.cancelled, actor=actor
+                )
     except NoResultFound:
         raise HTTPException(status_code=404, detail="Run not found")

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

@@ -22,36 +22,36 @@ logger = get_logger(__name__)
 
 
 @router.post("/", response_model=PydanticSandboxConfig)
-def create_sandbox_config(
+async def create_sandbox_config(
     config_create: SandboxConfigCreate,
     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)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
-    return server.sandbox_config_manager.create_or_update_sandbox_config(config_create, actor)
+    return await server.sandbox_config_manager.create_or_update_sandbox_config_async(config_create, actor)
 
 
 @router.post("/e2b/default", response_model=PydanticSandboxConfig)
-def create_default_e2b_sandbox_config(
+async def create_default_e2b_sandbox_config(
     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.get_or_create_default_sandbox_config(sandbox_type=SandboxType.E2B, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.sandbox_config_manager.get_or_create_default_sandbox_config_async(sandbox_type=SandboxType.E2B, actor=actor)
 
 
 @router.post("/local/default", response_model=PydanticSandboxConfig)
-def create_default_local_sandbox_config(
+async def create_default_local_sandbox_config(
     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.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.sandbox_config_manager.get_or_create_default_sandbox_config_async(sandbox_type=SandboxType.LOCAL, actor=actor)
 
 
 @router.post("/local", response_model=PydanticSandboxConfig)
-def create_custom_local_sandbox_config(
+async def create_custom_local_sandbox_config(
     local_sandbox_config: LocalSandboxConfig,
     server: SyncServer = Depends(get_letta_server),
     actor_id: str = Depends(get_user_id),
@@ -67,26 +67,26 @@ def create_custom_local_sandbox_config(
         )
 
     # Retrieve the user (actor)
-    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)
 
     # Wrap the LocalSandboxConfig into a SandboxConfigCreate
     sandbox_config_create = SandboxConfigCreate(config=local_sandbox_config)
 
     # Use the manager to create or update the sandbox config
-    sandbox_config = server.sandbox_config_manager.create_or_update_sandbox_config(sandbox_config_create, actor=actor)
+    sandbox_config = await server.sandbox_config_manager.create_or_update_sandbox_config_async(sandbox_config_create, actor=actor)
 
     return sandbox_config
 
 
 @router.patch("/{sandbox_config_id}", response_model=PydanticSandboxConfig)
-def update_sandbox_config(
+async def update_sandbox_config(
     sandbox_config_id: str,
     config_update: SandboxConfigUpdate,
     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_config(sandbox_config_id, config_update, actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.sandbox_config_manager.update_sandbox_config_async(sandbox_config_id, config_update, actor)
 
 
 @router.delete("/{sandbox_config_id}", status_code=204)
@@ -112,7 +112,7 @@ async def list_sandbox_configs(
 
 
 @router.post("/local/recreate-venv", response_model=PydanticSandboxConfig)
-def force_recreate_local_sandbox_venv(
+async def force_recreate_local_sandbox_venv(
     server: SyncServer = Depends(get_letta_server),
     actor_id: str = Depends(get_user_id),
 ):
@@ -120,10 +120,10 @@ def force_recreate_local_sandbox_venv(
     Forcefully recreate the virtual environment for the local sandbox.
     Deletes and recreates the venv, then reinstalls required dependencies.
     """
-    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)
 
     # Retrieve the local sandbox config
-    sbx_config = server.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=actor)
+    sbx_config = await server.sandbox_config_manager.get_or_create_default_sandbox_config_async(sandbox_type=SandboxType.LOCAL, actor=actor)
 
     local_configs = sbx_config.get_local_config()
     sandbox_dir = os.path.expanduser(local_configs.sandbox_dir)  # Expand tilde

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

@@ -1,3 +1,4 @@
+import asyncio
 import os
 import tempfile
 from typing import List, Optional
@@ -21,18 +22,18 @@ router = APIRouter(prefix="/sources", tags=["sources"])
 
 
 @router.get("/count", response_model=int, operation_id="count_sources")
-def count_sources(
+async def count_sources(
     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
 ):
     """
     Count all data sources created by a user.
     """
-    return server.source_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+    return await server.source_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
 
 
 @router.get("/{source_id}", response_model=Source, operation_id="retrieve_source")
-def retrieve_source(
+async def retrieve_source(
     source_id: str,
     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
@@ -42,14 +43,14 @@ def retrieve_source(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
-    source = server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
+    source = await server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
     if not source:
         raise HTTPException(status_code=404, detail=f"Source with id={source_id} not found.")
     return source
 
 
 @router.get("/name/{source_name}", response_model=str, operation_id="get_source_id_by_name")
-def get_source_id_by_name(
+async def get_source_id_by_name(
     source_name: str,
     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
@@ -59,14 +60,14 @@ def get_source_id_by_name(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
-    source = server.source_manager.get_source_by_name(source_name=source_name, actor=actor)
+    source = await server.source_manager.get_source_by_name(source_name=source_name, actor=actor)
     if not source:
         raise HTTPException(status_code=404, detail=f"Source with name={source_name} not found.")
     return source.id
 
 
 @router.get("/", response_model=List[Source], operation_id="list_sources")
-def list_sources(
+async def list_sources(
     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
 ):
@@ -74,8 +75,7 @@ def list_sources(
     List all data sources created by a user.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-
-    return server.list_all_sources(actor=actor)
+    return await server.source_manager.list_sources(actor=actor)
 
 
 @router.get("/count", response_model=int, operation_id="count_sources")
@@ -90,7 +90,7 @@ def count_sources(
 
 
 @router.post("/", response_model=Source, operation_id="create_source")
-def create_source(
+async def create_source(
     source_create: SourceCreate,
     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
@@ -99,6 +99,8 @@ def create_source(
     Create a new data source.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
+
+    # TODO: need to asyncify this
     if not source_create.embedding_config:
         if not source_create.embedding:
             # TODO: modify error type
@@ -115,11 +117,11 @@ def create_source(
         instructions=source_create.instructions,
         metadata=source_create.metadata,
     )
-    return server.source_manager.create_source(source=source, actor=actor)
+    return await server.source_manager.create_source(source=source, actor=actor)
 
 
 @router.patch("/{source_id}", response_model=Source, operation_id="modify_source")
-def modify_source(
+async def modify_source(
     source_id: str,
     source: SourceUpdate,
     server: "SyncServer" = Depends(get_letta_server),
@@ -130,13 +132,13 @@ def modify_source(
     """
     # TODO: allow updating the handle/embedding config
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    if not server.source_manager.get_source_by_id(source_id=source_id, actor=actor):
+    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 server.source_manager.update_source(source_id=source_id, source_update=source, actor=actor)
+    return await server.source_manager.update_source(source_id=source_id, source_update=source, actor=actor)
 
 
 @router.delete("/{source_id}", response_model=None, operation_id="delete_source")
-def delete_source(
+async def delete_source(
     source_id: str,
     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
@@ -145,20 +147,21 @@ def delete_source(
     Delete a data source.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    source = server.source_manager.get_source_by_id(source_id=source_id)
-    agents = server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
+    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:
             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)
             except:
                 pass
-    server.delete_source(source_id=source_id, actor=actor)
+    await server.delete_source(source_id=source_id, actor=actor)
 
 
 @router.post("/{source_id}/upload", response_model=Job, operation_id="upload_file_to_source")
-def upload_file_to_source(
+async def upload_file_to_source(
     file: UploadFile,
     source_id: str,
     background_tasks: BackgroundTasks,
@@ -170,7 +173,7 @@ def upload_file_to_source(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
-    source = server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
+    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()
 
@@ -184,8 +187,8 @@ def upload_file_to_source(
     server.job_manager.create_job(job, actor=actor)
 
     # create background tasks
-    background_tasks.add_task(load_file_to_source_async, server, source_id=source.id, file=file, job_id=job.id, bytes=bytes, actor=actor)
-    background_tasks.add_task(sleeptime_document_ingest_async, server, source_id, actor)
+    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))
 
     # return job information
     # Is this necessary? Can we just return the job from create_job?
@@ -195,8 +198,11 @@ def upload_file_to_source(
 
 
 @router.get("/{source_id}/passages", response_model=List[Passage], operation_id="list_source_passages")
-def list_source_passages(
+async def list_source_passages(
     source_id: str,
+    after: Optional[str] = Query(None, description="Message after which to retrieve the returned messages."),
+    before: Optional[str] = Query(None, description="Message before which to retrieve the returned messages."),
+    limit: int = Query(100, description="Maximum number of messages to retrieve."),
     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
 ):
@@ -204,12 +210,17 @@ def list_source_passages(
     List all passages associated with a data source.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    passages = server.list_data_source_passages(user_id=actor.id, source_id=source_id)
-    return passages
+    return await server.agent_manager.list_passages_async(
+        actor=actor,
+        source_id=source_id,
+        after=after,
+        before=before,
+        limit=limit,
+    )
 
 
 @router.get("/{source_id}/files", response_model=List[FileMetadata], operation_id="list_source_files")
-def list_source_files(
+async def list_source_files(
     source_id: str,
     limit: int = Query(1000, description="Number of files to return"),
     after: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
@@ -220,13 +231,13 @@ def list_source_files(
     List paginated files associated with a data source.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.source_manager.list_files(source_id=source_id, limit=limit, after=after, actor=actor)
+    return await server.source_manager.list_files(source_id=source_id, limit=limit, after=after, actor=actor)
 
 
 # it's redundant to include /delete in the URL path. The HTTP verb DELETE already implies that action.
 # it's still good practice to return a status indicating the success or failure of the deletion
 @router.delete("/{source_id}/{file_id}", status_code=204, operation_id="delete_file_from_source")
-def delete_file_from_source(
+async def delete_file_from_source(
     source_id: str,
     file_id: str,
     background_tasks: BackgroundTasks,
@@ -238,13 +249,15 @@ def delete_file_from_source(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
-    deleted_file = server.source_manager.delete_file(file_id=file_id, actor=actor)
-    background_tasks.add_task(sleeptime_document_ingest_async, server, source_id, actor, clear_history=True)
+    deleted_file = await server.source_manager.delete_file(file_id=file_id, actor=actor)
+
+    # TODO: make async
+    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.")
 
 
-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, file: UploadFile, bytes: bytes, actor: User):
     # Create a temporary directory (deleted after the context manager exits)
     with tempfile.TemporaryDirectory() as tmpdirname:
         # Sanitize the filename
@@ -256,12 +269,12 @@ def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, f
             buffer.write(bytes)
 
         # Pass the file to load_file_to_source
-        server.load_file_to_source(source_id, file_path, job_id, actor)
+        await server.load_file_to_source(source_id, file_path, job_id, actor)
 
 
-def sleeptime_document_ingest_async(server: SyncServer, source_id: str, actor: User, clear_history: bool = False):
-    source = server.source_manager.get_source_by_id(source_id=source_id)
-    agents = server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
+async def sleeptime_document_ingest_async(server: SyncServer, source_id: str, actor: User, clear_history: bool = False):
+    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:
-            server.sleeptime_document_ingest(agent, source, actor, clear_history)
+            server.sleeptime_document_ingest(agent, source, actor, clear_history)  # TODO: make async

letta/server/server.py

@@ -50,7 +50,7 @@ from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, ToolRe
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.llm_config import LLMConfig
-from letta.schemas.memory import ArchivalMemorySummary, ContextWindowOverview, Memory, RecallMemorySummary
+from letta.schemas.memory import ArchivalMemorySummary, Memory, RecallMemorySummary
 from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage, PassageUpdate
@@ -969,6 +969,11 @@ class SyncServer(Server):
         """Return the memory of an agent (core memory)"""
         return self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor).memory
 
+    async def get_agent_memory_async(self, agent_id: str, actor: User) -> Memory:
+        """Return the memory of an agent (core memory)"""
+        agent = await self.agent_manager.get_agent_by_id_async(agent_id=agent_id, actor=actor)
+        return agent.memory
+
     def get_archival_memory_summary(self, agent_id: str, actor: User) -> ArchivalMemorySummary:
         return ArchivalMemorySummary(size=self.agent_manager.passage_size(actor=actor, agent_id=agent_id))
 
@@ -1169,17 +1174,20 @@ class SyncServer(Server):
         # rebuild system prompt for agent, potentially changed
         return self.agent_manager.rebuild_system_prompt(agent_id=agent_id, actor=actor).memory
 
-    def delete_source(self, source_id: str, actor: User):
+    async def delete_source(self, source_id: str, actor: User):
         """Delete a data source"""
-        self.source_manager.delete_source(source_id=source_id, actor=actor)
+        await self.source_manager.delete_source(source_id=source_id, actor=actor)
 
         # delete data from passage store
+        # TODO: make async
         passages_to_be_deleted = self.agent_manager.list_passages(actor=actor, source_id=source_id, limit=None)
+
+        # TODO: make this async
         self.passage_manager.delete_passages(actor=actor, passages=passages_to_be_deleted)
 
         # TODO: delete data from agent passage stores (?)
 
-    def load_file_to_source(self, source_id: str, file_path: str, job_id: str, actor: User) -> Job:
+    async def load_file_to_source(self, source_id: str, file_path: str, job_id: str, actor: User) -> Job:
 
         # update job
         job = self.job_manager.get_job_by_id(job_id, actor=actor)
@@ -1189,21 +1197,22 @@ class SyncServer(Server):
         # try:
         from letta.data_sources.connectors import DirectoryConnector
 
-        source = self.source_manager.get_source_by_id(source_id=source_id)
+        # TODO: move this into a thread
+        source = await self.source_manager.get_source_by_id(source_id=source_id)
         if source is None:
             raise ValueError(f"Source {source_id} does not exist")
         connector = DirectoryConnector(input_files=[file_path])
-        num_passages, num_documents = self.load_data(user_id=source.created_by_id, source_name=source.name, connector=connector)
+        num_passages, num_documents = await self.load_data(user_id=source.created_by_id, source_name=source.name, connector=connector)
 
         # update all agents who have this source attached
-        agent_states = self.source_manager.list_attached_agents(source_id=source_id, actor=actor)
+        agent_states = await self.source_manager.list_attached_agents(source_id=source_id, actor=actor)
         for agent_state in agent_states:
             agent_id = agent_state.id
 
             # Attach source to agent
-            curr_passage_size = self.agent_manager.passage_size(actor=actor, agent_id=agent_id)
+            curr_passage_size = await self.agent_manager.passage_size_async(actor=actor, agent_id=agent_id)
             agent_state = self.agent_manager.attach_source(agent_id=agent_state.id, source_id=source_id, actor=actor)
-            new_passage_size = self.agent_manager.passage_size(actor=actor, agent_id=agent_id)
+            new_passage_size = await self.agent_manager.passage_size_async(actor=actor, agent_id=agent_id)
             assert new_passage_size >= curr_passage_size  # in case empty files are added
 
             # rebuild system prompt and force
@@ -1266,7 +1275,7 @@ class SyncServer(Server):
             actor=actor,
         )
 
-    def load_data(
+    async def load_data(
         self,
         user_id: str,
         connector: DataConnector,
@@ -1277,12 +1286,12 @@ class SyncServer(Server):
 
         # load data from a data source into the document store
         user = self.user_manager.get_user_by_id(user_id=user_id)
-        source = self.source_manager.get_source_by_name(source_name=source_name, actor=user)
+        source = await self.source_manager.get_source_by_name(source_name=source_name, actor=user)
         if source is None:
             raise ValueError(f"Data source {source_name} does not exist for user {user_id}")
 
         # load data into the document store
-        passage_count, document_count = load_data(connector, source, self.passage_manager, self.source_manager, actor=user)
+        passage_count, document_count = await load_data(connector, source, self.passage_manager, self.source_manager, actor=user)
         return passage_count, document_count
 
     def list_data_source_passages(self, user_id: str, source_id: str) -> List[Passage]:
@@ -1290,6 +1299,7 @@ class SyncServer(Server):
         return self.agent_manager.list_passages(actor=self.user_manager.get_user_or_default(user_id=user_id), source_id=source_id)
 
     def list_all_sources(self, actor: User) -> List[Source]:
+        # TODO: legacy: remove
         """List all sources (w/ extra metadata) belonging to a user"""
 
         sources = self.source_manager.list_sources(actor=actor)
@@ -1376,7 +1386,7 @@ class SyncServer(Server):
         """Asynchronously list available models with maximum concurrency"""
         import asyncio
 
-        providers = self.get_enabled_providers(
+        providers = await self.get_enabled_providers_async(
             provider_category=provider_category,
             provider_name=provider_name,
             provider_type=provider_type,
@@ -1422,7 +1432,7 @@ class SyncServer(Server):
         import asyncio
 
         # Get all eligible providers first
-        providers = self.get_enabled_providers(actor=actor)
+        providers = await self.get_enabled_providers_async(actor=actor)
 
         # Fetch embedding models from each provider concurrently
         async def get_provider_embedding_models(provider):
@@ -1475,6 +1485,35 @@ class SyncServer(Server):
 
         return providers
 
+    async def get_enabled_providers_async(
+        self,
+        actor: User,
+        provider_category: Optional[List[ProviderCategory]] = None,
+        provider_name: Optional[str] = None,
+        provider_type: Optional[ProviderType] = None,
+    ) -> List[Provider]:
+        providers = []
+        if not provider_category or ProviderCategory.base in provider_category:
+            providers_from_env = [p for p in self._enabled_providers]
+            providers.extend(providers_from_env)
+
+        if not provider_category or ProviderCategory.byok in provider_category:
+            providers_from_db = await self.provider_manager.list_providers_async(
+                name=provider_name,
+                provider_type=provider_type,
+                actor=actor,
+            )
+            providers_from_db = [p.cast_to_subtype() for p in providers_from_db]
+            providers.extend(providers_from_db)
+
+        if provider_name is not None:
+            providers = [p for p in providers if p.name == provider_name]
+
+        if provider_type is not None:
+            providers = [p for p in providers if p.provider_type == provider_type]
+
+        return providers
+
     @trace_method
     def get_llm_config_from_handle(
         self,
@@ -1613,14 +1652,6 @@ class SyncServer(Server):
     def add_embedding_model(self, request: EmbeddingConfig) -> EmbeddingConfig:
         """Add a new embedding model"""
 
-    def get_agent_context_window(self, agent_id: str, actor: User) -> ContextWindowOverview:
-        letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-        return letta_agent.get_context_window()
-
-    async def get_agent_context_window_async(self, agent_id: str, actor: User) -> ContextWindowOverview:
-        letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-        return await letta_agent.get_context_window_async()
-
     def run_tool_from_source(
         self,
         actor: User,