Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

69.4 KB
Raw Blame
import types
from collections.abc import Callable, Sequence
from types import SimpleNamespace
from typing import Any
from unittest.mock import MagicMock, create_autospec

import pytest
from sqlalchemy import event
from sqlalchemy.engine import Engine
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session

from core.entities.model_entities import (
    ModelStatus,
    ModelWithProviderEntity,
    SimpleModelProviderEntity,
)
from core.entities.provider_configuration import ProviderConfigurations
from core.entities.provider_entities import (
    CredentialConfiguration,
    CustomModelConfiguration,
)
from core.plugin.entities.plugin import PluginInstallationSource
from core.plugin.entities.plugin_daemon import PluginModelProviderBinding
from enums import DeploymentEdition
from graphon.model_runtime.entities.common_entities import I18nObject
from graphon.model_runtime.entities.model_entities import (
    FetchFrom,
    ModelType,
    ParameterRule,
    ParameterType,
)
from graphon.model_runtime.entities.provider_entities import (
    ConfigurateMethod,
    ProviderEntity,
)
from models.account import Account, TenantAccountRole
from models.provider import (
    Provider,
    ProviderCredential,
    ProviderModel,
    ProviderType,
    TenantDefaultModel,
    TenantPreferredModelProvider,
)
from services.credentials.query import CredentialQuery, ModelCredentialRecord
from services.errors.app_model_config import ProviderNotFoundError
from services.model_provider import service as service_module
from services.model_provider.service import ModelProviderService, _ProviderSummaryState


class _RecordingConfigurations:
    """Test double for ProviderConfigurations that records get_models calls."""

    def __init__(self) -> None:
        self.models: Sequence[object] = []
        self.get_models_impl: Callable[..., Sequence[object]] | None = None
        self.get_models_calls: list[dict[str, object]] = []

    def get_models(self, **kwargs: object) -> Sequence[object]:
        self.get_models_calls.append(kwargs)
        if self.get_models_impl is not None:
            return self.get_models_impl(**kwargs)
        return self.models


class _RecordingProviderManager:
    """Test double for ProviderManager that records calls instead of using mocks."""

    def __init__(self, configurations: object | None = None) -> None:
        self.configurations: object = configurations if configurations is not None else _RecordingConfigurations()
        self.get_configurations_error: Exception | None = None
        self.get_configurations_calls: list[str] = []
        self.get_default_model_result: object | None = None
        self.get_default_model_error: Exception | None = None
        self.get_default_model_calls: list[dict[str, object]] = []
        self.update_default_model_record_calls: list[dict[str, object]] = []

    def get_configurations(self, tenant_id: str) -> object:
        self.get_configurations_calls.append(tenant_id)
        if self.get_configurations_error is not None:
            raise self.get_configurations_error
        return self.configurations

    def get_default_model(self, *, tenant_id: str, model_type: ModelType) -> object | None:
        self.get_default_model_calls.append({"tenant_id": tenant_id, "model_type": model_type})
        if self.get_default_model_error is not None:
            raise self.get_default_model_error
        return self.get_default_model_result

    def update_default_model_record(self, *, tenant_id: str, model_type: ModelType, provider: str, model: str) -> None:
        self.update_default_model_record_calls.append(
            {
                "tenant_id": tenant_id,
                "model_type": model_type,
                "provider": provider,
                "model": model,
            }
        )


def _create_service_with_fake_manager(
    monkeypatch: pytest.MonkeyPatch,
) -> tuple[ModelProviderService, _RecordingProviderManager, _RecordingConfigurations]:
    configurations = _RecordingConfigurations()
    manager = _RecordingProviderManager(configurations)
    service = ModelProviderService()
    monkeypatch.setattr(service, "_get_provider_manager", lambda _tenant_id: manager)
    return service, manager, configurations


def _build_available_llm(model: str) -> ModelWithProviderEntity:
    provider = ProviderEntity(
        provider="langgenius/openai/openai",
        label=I18nObject(en_US="OpenAI"),
        supported_model_types=[ModelType.LLM],
        configurate_methods=[ConfigurateMethod.PREDEFINED_MODEL],
    )
    return ModelWithProviderEntity(
        model=model,
        label=I18nObject(en_US=model),
        model_type=ModelType.LLM,
        fetch_from=FetchFrom.PREDEFINED_MODEL,
        model_properties={},
        status=ModelStatus.ACTIVE,
        provider=SimpleModelProviderEntity(provider),
    )


def _build_provider_configuration(
    *,
    provider_name: str = "openai",
    supported_model_types: list[ModelType] | None = None,
    custom_models: list[Any] | None = None,
    custom_config_available: bool = True,
) -> SimpleNamespace:
    if supported_model_types is None:
        supported_model_types = [ModelType.LLM]

    return SimpleNamespace(
        provider=SimpleNamespace(
            provider=provider_name,
            label=I18nObject(en_US=provider_name),
            description=None,
            icon_small=None,
            icon_small_dark=None,
            background=None,
            help=None,
            supported_model_types=supported_model_types,
            configurate_methods=[],
            provider_credential_schema=None,
            model_credential_schema=None,
        ),
        preferred_provider_type=ProviderType.CUSTOM,
        custom_configuration=SimpleNamespace(
            provider=SimpleNamespace(
                current_credential_id="cred-1",
                current_credential_name="Credential 1",
                available_credentials=[],
            ),
            models=custom_models,
            can_added_models=[],
        ),
        system_configuration=SimpleNamespace(enabled=False, current_quota_type=None, quota_configurations=[]),
        is_custom_configuration_available=lambda: custom_config_available,
    )


def _build_model_provider_binding(
    source: PluginInstallationSource,
    *,
    installation_id: str = "installation-1",
    plugin_id: str = "langgenius/openai",
    plugin_unique_identifier: str = "langgenius/openai:1.0.0@checksum",
    verified: bool = True,
) -> PluginModelProviderBinding:
    return PluginModelProviderBinding(
        provider="openai",
        installation_id=installation_id,
        plugin_id=plugin_id,
        plugin_unique_identifier=plugin_unique_identifier,
        runtime_type="remote" if source == PluginInstallationSource.Remote else "local",
        source=source,
        version="1.0.0",
        verified=verified,
    )


