refactor: update model provider to use ModelFactory for instance mana… (#223)

* refactor: update model provider to use ModelFactory for instance management

* refactor: integrate ModelFactory for model instance mapping in tests

* refactor: remove unused imports and clean up test files

Author: Mairuis

python/dify_plugin/core/plugin_registration.py

@@ -320,7 +320,7 @@ def _resolve_model_providers(self):
                         models[model_cls.model_type] = model_cls
 
             model_factory = ModelFactory(provider, models)
-            provider_instance = cls(provider, models)  # type: ignore
+            provider_instance = cls(provider, model_factory)  # type: ignore
             self.models_mapping[provider.provider] = (
                 provider,
                 provider_instance,

python/dify_plugin/interfaces/model/__init__.py

@@ -1,27 +1,30 @@
 from abc import ABC, abstractmethod
+from typing import final
 
+from dify_plugin.core.model_factory import ModelFactory
 from dify_plugin.entities.model import AIModelEntity, ModelType
 from dify_plugin.entities.model.provider import ProviderEntity
 from dify_plugin.interfaces.model.ai_model import AIModel
 
 
 class ModelProvider(ABC):
     provider_schema: ProviderEntity
-    model_instance_map: dict[ModelType, AIModel]
+    model_factory: ModelFactory
 
+    @final
     def __init__(
         self,
         provider_schemas: ProviderEntity,
-        model_instance_map: dict[ModelType, AIModel],
+        model_factory: ModelFactory,
     ):
         """
         Initialize model provider
 
         :param provider_schemas: provider schemas
-        :param model_instance_map: model instance map
+        :param model_factory: model factory
         """
         self.provider_schema = provider_schemas
-        self.model_instance_map = model_instance_map
+        self.model_factory = model_factory
 
     @abstractmethod
     def validate_provider_credentials(self, credentials: dict) -> None:
@@ -71,7 +74,4 @@ def get_model_instance(self, model_type: ModelType) -> AIModel:
         :param model_type: model type defined in `ModelType`
         :return:
         """
-        if model_type in self.model_instance_map:
-            return self.model_instance_map[model_type]
-
-        raise ValueError(f"Model instance not found for model type: {model_type}")
+        return self.model_factory.get_instance(model_type)

python/tests/interfaces/model/test_construct_model_provider.py

@@ -0,0 +1,33 @@
+from unittest.mock import MagicMock
+
+from dify_plugin.core.model_factory import ModelFactory
+from dify_plugin.entities import I18nObject
+from dify_plugin.entities.model import ModelType
+from dify_plugin.entities.model.provider import ProviderEntity
+from dify_plugin.interfaces.model import ModelProvider
+
+
+def test_construct_model_provider():
+    """
+    Ensure ModelProvider constructor is intact and usable.
+    This guards against overriding or changing __init__ signature.
+    """
+
+    class ProviderImpl(ModelProvider):
+        def validate_provider_credentials(self, credentials: dict) -> None:
+            pass
+
+    provider_schema = ProviderEntity(
+        provider="test",
+        label=I18nObject(en_US="test"),
+        supported_model_types=[ModelType.LLM],
+        configurate_methods=[],
+    )
+
+    model_factory = MagicMock(spec=ModelFactory)
+
+    provider = ProviderImpl(provider_schemas=provider_schema, model_factory=model_factory)
+
+    assert provider is not None
+    assert provider.get_provider_schema() == provider_schema
+    assert provider.model_factory is model_factory

python/tests/interfaces/model/test_model_registry_get_model.py

@@ -0,0 +1,35 @@
+from unittest.mock import MagicMock
+
+from dify_plugin.core.model_factory import ModelFactory
+from dify_plugin.entities import I18nObject
+from dify_plugin.entities.model import ModelType
+from dify_plugin.entities.model.provider import ProviderEntity
+from dify_plugin.interfaces.model import ModelProvider
+
+
+def test_model_provider_get_model_instance_delegates_to_factory():
+    """
+    Ensure ModelProvider.get_model_instance forwards to ModelFactory.get_instance.
+    Constructor usage mirrors test_construct_tool.py style (inline subclass, minimal init).
+    """
+
+    class MockModelProvider(ModelProvider):
+        def validate_provider_credentials(self, credentials: dict) -> None:
+            pass
+
+    provider_schema = ProviderEntity(
+        provider="test",
+        label=I18nObject(en_US="test"),
+        supported_model_types=[ModelType.LLM],
+        configurate_methods=[],
+    )
+
+    model_factory = MagicMock(spec=ModelFactory)
+    expected_instance = object()
+    model_factory.get_instance.return_value = expected_instance
+
+    provider = MockModelProvider(provider_schemas=provider_schema, model_factory=model_factory)
+
+    result = provider.get_model_instance(ModelType.LLM)
+    assert result is expected_instance
+    model_factory.get_instance.assert_called_once_with(ModelType.LLM)

python/tests/test_model_registry_get_model.py

@@ -148,7 +148,10 @@ def mock_resolve_plugin_cls(self: PluginRegistration):
                         supported_model_types=[ModelType.LLM],
                         configurate_methods=[],
                     ),
-                    model_instance_map={},
+                    model_factory=ModelFactory(
+                        provider=provider_configuration,
+                        models={ModelType.LLM: MockLLM},
+                    ),
                 ),
                 ModelFactory(
                     provider=provider_configuration,