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

letta/services/message_manager.py

@@ -49,7 +49,7 @@ class MessageManager:
     def get_messages_by_ids(self, message_ids: List[str], actor: PydanticUser) -> List[PydanticMessage]:
         """Fetch messages by ID and return them in the requested order."""
         with db_registry.session() as session:
-            results = MessageModel.list(db_session=session, id=message_ids, organization_id=actor.organization_id, limit=len(message_ids))
+            results = MessageModel.read_multiple(db_session=session, identifiers=message_ids, actor=actor)
         return self._get_messages_by_id_postprocess(results, message_ids)
 
     @enforce_types
@@ -57,10 +57,8 @@ class MessageManager:
     async def get_messages_by_ids_async(self, message_ids: List[str], actor: PydanticUser) -> List[PydanticMessage]:
         """Fetch messages by ID and return them in the requested order. Async version of above function."""
         async with db_registry.async_session() as session:
-            results = await MessageModel.list_async(
-                db_session=session, id=message_ids, organization_id=actor.organization_id, limit=len(message_ids)
-            )
-        return self._get_messages_by_id_postprocess(results, message_ids)
+            results = await MessageModel.read_multiple_async(db_session=session, identifiers=message_ids, actor=actor)
+            return self._get_messages_by_id_postprocess(results, message_ids)
 
     def _get_messages_by_id_postprocess(
         self,
@@ -349,6 +347,29 @@ class MessageManager:
             ascending=ascending,
         )
 