class TestModelProviderServiceCases:
    @staticmethod
    @pytest.mark.parametrize("has_active_models", [True, False])
    def test_initialize_default_llm_selects_first_active_model_once(
        sqlite_session: Session,
        has_active_models: bool,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        sqlite_session.add_all(
            [
                TenantDefaultModel(
                    tenant_id="other-tenant",
                    model_type=ModelType.LLM,
                    provider_name="other",
                    model_name="other-model",
                ),
                TenantDefaultModel(
                    tenant_id="tenant-1",
                    model_type=ModelType.TEXT_EMBEDDING,
                    provider_name="embedding",
                    model_name="embedding-model",
                ),
            ]
        )
        sqlite_session.commit()
        service, _manager, configurations = _create_service_with_fake_manager(monkeypatch)
        models = [_build_available_llm("gpt-4o-mini"), _build_available_llm("gpt-4o")] if has_active_models else []
        configurations.models = models

        service.initialize_default_llm("tenant-1")
        service.initialize_default_llm("tenant-1")

        expected_defaults = {
            ("other-tenant", ModelType.LLM, "other", "other-model"),
            ("tenant-1", ModelType.TEXT_EMBEDDING, "embedding", "embedding-model"),
        }
        if has_active_models:
            expected_defaults.add(("tenant-1", ModelType.LLM, "langgenius/openai/openai", "gpt-4o-mini"))
        assert {
            (
                record.tenant_id,
                record.model_type,
                record.provider_name,
                record.model_name,
            )
            for record in sqlite_session.query(TenantDefaultModel).all()
        } == expected_defaults
        assert len(configurations.get_models_calls) == (1 if has_active_models else 2)
        assert configurations.get_models_calls[-1] == {
            "model_type": ModelType.LLM,
            "only_active": True,
        }

    @staticmethod
    def test_initialize_default_llm_preserves_existing_selection(
        sqlite_session: Session, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        saved_default = TenantDefaultModel(
            tenant_id="tenant-1",
            model_type=ModelType.LLM,
            provider_name="chosen-provider",
            model_name="chosen-model",
        )
        sqlite_session.add(saved_default)
        sqlite_session.commit()
        service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)

        service.initialize_default_llm("tenant-1")

        assert manager.get_configurations_calls == []
        sqlite_session.refresh(saved_default)
        assert (saved_default.provider_name, saved_default.model_name) == (
            "chosen-provider",
            "chosen-model",
        )

    @staticmethod
    @pytest.mark.parametrize("selection_time", ["discovery", "insert"])
    def test_initialize_default_llm_preserves_concurrent_selection(
        sqlite_session: Session,
        sqlite_engine: Engine,
        selection_time: str,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        service, _manager, configurations = _create_service_with_fake_manager(monkeypatch)
        selected = False

        def save_selection() -> None:
            nonlocal selected
            selected = True
            sqlite_session.add(
                TenantDefaultModel(
                    tenant_id="tenant-1",
                    model_type=ModelType.LLM,
                    provider_name="chosen-provider",
                    model_name="chosen-model",
                )
            )
            sqlite_session.commit()

        def discover_models(*, model_type: ModelType, only_active: bool) -> list[ModelWithProviderEntity]:
            assert model_type == ModelType.LLM
            assert only_active
            if selection_time == "discovery":
                save_selection()
            return [_build_available_llm("gpt-4o-mini")]

        configurations.get_models_impl = discover_models

        def select_before_insert(
            _connection: Any,
            _cursor: Any,
            statement: str,
            _parameters: Any,
            _context: Any,
            _executemany: bool,
        ) -> None:
            if (
                selection_time == "insert"
                and not selected
                and statement.startswith("INSERT INTO tenant_default_models")
            ):
                save_selection()

        event.listen(sqlite_engine, "before_cursor_execute", select_before_insert)
        try:
            service.initialize_default_llm("tenant-1")
        finally:
            event.remove(sqlite_engine, "before_cursor_execute", select_before_insert)

        defaults = sqlite_session.query(TenantDefaultModel).all()
        assert selected
        assert len(defaults) == 1
        assert (defaults[0].provider_name, defaults[0].model_name) == (
            "chosen-provider",
            "chosen-model",
        )

    @staticmethod
    def test_initialize_default_llm_propagates_database_failure(
        sqlite_session: Session, sqlite_engine: Engine, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        service, _manager, configurations = _create_service_with_fake_manager(monkeypatch)
        configurations.models = [_build_available_llm("gpt-4o-mini")]
        with sqlite_engine.begin() as connection:
            connection.exec_driver_sql(
                "CREATE TRIGGER reject_default_model BEFORE INSERT ON tenant_default_models "
                "BEGIN SELECT RAISE(ABORT, 'default model write rejected'); END"
            )

        with pytest.raises(IntegrityError, match="default model write rejected"):
            service.initialize_default_llm("tenant-1")

        assert sqlite_session.query(TenantDefaultModel).count() == 0

    @staticmethod
    def test_available_credentials_use_injected_query_for_admin_viewer(
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
        user = Account(name="Admin", email="[email protected]")
        user.id = "actor"
        user.role = TenantAccountRole.ADMIN
        query = create_autospec(CredentialQuery, instance=True, spec_set=True)
        query.list_models.return_value = [ModelCredentialRecord(id="credential", name="Shared credential")]

        result = service.get_provider_available_credentials("tenant", "openai", user=user, credential_query=query)

        query.list_models.assert_called_once_with(workspace_id="tenant", provider="openai", actor_id="actor")
        assert result == [CredentialConfiguration(credential_id="credential", credential_name="Shared credential")]
        assert manager.get_configurations_calls == []

    class TestModelProviderServiceConfiguration:
        def test__get_provider_configuration_should_return_configuration_when_provider_exists(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
            provider_configuration = SimpleNamespace(name="provider-config")
            manager.configurations = {"openai": provider_configuration}

            result = service._get_provider_configuration(tenant_id="tenant-1", provider="openai")

            assert result is provider_configuration

        def test__get_provider_configuration_should_raise_error_when_provider_is_missing(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
            manager.configurations = dict[str, Any]()

            with pytest.raises(ProviderNotFoundError, match="does not exist"):
                service._get_provider_configuration(tenant_id="tenant-1", provider="missing")

        def test_get_provider_list_should_filter_by_model_type_and_build_no_configure_status(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
            allowed = _build_provider_configuration(
                provider_name="openai",
                supported_model_types=[ModelType.LLM],
                custom_config_available=False,
            )
            filtered = _build_provider_configuration(
                provider_name="embedding",
                supported_model_types=[ModelType.TEXT_EMBEDDING],
                custom_config_available=True,
            )
            manager.configurations = {"openai": allowed, "embedding": filtered}

            result = service.get_provider_list(tenant_id="tenant-1", model_type=ModelType.LLM)

            assert len(result) == 1
            assert result[0].provider == "openai"
            assert result[0].custom_configuration.status.value == "no-configure"

        def test_get_provider_summary_list_uses_lightweight_state_and_plugin_bindings(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service = ModelProviderService()
            provider = SimpleNamespace(
                provider="langgenius/openai/openai",
                label=I18nObject(en_US="OpenAI"),
                description=I18nObject(en_US="OpenAI models"),
                icon_small=I18nObject(en_US="icon.svg"),
                icon_small_dark=I18nObject(en_US="icon-dark.svg"),
                supported_model_types=[ModelType.LLM],
                configurate_methods=[ConfigurateMethod.PREDEFINED_MODEL],
            )
            binding = SimpleNamespace(
                provider="openai",
                plugin_id="langgenius/openai",
                installation_id="installation-1",
                plugin_unique_identifier="langgenius/openai:1.2.3@checksum",
                runtime_type="local",
                source=PluginInstallationSource.Marketplace,
                version="1.2.3",
                verified=True,
            )
            state = _ProviderSummaryState(
                has_custom_provider=True,
                available_credentials=[
                    CredentialConfiguration(
                        credential_id="credential-1",
                        credential_name="Production",
                    ),
                    CredentialConfiguration(
                        credential_id="credential-2",
                        credential_name="Backup",
                    ),
                ],
                has_custom_models=True,
                current_credential_id="credential-1",
                current_credential_name="Production",
                current_credential_usable=True,
                preferred_provider_type=ProviderType.CUSTOM,
            )
            call_order: list[str] = []
            manager_constructor = MagicMock(side_effect=AssertionError("summary must not construct ProviderManager"))
            monkeypatch.setattr(service, "_get_provider_manager", manager_constructor)
            monkeypatch.setattr(
                service_module.PluginService,
                "list_model_provider_bindings",
                MagicMock(side_effect=lambda *_args, **_kwargs: call_order.append("bindings") or [binding]),
            )
            monkeypatch.setattr(
                service_module.PluginService,
                "fetch_plugin_model_providers",
                MagicMock(side_effect=lambda *_args, **_kwargs: call_order.append("providers") or [provider]),
            )
            monkeypatch.setattr(
                service,
                "_load_provider_summary_states",
                MagicMock(return_value={provider.provider: state}),
            )
            monkeypatch.setattr(
                service_module.ext_hosting_provider.hosting_configuration,
                "provider_map",
                {provider.provider: SimpleNamespace(enabled=True, quotas=[SimpleNamespace()])},
            )

            providers, plugins = service.get_provider_summary_list(tenant_id="tenant-1")

            assert len(providers) == 1
            assert providers[0].provider == provider.provider
            assert providers[0].plugin_id == "langgenius/openai"
            assert providers[0].is_configured is True
            assert providers[0].custom_configuration.available_credentials == [
                CredentialConfiguration(
                    credential_id="credential-1",
                    credential_name="Production",
                ),
                CredentialConfiguration(
                    credential_id="credential-2",
                    credential_name="Backup",
                ),
            ]
            assert providers[0].custom_configuration.has_custom_models is True
            assert providers[0].custom_configuration.current_credential_name == "Production"
            assert providers[0].custom_configuration.current_credential_usable is True
            assert providers[0].system_configuration.enabled is True
            assert plugins["langgenius/openai"].installation_id == "installation-1"
            assert plugins["langgenius/openai"].version == "1.2.3"
            assert call_order == ["bindings", "providers"]
            manager_constructor.assert_not_called()

        def test_get_provider_summary_list_enables_system_only_for_verified_hosted_non_package_bindings(
            self,
            monkeypatch: pytest.MonkeyPatch,
        ) -> None:
            marketplace_binding = _build_model_provider_binding(PluginInstallationSource.Marketplace)
            package_binding = _build_model_provider_binding(
                PluginInstallationSource.Package,
                installation_id="installation-package",
                plugin_id="langgenius/package",
                plugin_unique_identifier="langgenius/package:1.0.0@checksum",
            )
            unhosted_binding = _build_model_provider_binding(
                PluginInstallationSource.Marketplace,
                installation_id="installation-unhosted",
                plugin_id="langgenius/unhosted",
                plugin_unique_identifier="langgenius/unhosted:1.0.0@checksum",
            )
            remote_binding = _build_model_provider_binding(
                PluginInstallationSource.Remote,
                installation_id="installation-remote",
                plugin_id="langgenius/remote",
                plugin_unique_identifier="langgenius/remote:1.0.0@checksum",
            )
            unverified_binding = _build_model_provider_binding(
                PluginInstallationSource.Marketplace,
                installation_id="installation-unverified",
                plugin_id="langgenius/unverified",
                plugin_unique_identifier="langgenius/unverified:1.0.0@checksum",
                verified=False,
            )
            bindings = [
                marketplace_binding,
                package_binding,
                unhosted_binding,
                remote_binding,
                unverified_binding,
            ]
            provider_entities = [
                SimpleNamespace(
                    provider=f"{binding.plugin_id}/openai",
                    label=I18nObject(en_US=binding.plugin_id),
                    description=None,
                    icon_small=None,
                    icon_small_dark=None,
                    supported_model_types=[ModelType.LLM],
                    configurate_methods=[],
                )
                for binding in bindings
            ]
            monkeypatch.setattr(
                service_module.ext_hosting_provider.hosting_configuration,
                "provider_map",
                {
                    "langgenius/openai/openai": SimpleNamespace(enabled=True, quotas=[SimpleNamespace()]),
                    "langgenius/package/openai": SimpleNamespace(enabled=True, quotas=[SimpleNamespace()]),
                    "langgenius/remote/openai": SimpleNamespace(enabled=True, quotas=[SimpleNamespace()]),
                    "langgenius/unverified/openai": SimpleNamespace(enabled=True, quotas=[SimpleNamespace()]),
                },
            )
            monkeypatch.setattr(
                service_module.PluginService,
                "list_model_provider_bindings",
                MagicMock(return_value=bindings),
            )
            monkeypatch.setattr(
                service_module.PluginService,
                "fetch_plugin_model_providers",
                MagicMock(return_value=provider_entities),
            )
            monkeypatch.setattr(
                ModelProviderService,
                "_load_provider_summary_states",
                MagicMock(return_value={}),
            )
            monkeypatch.setattr(service_module, "is_filtered", MagicMock(return_value=False))

            providers, _ = ModelProviderService().get_provider_summary_list("tenant-1")

            assert {provider.provider: provider.system_configuration.enabled for provider in providers} == {
                "langgenius/openai/openai": True,
                "langgenius/package/openai": False,
                "langgenius/unhosted/openai": False,
                "langgenius/remote/openai": True,
                "langgenius/unverified/openai": False,
            }

        def test_model_provider_binding_without_verified_field_fails_closed(
            self,
        ) -> None:
            binding = PluginModelProviderBinding.model_validate(
                {
                    "provider": "openai",
                    "installation_id": "installation-1",
                    "plugin_id": "langgenius/openai",
                    "plugin_unique_identifier": "langgenius/openai:1.0.0@checksum",
                    "runtime_type": "local",
                    "source": "marketplace",
                    "version": "1.0.0",
                }
            )

            assert binding.verified is False

        def test_get_provider_summary_list_returns_all_unique_provider_metadata(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service = ModelProviderService()
            llm_provider = SimpleNamespace(
                provider="langgenius/openai/openai",
                label=I18nObject(en_US="OpenAI"),
                description=None,
                icon_small=None,
                icon_small_dark=None,
                supported_model_types=[ModelType.LLM],
                configurate_methods=[],
            )
            embedding_provider = SimpleNamespace(
                provider="langgenius/embedding/embedding",
                label=I18nObject(en_US="Embedding"),
                description=None,
                icon_small=None,
                icon_small_dark=None,
                supported_model_types=[ModelType.TEXT_EMBEDDING],
                configurate_methods=[],
            )
            llm_binding = SimpleNamespace(
                provider="openai",
                plugin_id="langgenius/openai",
                installation_id="installation-openai",
                plugin_unique_identifier="langgenius/openai:1.0.0@checksum",
                runtime_type="local",
                source=service_module.PluginInstallationSource.Marketplace,
                version="1.0.0",
                verified=False,
            )
            embedding_binding = SimpleNamespace(
                provider="embedding",
                plugin_id="langgenius/embedding",
                installation_id="installation-embedding",
                plugin_unique_identifier="langgenius/embedding:1.0.0@checksum",
                runtime_type="local",
                source=service_module.PluginInstallationSource.Marketplace,
                version="1.0.0",
                verified=False,
            )
            monkeypatch.setattr(
                service_module.PluginService,
                "list_model_provider_bindings",
                MagicMock(return_value=[llm_binding, embedding_binding]),
            )
            monkeypatch.setattr(
                service_module.PluginService,
                "fetch_plugin_model_providers",
                MagicMock(return_value=[llm_provider, llm_provider, embedding_provider]),
            )
            monkeypatch.setattr(service, "_load_provider_summary_states", MagicMock(return_value={}))
            monkeypatch.setattr(service_module, "is_filtered", MagicMock(return_value=False))

            providers, plugins = service.get_provider_summary_list(tenant_id="tenant-1")

            assert [provider.provider for provider in providers] == [
                "langgenius/openai/openai",
                "langgenius/embedding/embedding",
            ]
            assert providers[0].is_configured is False
            assert providers[0].custom_configuration.status.value == "no-configure"
            assert providers[0].custom_configuration.has_custom_models is False
            assert providers[0].custom_configuration.available_credentials == []
            assert set(plugins) == {"langgenius/openai", "langgenius/embedding"}

        def test_preferred_provider_fallback_uses_custom_presence_not_configuration_status(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            from tests.helpers.unit.config_override import apply_config_overrides

            apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
            state = _ProviderSummaryState(has_custom_provider=True)

            preferred_provider_type = ModelProviderService._get_preferred_provider_type(
                state,
                custom_present=True,
                system_enabled=True,
            )

            assert preferred_provider_type == ProviderType.CUSTOM

        def test_load_provider_summary_states_reads_only_lightweight_columns(
            self,
            sqlite_engine: Engine,
            sqlite_session: Session,
        ) -> None:
            canonical_provider = "langgenius/openai/openai"
            legacy_credential = ProviderCredential(
                tenant_id="tenant-1",
                provider_name="openai",
                credential_name="Legacy",
                encrypted_config="legacy-secret",
            )
            legacy_credential.id = "credential-legacy"
            current_credential = ProviderCredential(
                tenant_id="tenant-1",
                provider_name=canonical_provider,
                credential_name="Production",
                encrypted_config="production-secret",
            )
            current_credential.id = "credential-current"
            foreign_credential = ProviderCredential(
                tenant_id="tenant-2",
                provider_name=canonical_provider,
                credential_name="Foreign",
                encrypted_config="foreign-secret",
            )
            foreign_credential.id = "credential-foreign"
            sqlite_session.add_all(
                [
                    legacy_credential,
                    current_credential,
                    foreign_credential,
                    Provider(
                        tenant_id="tenant-1",
                        provider_name="openai",
                        provider_type=ProviderType.CUSTOM,
                        is_valid=True,
                        credential_id=legacy_credential.id,
                    ),
                    Provider(
                        tenant_id="tenant-1",
                        provider_name=canonical_provider,
                        provider_type=ProviderType.CUSTOM,
                        is_valid=True,
                        credential_id=current_credential.id,
                    ),
                    Provider(
                        tenant_id="tenant-2",
                        provider_name=canonical_provider,
                        provider_type=ProviderType.CUSTOM,
                        is_valid=True,
                        credential_id=foreign_credential.id,
                    ),
                    ProviderModel(
                        tenant_id="tenant-1",
                        provider_name="openai",
                        model_name="gpt-4o",
                        model_type=ModelType.LLM,
                        is_valid=True,
                    ),
                    ProviderModel(
                        tenant_id="tenant-2",
                        provider_name="langgenius/foreign/foreign",
                        model_name="foreign-model",
                        model_type=ModelType.LLM,
                        is_valid=True,
                    ),
                    TenantPreferredModelProvider(
                        tenant_id="tenant-1",
                        provider_name=canonical_provider,
                        preferred_provider_type=ProviderType.SYSTEM,
                    ),
                    TenantPreferredModelProvider(
                        tenant_id="tenant-2",
                        provider_name=canonical_provider,
                        preferred_provider_type=ProviderType.CUSTOM,
                    ),
                ]
            )
            sqlite_session.commit()
            statements: list[str] = []

            def capture_statement(
                _connection,
                _cursor,
                statement: str,
                _parameters,
                _context,
                _executemany,
            ) -> None:
                statements.append(statement)

            event.listen(sqlite_engine, "before_cursor_execute", capture_statement)
            try:
                states = ModelProviderService._load_provider_summary_states("tenant-1")
            finally:
                event.remove(sqlite_engine, "before_cursor_execute", capture_statement)

            state = states[canonical_provider]
            assert state.has_custom_provider is True
            assert state.available_credentials == [
                CredentialConfiguration(
                    credential_id="credential-legacy",
                    credential_name="Legacy",
                ),
                CredentialConfiguration(
                    credential_id="credential-current",
                    credential_name="Production",
                ),
            ]
            assert state.has_custom_models is True
            assert state.current_credential_id == "credential-current"
            assert state.current_credential_name == "Production"
            assert state.current_credential_usable is True
            assert state.preferred_provider_type == ProviderType.SYSTEM

            assert len(statements) == 4
            assert all("encrypted_config" not in statement for statement in statements)
            assert "count(" not in statements[1].lower()
            assert "provider_credentials.id" in statements[1]
            assert "provider_credentials.credential_name" in statements[1]
            assert "ORDER BY provider_credentials.created_at DESC, provider_credentials.id DESC" in statements[1]
            assert "provider_model_credentials" in statements[2]

        def test_list_models_should_pass_filters_through(self, monkeypatch: pytest.MonkeyPatch) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
            filters: list[dict[str, object]] = []

            def get_models(_self: ProviderConfigurations, **kwargs: object) -> list[ModelWithProviderEntity]:
                filters.append(kwargs)
                return []

            monkeypatch.setattr(ProviderConfigurations, "get_models", get_models)
            manager.configurations = ProviderConfigurations(tenant_id="tenant-1")

            assert service.list_models("tenant-1", provider=None, model_type=ModelType.LLM) == []
            assert filters == [{"provider": None, "model_type": ModelType.LLM}]

        def test_get_models_by_provider_should_wrap_model_entities_with_tenant_context(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)

            class _Model:
                def __init__(self, model_name: str) -> None:
                    self.model_name = model_name

                def model_dump(self) -> dict[str, Any]:
                    return {
                        "model": self.model_name,
                        "label": {"en_US": self.model_name},
                        "model_type": ModelType.LLM,
                        "features": [],
                        "fetch_from": FetchFrom.PREDEFINED_MODEL,
                        "model_properties": {},
                        "deprecated": False,
                        "status": ModelStatus.ACTIVE,
                        "load_balancing_enabled": False,
                        "has_invalid_load_balancing_configs": False,
                        "provider": {
                            "provider": "openai",
                            "label": {"en_US": "OpenAI"},
                            "icon_small": None,
                            "icon_small_dark": None,
                            "supported_model_types": [ModelType.LLM],
                        },
                    }

            provider_configurations = SimpleNamespace(
                get_models=MagicMock(return_value=[_Model("gpt-4o"), _Model("gpt-4o-mini")])
            )
            manager.configurations = provider_configurations

            result = service.get_models_by_provider(tenant_id="tenant-1", provider="openai")

            assert len(result) == 2
            assert result[0].model == "gpt-4o"
            assert result[1].provider.provider == "openai"
            provider_configurations.get_models.assert_called_once_with(provider="openai")

    class TestModelProviderServiceDelegation:
        @pytest.mark.parametrize(
            (
                "method_name",
                "method_kwargs",
                "provider_method_name",
                "provider_call_kwargs",
                "provider_return",
            ),
            [
                (
                    "get_provider_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "credential_id": "cred-1",
                    },
                    "get_provider_credential",
                    {"credential_id": "cred-1"},
                    {"token": "abc"},
                ),
                (
                    "validate_provider_credentials",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "credentials": {"token": "abc"},
                    },
                    "validate_provider_credentials",
                    ({"token": "abc"},),
                    None,
                ),
                (
                    "create_provider_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "credentials": {"token": "abc"},
                        "credential_name": "A",
                    },
                    "create_provider_credential",
                    ({"token": "abc"}, "A"),
                    "new-credential-id",
                ),
                (
                    "update_provider_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "credentials": {"token": "abc"},
                        "credential_id": "cred-1",
                        "credential_name": "B",
                    },
                    "update_provider_credential",
                    {
                        "credential_id": "cred-1",
                        "credentials": {"token": "abc"},
                        "credential_name": "B",
                    },
                    None,
                ),
                (
                    "remove_provider_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "credential_id": "cred-1",
                    },
                    "delete_provider_credential",
                    {"credential_id": "cred-1"},
                    None,
                ),
                (
                    "switch_active_provider_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "credential_id": "cred-1",
                    },
                    "switch_active_provider_credential",
                    {"credential_id": "cred-1"},
                    None,
                ),
            ],
        )
        def test_provider_credential_methods_should_delegate_to_provider_configuration(
            self,
            method_name: str,
            method_kwargs: dict[str, Any],
            provider_method_name: str,
            provider_call_kwargs: Any,
            provider_return: Any,
            monkeypatch: pytest.MonkeyPatch,
        ) -> None:
            service = ModelProviderService()
            provider_configuration = MagicMock()
            getattr(provider_configuration, provider_method_name).return_value = provider_return
            get_provider_config_mock = MagicMock(return_value=provider_configuration)
            monkeypatch.setattr(service, "_get_provider_configuration", get_provider_config_mock)

            result = getattr(service, method_name)(**method_kwargs)

            get_provider_config_mock.assert_called_once_with("tenant-1", "openai")
            provider_method = getattr(provider_configuration, provider_method_name)
            match provider_call_kwargs:
                case tuple():
                    provider_method.assert_called_once_with(*provider_call_kwargs)
                case dict():
                    provider_method.assert_called_once_with(**provider_call_kwargs)
                case _:
                    provider_method.assert_called_once_with(provider_call_kwargs)
            if method_name == "get_provider_credential":
                assert result == {"token": "abc"}
            if method_name == "create_provider_credential":
                assert result == "new-credential-id"

        @pytest.mark.parametrize(
            (
                "method_name",
                "method_kwargs",
                "provider_method_name",
                "expected_kwargs",
                "provider_return",
            ),
            [
                (
                    "get_model_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credential_id": "cred-1",
                    },
                    "get_custom_model_credential",
                    {
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credential_id": "cred-1",
                    },
                    {"api_key": "x"},
                ),
                (
                    "validate_model_credentials",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credentials": {"api_key": "x"},
                    },
                    "validate_custom_model_credentials",
                    {
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credentials": {"api_key": "x"},
                    },
                    None,
                ),
                (
                    "create_model_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credentials": {"api_key": "x"},
                        "credential_name": "cred-a",
                    },
                    "create_custom_model_credential",
                    {
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credentials": {"api_key": "x"},
                        "credential_name": "cred-a",
                    },
                    "new-credential-id",
                ),
                (
                    "update_model_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credentials": {"api_key": "x"},
                        "credential_id": "cred-1",
                        "credential_name": "cred-b",
                    },
                    "update_custom_model_credential",
                    {
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credentials": {"api_key": "x"},
                        "credential_id": "cred-1",
                        "credential_name": "cred-b",
                    },
                    None,
                ),
                (
                    "remove_model_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credential_id": "cred-1",
                    },
                    "delete_custom_model_credential",
                    {
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credential_id": "cred-1",
                    },
                    None,
                ),
                (
                    "switch_active_custom_model_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credential_id": "cred-1",
                    },
                    "switch_custom_model_credential",
                    {
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credential_id": "cred-1",
                    },
                    None,
                ),
                (
                    "add_model_credential_to_model_list",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credential_id": "cred-1",
                    },
                    "add_model_credential_to_model",
                    {
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credential_id": "cred-1",
                    },
                    None,
                ),
                (
                    "remove_model",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                    },
                    "delete_custom_model",
                    {"model_type": ModelType.LLM, "model": "gpt-4o"},
                    None,
                ),
            ],
        )
        def test_custom_model_methods_should_convert_model_type_and_delegate(
            self,
            method_name: str,
            method_kwargs: dict[str, Any],
            provider_method_name: str,
            expected_kwargs: dict[str, Any],
            provider_return: Any,
            monkeypatch: pytest.MonkeyPatch,
        ) -> None:
            service = ModelProviderService()
            provider_configuration = MagicMock()
            getattr(provider_configuration, provider_method_name).return_value = provider_return
            get_provider_config_mock = MagicMock(return_value=provider_configuration)
            monkeypatch.setattr(service, "_get_provider_configuration", get_provider_config_mock)

            result = getattr(service, method_name)(**method_kwargs)

            get_provider_config_mock.assert_called_once_with("tenant-1", "openai")
            getattr(provider_configuration, provider_method_name).assert_called_once_with(**expected_kwargs)
            if method_name == "get_model_credential":
                assert result == {"api_key": "x"}
            if method_name == "create_model_credential":
                assert result == "new-credential-id"

        @pytest.mark.parametrize(
            ("method_name", "method_kwargs", "provider_method_name", "expected_kwargs"),
            [
                (
                    "get_model_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": "llm",
                        "model": "gpt-4o",
                        "credential_id": "cred-1",
                    },
                    "get_custom_model_credential",
                    {
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credential_id": "cred-1",
                    },
                ),
                (
                    "create_model_credential",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": "llm",
                        "model": "gpt-4o",
                        "credentials": {"api_key": "x"},
                        "credential_name": "cred-a",
                    },
                    "create_custom_model_credential",
                    {
                        "model_type": ModelType.LLM,
                        "model": "gpt-4o",
                        "credentials": {"api_key": "x"},
                        "credential_name": "cred-a",
                    },
                ),
                (
                    "remove_model",
                    {
                        "tenant_id": "tenant-1",
                        "provider": "openai",
                        "model_type": "llm",
                        "model": "gpt-4o",
                    },
                    "delete_custom_model",
                    {"model_type": ModelType.LLM, "model": "gpt-4o"},
                ),
            ],
        )
        def test_custom_model_methods_use_model_type_constructor_directly(
            self,
            method_name: str,
            method_kwargs: dict[str, Any],
            provider_method_name: str,
            expected_kwargs: dict[str, Any],
            monkeypatch: pytest.MonkeyPatch,
        ) -> None:
            service = ModelProviderService()
            provider_configuration = MagicMock()
            get_provider_config_mock = MagicMock(return_value=provider_configuration)
            monkeypatch.setattr(service, "_get_provider_configuration", get_provider_config_mock)

            getattr(service, method_name)(**method_kwargs)

            get_provider_config_mock.assert_called_once_with("tenant-1", "openai")
            getattr(provider_configuration, provider_method_name).assert_called_once_with(**expected_kwargs)

    class TestModelProviderServiceListingsAndDefaults:
        def test_get_models_by_model_type_should_group_active_non_deprecated_models(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
            openai_provider = SimpleNamespace(
                provider="openai",
                label=I18nObject(en_US="OpenAI"),
                icon_small=None,
                icon_small_dark=None,
            )
            anthropic_provider = SimpleNamespace(
                provider="anthropic",
                label=I18nObject(en_US="Anthropic"),
                icon_small=None,
                icon_small_dark=None,
            )
            models = [
                SimpleNamespace(
                    provider=openai_provider,
                    model="gpt-4o",
                    label=I18nObject(en_US="GPT-4o"),
                    model_type=ModelType.LLM,
                    features=[],
                    fetch_from=FetchFrom.PREDEFINED_MODEL,
                    model_properties={},
                    status=ModelStatus.ACTIVE,
                    load_balancing_enabled=False,
                    deprecated=False,
                ),
                SimpleNamespace(
                    provider=openai_provider,
                    model="old-openai",
                    label=I18nObject(en_US="Old OpenAI"),
                    model_type=ModelType.LLM,
                    features=[],
                    fetch_from=FetchFrom.PREDEFINED_MODEL,
                    model_properties={},
                    status=ModelStatus.ACTIVE,
                    load_balancing_enabled=False,
                    deprecated=True,
                ),
                SimpleNamespace(
                    provider=anthropic_provider,
                    model="old-anthropic",
                    label=I18nObject(en_US="Old Anthropic"),
                    model_type=ModelType.LLM,
                    features=[],
                    fetch_from=FetchFrom.PREDEFINED_MODEL,
                    model_properties={},
                    status=ModelStatus.ACTIVE,
                    load_balancing_enabled=False,
                    deprecated=True,
                ),
            ]
            provider_configurations = SimpleNamespace(get_models=MagicMock(return_value=models))
            manager.configurations = provider_configurations

            result = service.get_models_by_model_type(tenant_id="tenant-1", model_type=ModelType.LLM)

            provider_configurations.get_models.assert_called_once_with(model_type=ModelType.LLM, only_active=True)
            assert len(result) == 1
            assert result[0].provider == "openai"
            assert len(result[0].models) == 1
            assert result[0].models[0].model == "gpt-4o"

        @pytest.mark.parametrize(
            ("credentials", "schema", "expected_count"),
            [
                (None, None, 0),
                ({"api_key": "x"}, None, 0),
                (
                    {"api_key": "x"},
                    SimpleNamespace(
                        parameter_rules=[
                            ParameterRule(
                                name="temperature",
                                label=I18nObject(en_US="Temperature"),
                                type=ParameterType.FLOAT,
                            )
                        ]
                    ),
                    1,
                ),
            ],
        )
        def test_get_model_parameter_rules_should_handle_missing_credentials_and_schema(
            self,
            credentials: dict[str, Any] | None,
            schema: Any,
            expected_count: int,
            monkeypatch: pytest.MonkeyPatch,
        ) -> None:
            service = ModelProviderService()
            provider_configuration = MagicMock()
            provider_configuration.get_current_credentials.return_value = credentials
            provider_configuration.get_model_schema.return_value = schema
            monkeypatch.setattr(
                service,
                "_get_provider_configuration",
                MagicMock(return_value=provider_configuration),
            )

            result = service.get_model_parameter_rules(tenant_id="tenant-1", provider="openai", model="gpt-4o")

            assert len(result) == expected_count
            provider_configuration.get_current_credentials.assert_called_once_with(
                model_type=ModelType.LLM,
                model="gpt-4o",
            )
            if credentials:
                provider_configuration.get_model_schema.assert_called_once_with(
                    model_type=ModelType.LLM,
                    model="gpt-4o",
                    credentials=credentials,
                )
            else:
                provider_configuration.get_model_schema.assert_not_called()

        def test_get_default_model_selection_uses_saved_workspace_choice(
            self, sqlite_session: Session, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            sqlite_session.add(
                TenantDefaultModel(
                    tenant_id="tenant-1",
                    model_type=ModelType.LLM,
                    provider_name="langgenius/openai/openai",
                    model_name="gpt-4o",
                )
            )
            sqlite_session.commit()
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)

            result = service.get_default_model_selection("tenant-1", ModelType.LLM, session=sqlite_session)

            assert result == ("langgenius/openai/openai", "gpt-4o")
            assert manager.get_configurations_calls == []

        def test_get_default_model_selection_uses_first_active_model_without_writing(
            self, sqlite_session: Session, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, _manager, configurations = _create_service_with_fake_manager(monkeypatch)
            configurations.models = [
                SimpleNamespace(
                    model="gpt-4o",
                    provider=SimpleNamespace(provider="langgenius/openai/openai"),
                )
            ]

            result = service.get_default_model_selection("tenant-1", ModelType.LLM, session=sqlite_session)

            assert result == ("langgenius/openai/openai", "gpt-4o")
            assert configurations.get_models_calls == [{"model_type": ModelType.LLM, "only_active": True}]
            assert sqlite_session.query(TenantDefaultModel).filter_by(tenant_id="tenant-1").first() is None

        def test_get_default_model_selection_returns_none_when_provider_discovery_fails(
            self, sqlite_session: Session, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
            manager.get_configurations_error = RuntimeError("provider unavailable")

            result = service.get_default_model_selection("tenant-1", ModelType.LLM, session=sqlite_session)

            assert result is None

        def test_get_default_model_selection_returns_none_when_no_active_models(
            self, sqlite_session: Session, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, _manager, configurations = _create_service_with_fake_manager(monkeypatch)
            configurations.models = []

            result = service.get_default_model_selection("tenant-1", ModelType.LLM, session=sqlite_session)

            assert result is None
            assert configurations.get_models_calls == [{"model_type": ModelType.LLM, "only_active": True}]

        def test_get_default_model_of_model_type_should_return_response_when_manager_returns_model(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
            manager.get_default_model_result = SimpleNamespace(
                model="gpt-4o",
                model_type=ModelType.LLM,
                provider=SimpleNamespace(
                    provider="openai",
                    label=I18nObject(en_US="OpenAI"),
                    icon_small=None,
                    supported_model_types=[ModelType.LLM],
                ),
            )

            result = service.get_default_model_of_model_type(tenant_id="tenant-1", model_type=ModelType.LLM)

            assert result is not None
            assert result.model == "gpt-4o"
            assert result.provider.provider == "openai"
            assert manager.get_default_model_calls == [{"tenant_id": "tenant-1", "model_type": ModelType.LLM}]

        def test_get_default_model_of_model_type_should_return_none_when_manager_returns_none(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)

            result = service.get_default_model_of_model_type(tenant_id="tenant-1", model_type=ModelType.LLM)

            assert result is None
            assert manager.get_default_model_calls == [{"tenant_id": "tenant-1", "model_type": ModelType.LLM}]

        def test_get_default_model_of_model_type_should_return_none_when_no_configuration_is_saved(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
            manager.get_default_model_error = RuntimeError("boom")

            result = service.get_default_model_of_model_type(tenant_id="tenant-1", model_type=ModelType.LLM)

            assert result is None

        @pytest.mark.parametrize(
            "error",
            [
                ValueError("Invalid provider: langgenius/openai/openai"),
                RuntimeError("Plugin daemon unavailable"),
            ],
        )
        def test_get_default_model_of_model_type_should_preserve_saved_configuration_on_provider_failure(
            self,
            sqlite_session: Session,
            error: Exception,
            monkeypatch: pytest.MonkeyPatch,
        ) -> None:
            saved_model = TenantDefaultModel(
                tenant_id="tenant-1",
                model_type=ModelType.LLM,
                provider_name="langgenius/openai/openai",
                model_name="gpt-4o",
            )
            sqlite_session.add(saved_model)
            sqlite_session.commit()
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
            manager.get_default_model_error = error

            result = service.get_default_model_of_model_type(tenant_id="tenant-1", model_type=ModelType.LLM)

            assert result is not None
            assert result.model == "gpt-4o"
            assert result.model_type == ModelType.LLM
            assert result.provider.provider == "langgenius/openai/openai"
            assert result.provider.tenant_id == "tenant-1"
            assert result.provider.label.en_us == "langgenius/openai/openai"
            assert result.provider.label.zh_hans == "langgenius/openai/openai"
            assert result.provider.icon_small is None
            assert result.provider.supported_model_types == []
            assert result.model_dump(mode="json")["model_type"] == "llm"
            sqlite_session.refresh(saved_model)
            assert saved_model.model_name == "gpt-4o"
            assert saved_model.provider_name == "langgenius/openai/openai"

        @pytest.mark.parametrize(
            ("tenant_id", "model_type"),
            [("other-tenant", ModelType.LLM), ("tenant-1", ModelType.TEXT_EMBEDDING)],
        )
        def test_get_default_model_of_model_type_should_not_fall_back_to_another_tenant_or_model_type(
            self,
            sqlite_session: Session,
            tenant_id: str,
            model_type: ModelType,
            monkeypatch: pytest.MonkeyPatch,
        ) -> None:
            sqlite_session.add(
                TenantDefaultModel(
                    tenant_id=tenant_id,
                    model_type=model_type,
                    provider_name="langgenius/openai/openai",
                    model_name="configured-model",
                )
            )
            sqlite_session.commit()
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)
            manager.get_default_model_error = ValueError("Invalid provider: langgenius/openai/openai")

            result = service.get_default_model_of_model_type(tenant_id="tenant-1", model_type=ModelType.LLM)

            assert result is None

        def test_update_default_model_of_model_type_should_delegate_to_provider_manager(
            self, monkeypatch: pytest.MonkeyPatch
        ) -> None:
            service, manager, _configurations = _create_service_with_fake_manager(monkeypatch)

            service.update_default_model_of_model_type(
                tenant_id="tenant-1",
                model_type=ModelType.LLM,
                provider="openai",
                model="gpt-4o",
            )

            assert manager.update_default_model_record_calls == [
                {
                    "tenant_id": "tenant-1",
                    "model_type": ModelType.LLM,
                    "provider": "openai",
                    "model": "gpt-4o",
                }
            ]

        def test_get_model_provider_icon_should_fetch_icon_bytes_from_factory(
            self,
            monkeypatch: pytest.MonkeyPatch,
        ) -> None:
            service = ModelProviderService()
            factory_instance = MagicMock()
            factory_instance.get_provider_icon.return_value = (
                b"icon-bytes",
                "image/png",
            )
            factory_constructor = MagicMock(return_value=factory_instance)
            monkeypatch.setattr(
                service_module,
                "create_plugin_model_provider_factory",
                factory_constructor,
            )

            result = service.get_model_provider_icon(
                tenant_id="tenant-1",
                provider="openai",
                icon_type="icon_small",
                lang="en_US",
            )

            factory_constructor.assert_called_once_with(tenant_id="tenant-1")
            factory_instance.get_provider_icon.assert_called_once_with("openai", "icon_small", "en_US")
            assert result == (b"icon-bytes", "image/png")

        def test_switch_preferred_provider_should_convert_enum_and_delegate(
            self,
            monkeypatch: pytest.MonkeyPatch,
        ) -> None:
            service = ModelProviderService()
            provider_configuration = MagicMock()
            monkeypatch.setattr(
                service,
                "_get_provider_configuration",
                MagicMock(return_value=provider_configuration),
            )

            service.switch_preferred_provider(
                tenant_id="tenant-1",
                provider="openai",
                preferred_provider_type=ProviderType.SYSTEM.value,
            )

            provider_configuration.switch_preferred_provider_type.assert_called_once_with(ProviderType.SYSTEM)

        @pytest.mark.parametrize(
            ("method_name", "provider_method_name"),
            [
                ("enable_model", "enable_model"),
                ("disable_model", "disable_model"),
            ],
        )
        def test_model_enablement_methods_should_convert_model_type_and_delegate(
            self,
            method_name: str,
            provider_method_name: str,
            monkeypatch: pytest.MonkeyPatch,
        ) -> None:
            service = ModelProviderService()
            provider_configuration = MagicMock()
            monkeypatch.setattr(
                service,
                "_get_provider_configuration",
                MagicMock(return_value=provider_configuration),
            )

            getattr(service, method_name)(
                tenant_id="tenant-1",
                provider="openai",
                model="gpt-4o",
                model_type=ModelType.LLM,
            )

            getattr(provider_configuration, provider_method_name).assert_called_once_with(
                model="gpt-4o",
                model_type=ModelType.LLM,
            )


class _FakeConfigurations:
    def __init__(self, provider_configuration: types.SimpleNamespace) -> None:
        self._provider_configuration = provider_configuration

    def values(self) -> list[types.SimpleNamespace]:
        return [self._provider_configuration]


class TestModelProviderServiceSanitizationCases:
    @staticmethod
    @pytest.fixture
    def service_with_fake_configurations(
        monkeypatch: pytest.MonkeyPatch,
    ) -> ModelProviderService:
        # Build a fake provider schema with minimal fields used by ProviderResponse
        fake_provider = types.SimpleNamespace(
            provider="langgenius/openai_api_compatible/openai_api_compatible",
            label=I18nObject(en_US="OpenAI API Compatible", zh_Hans="OpenAI API Compatible"),
            description=None,
            icon_small=None,
            icon_small_dark=None,
            background=None,
            help=None,
            supported_model_types=[ModelType.LLM],
            configurate_methods=[ConfigurateMethod.CUSTOMIZABLE_MODEL],
            provider_credential_schema=None,
            model_credential_schema=None,
        )

        # Include decrypted credentials to simulate the leak source
        custom_model = CustomModelConfiguration(
            model="gpt-4o-mini",
            model_type=ModelType.LLM,
            credentials={"api_key": "sk-plain-text", "endpoint": "https://example.com"},
            current_credential_id="cred-1",
            current_credential_name="API KEY 1",
            available_model_credentials=[],
            unadded_to_model_list=False,
        )

        fake_custom_provider = types.SimpleNamespace(
            current_credential_id="cred-1",
            current_credential_name="API KEY 1",
            available_credentials=[CredentialConfiguration(credential_id="cred-1", credential_name="API KEY 1")],
        )

        fake_custom_configuration = types.SimpleNamespace(
            provider=fake_custom_provider, models=[custom_model], can_added_models=[]
        )

        fake_system_configuration = types.SimpleNamespace(
            enabled=False, current_quota_type=None, quota_configurations=[]
        )

        fake_provider_configuration = types.SimpleNamespace(
            provider=fake_provider,
            preferred_provider_type=ProviderType.CUSTOM,
            custom_configuration=fake_custom_configuration,
            system_configuration=fake_system_configuration,
            is_custom_configuration_available=lambda: True,
        )

        class _FakeProviderManager:
            def get_configurations(self, _tenant_id: str) -> _FakeConfigurations:
                return _FakeConfigurations(fake_provider_configuration)

        svc = ModelProviderService()
        monkeypatch.setattr(svc, "_get_provider_manager", lambda _tenant_id: _FakeProviderManager())
        return svc

    @staticmethod
    def test_get_provider_list_strips_credentials(
        service_with_fake_configurations: ModelProviderService,
    ) -> None:
        providers = service_with_fake_configurations.get_provider_list(tenant_id="tenant-1", model_type=None)

        assert len(providers) == 1
        custom_models = providers[0].custom_configuration.custom_models

        assert custom_models is not None
        assert len(custom_models) == 1
        # The sanitizer should drop credentials in list response
        assert custom_models[0].credentials is None