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
fix(api): initialize default LLMs during onboarding (#44350)
林玮 (Jade Lin)08d3c547ecb6
diff --git a/api/core/provider_manager.py b/api/core/provider_manager.pyindex 1da339626e9..f234be9b71e 100644--- a/api/core/provider_manager.py+++ b/api/core/provider_manager.py@@ -847,7 +847,7 @@ class ProviderManager:def get_default_model(self, tenant_id: str, model_type: ModelType) -> DefaultModelEntity | None:"""- Get default model.+ Get the configured default model, or None when no default is saved.:param tenant_id: workspace id:param model_type: model type@@ -859,27 +859,6 @@ class ProviderManager:)default_model = db.session.scalar(stmt)- # If it does not exist, get the first available provider model from get_configurations- # and update the TenantDefaultModel record- if not default_model:- # Get provider configurations- provider_configurations = self.get_configurations(tenant_id)-- # get available models from provider_configurations- available_models = provider_configurations.get_models(model_type=model_type, only_active=True)-- if available_models:- available_model = available_models[0]-- default_model = TenantDefaultModel(- tenant_id=tenant_id,- model_type=model_type,- provider_name=available_model.provider.provider,- model_name=available_model.model,- )- db.session.add(default_model)- db.session.commit()-if not default_model:return Nonediff --git a/api/services/model_provider/service.py b/api/services/model_provider/service.pyindex 5d0ca59e980..22212724bd4 100644--- a/api/services/model_provider/service.py+++ b/api/services/model_provider/service.py@@ -5,6 +5,7 @@ from dataclasses import dataclass, fieldfrom typing import TYPE_CHECKING, Anyfrom sqlalchemy import and_, select+from sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.orm import Sessionfrom services.credentials.query import CredentialQuery@@ -881,6 +882,49 @@ class ModelProviderService:),)+ def initialize_default_llm(self, tenant_id: str) -> None:+ """Save the first active LLM during onboarding without replacing a configured default."""+ saved_default = select(TenantDefaultModel.id).where(+ TenantDefaultModel.tenant_id == tenant_id,+ TenantDefaultModel.model_type == ModelType.LLM,+ )+ with session_factory.create_session() as session:+ if session.scalar(saved_default) is not None:+ return++ configurations = self._get_provider_manager(tenant_id).get_configurations(tenant_id)+ available_models = configurations.get_models(model_type=ModelType.LLM, only_active=True)+ if not available_models:+ logger.info("No active LLM available for default model initialization, tenant_id: %s", tenant_id)+ return++ model = available_models[0]+ try:+ with session_factory.create_session() as session, session.begin():+ if session.scalar(saved_default) is not None:+ return+ session.add(+ TenantDefaultModel(+ tenant_id=tenant_id,+ model_type=ModelType.LLM,+ provider_name=model.provider.provider,+ model_name=model.model,+ )+ )+ except IntegrityError:+ # A concurrent initializer or user selection may have saved the default first.+ with session_factory.create_session() as session:+ if session.scalar(saved_default) is None:+ raise+ return++ logger.info(+ "Initialized default LLM for tenant %s: provider=%s model=%s",+ tenant_id,+ model.provider.provider,+ model.model,+ )+def update_default_model_of_model_type(self, tenant_id: str, model_type: str, provider: str, model: str):"""update default model of model type.diff --git a/api/tasks/install_default_plugins_task.py b/api/tasks/install_default_plugins_task.pyindex 67b2a79b016..84bfe629d31 100644--- a/api/tasks/install_default_plugins_task.py+++ b/api/tasks/install_default_plugins_task.py@@ -8,6 +8,7 @@ from configs import dify_configfrom core.helper import marketplacefrom core.plugin.entities.plugin_daemon import PluginInstallTaskStatusfrom core.plugin.plugin_service import PluginService+from graphon.model_runtime.entities.model_entities import ModelTypefrom services.model_provider.service import ModelProviderServicelogger = logging.getLogger(__name__)@@ -15,10 +16,7 @@ logger = logging.getLogger(__name__)@shared_task(queue="plugin", bind=True, max_retries=60, default_retry_delay=5)def configure_default_models_task(self, tenant_id: str, plugin_install_task_id: str | None) -> None:- """Set explicitly configured default models after default plugins finish installing."""- if not dify_config.NEW_USER_DEFAULT_MODELS:- return-+ """Apply explicit defaults and initialize an unset LLM after default plugins finish installing."""plugin_install_failed = Falseif plugin_install_task_id:try:@@ -46,7 +44,8 @@ def configure_default_models_task(self, tenant_id: str, plugin_install_task_id:model_provider_service = ModelProviderService()failed_model_types: list[str] = []- for model_type, provider, model in dify_config.NEW_USER_DEFAULT_MODEL_LIST:+ model_settings = dify_config.NEW_USER_DEFAULT_MODEL_LIST+ for model_type, provider, model in model_settings:try:model_provider_service.update_default_model_of_model_type(tenant_id=tenant_id,@@ -64,6 +63,13 @@ def configure_default_models_task(self, tenant_id: str, plugin_install_task_id:model,)+ if not any(model_type == ModelType.LLM for model_type, _, _ in model_settings):+ try:+ model_provider_service.initialize_default_llm(tenant_id)+ except Exception:+ failed_model_types.append(ModelType.LLM.value)+ logger.exception("Failed to initialize default LLM for tenant %s", tenant_id)+if plugin_install_failed or failed_model_types:raise RuntimeError(f"Failed to initialize defaults for tenant {tenant_id}; "@@ -89,11 +95,10 @@ def install_default_plugins_task(tenant_id: str, plugin_ids: list[str]) -> None:returnresponse = PluginService.install_from_marketplace_pkg(tenant_id, plugin_identifiers)- if dify_config.NEW_USER_DEFAULT_MODELS:- configure_default_models_task.delay(- tenant_id,- None if response.all_installed else response.task_id,- )+ configure_default_models_task.delay(+ tenant_id,+ None if response.all_installed else response.task_id,+ )except Exception:logger.exception("Failed to install default plugins for tenant %s", tenant_id)raisediff --git a/api/tests/unit_tests/core/test_provider_manager.py b/api/tests/unit_tests/core/test_provider_manager.pyindex 8f364f37f90..400281cce15 100644--- a/api/tests/unit_tests/core/test_provider_manager.py+++ b/api/tests/unit_tests/core/test_provider_manager.py@@ -9,7 +9,12 @@ from sqlalchemy import Engine, event, selectfrom sqlalchemy.orm import Session, sessionmakerfrom core import provider_manager as provider_manager_module-from core.entities.model_entities import DefaultModelSetting+from core.entities.model_entities import (+ DefaultModelSetting,+ ModelStatus,+ ModelWithProviderEntity,+ SimpleModelProviderEntity,+)from core.entities.provider_entities import (CustomConfiguration,CustomProviderConfiguration,@@ -22,7 +27,7 @@ from core.plugin.entities.plugin_daemon import PluginModelProviderDeclarationfrom core.provider_manager import ProviderConfigurationCacheSource, ProviderManagerfrom enums import DeploymentEditionfrom graphon.model_runtime.entities.common_entities import I18nObject-from graphon.model_runtime.entities.model_entities import ModelType+from graphon.model_runtime.entities.model_entities import FetchFrom, ModelTypefrom graphon.model_runtime.entities.provider_entities import ConfigurateMethodfrom models.base import TypeBasefrom models.provider import (@@ -512,80 +517,6 @@ def test__to_model_settings_lb_disabled(mock_provider_entity, provider_db: Sessiassert len(result[0].load_balancing_configs) == 0-def test_get_default_model_uses_first_available_active_model(provider_db: Session):- other_tenant_default = TenantDefaultModel(- tenant_id="other-tenant",- provider_name="anthropic",- model_name="claude",- model_type=ModelType.LLM,- )- provider_db.add(other_tenant_default)- provider_db.commit()- provider_configurations = Mock()- provider_configurations.get_models.return_value = [- Mock(model="gpt-3.5-turbo", provider=Mock(provider="openai")),- Mock(model="gpt-4", provider=Mock(provider="openai")),- ]-- manager = _build_provider_manager()- with (- patch.object(manager, "get_configurations", return_value=provider_configurations),- patch("core.provider_manager.ModelProviderFactory") as mock_factory_cls,- ):- mock_factory_cls.return_value.get_provider_schema.return_value = Mock(- provider="openai",- label=I18nObject(en_US="OpenAI", zh_Hans="OpenAI"),- icon_small=I18nObject(en_US="icon_small.png", zh_Hans="icon_small.png"),- supported_model_types=[ModelType.LLM],- )-- result = manager.get_default_model("tenant-id", ModelType.LLM)-- assert result is not None- assert result.model == "gpt-3.5-turbo"- assert result.provider.provider == "openai"- provider_configurations.get_models.assert_called_once_with(model_type=ModelType.LLM, only_active=True)- saved_default_model = provider_db.scalar(- select(TenantDefaultModel).where(TenantDefaultModel.tenant_id == "tenant-id")- )- assert saved_default_model is not None- assert saved_default_model.model_name == "gpt-3.5-turbo"- assert saved_default_model.provider_name == "openai"- assert (- provider_db.scalar(select(TenantDefaultModel).where(TenantDefaultModel.tenant_id == "other-tenant"))- is other_tenant_default- )---def test_get_default_model_returns_none_when_no_default_or_active_models(provider_db: Session):- provider_db.add(- TenantDefaultModel(- tenant_id="other-tenant",- provider_name="anthropic",- model_name="claude",- model_type=ModelType.LLM,- )- )- provider_db.commit()- provider_configurations = Mock()- provider_configurations.get_models.return_value = []- manager = _build_provider_manager()-- with (- patch.object(manager, "get_configurations", return_value=provider_configurations),- patch("core.provider_manager.ModelProviderFactory") as mock_factory_cls,- ):- result = manager.get_default_model("tenant-id", ModelType.LLM)-- assert result is None- provider_configurations.get_models.assert_called_once_with(model_type=ModelType.LLM, only_active=True)- mock_factory_cls.assert_not_called()- assert provider_db.scalar(select(TenantDefaultModel).where(TenantDefaultModel.tenant_id == "tenant-id")) is None- assert (- provider_db.scalar(select(TenantDefaultModel).where(TenantDefaultModel.tenant_id == "other-tenant")) is not None- )--def test_get_default_model_uses_injected_runtime_for_existing_default_record(provider_db: Session):existing_default_model = TenantDefaultModel(tenant_id="tenant-id",@@ -999,11 +930,23 @@ def test_replace_default_model_records_removes_omitted_types_only_for_current_te)provider_db.add_all([existing_default, omitted_default, other_tenant_default])provider_db.commit()+ embedding_provider = _build_plugin_provider_declaration(None)+ embedding_provider.supported_model_types = [ModelType.TEXT_EMBEDDING]+ available_embedding_model = ModelWithProviderEntity(+ model="text-embedding-3-small",+ label=I18nObject(en_US="text-embedding-3-small"),+ model_type=ModelType.TEXT_EMBEDDING,+ fetch_from=FetchFrom.PREDEFINED_MODEL,+ model_properties={},+ status=ModelStatus.ACTIVE,+ provider=SimpleModelProviderEntity(embedding_provider),+ )configurations = MagicMock()configurations.__contains__.return_value = Trueconfigurations.get_models.side_effect = lambda model_type, **_kwargs: {ModelType.LLM: [Mock(model="gpt-4")],ModelType.RERANK: [Mock(model="rerank-v3")],+ ModelType.TEXT_EMBEDDING: [available_embedding_model],}[model_type]settings = ([]@@ -1014,8 +957,16 @@ def test_replace_default_model_records_removes_omitted_types_only_for_current_te])- with patch.object(manager, "get_configurations", return_value=configurations) as get_configurations:+ with (+ patch.object(manager, "get_configurations", return_value=configurations) as get_configurations,+ patch("core.provider_manager.ModelProviderFactory") as mock_factory_cls,+ ):manager.replace_default_model_records("tenant-id", settings)+ provider_db.expire_all()+ for _ in range(2):+ assert manager.get_default_model("tenant-id", ModelType.TEXT_EMBEDDING) is None++ mock_factory_cls.assert_not_called()provider_db.expire_all()defaults = list(provider_db.scalars(select(TenantDefaultModel)))diff --git a/api/tests/unit_tests/services/test_model_provider_service.py b/api/tests/unit_tests/services/test_model_provider_service.pyindex 64146e1db67..980bb86b7a4 100644--- a/api/tests/unit_tests/services/test_model_provider_service.py+++ b/api/tests/unit_tests/services/test_model_provider_service.py@@ -5,9 +5,10 @@ from unittest.mock import MagicMock, create_autospecimport pytestfrom sqlalchemy import eventfrom sqlalchemy.engine import Engine+from sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.orm import Session-from core.entities.model_entities import ModelStatus, ModelWithProviderEntity+from core.entities.model_entities import ModelStatus, ModelWithProviderEntity, SimpleModelProviderEntityfrom core.entities.provider_configuration import ProviderConfigurationsfrom core.entities.provider_entities import CredentialConfigurationfrom core.plugin.entities.plugin import PluginInstallationSource@@ -15,7 +16,7 @@ from core.plugin.entities.plugin_daemon import PluginModelProviderBindingfrom enums import DeploymentEditionfrom graphon.model_runtime.entities.common_entities import I18nObjectfrom graphon.model_runtime.entities.model_entities import FetchFrom, ModelType, ParameterRule, ParameterType-from graphon.model_runtime.entities.provider_entities import ConfigurateMethod+from graphon.model_runtime.entities.provider_entities import ConfigurateMethod, ProviderEntityfrom models.account import Account, TenantAccountRolefrom models.provider import (Provider,@@ -38,6 +39,141 @@ def _create_service_with_mocked_manager() -> tuple[ModelProviderService, MagicMoreturn service, manager+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),+ )++[email protected]("has_active_models", [True, False])+def test_initialize_default_llm_selects_first_active_model_once(+ sqlite_session: Session, has_active_models: bool+) -> 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 = _create_service_with_mocked_manager()+ models = [_build_available_llm("gpt-4o-mini"), _build_available_llm("gpt-4o")] if has_active_models else []+ configurations = manager.get_configurations.return_value+ configurations.get_models.return_value = 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 configurations.get_models.call_count == (1 if has_active_models else 2)+ configurations.get_models.assert_called_with(model_type=ModelType.LLM, only_active=True)+++def test_initialize_default_llm_preserves_existing_selection(sqlite_session: Session) -> 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 = _create_service_with_mocked_manager()++ service.initialize_default_llm("tenant-1")++ manager.get_configurations.assert_not_called()+ sqlite_session.refresh(saved_default)+ assert (saved_default.provider_name, saved_default.model_name) == ("chosen-provider", "chosen-model")++[email protected]("selection_time", ["discovery", "insert"])+def test_initialize_default_llm_preserves_concurrent_selection(+ sqlite_session: Session, sqlite_engine: Engine, selection_time: str+) -> None:+ service, manager = _create_service_with_mocked_manager()+ 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")]++ manager.get_configurations.return_value.get_models.side_effect = 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")+++def test_initialize_default_llm_propagates_database_failure(sqlite_session: Session, sqlite_engine: Engine) -> None:+ service, manager = _create_service_with_mocked_manager()+ manager.get_configurations.return_value.get_models.return_value = [_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++def test_available_credentials_use_injected_query_for_admin_viewer() -> None:service, manager = _create_service_with_mocked_manager()user = Account(name="Admin", email="[email protected]")diff --git a/api/tests/unit_tests/tasks/test_install_default_plugins_task.py b/api/tests/unit_tests/tasks/test_install_default_plugins_task.pyindex e44f75ea497..2a24a374951 100644--- a/api/tests/unit_tests/tasks/test_install_default_plugins_task.py+++ b/api/tests/unit_tests/tasks/test_install_default_plugins_task.py@@ -1,11 +1,12 @@import loggingfrom types import SimpleNamespacefrom typing import Protocol, cast-from unittest.mock import MagicMock, call+from unittest.mock import MagicMock, call, patchimport pytestfrom celery.exceptions import Retry+from core.plugin.entities.plugin_daemon import PluginInstallTaskStartResponsefrom tests.unit_tests.config_override import apply_config_overrides@@ -41,10 +42,12 @@ def test_install_default_plugins_task_installs_latest_identifiers(monkeypatch: pmonkeypatch.setattr(task_module.marketplace, "batch_fetch_plugin_manifests", fetch)monkeypatch.setattr(task_module.PluginService, "install_from_marketplace_pkg", install)- install_default_plugins_task.run("tenant-1", plugin_ids)+ with patch.object(task_module.configure_default_models_task, "delay") as configure:+ install_default_plugins_task.run("tenant-1", plugin_ids)fetch.assert_called_once_with(plugin_ids)install.assert_called_once_with("tenant-1", plugin_identifiers)+ configure.assert_called_once_with("tenant-1", None)def test_install_default_plugins_task_skips_missing_plugins(@@ -63,47 +66,56 @@ def test_install_default_plugins_task_skips_missing_plugins(monkeypatch.setattr(task_module.marketplace, "batch_fetch_plugin_manifests", fetch)monkeypatch.setattr(task_module.PluginService, "install_from_marketplace_pkg", install)- with caplog.at_level(logging.WARNING, logger=task_module.logger.name):+ with (+ caplog.at_level(logging.WARNING, logger=task_module.logger.name),+ patch.object(task_module.configure_default_models_task, "delay"),+ ):install_default_plugins_task.run("tenant-1", ["langgenius/openai", "missing/plugin"])install.assert_called_once_with("tenant-1", ["langgenius/openai:1.0.0@aaa"])assert "Default plugins not found in marketplace: missing/plugin" in caplog.text[email protected]("configured_models", ["", "llm:provider:model"])[email protected]("all_installed", [False, True])def test_install_default_plugins_task_queues_model_configuration_after_daemon_install(monkeypatch: pytest.MonkeyPatch,+ configured_models: str,+ all_installed: bool,) -> None:import tasks.install_default_plugins_task as task_modulefrom tasks.install_default_plugins_task import install_default_plugins_taskplugin_id = "langgenius/openai"plugin_identifier = "langgenius/openai:1.0.0@aaa"- apply_config_overrides(monkeypatch, NEW_USER_DEFAULT_MODELS="llm:provider:model")+ apply_config_overrides(monkeypatch, NEW_USER_DEFAULT_MODELS=configured_models)monkeypatch.setattr(task_module.marketplace,"batch_fetch_plugin_manifests",MagicMock(return_value=[SimpleNamespace(plugin_id=plugin_id, latest_package_identifier=plugin_identifier)]),)- monkeypatch.setattr(- task_module.PluginService,- "install_from_marketplace_pkg",- MagicMock(return_value=SimpleNamespace(all_installed=False, task_id="install-task-1")),- )- delay = MagicMock()- monkeypatch.setattr(task_module.configure_default_models_task, "delay", delay)-- install_default_plugins_task.run("tenant-1", [plugin_id])+ with (+ patch.object(+ task_module.PluginService,+ "install_from_marketplace_pkg",+ return_value=PluginInstallTaskStartResponse(all_installed=all_installed, task_id="install-task-1"),+ ),+ patch.object(task_module.configure_default_models_task, "delay") as delay,+ ):+ install_default_plugins_task.run("tenant-1", [plugin_id])- delay.assert_called_once_with("tenant-1", "install-task-1")+ delay.assert_called_once_with("tenant-1", None if all_installed else "install-task-1")[email protected]("configured_models", ["", "llm:provider:model"])def test_configure_default_models_task_retries_while_plugins_are_installing(monkeypatch: pytest.MonkeyPatch,+ configured_models: str,) -> None:import tasks.install_default_plugins_task as task_modulefrom tasks.install_default_plugins_task import configure_default_models_task- apply_config_overrides(monkeypatch, NEW_USER_DEFAULT_MODELS="llm:provider:model")+ apply_config_overrides(monkeypatch, NEW_USER_DEFAULT_MODELS=configured_models)monkeypatch.setattr(task_module.PluginService,"fetch_install_task",@@ -155,3 +167,37 @@ def test_configure_default_models_task_sets_each_explicit_model(monkeypatch: pytmodel="text-embedding-3-small",),]+ model_provider_service.initialize_default_llm.assert_not_called()++[email protected]("configured_models", ["", "text-embedding:provider:embedding-model"])+def test_configure_default_models_task_initializes_llm_without_an_explicit_llm(+ monkeypatch: pytest.MonkeyPatch, configured_models: str+) -> None:+ import tasks.install_default_plugins_task as task_module++ apply_config_overrides(monkeypatch, NEW_USER_DEFAULT_MODELS=configured_models)+ with (+ patch.object(task_module.ModelProviderService, "initialize_default_llm") as initialize,+ patch.object(task_module.ModelProviderService, "update_default_model_of_model_type") as update,+ ):+ task_module.configure_default_models_task.run("tenant-1", None)++ initialize.assert_called_once_with("tenant-1")+ if configured_models:+ update.assert_called_once_with(+ tenant_id="tenant-1", model_type="text-embedding", provider="provider", model="embedding-model"+ )+ else:+ update.assert_not_called()+++def test_configure_default_models_task_reports_initialization_failure(monkeypatch: pytest.MonkeyPatch) -> None:+ import tasks.install_default_plugins_task as task_module++ apply_config_overrides(monkeypatch, NEW_USER_DEFAULT_MODELS="")+ with patch.object(+ task_module.ModelProviderService, "initialize_default_llm", side_effect=RuntimeError("unavailable")+ ):+ with pytest.raises(RuntimeError, match="Failed to initialize defaults for tenant tenant-1; model types: llm"):+ task_module.configure_default_models_task.run("tenant-1", None)