letta-nightly 0.8.17.dev20250723104501__py3-none-any.whl → 0.9.0.dev20250724081419__py3-none-any.whl

letta/schemas/providers/anthropic.py

@@ -0,0 +1,78 @@
+import warnings
+from typing import Literal
+
+from pydantic import Field
+
+from letta.schemas.enums import ProviderCategory, ProviderType
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.providers.base import Provider
+
+
+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"
+
+    async def check_api_key(self):
+        from letta.llm_api.anthropic import anthropic_check_valid_api_key
+
+        anthropic_check_valid_api_key(self.api_key)
+
+    async def list_llm_models_async(self) -> list[LLMConfig]:
+        from letta.llm_api.anthropic import anthropic_get_model_list_async
+
+        models = await anthropic_get_model_list_async(api_key=self.api_key)
+        return self._list_llm_models(models)
+
+    def _list_llm_models(self, models) -> list[LLMConfig]:
+        from letta.llm_api.anthropic import MODEL_LIST
+
+        configs = []
+        for model in models:
+            if any((model.get("type") != "model", "id" not in model, model.get("id").startswith("claude-2"))):
+                continue
+
+            # Anthropic doesn't return the context window in their API
+            if "context_window" not in model:
+                # Remap list to name: context_window
+                model_library = {m["name"]: m["context_window"] for m in MODEL_LIST}
+                # Attempt to look it up in a hardcoded list
+                if model["id"] in model_library:
+                    model["context_window"] = model_library[model["id"]]
+                else:
+                    # On fallback, we can set 200k (generally safe), but we should warn the user
+                    warnings.warn(f"Couldn't find context window size for model {model['id']}, defaulting to 200,000")
+                    model["context_window"] = 200000
+
+            max_tokens = 8192
+            if "claude-3-opus" in model["id"]:
+                max_tokens = 4096
+            if "claude-3-haiku" in model["id"]:
+                max_tokens = 4096
+            # TODO: set for 3-7 extended thinking mode
+
+            # NOTE: from 2025-02
+            # We set this to false by default, because Anthropic can
+            # natively support <thinking> tags inside of content fields
+            # However, putting COT inside of tool calls can make it more
+            # reliable for tool calling (no chance of a non-tool call step)
+            # Since tool_choice_type 'any' doesn't work with in-content COT
+            # NOTE For Haiku, it can be flaky if we don't enable this by default
+            # inner_thoughts_in_kwargs = True if "haiku" in model["id"] else False
+            inner_thoughts_in_kwargs = True  # we no longer support thinking tags
+
+            configs.append(
+                LLMConfig(
+                    model=model["id"],
+                    model_endpoint_type="anthropic",
+                    model_endpoint=self.base_url,
+                    context_window=model["context_window"],
+                    handle=self.get_handle(model["id"]),
+                    put_inner_thoughts_in_kwargs=inner_thoughts_in_kwargs,
+                    max_tokens=max_tokens,
+                    provider_name=self.name,
+                    provider_category=self.provider_category,
+                )
+            )
+        return configs

letta/schemas/providers/azure.py

