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.

fix(api): initialize default LLMs during onboarding (#44350)

林玮 (Jade Lin)08d3c547ecb6
diff --git a/api/core/provider_manager.py b/api/core/provider_manager.py
index 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 None
diff --git a/api/services/model_provider/service.py b/api/services/model_provider/service.py
index 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, field
from typing import TYPE_CHECKING, Any
from sqlalchemy import and_, select
+from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from 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.py
index 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_config
from core.helper import marketplace
from core.plugin.entities.plugin_daemon import PluginInstallTaskStatus
from core.plugin.plugin_service import PluginService
+from graphon.model_runtime.entities.model_entities import ModelType
from services.model_provider.service import ModelProviderService
logger = 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 = False
if 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:
return
response = 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)
raise
diff --git a/api/tests/unit_tests/core/test_provider_manager.py b/api/tests/unit_tests/core/test_provider_manager.py
index 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, select
from sqlalchemy.orm import Session, sessionmaker
from 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 PluginModelProviderDeclaration
from core.provider_manager import ProviderConfigurationCacheSource, ProviderManager
from enums import DeploymentEdition
from 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, ModelType
from graphon.model_runtime.entities.provider_entities import ConfigurateMethod
from models.base import TypeBase
from models.provider import (
@@ -512,80 +517,6 @@ def test__to_model_settings_lb_disabled(mock_provider_entity, provider_db: Sessi
assert 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 = True
configurations.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.py
index 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_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
+from core.entities.model_entities import ModelStatus, ModelWithProviderEntity, SimpleModelProviderEntity
from core.entities.provider_configuration import ProviderConfigurations
from core.entities.provider_entities import CredentialConfiguration
from core.plugin.entities.plugin import PluginInstallationSource
@@ -15,7 +16,7 @@ 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
+from graphon.model_runtime.entities.provider_entities import ConfigurateMethod, ProviderEntity
from models.account import Account, TenantAccountRole
from models.provider import (
Provider,
@@ -38,6 +39,141 @@ def _create_service_with_mocked_manager() -> tuple[ModelProviderService, MagicMo
return 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.py
index 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 logging
from types import SimpleNamespace
from typing import Protocol, cast
-from unittest.mock import MagicMock, call
+from unittest.mock import MagicMock, call, patch
import pytest
from celery.exceptions import Retry
+from core.plugin.entities.plugin_daemon import PluginInstallTaskStartResponse
from tests.unit_tests.config_override import apply_config_overrides
@@ -41,10 +42,12 @@ def test_install_default_plugins_task_installs_latest_identifiers(monkeypatch: p
monkeypatch.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_module
from tasks.install_default_plugins_task import install_default_plugins_task
plugin_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_module
from 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: pyt
model="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)