letta-nightly 0.7.10.dev20250507104304__py3-none-any.whl → 0.7.11.dev20250507230415__py3-none-any.whl

letta/schemas/providers.py

@@ -9,7 +9,7 @@ from letta.llm_api.azure_openai import get_azure_chat_completions_endpoint, get_
 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")
@@ -113,6 +114,7 @@ class ProviderUpdate(ProviderBase):
 
 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 +125,7 @@ class LettaProvider(Provider):
                 context_window=8192,
                 handle=self.get_handle("letta-free"),
                 provider_name=self.name,
+                provider_category=self.provider_category,
             )
         ]
 
@@ -141,6 +144,7 @@ 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.")
 
@@ -225,6 +229,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 +286,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 +338,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 +351,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 +478,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 +532,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,6 +545,7 @@ 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"
 
@@ -611,6 +622,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 +633,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 +658,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 +686,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 +717,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 +801,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 +821,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 +843,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 +892,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,6 +947,7 @@ 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"
 
@@ -955,6 +976,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 +1013,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 +1031,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 +1056,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 +1090,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 +1132,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 +1152,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 +1167,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 +1188,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 +1204,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 +1223,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,7 +1,9 @@
 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.orm.errors import NoResultFound
 from letta.schemas.enums import ProviderType
 from letta.schemas.providers import Provider, ProviderCreate, ProviderUpdate
 from letta.server.rest_api.utils import get_letta_server

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:

letta/services/provider_manager.py

@@ -1,9 +1,9 @@
 from typing import List, Optional, Union
 
 from letta.orm.provider import Provider as ProviderModel
-from letta.schemas.enums import ProviderType
+from letta.schemas.enums import ProviderCategory, ProviderType
 from letta.schemas.providers import Provider as PydanticProvider
-from letta.schemas.providers import ProviderUpdate
+from letta.schemas.providers import ProviderCreate, ProviderUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types
 
@@ -16,9 +16,12 @@ class ProviderManager:
         self.session_maker = db_context
 
     @enforce_types
-    def create_provider(self, provider: PydanticProvider, actor: PydanticUser) -> PydanticProvider:
+    def create_provider(self, request: ProviderCreate, actor: PydanticUser) -> PydanticProvider:
         """Create a new provider if it doesn't already exist."""
         with self.session_maker() 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")
 
@@ -65,11 +68,11 @@ class ProviderManager:
     @enforce_types
     def list_providers(
         self,
+        actor: PydanticUser,
         name: Optional[str] = None,
         provider_type: Optional[ProviderType] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 50,
-        actor: PydanticUser = None,
     ) -> List[PydanticProvider]:
         """List all providers with optional pagination."""
         filter_kwargs = {}
@@ -88,11 +91,11 @@ class ProviderManager:
             return [provider.to_pydantic() for provider in providers]
 
     @enforce_types
-    def get_provider_id_from_name(self, provider_name: Union[str, None]) -> Optional[str]:
-        providers = self.list_providers(name=provider_name)
+    def get_provider_id_from_name(self, provider_name: Union[str, None], actor: PydanticUser) -> Optional[str]:
+        providers = self.list_providers(name=provider_name, actor=actor)
         return providers[0].id if providers else None
 
     @enforce_types
-    def get_override_key(self, provider_name: Union[str, None]) -> Optional[str]:
-        providers = self.list_providers(name=provider_name)
+    def get_override_key(self, provider_name: Union[str, None], actor: PydanticUser) -> Optional[str]:
+        providers = self.list_providers(name=provider_name, actor=actor)
         return providers[0].api_key if providers else None

letta/settings.py

@@ -195,6 +195,8 @@ class Settings(BaseSettings):
 
     # experimental toggle
     use_experimental: bool = False
+    use_vertex_structured_outputs_experimental: bool = False
+    use_vertex_async_loop_experimental: bool = False
 
     # LLM provider client settings
     httpx_max_retries: int = 5

{letta_nightly-0.7.10.dev20250507104304.dist-info → letta_nightly-0.7.11.dev20250507230415.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.10.dev20250507104304
+Version: 0.7.11.dev20250507230415
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team