@@ -0,0 +1,80 @@
+from typing import ClassVar, Literal
+
+from pydantic import Field, field_validator
+
+from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE, LLM_MAX_TOKENS
+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.enums import ProviderCategory, ProviderType
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.providers.base import Provider
+
+
+class AzureProvider(Provider):
+    LATEST_API_VERSION: ClassVar[str] = "2024-09-01-preview"
+
+    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)")
+    # Note: 2024-09-01-preview was set here until 2025-07-16.
+    # set manually, see: https://learn.microsoft.com/en-us/azure/ai-services/openai/api-version-deprecation
+    latest_api_version: str = "2025-04-01-preview"
+    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`."
+    )
+    api_key: str = Field(..., description="API key for the Azure API.")
+    api_version: str = Field(default=LATEST_API_VERSION, description="API version for the Azure API")
+
+    @field_validator("api_version", mode="before")
+    def replace_none_with_default(cls, v):
+        return v if v is not None else cls.LATEST_API_VERSION
+
+    async def list_llm_models_async(self) -> list[LLMConfig]:
+        # TODO (cliandy): asyncify
+        from letta.llm_api.azure_openai import azure_openai_get_chat_completion_model_list
+
+        model_options = azure_openai_get_chat_completion_model_list(self.base_url, api_key=self.api_key, api_version=self.api_version)
+        configs = []
+        for model_option in model_options:
+            model_name = model_option["id"]
+            context_window_size = self.get_model_context_window(model_name)
+            model_endpoint = get_azure_chat_completions_endpoint(self.base_url, model_name, self.api_version)
+            configs.append(
+                LLMConfig(
+                    model=model_name,
+                    model_endpoint_type="azure",
+                    model_endpoint=model_endpoint,
+                    context_window=context_window_size,
+                    handle=self.get_handle(model_name),
+                    provider_name=self.name,
+                    provider_category=self.provider_category,
+                )
+            )
+        return configs
+
+    async def list_embedding_models_async(self) -> list[EmbeddingConfig]:
+        # TODO (cliandy): asyncify dependent function calls
+        from letta.llm_api.azure_openai import azure_openai_get_embeddings_model_list
+
+        model_options = azure_openai_get_embeddings_model_list(self.base_url, api_key=self.api_key, api_version=self.api_version)
+        configs = []
+        for model_option in model_options:
+            model_name = model_option["id"]
+            model_endpoint = get_azure_embeddings_endpoint(self.base_url, model_name, self.api_version)
+            configs.append(
+                EmbeddingConfig(
+                    embedding_model=model_name,
+                    embedding_endpoint_type="azure",
+                    embedding_endpoint=model_endpoint,
+                    embedding_dim=768,  # TODO generated 1536?
+                    embedding_chunk_size=DEFAULT_EMBEDDING_CHUNK_SIZE,  # old note: max is 2048
+                    handle=self.get_handle(model_name, is_embedding=True),
+                    batch_size=1024,
+                )
+            )
+        return configs
+
+    def get_model_context_window(self, model_name: str) -> int | None:
+        # Hard coded as there are no API endpoints for this
+        llm_default = LLM_MAX_TOKENS.get(model_name, 4096)
+        return AZURE_MODEL_TO_CONTEXT_LENGTH.get(model_name, llm_default)

letta/schemas/providers/base.py

@@ -0,0 +1,201 @@
+from datetime import datetime
+
+from pydantic import BaseModel, Field, model_validator
+
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.embedding_config_overrides import EMBEDDING_HANDLE_OVERRIDES
+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
+from letta.settings import model_settings
+
+
+class ProviderBase(LettaBase):
+    __id_prefix__ = "provider"
+
+
+class Provider(ProviderBase):
+    id: str | None = 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: str | None = Field(None, description="API key or secret key used for requests to the provider.")
+    base_url: str | None = Field(None, description="Base URL for the provider.")
+    access_key: str | None = Field(None, description="Access key used for requests to the provider.")
+    region: str | None = Field(None, description="Region used for requests to the provider.")
+    organization_id: str | None = Field(None, description="The organization id of the user")
+    updated_at: datetime | None = Field(None, description="The last update timestamp of the provider.")
+
+    @model_validator(mode="after")
+    def default_base_url(self):
+        if self.provider_type == ProviderType.openai and self.base_url is None:
+            self.base_url = model_settings.openai_api_base
+        return self
+
+    def resolve_identifier(self):
+        if not self.id:
+            self.id = ProviderBase.generate_id(prefix=ProviderBase.__id_prefix__)
+
+    async def check_api_key(self):
+        """Check if the API key is valid for the provider"""
+        raise NotImplementedError
+
+    def list_llm_models(self) -> list[LLMConfig]:
+        """List available LLM models (deprecated: use list_llm_models_async)"""
+        import asyncio
+        import warnings
+
+        warnings.warn("list_llm_models is deprecated, use list_llm_models_async instead", DeprecationWarning, stacklevel=2)
+
+        # Simplified asyncio handling - just use asyncio.run()
+        # This works in most contexts and avoids complex event loop detection
+        try:
+            return asyncio.run(self.list_llm_models_async())
+        except RuntimeError as e:
+            # If we're in an active event loop context, use a thread pool
+            if "cannot be called from a running event loop" in str(e):
+                import concurrent.futures
+
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(asyncio.run, self.list_llm_models_async())
+                    return future.result()
+            else:
+                raise
+
+    async def list_llm_models_async(self) -> list[LLMConfig]:
+        return []
+
+    def list_embedding_models(self) -> list[EmbeddingConfig]:
+        """List available embedding models (deprecated: use list_embedding_models_async)"""
+        import asyncio
+        import warnings
+
+        warnings.warn("list_embedding_models is deprecated, use list_embedding_models_async instead", DeprecationWarning, stacklevel=2)
+
+        # Simplified asyncio handling - just use asyncio.run()
+        # This works in most contexts and avoids complex event loop detection
+        try:
+            return asyncio.run(self.list_embedding_models_async())
+        except RuntimeError as e:
+            # If we're in an active event loop context, use a thread pool
+            if "cannot be called from a running event loop" in str(e):
+                import concurrent.futures
+
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(asyncio.run, self.list_embedding_models_async())
+                    return future.result()
+            else:
+                raise
+
+    async def list_embedding_models_async(self) -> list[EmbeddingConfig]:
+        """List available embedding models. The following do not have support for embedding models:
+        Anthropic, Bedrock, Cerebras, Deepseek, Groq, Mistral, xAI
+        """
+        return []
+
+    def get_model_context_window(self, model_name: str) -> int | None:
+        raise NotImplementedError
+
+    async def get_model_context_window_async(self, model_name: str) -> int | None:
+        raise NotImplementedError
+
+    def get_handle(self, model_name: str, is_embedding: bool = False, base_name: str | None = None) -> str:
+        """
+        Get the handle for a model, with support for custom overrides.
+
+        Args:
+            model_name (str): The name of the model.
+            is_embedding (bool, optional): Whether the handle is for an embedding model. Defaults to False.
+
+        Returns:
+            str: The handle for the model.
+        """
+        base_name = base_name if base_name else self.name
+
+        overrides = EMBEDDING_HANDLE_OVERRIDES if is_embedding else LLM_HANDLE_OVERRIDES
+        if base_name in overrides and model_name in overrides[base_name]:
+            model_name = overrides[base_name][model_name]
+
+        return f"{base_name}/{model_name}"
+
+    def cast_to_subtype(self):
+        # Import here to avoid circular imports
+        from letta.schemas.providers import (
+            AnthropicProvider,
+            AzureProvider,
+            BedrockProvider,
+            CerebrasProvider,
+            CohereProvider,
+            DeepSeekProvider,
+            GoogleAIProvider,
+            GoogleVertexProvider,
+            GroqProvider,
+            LettaProvider,
+            LMStudioOpenAIProvider,
+            MistralProvider,
+            OllamaProvider,
+            OpenAIProvider,
+            TogetherProvider,
+            VLLMProvider,
+            XAIProvider,
+        )
+
+        match self.provider_type:
+            case ProviderType.letta:
+                return LettaProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.openai:
+                return OpenAIProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.anthropic:
+                return AnthropicProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.google_ai:
+                return GoogleAIProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.google_vertex:
+                return GoogleVertexProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.azure:
+                return AzureProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.groq:
+                return GroqProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.together:
+                return TogetherProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.ollama:
+                return OllamaProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.vllm:
+                return VLLMProvider(**self.model_dump(exclude_none=True))  # Removed support for CompletionsProvider
+            case ProviderType.mistral:
+                return MistralProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.deepseek:
+                return DeepSeekProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.cerebras:
+                return CerebrasProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.xai:
+                return XAIProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.lmstudio_openai:
+                return LMStudioOpenAIProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.bedrock:
+                return BedrockProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.cohere:
+                return CohereProvider(**self.model_dump(exclude_none=True))
+            case _:
+                raise ValueError(f"Unknown provider type: {self.provider_type}")
+
+
+class ProviderCreate(ProviderBase):
+    name: str = Field(..., description="The name of the provider.")
+    provider_type: ProviderType = Field(..., description="The type of the provider.")
+    api_key: str = Field(..., description="API key or secret key used for requests to the provider.")
+    access_key: str | None = Field(None, description="Access key used for requests to the provider.")
+    region: str | None = Field(None, description="Region used for requests to the provider.")
+
+
+class ProviderUpdate(ProviderBase):
+    api_key: str = Field(..., description="API key or secret key used for requests to the provider.")
+    access_key: str | None = Field(None, description="Access key used for requests to the provider.")
+    region: str | None = Field(None, description="Region 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 or secret key used for requests to the provider.")
+    access_key: str | None = Field(None, description="Access key used for requests to the provider.")
+    region: str | None = Field(None, description="Region used for requests to the provider.")

letta/schemas/providers/bedrock.py

@@ -0,0 +1,78 @@
+"""
+Note that this formally only supports Anthropic Bedrock.
+TODO (cliandy): determine what other providers are supported and what is needed to add support.
+"""
+
+from typing import Literal
+
+from pydantic import Field
+
+from letta.log import get_logger
+from letta.schemas.enums import ProviderCategory, ProviderType
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.providers.base import Provider
+
+logger = get_logger(__name__)
+
+
+class BedrockProvider(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)")
+    region: str = Field(..., description="AWS region for Bedrock")
+
+    async def check_api_key(self):
+        """Check if the Bedrock credentials are valid"""
+        from letta.errors import LLMAuthenticationError
+        from letta.llm_api.aws_bedrock import bedrock_get_model_list_async
+
+        try:
+            # For BYOK providers, use the custom credentials
+            if self.provider_category == ProviderCategory.byok:
+                # If we can list models, the credentials are valid
+                await bedrock_get_model_list_async(
+                    access_key_id=self.access_key,
+                    secret_access_key=self.api_key,  # api_key stores the secret access key
+                    region_name=self.region,
+                )
+            else:
+                # For base providers, use default credentials
+                bedrock_get_model_list(region_name=self.region)
+        except Exception as e:
+            raise LLMAuthenticationError(message=f"Failed to authenticate with Bedrock: {e}")
+
+    async def list_llm_models_async(self) -> list[LLMConfig]:
+        from letta.llm_api.aws_bedrock import bedrock_get_model_list_async
+
+        models = await bedrock_get_model_list_async(
+            self.access_key,
+            self.api_key,
+            self.region,
+        )
+
+        configs = []
+        for model_summary in models:
+            model_arn = model_summary["inferenceProfileArn"]
+            configs.append(
+                LLMConfig(
+                    model=model_arn,
+                    model_endpoint_type=self.provider_type.value,
+                    model_endpoint=None,
+                    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
+
+    def get_model_context_window(self, model_name: str) -> int | None:
+        # Context windows for Claude models
+        from letta.llm_api.aws_bedrock import bedrock_get_model_context_window
+
+        return bedrock_get_model_context_window(model_name)
+
+    def get_handle(self, model_name: str, is_embedding: bool = False, base_name: str | None = None) -> str:
+        logger.debug("Getting handle for model_name: %s", model_name)
+        model = model_name.split(".")[-1]
+        return f"{self.name}/{model}"

letta/schemas/providers/cerebras.py

@@ -0,0 +1,79 @@
+import warnings
+from typing import Literal
+
+from pydantic import Field
+
+from letta.schemas.enums import ProviderCategory, ProviderType
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.providers.openai import OpenAIProvider
+
+
+class CerebrasProvider(OpenAIProvider):
+    """
+    Cerebras Inference API is OpenAI-compatible and focuses on ultra-fast inference.
+
+    Available Models (as of 2025):
+    - llama-4-scout-17b-16e-instruct: Llama 4 Scout (109B params, 10M context, ~2600 tokens/s)
+    - llama3.1-8b: Llama 3.1 8B (8B params, 128K context, ~2200 tokens/s)
+    - llama-3.3-70b: Llama 3.3 70B (70B params, 128K context, ~2100 tokens/s)
+    - qwen-3-32b: Qwen 3 32B (32B params, 131K context, ~2100 tokens/s)
+    - deepseek-r1-distill-llama-70b: DeepSeek R1 Distill (70B params, 128K context, ~1700 tokens/s)
+    """
+
+    provider_type: Literal[ProviderType.cerebras] = Field(ProviderType.cerebras, 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.cerebras.ai/v1", description="Base URL for the Cerebras API.")
+    api_key: str = Field(..., description="API key for the Cerebras API.")
+
+    def get_model_context_window_size(self, model_name: str) -> int | None:
+        """Cerebras has limited context window sizes.
+
+        see https://inference-docs.cerebras.ai/support/pricing for details by plan
+        """
+        is_free_tier = True
+        if is_free_tier:
+            return 8192
+        return 128000
+
+    async def list_llm_models_async(self) -> list[LLMConfig]:
+        from letta.llm_api.openai import openai_get_model_list_async
+
+        response = await openai_get_model_list_async(self.base_url, api_key=self.api_key)
+
+        if "data" in response:
+            data = response["data"]
+        else:
+            data = response
+
+        configs = []
+        for model in data:
+            assert "id" in model, f"Cerebras model missing 'id' field: {model}"
+            model_name = model["id"]
+
+            # Check if model has context_length in response
+            if "context_length" in model:
+                context_window_size = model["context_length"]
+            else:
+                context_window_size = self.get_model_context_window_size(model_name)
+
+            if not context_window_size:
+                warnings.warn(f"Couldn't find context window size for model {model_name}")
+                continue
+
+            # Cerebras supports function calling
+            put_inner_thoughts_in_kwargs = True
+
+            configs.append(
+                LLMConfig(
+                    model=model_name,
+                    model_endpoint_type="openai",  # Cerebras uses OpenAI-compatible endpoint
+                    model_endpoint=self.base_url,
+                    context_window=context_window_size,
+                    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,
+                )
+            )
+
+        return configs

letta/schemas/providers/cohere.py

@@ -0,0 +1,18 @@
+from typing import Literal
+
+from pydantic import Field
+
+from letta.schemas.enums import ProviderCategory, ProviderType
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.providers.openai import OpenAIProvider
+
+
+# TODO (cliandy): this needs to be implemented
+class CohereProvider(OpenAIProvider):
+    provider_type: Literal[ProviderType.cohere] = Field(ProviderType.cohere, description="The type of the provider.")
+    provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
+    base_url: str = ""
+    api_key: str = Field(..., description="API key for the Cohere API.")
+
+    async def list_llm_models_async(self) -> list[LLMConfig]:
+        raise NotImplementedError

letta/schemas/providers/deepseek.py

@@ -0,0 +1,63 @@
+from typing import Literal
+
+from pydantic import Field
+
+from letta.schemas.enums import ProviderCategory, ProviderType
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.providers.openai import OpenAIProvider
+
+
+class DeepSeekProvider(OpenAIProvider):
+    """
+    DeepSeek ChatCompletions API is similar to OpenAI's reasoning API,
+    but with slight differences:
+    * For example, DeepSeek's API requires perfect interleaving of user/assistant
+    * It also does not support native function calling
+    """
+
+    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.")
+
+    # TODO (cliandy): this may need to be updated to reflect current models
+    def get_model_context_window_size(self, model_name: str) -> int | None:
+        # DeepSeek doesn't return context window in the model listing,
+        # so these are hardcoded from their website
+        if model_name == "deepseek-reasoner":
+            return 64000
+        elif model_name == "deepseek-chat":
+            return 64000
+        else:
+            return None
+
+    async def list_llm_models_async(self) -> list[LLMConfig]:
+        from letta.llm_api.openai import openai_get_model_list_async
+
+        response = await openai_get_model_list_async(self.base_url, api_key=self.api_key)
+        data = response.get("data", response)
+
+        configs = []
+        for model in data:
+            check = self._do_model_checks_for_name_and_context_size(model)
+            if check is None:
+                continue
+            model_name, context_window_size = check
+
+            # Not used for deepseek-reasoner, but otherwise is true
+            put_inner_thoughts_in_kwargs = False if model_name == "deepseek-reasoner" else True
+
+            configs.append(
+                LLMConfig(
+                    model=model_name,
+                    model_endpoint_type="deepseek",
+                    model_endpoint=self.base_url,
+                    context_window=context_window_size,
+                    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,
+                )
+            )
+
+        return configs