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.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
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