+    @enforce_types
+    @trace_method
+    async def list_user_messages_for_agent_async(
+        self,
+        agent_id: str,
+        actor: PydanticUser,
+        after: Optional[str] = None,
+        before: Optional[str] = None,
+        query_text: Optional[str] = None,
+        limit: Optional[int] = 50,
+        ascending: bool = True,
+    ) -> List[PydanticMessage]:
+        return await self.list_messages_for_agent_async(
+            agent_id=agent_id,
+            actor=actor,
+            after=after,
+            before=before,
+            query_text=query_text,
+            roles=[MessageRole.user],
+            limit=limit,
+            ascending=ascending,
+        )
+
     @enforce_types
     @trace_method
     def list_messages_for_agent(
@@ -400,24 +421,17 @@ class MessageManager:
             if group_id:
                 query = query.filter(MessageModel.group_id == group_id)
 
-            # If query_text is provided, filter messages by matching any "text" type content block
-            # whose text includes the query string (case-insensitive).
+            # If query_text is provided, filter messages using subquery + json_array_elements.
             if query_text:
-                dialect_name = session.bind.dialect.name
-
-                if dialect_name == "postgresql":  # using subquery + json_array_elements.
-                    content_element = func.json_array_elements(MessageModel.content).alias("content_element")
-                    subquery_sql = text("content_element->>'type' = 'text' AND content_element->>'text' ILIKE :query_text")
-                    subquery = select(1).select_from(content_element).where(subquery_sql)
-
-                elif dialect_name == "sqlite":  # using `json_each` and JSON path expressions
-                    json_item = func.json_each(MessageModel.content).alias("json_item")
-                    subquery_sql = text(
-                        "json_extract(value, '$.type') = 'text' AND lower(json_extract(value, '$.text')) LIKE lower(:query_text)"
+                content_element = func.json_array_elements(MessageModel.content).alias("content_element")
+                query = query.filter(
+                    exists(
+                        select(1)
+                        .select_from(content_element)
+                        .where(text("content_element->>'type' = 'text' AND content_element->>'text' ILIKE :query_text"))
+                        .params(query_text=f"%{query_text}%")
                     )
-                    subquery = select(1).select_from(json_item).where(subquery_sql)
-
-                query = query.filter(exists(subquery.params(query_text=f"%{query_text}%")))
+                )
 
             # If role(s) are provided, filter messages by those roles.
             if roles:
@@ -557,23 +571,23 @@ class MessageManager:
 
     @enforce_types
     @trace_method
-    def delete_all_messages_for_agent(self, agent_id: str, actor: PydanticUser) -> int:
+    async def delete_all_messages_for_agent_async(self, agent_id: str, actor: PydanticUser) -> int:
         """
         Efficiently deletes all messages associated with a given agent_id,
         while enforcing permission checks and avoiding any ORM‑level loads.
         """
-        with db_registry.session() as session:
+        async with db_registry.async_session() as session:
             # 1) verify the agent exists and the actor has access
-            AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
+            await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
 
             # 2) issue a CORE DELETE against the mapped class
             stmt = (
                 delete(MessageModel).where(MessageModel.agent_id == agent_id).where(MessageModel.organization_id == actor.organization_id)
             )
-            result = session.execute(stmt)
+            result = await session.execute(stmt)
 
             # 3) commit once
-            session.commit()
+            await session.commit()
 
             # 4) return the number of rows deleted
             return result.rowcount

letta/services/organization_manager.py

@@ -17,9 +17,9 @@ class OrganizationManager:
 
     @enforce_types
     @trace_method
-    def get_default_organization(self) -> PydanticOrganization:
+    async def get_default_organization_async(self) -> PydanticOrganization:
         """Fetch the default organization."""
-        return self.get_organization_by_id(self.DEFAULT_ORG_ID)
+        return await self.get_organization_by_id_async(self.DEFAULT_ORG_ID)
 
     @enforce_types
     @trace_method
@@ -29,52 +29,80 @@ class OrganizationManager:
             organization = OrganizationModel.read(db_session=session, identifier=org_id)
             return organization.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def get_organization_by_id_async(self, org_id: str) -> Optional[PydanticOrganization]:
+        """Fetch an organization by ID."""
+        async with db_registry.async_session() as session:
+            organization = await OrganizationModel.read_async(db_session=session, identifier=org_id)
+            return organization.to_pydantic()
+
     @enforce_types
     @trace_method
     def create_organization(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
+        """Create the default organization."""
+        with db_registry.session() as session:
+            try:
+                organization = OrganizationModel.read(db_session=session, identifier=pydantic_org.id)
+                return organization.to_pydantic()
+            except:
+                organization = OrganizationModel(**pydantic_org.model_dump(to_orm=True))
+                organization = organization.create(session)
+                return organization.to_pydantic()
+
+    @enforce_types
+    @trace_method
+    async def create_organization_async(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
         """Create a new organization."""
         try:
-            org = self.get_organization_by_id(pydantic_org.id)
+            org = await self.get_organization_by_id_async(pydantic_org.id)
             return org
         except NoResultFound:
-            return self._create_organization(pydantic_org=pydantic_org)
+            return await self._create_organization_async(pydantic_org=pydantic_org)
 
     @enforce_types
     @trace_method
-    def _create_organization(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
-        with db_registry.session() as session:
+    async def _create_organization_async(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
+        async with db_registry.async_session() as session:
             org = OrganizationModel(**pydantic_org.model_dump(to_orm=True))
-            org.create(session)
+            await org.create_async(session)
             return org.to_pydantic()
 
     @enforce_types
     @trace_method
     def create_default_organization(self) -> PydanticOrganization:
         """Create the default organization."""
-        return self.create_organization(PydanticOrganization(name=self.DEFAULT_ORG_NAME, id=self.DEFAULT_ORG_ID))
+        pydantic_org = PydanticOrganization(name=self.DEFAULT_ORG_NAME, id=self.DEFAULT_ORG_ID)
+        return self.create_organization(pydantic_org)
 
     @enforce_types
     @trace_method
-    def update_organization_name_using_id(self, org_id: str, name: Optional[str] = None) -> PydanticOrganization:
+    async def create_default_organization_async(self) -> PydanticOrganization:
+        """Create the default organization."""
+        return await self.create_organization_async(PydanticOrganization(name=self.DEFAULT_ORG_NAME, id=self.DEFAULT_ORG_ID))
+
+    @enforce_types
+    @trace_method
+    async def update_organization_name_using_id_async(self, org_id: str, name: Optional[str] = None) -> PydanticOrganization:
         """Update an organization."""
-        with db_registry.session() as session:
-            org = OrganizationModel.read(db_session=session, identifier=org_id)
+        async with db_registry.async_session() as session:
+            org = await OrganizationModel.read_async(db_session=session, identifier=org_id)
             if name:
                 org.name = name
-            org.update(session)
+            await org.update_async(session)
             return org.to_pydantic()
 
     @enforce_types
     @trace_method
-    def update_organization(self, org_id: str, org_update: OrganizationUpdate) -> PydanticOrganization:
+    async def update_organization_async(self, org_id: str, org_update: OrganizationUpdate) -> PydanticOrganization:
         """Update an organization."""
-        with db_registry.session() as session:
-            org = OrganizationModel.read(db_session=session, identifier=org_id)
+        async with db_registry.async_session() as session:
+            org = await OrganizationModel.read_async(db_session=session, identifier=org_id)
             if org_update.name:
                 org.name = org_update.name
             if org_update.privileged_tools:
                 org.privileged_tools = org_update.privileged_tools
-            org.update(session)
+            await org.update_async(session)
             return org.to_pydantic()
 
     @enforce_types
@@ -87,10 +115,18 @@ class OrganizationManager:
 
     @enforce_types
     @trace_method
-    def list_organizations(self, after: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticOrganization]:
+    async def delete_organization_by_id_async(self, org_id: str):
+        """Delete an organization by marking it as deleted."""
+        async with db_registry.async_session() as session:
+            organization = await OrganizationModel.read_async(db_session=session, identifier=org_id)
+            await organization.hard_delete_async(session)
+
+    @enforce_types
+    @trace_method
+    async def list_organizations_async(self, after: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticOrganization]:
         """List all organizations with optional pagination."""
-        with db_registry.session() as session:
-            organizations = OrganizationModel.list(
+        async with db_registry.async_session() as session:
+            organizations = await OrganizationModel.list_async(
                 db_session=session,
                 after=after,
                 limit=limit,

letta/services/passage_manager.py

@@ -1,7 +1,11 @@
+import asyncio
 from datetime import datetime, timezone
+from functools import lru_cache
 from typing import List, Optional
 
-from openai import OpenAI
+from async_lru import alru_cache
+from openai import AsyncOpenAI, OpenAI
+from sqlalchemy import select
 
 from letta.constants import MAX_EMBEDDING_DIM
 from letta.embeddings import embedding_model, parse_and_chunk_text
@@ -15,6 +19,26 @@ from letta.tracing import trace_method
 from letta.utils import enforce_types
 
 
+# TODO: Add redis-backed caching for backend
+@lru_cache(maxsize=8192)
+def get_openai_embedding(text: str, model: str, endpoint: str) -> List[float]:
+    from letta.settings import model_settings
+
+    client = OpenAI(api_key=model_settings.openai_api_key, base_url=endpoint, max_retries=0)
+    response = client.embeddings.create(input=text, model=model)
+    return response.data[0].embedding
+
+
+# TODO: Add redis-backed caching for backend
+@alru_cache(maxsize=8192)
+async def get_openai_embedding_async(text: str, model: str, endpoint: str) -> List[float]:
+    from letta.settings import model_settings
+
+    client = AsyncOpenAI(api_key=model_settings.openai_api_key, base_url=endpoint, max_retries=0)
+    response = await client.embeddings.create(input=text, model=model)
+    return response.data[0].embedding
+
+
 class PassageManager:
     """Manager class to handle business logic related to Passages."""
 
@@ -35,11 +59,45 @@ class PassageManager:
                 except NoResultFound:
                     raise NoResultFound(f"Passage with id {passage_id} not found in database.")
 
+    @enforce_types
+    @trace_method
+    async def get_passage_by_id_async(self, passage_id: str, actor: PydanticUser) -> Optional[PydanticPassage]:
+        """Fetch a passage by ID."""
+        async with db_registry.async_session() as session:
+            # Try source passages first
+            try:
+                passage = await SourcePassage.read_async(db_session=session, identifier=passage_id, actor=actor)
+                return passage.to_pydantic()
+            except NoResultFound:
+                # Try archival passages
+                try:
+                    passage = await AgentPassage.read_async(db_session=session, identifier=passage_id, actor=actor)
+                    return passage.to_pydantic()
+                except NoResultFound:
+                    raise NoResultFound(f"Passage with id {passage_id} not found in database.")
+
     @enforce_types
     @trace_method
     def create_passage(self, pydantic_passage: PydanticPassage, actor: PydanticUser) -> PydanticPassage:
+        """Create a new passage in the appropriate table based on whether it has agent_id or source_id."""
+        passage = self._preprocess_passage_for_creation(pydantic_passage=pydantic_passage)
+
+        with db_registry.session() as session:
+            passage.create(session, actor=actor)
+            return passage.to_pydantic()
+
+    @enforce_types
+    @trace_method
+    async def create_passage_async(self, pydantic_passage: PydanticPassage, actor: PydanticUser) -> PydanticPassage:
         """Create a new passage in the appropriate table based on whether it has agent_id or source_id."""
         # Common fields for both passage types
+        passage = self._preprocess_passage_for_creation(pydantic_passage=pydantic_passage)
+        async with db_registry.async_session() as session:
+            passage = await passage.create_async(session, actor=actor)
+            return passage.to_pydantic()
+
+    @trace_method
+    def _preprocess_passage_for_creation(self, pydantic_passage: PydanticPassage) -> "SqlAlchemyBase":
         data = pydantic_passage.model_dump(to_orm=True)
         common_fields = {
             "id": data.get("id"),
@@ -68,9 +126,7 @@ class PassageManager:
         else:
             raise ValueError("Passage must have either agent_id or source_id")
 
-        with db_registry.session() as session:
-            passage.create(session, actor=actor)
-            return passage.to_pydantic()
+        return passage
 
     @enforce_types
     @trace_method
@@ -78,6 +134,33 @@ class PassageManager:
         """Create multiple passages."""
         return [self.create_passage(p, actor) for p in passages]
 
+    @enforce_types
+    @trace_method
+    async def create_many_passages_async(self, passages: List[PydanticPassage], actor: PydanticUser) -> List[PydanticPassage]:
+        """Create multiple passages."""
+        async with db_registry.async_session() as session:
+            agent_passages = []
+            source_passages = []
+
+            for p in passages:
+                model = self._preprocess_passage_for_creation(p)
+                if isinstance(model, AgentPassage):
+                    agent_passages.append(model)
+                elif isinstance(model, SourcePassage):
+                    source_passages.append(model)
+                else:
+                    raise TypeError(f"Unexpected passage type: {type(model)}")
+
+            results = []
+            if agent_passages:
+                agent_created = await AgentPassage.batch_create_async(items=agent_passages, db_session=session, actor=actor)
+                results.extend(agent_created)
+            if source_passages:
+                source_created = await SourcePassage.batch_create_async(items=source_passages, db_session=session, actor=actor)
+                results.extend(source_created)
+
+            return [p.to_pydantic() for p in results]
+
     @enforce_types
     @trace_method
     def insert_passage(
@@ -106,14 +189,11 @@ class PassageManager:
                     embedding = embed_model.get_text_embedding(text)
                 else:
                     # TODO should have the settings passed in via the server call
-                    from letta.settings import model_settings
-
-                    # Simple OpenAI client code
-                    client = OpenAI(
-                        api_key=model_settings.openai_api_key, base_url=agent_state.embedding_config.embedding_endpoint, max_retries=0
+                    embedding = get_openai_embedding(
+                        text,
+                        agent_state.embedding_config.embedding_model,
+                        agent_state.embedding_config.embedding_endpoint,
                     )
-                    response = client.embeddings.create(input=text, model=agent_state.embedding_config.embedding_model)
-                    embedding = response.data[0].embedding
 
                 if isinstance(embedding, dict):
                     try:
@@ -140,6 +220,78 @@ class PassageManager:
         except Exception as e:
             raise e
 
+    @enforce_types
+    @trace_method
+    async def insert_passage_async(
+        self,
+        agent_state: AgentState,
+        agent_id: str,
+        text: str,
+        actor: PydanticUser,
+    ) -> List[PydanticPassage]:
+        """Insert passage(s) into archival memory"""
+
+        embedding_chunk_size = agent_state.embedding_config.embedding_chunk_size
+        text_chunks = list(parse_and_chunk_text(text, embedding_chunk_size))
+
+        if not text_chunks:
+            return []
+
+        try:
+            embeddings = await self._generate_embeddings_concurrent(text_chunks, agent_state.embedding_config)
+
+            passages = [
+                PydanticPassage(
+                    organization_id=actor.organization_id,
+                    agent_id=agent_id,
+                    text=chunk_text,
+                    embedding=embedding,
+                    embedding_config=agent_state.embedding_config,
+                )
+                for chunk_text, embedding in zip(text_chunks, embeddings)
+            ]
+
+            passages = await self.create_many_passages_async(passages=passages, actor=actor)
+
+            return passages
+
+        except Exception as e:
+            raise e
+
+    async def _generate_embeddings_concurrent(self, text_chunks: List[str], embedding_config) -> List[List[float]]:
+        """Generate embeddings for all text chunks concurrently"""
+
+        if embedding_config.embedding_endpoint_type != "openai":
+            embed_model = embedding_model(embedding_config)
+            loop = asyncio.get_event_loop()
+
+            tasks = [loop.run_in_executor(None, embed_model.get_text_embedding, text) for text in text_chunks]
+            embeddings = await asyncio.gather(*tasks)
+        else:
+            tasks = [
+                get_openai_embedding_async(
+                    text,
+                    embedding_config.embedding_model,
+                    embedding_config.embedding_endpoint,
+                )
+                for text in text_chunks
+            ]
+            embeddings = await asyncio.gather(*tasks)
+
+        processed_embeddings = []
+        for embedding in embeddings:
+            if isinstance(embedding, dict):
+                try:
+                    processed_embeddings.append(embedding["data"][0]["embedding"])
+                except (KeyError, IndexError):
+                    raise TypeError(
+                        f"Got back an unexpected payload from text embedding function, type={type(embedding)}, value={embedding}"
+                    )
+            else:
+                processed_embeddings.append(embedding)
+
+        return processed_embeddings
+
     @enforce_types
     @trace_method
     def update_passage_by_id(self, passage_id: str, passage: PydanticPassage, actor: PydanticUser, **kwargs) -> Optional[PydanticPassage]:
@@ -197,6 +349,28 @@ class PassageManager:
                 except NoResultFound:
                     raise NoResultFound(f"Passage with id {passage_id} not found.")
 
+    @enforce_types
+    @trace_method
+    async def delete_passage_by_id_async(self, passage_id: str, actor: PydanticUser) -> bool:
+        """Delete a passage from either source or archival passages."""
+        if not passage_id:
+            raise ValueError("Passage ID must be provided.")
+
+        async with db_registry.async_session() as session:
+            # Try source passages first
+            try:
+                passage = await SourcePassage.read_async(db_session=session, identifier=passage_id, actor=actor)
+                await passage.hard_delete_async(session, actor=actor)
+                return True
+            except NoResultFound:
+                # Try archival passages
+                try:
+                    passage = await AgentPassage.read_async(db_session=session, identifier=passage_id, actor=actor)
+                    await passage.hard_delete_async(session, actor=actor)
+                    return True
+                except NoResultFound:
+                    raise NoResultFound(f"Passage with id {passage_id} not found.")
+
     @enforce_types
     @trace_method
     def delete_passages(
@@ -210,6 +384,17 @@ class PassageManager:
             self.delete_passage_by_id(passage_id=passage.id, actor=actor)
         return True
 
+    @enforce_types
+    @trace_method
+    async def delete_source_passages_async(
+        self,
+        actor: PydanticUser,
+        passages: List[PydanticPassage],
+    ) -> bool:
+        async with db_registry.async_session() as session:
+            await SourcePassage.bulk_hard_delete_async(db_session=session, identifiers=[p.id for p in passages], actor=actor)
+            return True
+
     @enforce_types
     @trace_method
     def size(
@@ -243,7 +428,7 @@ class PassageManager:
 
     @enforce_types
     @trace_method
-    def estimate_embeddings_size(
+    async def estimate_embeddings_size_async(
         self,
         actor: PydanticUser,
         agent_id: Optional[str] = None,
@@ -263,4 +448,17 @@ class PassageManager:
             raise ValueError(f"Invalid storage unit: {storage_unit}. Must be one of {list(BYTES_PER_STORAGE_UNIT.keys())}.")
         BYTES_PER_EMBEDDING_DIM = 4
         GB_PER_EMBEDDING = BYTES_PER_EMBEDDING_DIM / BYTES_PER_STORAGE_UNIT[storage_unit] * MAX_EMBEDDING_DIM
-        return self.size(actor=actor, agent_id=agent_id) * GB_PER_EMBEDDING
+        return await self.size_async(actor=actor, agent_id=agent_id) * GB_PER_EMBEDDING
+
+    @enforce_types
+    @trace_method
+    async def list_passages_by_file_id_async(self, file_id: str, actor: PydanticUser) -> List[PydanticPassage]:
+        """
+        List all source passages associated with a given file_id.
+        """
+        async with db_registry.async_session() as session:
+            result = await session.execute(
+                select(SourcePassage).where(SourcePassage.file_id == file_id).where(SourcePassage.organization_id == actor.organization_id)
+            )
+            passages = result.scalars().all()
+            return [p.to_pydantic() for p in passages]

letta/services/provider_manager.py

@@ -33,13 +33,34 @@ class ProviderManager:
             new_provider.create(session, actor=actor)
             return new_provider.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def create_provider_async(self, request: ProviderCreate, actor: PydanticUser) -> PydanticProvider:
+        """Create a new provider if it doesn't already exist."""
+        async with db_registry.async_session() as session:
+            provider_create_args = {**request.model_dump(), "provider_category": ProviderCategory.byok}
+            provider = PydanticProvider(**provider_create_args)
+
+            if provider.name == provider.provider_type.value:
+                raise ValueError("Provider name must be unique and different from provider type")
+
+            # Assign the organization id based on the actor
+            provider.organization_id = actor.organization_id
+
+            # Lazily create the provider id prior to persistence
+            provider.resolve_identifier()
+
+            new_provider = ProviderModel(**provider.model_dump(to_orm=True, exclude_unset=True))
+            await new_provider.create_async(session, actor=actor)
+            return new_provider.to_pydantic()
+
     @enforce_types
     @trace_method
     def update_provider(self, provider_id: str, provider_update: ProviderUpdate, actor: PydanticUser) -> PydanticProvider:
         """Update provider details."""
         with db_registry.session() as session:
             # Retrieve the existing provider by ID
-            existing_provider = ProviderModel.read(db_session=session, identifier=provider_id, actor=actor)
+            existing_provider = ProviderModel.read(db_session=session, identifier=provider_id, actor=actor, check_is_deleted=True)
 
             # Update only the fields that are provided in ProviderUpdate
             update_data = provider_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
@@ -56,7 +77,7 @@ class ProviderManager:
         """Delete a provider."""
         with db_registry.session() as session:
             # Clear api key field
-            existing_provider = ProviderModel.read(db_session=session, identifier=provider_id, actor=actor)
+            existing_provider = ProviderModel.read(db_session=session, identifier=provider_id, actor=actor, check_is_deleted=True)
             existing_provider.api_key = None
             existing_provider.update(session, actor=actor)
 
@@ -65,6 +86,23 @@ class ProviderManager:
 
             session.commit()
 
+    @enforce_types
+    @trace_method
+    async def delete_provider_by_id_async(self, provider_id: str, actor: PydanticUser):
+        """Delete a provider."""
+        async with db_registry.async_session() as session:
+            # Clear api key field
+            existing_provider = await ProviderModel.read_async(
+                db_session=session, identifier=provider_id, actor=actor, check_is_deleted=True
+            )
+            existing_provider.api_key = None
+            await existing_provider.update_async(session, actor=actor)
+
+            # Soft delete in provider table
+            await existing_provider.delete_async(session, actor=actor)
+
+            await session.commit()
+
     @enforce_types
     @trace_method
     def list_providers(
@@ -87,6 +125,7 @@ class ProviderManager:
                 after=after,
                 limit=limit,
                 actor=actor,
+                check_is_deleted=True,
                 **filter_kwargs,
             )
             return [provider.to_pydantic() for provider in providers]
@@ -113,6 +152,7 @@ class ProviderManager:
                 after=after,
                 limit=limit,
                 actor=actor,
+                check_is_deleted=True,
                 **filter_kwargs,
             )
             return [provider.to_pydantic() for provider in providers]
@@ -129,6 +169,12 @@ class ProviderManager:
         providers = self.list_providers(name=provider_name, actor=actor)
         return providers[0].api_key if providers else None
 
+    @enforce_types
+    @trace_method
+    async def get_override_key_async(self, provider_name: Union[str, None], actor: PydanticUser) -> Optional[str]:
+        providers = await self.list_providers_async(name=provider_name, actor=actor)
+        return providers[0].api_key if providers else None
+
     @enforce_types
     @trace_method
     def check_provider_api_key(self, provider_check: ProviderCheck) -> None: