letta-nightly 0.7.10.dev20250507104304__py3-none-any.whl → 0.7.12.dev20250508044425__py3-none-any.whl

letta/schemas/providers.py

@@ -2,14 +2,14 @@ import warnings
 from datetime import datetime
 from typing import List, Literal, Optional
 
-from pydantic import Field, model_validator
+from pydantic import BaseModel, Field, model_validator
 
 from letta.constants import LETTA_MODEL_ENDPOINT, LLM_MAX_TOKENS, MIN_CONTEXT_WINDOW
 from letta.llm_api.azure_openai import get_azure_chat_completions_endpoint, get_azure_embeddings_endpoint
 from letta.llm_api.azure_openai_constants import AZURE_MODEL_TO_CONTEXT_LENGTH
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.embedding_config_overrides import EMBEDDING_HANDLE_OVERRIDES
-from letta.schemas.enums import ProviderType
+from letta.schemas.enums import ProviderCategory, ProviderType
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.llm_config_overrides import LLM_HANDLE_OVERRIDES
@@ -24,6 +24,7 @@ class Provider(ProviderBase):
     id: Optional[str] = Field(None, description="The id of the provider, lazily created by the database manager.")
     name: str = Field(..., description="The name of the provider")
     provider_type: ProviderType = Field(..., description="The type of the provider")
+    provider_category: ProviderCategory = Field(..., description="The category of the provider (base or byok)")
     api_key: Optional[str] = Field(None, description="API key used for requests to the provider.")
     base_url: Optional[str] = Field(None, description="Base URL for the provider.")
     organization_id: Optional[str] = Field(None, description="The organization id of the user")
@@ -39,6 +40,10 @@ class Provider(ProviderBase):
         if not self.id:
             self.id = ProviderBase.generate_id(prefix=ProviderBase.__id_prefix__)
 
+    def check_api_key(self):
+        """Check if the API key is valid for the provider"""
+        raise NotImplementedError
+
     def list_llm_models(self) -> List[LLMConfig]:
         return []
 
@@ -111,8 +116,14 @@ class ProviderUpdate(ProviderBase):
     api_key: str = Field(..., description="API key used for requests to the provider.")
 
 
+class ProviderCheck(BaseModel):
+    provider_type: ProviderType = Field(..., description="The type of the provider.")
+    api_key: str = Field(..., description="API key used for requests to the provider.")
+
+
 class LettaProvider(Provider):
     provider_type: Literal[ProviderType.letta] = Field(ProviderType.letta, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
 
     def list_llm_models(self) -> List[LLMConfig]:
         return [
@@ -123,6 +134,7 @@ class LettaProvider(Provider):
                 context_window=8192,
                 handle=self.get_handle("letta-free"),
                 provider_name=self.name,
+                provider_category=self.provider_category,
             )
         ]
 
@@ -141,9 +153,15 @@ class LettaProvider(Provider):
 
 class OpenAIProvider(Provider):
     provider_type: Literal[ProviderType.openai] = Field(ProviderType.openai, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     api_key: str = Field(..., description="API key for the OpenAI API.")
     base_url: str = Field(..., description="Base URL for the OpenAI API.")
 
+    def check_api_key(self):
+        from letta.llm_api.openai import openai_check_valid_api_key
+
+        openai_check_valid_api_key(self.base_url, self.api_key)
+
     def list_llm_models(self) -> List[LLMConfig]:
         from letta.llm_api.openai import openai_get_model_list
 
@@ -225,6 +243,7 @@ class OpenAIProvider(Provider):
                     context_window=context_window_size,
                     handle=self.get_handle(model_name),
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
 
@@ -281,6 +300,7 @@ class DeepSeekProvider(OpenAIProvider):
     """
 
     provider_type: Literal[ProviderType.deepseek] = Field(ProviderType.deepseek, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     base_url: str = Field("https://api.deepseek.com/v1", description="Base URL for the DeepSeek API.")
     api_key: str = Field(..., description="API key for the DeepSeek API.")
 
@@ -332,6 +352,7 @@ class DeepSeekProvider(OpenAIProvider):
                     handle=self.get_handle(model_name),
                     put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
 
@@ -344,6 +365,7 @@ class DeepSeekProvider(OpenAIProvider):
 
 class LMStudioOpenAIProvider(OpenAIProvider):
     provider_type: Literal[ProviderType.lmstudio_openai] = Field(ProviderType.lmstudio_openai, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     base_url: str = Field(..., description="Base URL for the LMStudio OpenAI API.")
     api_key: Optional[str] = Field(None, description="API key for the LMStudio API.")
 
@@ -470,6 +492,7 @@ class XAIProvider(OpenAIProvider):
     """https://docs.x.ai/docs/api-reference"""
 
     provider_type: Literal[ProviderType.xai] = Field(ProviderType.xai, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     api_key: str = Field(..., description="API key for the xAI/Grok API.")
     base_url: str = Field("https://api.x.ai/v1", description="Base URL for the xAI/Grok API.")
 
@@ -523,6 +546,7 @@ class XAIProvider(OpenAIProvider):
                     context_window=context_window_size,
                     handle=self.get_handle(model_name),
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
 
@@ -535,9 +559,15 @@ class XAIProvider(OpenAIProvider):
 
 class AnthropicProvider(Provider):
     provider_type: Literal[ProviderType.anthropic] = Field(ProviderType.anthropic, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     api_key: str = Field(..., description="API key for the Anthropic API.")
     base_url: str = "https://api.anthropic.com/v1"
 
+    def check_api_key(self):
+        from letta.llm_api.anthropic import anthropic_check_valid_api_key
+
+        anthropic_check_valid_api_key(self.api_key)
+
     def list_llm_models(self) -> List[LLMConfig]:
         from letta.llm_api.anthropic import MODEL_LIST, anthropic_get_model_list
 
@@ -611,6 +641,7 @@ class AnthropicProvider(Provider):
                     put_inner_thoughts_in_kwargs=inner_thoughts_in_kwargs,
                     max_tokens=max_tokens,
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
         return configs
@@ -621,6 +652,7 @@ class AnthropicProvider(Provider):
 
 class MistralProvider(Provider):
     provider_type: Literal[ProviderType.mistral] = Field(ProviderType.mistral, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     api_key: str = Field(..., description="API key for the Mistral API.")
     base_url: str = "https://api.mistral.ai/v1"
 
@@ -645,6 +677,7 @@ class MistralProvider(Provider):
                         context_window=model["max_context_length"],
                         handle=self.get_handle(model["id"]),
                         provider_name=self.name,
+                        provider_category=self.provider_category,
                     )
                 )
 
@@ -672,6 +705,7 @@ class OllamaProvider(OpenAIProvider):
     """
 
     provider_type: Literal[ProviderType.ollama] = Field(ProviderType.ollama, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     base_url: str = Field(..., description="Base URL for the Ollama API.")
     api_key: Optional[str] = Field(None, description="API key for the Ollama API (default: `None`).")
     default_prompt_formatter: str = Field(
@@ -702,6 +736,7 @@ class OllamaProvider(OpenAIProvider):
                     context_window=context_window,
                     handle=self.get_handle(model["name"]),
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
         return configs
@@ -785,6 +820,7 @@ class OllamaProvider(OpenAIProvider):
 
 class GroqProvider(OpenAIProvider):
     provider_type: Literal[ProviderType.groq] = Field(ProviderType.groq, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     base_url: str = "https://api.groq.com/openai/v1"
     api_key: str = Field(..., description="API key for the Groq API.")
 
@@ -804,6 +840,7 @@ class GroqProvider(OpenAIProvider):
                     context_window=model["context_window"],
                     handle=self.get_handle(model["id"]),
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
         return configs
@@ -825,6 +862,7 @@ class TogetherProvider(OpenAIProvider):
     """
 
     provider_type: Literal[ProviderType.together] = Field(ProviderType.together, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     base_url: str = "https://api.together.ai/v1"
     api_key: str = Field(..., description="API key for the TogetherAI API.")
     default_prompt_formatter: str = Field(..., description="Default prompt formatter (aka model wrapper) to use on vLLM /completions API.")
@@ -873,6 +911,7 @@ class TogetherProvider(OpenAIProvider):
                     context_window=context_window_size,
                     handle=self.get_handle(model_name),
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
 
@@ -927,9 +966,15 @@ class TogetherProvider(OpenAIProvider):
 class GoogleAIProvider(Provider):
     # gemini
     provider_type: Literal[ProviderType.google_ai] = Field(ProviderType.google_ai, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     api_key: str = Field(..., description="API key for the Google AI API.")
     base_url: str = "https://generativelanguage.googleapis.com"
 
+    def check_api_key(self):
+        from letta.llm_api.google_ai_client import google_ai_check_valid_api_key
+
+        google_ai_check_valid_api_key(self.api_key)
+
     def list_llm_models(self):
         from letta.llm_api.google_ai_client import google_ai_get_model_list
 
@@ -955,6 +1000,7 @@ class GoogleAIProvider(Provider):
                     handle=self.get_handle(model),
                     max_tokens=8192,
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
         return configs
@@ -991,6 +1037,7 @@ class GoogleAIProvider(Provider):
 
 class GoogleVertexProvider(Provider):
     provider_type: Literal[ProviderType.google_vertex] = Field(ProviderType.google_vertex, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     google_cloud_project: str = Field(..., description="GCP project ID for the Google Vertex API.")
     google_cloud_location: str = Field(..., description="GCP region for the Google Vertex API.")
 
@@ -1008,6 +1055,7 @@ class GoogleVertexProvider(Provider):
                     handle=self.get_handle(model),
                     max_tokens=8192,
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
         return configs
@@ -1032,6 +1080,7 @@ class GoogleVertexProvider(Provider):
 
 class AzureProvider(Provider):
     provider_type: Literal[ProviderType.azure] = Field(ProviderType.azure, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     latest_api_version: str = "2024-09-01-preview"  # https://learn.microsoft.com/en-us/azure/ai-services/openai/api-version-deprecation
     base_url: str = Field(
         ..., description="Base URL for the Azure API endpoint. This should be specific to your org, e.g. `https://letta.openai.azure.com`."
@@ -1065,6 +1114,7 @@ class AzureProvider(Provider):
                     context_window=context_window_size,
                     handle=self.get_handle(model_name),
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 ),
             )
         return configs
@@ -1106,6 +1156,7 @@ class VLLMChatCompletionsProvider(Provider):
 
     # NOTE: vLLM only serves one model at a time (so could configure that through env variables)
     provider_type: Literal[ProviderType.vllm] = Field(ProviderType.vllm, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     base_url: str = Field(..., description="Base URL for the vLLM API.")
 
     def list_llm_models(self) -> List[LLMConfig]:
@@ -1125,6 +1176,7 @@ class VLLMChatCompletionsProvider(Provider):
                     context_window=model["max_model_len"],
                     handle=self.get_handle(model["id"]),
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
         return configs
@@ -1139,6 +1191,7 @@ class VLLMCompletionsProvider(Provider):
 
     # NOTE: vLLM only serves one model at a time (so could configure that through env variables)
     provider_type: Literal[ProviderType.vllm] = Field(ProviderType.vllm, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     base_url: str = Field(..., description="Base URL for the vLLM API.")
     default_prompt_formatter: str = Field(..., description="Default prompt formatter (aka model wrapper) to use on vLLM /completions API.")
 
@@ -1159,6 +1212,7 @@ class VLLMCompletionsProvider(Provider):
                     context_window=model["max_model_len"],
                     handle=self.get_handle(model["id"]),
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
         return configs
@@ -1174,6 +1228,7 @@ class CohereProvider(OpenAIProvider):
 
 class AnthropicBedrockProvider(Provider):
     provider_type: Literal[ProviderType.bedrock] = Field(ProviderType.bedrock, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     aws_region: str = Field(..., description="AWS region for Bedrock")
 
     def list_llm_models(self):
@@ -1192,6 +1247,7 @@ class AnthropicBedrockProvider(Provider):
                     context_window=self.get_model_context_window(model_arn),
                     handle=self.get_handle(model_arn),
                     provider_name=self.name,
+                    provider_category=self.provider_category,
                 )
             )
         return configs

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

@@ -631,12 +631,17 @@ async def send_message(
     # TODO: This is redundant, remove soon
     agent = server.agent_manager.get_agent_by_id(agent_id, actor)
 
-    if (
+    if all(
+        (
+            settings.use_experimental,
+            not agent.enable_sleeptime,
+            not agent.multi_agent_group,
+            not agent.agent_type == AgentType.sleeptime_agent,
+        )
+    ) and (
+        # LLM Model Check: (1) Anthropic or (2) Google Vertex + Flag
         agent.llm_config.model_endpoint_type == "anthropic"
-        and not agent.enable_sleeptime
-        and not agent.multi_agent_group
-        and not agent.agent_type == AgentType.sleeptime_agent
-        and settings.use_experimental
+        or (agent.llm_config.model_endpoint_type == "google_vertex" and settings.use_vertex_async_loop_experimental)
     ):
         experimental_agent = LettaAgent(
             agent_id=agent_id,

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

@@ -1,8 +1,9 @@
 from typing import TYPE_CHECKING, List, Optional
 
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Depends, Header, Query
 
 from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import ProviderCategory, ProviderType
 from letta.schemas.llm_config import LLMConfig
 from letta.server.rest_api.utils import get_letta_server
 
@@ -14,11 +15,19 @@ router = APIRouter(prefix="/models", tags=["models", "llms"])
 
 @router.get("/", response_model=List[LLMConfig], operation_id="list_models")
 def list_llm_models(
-    byok_only: Optional[bool] = Query(None),
+    provider_category: Optional[List[ProviderCategory]] = Query(None),
+    provider_name: Optional[str] = Query(None),
+    provider_type: Optional[ProviderType] = Query(None),
     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
 ):
-
-    models = server.list_llm_models(byok_only=byok_only)
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    models = server.list_llm_models(
+        provider_category=provider_category,
+        provider_name=provider_name,
+        provider_type=provider_type,
+        actor=actor,
+    )
     # print(models)
     return models
 
@@ -26,8 +35,9 @@ def list_llm_models(
 @router.get("/embedding", response_model=List[EmbeddingConfig], operation_id="list_embedding_models")
 def list_embedding_models(
     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
 ):
-
-    models = server.list_embedding_models()
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    models = server.list_embedding_models(actor=actor)
     # print(models)
     return models

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

@@ -1,9 +1,12 @@
 from typing import TYPE_CHECKING, List, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, status
+from fastapi.responses import JSONResponse
 
+from letta.errors import LLMAuthenticationError
+from letta.orm.errors import NoResultFound
 from letta.schemas.enums import ProviderType
-from letta.schemas.providers import Provider, ProviderCreate, ProviderUpdate
+from letta.schemas.providers import Provider, ProviderCheck, ProviderCreate, ProviderUpdate
 from letta.server.rest_api.utils import get_letta_server
 
 if TYPE_CHECKING:
@@ -45,7 +48,8 @@ def create_provider(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
-    provider = Provider(**request.model_dump())
+    provider = ProviderCreate(**request.model_dump())
+
     provider = server.provider_manager.create_provider(provider, actor=actor)
     return provider
 
@@ -61,7 +65,23 @@ def modify_provider(
     Update an existing custom provider
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.provider_manager.update_provider(provider_id=provider_id, request=request, actor=actor)
+    return server.provider_manager.update_provider(provider_id=provider_id, provider_update=request, actor=actor)
+
+
+@router.get("/check", response_model=None, operation_id="check_provider")
+def check_provider(
+    provider_type: ProviderType = Query(...),
+    api_key: str = Header(..., alias="x-api-key"),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    try:
+        provider_check = ProviderCheck(provider_type=provider_type, api_key=api_key)
+        server.provider_manager.check_provider_api_key(provider_check=provider_check)
+        return JSONResponse(status_code=status.HTTP_200_OK, content={"message": f"Valid api key for provider_type={provider_type.value}"})
+    except LLMAuthenticationError as e:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=f"{e.message}")
+    except Exception as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"{e}")
 
 
 @router.delete("/{provider_id}", response_model=None, operation_id="delete_provider")

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

@@ -106,6 +106,7 @@ def create_source(
         source_create.embedding_config = server.get_embedding_config_from_handle(
             handle=source_create.embedding,
             embedding_chunk_size=source_create.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE,
+            actor=actor,
         )
     source = Source(
         name=source_create.name,

letta/server/server.py

@@ -42,7 +42,7 @@ from letta.schemas.block import Block, BlockUpdate, CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 
 # openai schemas
-from letta.schemas.enums import JobStatus, MessageStreamStatus
+from letta.schemas.enums import JobStatus, MessageStreamStatus, ProviderCategory, ProviderType
 from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate
 from letta.schemas.group import GroupCreate, ManagerType, SleeptimeManager, VoiceSleeptimeManager
 from letta.schemas.job import Job, JobUpdate
@@ -734,17 +734,17 @@ class SyncServer(Server):
         return self._command(user_id=user_id, agent_id=agent_id, command=command)
 
     @trace_method
-    def get_cached_llm_config(self, **kwargs):
+    def get_cached_llm_config(self, actor: User, **kwargs):
         key = make_key(**kwargs)
         if key not in self._llm_config_cache:
-            self._llm_config_cache[key] = self.get_llm_config_from_handle(**kwargs)
+            self._llm_config_cache[key] = self.get_llm_config_from_handle(actor=actor, **kwargs)
         return self._llm_config_cache[key]
 
     @trace_method
-    def get_cached_embedding_config(self, **kwargs):
+    def get_cached_embedding_config(self, actor: User, **kwargs):
         key = make_key(**kwargs)
         if key not in self._embedding_config_cache:
-            self._embedding_config_cache[key] = self.get_embedding_config_from_handle(**kwargs)
+            self._embedding_config_cache[key] = self.get_embedding_config_from_handle(actor=actor, **kwargs)
         return self._embedding_config_cache[key]
 
     @trace_method
@@ -766,7 +766,7 @@ class SyncServer(Server):
                 "enable_reasoner": request.enable_reasoner,
             }
             log_event(name="start get_cached_llm_config", attributes=config_params)
-            request.llm_config = self.get_cached_llm_config(**config_params)
+            request.llm_config = self.get_cached_llm_config(actor=actor, **config_params)
             log_event(name="end get_cached_llm_config", attributes=config_params)
 
         if request.embedding_config is None:
@@ -777,7 +777,7 @@ class SyncServer(Server):
                 "embedding_chunk_size": request.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE,
             }
             log_event(name="start get_cached_embedding_config", attributes=embedding_config_params)
-            request.embedding_config = self.get_cached_embedding_config(**embedding_config_params)
+            request.embedding_config = self.get_cached_embedding_config(actor=actor, **embedding_config_params)
             log_event(name="end get_cached_embedding_config", attributes=embedding_config_params)
 
         log_event(name="start create_agent db")
@@ -802,10 +802,10 @@ class SyncServer(Server):
         actor: User,
     ) -> AgentState:
         if request.model is not None:
-            request.llm_config = self.get_llm_config_from_handle(handle=request.model)
+            request.llm_config = self.get_llm_config_from_handle(handle=request.model, actor=actor)
 
         if request.embedding is not None:
-            request.embedding_config = self.get_embedding_config_from_handle(handle=request.embedding)
+            request.embedding_config = self.get_embedding_config_from_handle(handle=request.embedding, actor=actor)
 
         if request.enable_sleeptime:
             agent = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
@@ -1201,10 +1201,21 @@ class SyncServer(Server):
         except NoResultFound:
             raise HTTPException(status_code=404, detail=f"Organization with id {org_id} not found")
 
-    def list_llm_models(self, byok_only: bool = False) -> List[LLMConfig]:
+    def list_llm_models(
+        self,
+        actor: User,
+        provider_category: Optional[List[ProviderCategory]] = None,
+        provider_name: Optional[str] = None,
+        provider_type: Optional[ProviderType] = None,
+    ) -> List[LLMConfig]:
         """List available models"""
         llm_models = []
-        for provider in self.get_enabled_providers(byok_only=byok_only):
+        for provider in self.get_enabled_providers(
+            provider_category=provider_category,
+            provider_name=provider_name,
+            provider_type=provider_type,
+            actor=actor,
+        ):
             try:
                 llm_models.extend(provider.list_llm_models())
             except Exception as e:
@@ -1214,26 +1225,49 @@ class SyncServer(Server):
 
         return llm_models
 
-    def list_embedding_models(self) -> List[EmbeddingConfig]:
+    def list_embedding_models(self, actor: User) -> List[EmbeddingConfig]:
         """List available embedding models"""
         embedding_models = []
-        for provider in self.get_enabled_providers():
+        for provider in self.get_enabled_providers(actor):
             try:
                 embedding_models.extend(provider.list_embedding_models())
             except Exception as e:
                 warnings.warn(f"An error occurred while listing embedding models for provider {provider}: {e}")
         return embedding_models
 
-    def get_enabled_providers(self, byok_only: bool = False):
-        providers_from_db = {p.name: p.cast_to_subtype() for p in self.provider_manager.list_providers()}
-        if byok_only:
-            return list(providers_from_db.values())
-        providers_from_env = {p.name: p for p in self._enabled_providers}
-        return list(providers_from_env.values()) + list(providers_from_db.values())
+    def get_enabled_providers(
+        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 = self.provider_manager.list_providers(
+                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,
+        actor: User,
         handle: str,
         context_window_limit: Optional[int] = None,
         max_tokens: Optional[int] = None,
@@ -1242,7 +1276,7 @@ class SyncServer(Server):
     ) -> LLMConfig:
         try:
             provider_name, model_name = handle.split("/", 1)
-            provider = self.get_provider_from_name(provider_name)
+            provider = self.get_provider_from_name(provider_name, actor)
 
             llm_configs = [config for config in provider.list_llm_models() if config.handle == handle]
             if not llm_configs:
@@ -1286,11 +1320,11 @@ class SyncServer(Server):
 
     @trace_method
     def get_embedding_config_from_handle(
-        self, handle: str, embedding_chunk_size: int = constants.DEFAULT_EMBEDDING_CHUNK_SIZE
+        self, actor: User, handle: str, embedding_chunk_size: int = constants.DEFAULT_EMBEDDING_CHUNK_SIZE
     ) -> EmbeddingConfig:
         try:
             provider_name, model_name = handle.split("/", 1)
-            provider = self.get_provider_from_name(provider_name)
+            provider = self.get_provider_from_name(provider_name, actor)
 
             embedding_configs = [config for config in provider.list_embedding_models() if config.handle == handle]
             if not embedding_configs:
@@ -1313,8 +1347,8 @@ class SyncServer(Server):
 
         return embedding_config
 
-    def get_provider_from_name(self, provider_name: str) -> Provider:
-        providers = [provider for provider in self.get_enabled_providers() if provider.name == provider_name]
+    def get_provider_from_name(self, provider_name: str, actor: User) -> Provider:
+        providers = [provider for provider in self.get_enabled_providers(actor) if provider.name == provider_name]
         if not providers:
             raise ValueError(f"Provider {provider_name} is not supported")
         elif len(providers) > 1: