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): align hosted moderation provider validation (#44200)

林玮 (Jade Lin)73c2c696ff8f
diff --git a/api/core/helper/moderation.py b/api/core/helper/moderation.py
index 18b9b72e9de..520c6ad3d98 100644
--- a/api/core/helper/moderation.py
+++ b/api/core/helper/moderation.py
@@ -4,10 +4,13 @@ from typing import cast
from core.app.entities.app_invoke_entities import ModelConfigWithCredentialsEntity
from core.entities import DEFAULT_PLUGIN_ID
+from core.plugin.entities.plugin import PluginInstallationSource
+from core.plugin.entities.plugin_daemon import PluginModelProviderDeclaration
from core.plugin.impl.model_runtime_factory import create_plugin_model_assembly
+from core.plugin.plugin_service import PluginService
from extensions.ext_hosting_provider import hosting_configuration
from graphon.model_runtime.entities.model_entities import ModelType
-from graphon.model_runtime.errors.invoke import InvokeBadRequestError
+from graphon.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeBadRequestError
from graphon.model_runtime.model_providers.base.moderation_model import ModerationModel
from models.provider import ProviderType
@@ -46,6 +49,17 @@ def check_moderation(tenant_id: str, model_config: ModelConfigWithCredentialsEnt
provider=openai_provider_name, model_type=ModelType.MODERATION
)
model_type_instance = cast(ModerationModel, model_type_instance)
+ declaration = PluginModelProviderDeclaration.model_validate(model_type_instance.provider_schema)
+ if (
+ declaration.provider != openai_provider_name
+ or declaration.installation_source != PluginInstallationSource.Marketplace
+ or not PluginService.is_plugin_verified(tenant_id, declaration.plugin_unique_identifier)
+ ):
+ raise InvokeAuthorizationError("Untrusted hosted moderation provider.")
+ except Exception:
+ raise InvokeAuthorizationError("Untrusted hosted moderation provider.") from None
+
+ try:
moderation_result = model_type_instance.invoke(
model="omni-moderation-latest", credentials=hosting_openai_config.credentials, text=text_chunk
)
diff --git a/api/tests/unit_tests/core/helper/test_moderation.py b/api/tests/unit_tests/core/helper/test_moderation.py
index c33002329b2..d17e8d9d33d 100644
--- a/api/tests/unit_tests/core/helper/test_moderation.py
+++ b/api/tests/unit_tests/core/helper/test_moderation.py
@@ -1,158 +1,167 @@
-from types import SimpleNamespace
-from typing import cast
+from unittest.mock import MagicMock
import pytest
from pytest_mock import MockerFixture
from core.app.entities.app_invoke_entities import ModelConfigWithCredentialsEntity
from core.helper.moderation import check_moderation
-from graphon.model_runtime.errors.invoke import InvokeBadRequestError
+from core.hosting_configuration import HostedModerationConfig, HostingConfiguration, HostingProvider
+from core.plugin.entities.plugin import PluginInstallationSource
+from core.plugin.entities.plugin_daemon import PluginModelProviderDeclaration
+from core.plugin.impl.model import PluginModelClient
+from core.plugin.plugin_service import PluginService
+from graphon.model_runtime.entities.common_entities import I18nObject
+from graphon.model_runtime.entities.model_entities import ModelType
+from graphon.model_runtime.entities.provider_entities import ConfigurateMethod, ProviderEntity
+from graphon.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeBadRequestError
+from graphon.model_runtime.model_providers.model_provider_factory import ModelProviderFactory
from models.provider import ProviderType
+from tests.unit_tests.core.model_fixtures import make_model_config
+OPENAI_PROVIDER = "langgenius/openai/openai"
+ANTHROPIC_PROVIDER = "langgenius/anthropic/anthropic"
-def _build_model_config(provider: str = "openai") -> SimpleNamespace:
- return SimpleNamespace(
- provider=provider,
- provider_model_bundle=SimpleNamespace(
- configuration=SimpleNamespace(using_provider_type=ProviderType.SYSTEM),
- ),
- )
-
-
-def test_check_moderation_returns_false_when_feature_not_enabled(mocker: MockerFixture) -> None:
- mocker.patch(
- "core.helper.moderation.hosting_configuration",
- SimpleNamespace(moderation_config=None, provider_map={}),
- )
-
- assert (
- check_moderation(
- "tenant-1",
- cast(ModelConfigWithCredentialsEntity, _build_model_config()),
- "hello",
- )
- is False
- )
-
-
-def test_check_moderation_returns_false_when_hosting_credentials_missing(mocker: MockerFixture) -> None:
- openai_provider = "langgenius/openai/openai"
- mocker.patch(
- "core.helper.moderation.hosting_configuration",
- SimpleNamespace(
- moderation_config=SimpleNamespace(enabled=True, providers={"openai"}),
- provider_map={openai_provider: SimpleNamespace(enabled=True, credentials=None)},
- ),
- )
-
- assert (
- check_moderation(
- "tenant-1",
- cast(ModelConfigWithCredentialsEntity, _build_model_config()),
- "hello",
- )
- is False
- )
-
-
-def test_check_moderation_returns_true_when_model_accepts_text(mocker: MockerFixture) -> None:
- openai_provider = "langgenius/openai/openai"
- hosting_openai = SimpleNamespace(enabled=True, credentials={"api_key": "k"})
- mocker.patch(
- "core.helper.moderation.hosting_configuration",
- SimpleNamespace(
- moderation_config=SimpleNamespace(enabled=True, providers={"openai"}),
- provider_map={openai_provider: hosting_openai},
- ),
- )
- mocker.patch("core.helper.moderation.secrets.choice", return_value="chunk")
-
- moderation_model = SimpleNamespace(invoke=lambda **invoke_kwargs: invoke_kwargs["text"] == "chunk")
- assembly = SimpleNamespace(create_model_type_instance=lambda **_factory_kwargs: moderation_model)
- mocker.patch("core.helper.moderation.create_plugin_model_assembly", return_value=assembly)
-
- assert (
- check_moderation(
- "tenant-1",
- cast(ModelConfigWithCredentialsEntity, _build_model_config()),
- "abc",
- )
- is True
- )
-
-def test_check_moderation_returns_true_when_text_is_empty(mocker: MockerFixture) -> None:
- openai_provider = "langgenius/openai/openai"
- hosting_openai = SimpleNamespace(enabled=True, credentials={"api_key": "k"})
- mocker.patch(
- "core.helper.moderation.hosting_configuration",
- SimpleNamespace(
- moderation_config=SimpleNamespace(enabled=True, providers={"openai"}),
- provider_map={openai_provider: hosting_openai},
- ),
- )
- factory_mock = mocker.patch("core.helper.moderation.create_plugin_model_assembly")
- choice_mock = mocker.patch("core.helper.moderation.secrets.choice")
-
- assert (
- check_moderation(
- "tenant-1",
- cast(ModelConfigWithCredentialsEntity, _build_model_config()),
- "",
- )
- is True
[email protected](autouse=True)
+def hosting(mocker: MockerFixture) -> HostingConfiguration:
+ configuration = HostingConfiguration()
+ configuration.moderation_config = HostedModerationConfig(enabled=True, providers=[ANTHROPIC_PROVIDER])
+ configuration.provider_map[OPENAI_PROVIDER] = HostingProvider(
+ enabled=True, credentials={"api_key": "fake-hosted-key"}
)
- factory_mock.assert_not_called()
- choice_mock.assert_not_called()
-
-
-def test_check_moderation_returns_false_when_model_rejects_text(mocker: MockerFixture) -> None:
- openai_provider = "langgenius/openai/openai"
- hosting_openai = SimpleNamespace(enabled=True, credentials={"api_key": "k"})
- mocker.patch(
- "core.helper.moderation.hosting_configuration",
- SimpleNamespace(
- moderation_config=SimpleNamespace(enabled=True, providers={"openai"}),
- provider_map={openai_provider: hosting_openai},
- ),
+ mocker.patch("core.helper.moderation.hosting_configuration", configuration)
+ return configuration
+
+
+def model_config() -> ModelConfigWithCredentialsEntity:
+ configuration = make_model_config(provider=ANTHROPIC_PROVIDER, model="test-model", mode="chat")
+ configuration.provider_model_bundle.configuration.using_provider_type = ProviderType.SYSTEM
+ return configuration
+
+
[email protected](autouse=True)
+def provider_declaration(mocker: MockerFixture) -> PluginModelProviderDeclaration:
+ declaration = PluginModelProviderDeclaration(
+ provider=OPENAI_PROVIDER,
+ plugin_unique_identifier="langgenius/openai:1.0.0@checksum",
+ installation_source=PluginInstallationSource.Marketplace,
+ label=I18nObject(en_US="OpenAI"),
+ supported_model_types=[ModelType.MODERATION],
+ configurate_methods=[ConfigurateMethod.PREDEFINED_MODEL],
)
- mocker.patch("core.helper.moderation.secrets.choice", return_value="chunk")
-
- moderation_model = SimpleNamespace(invoke=lambda **_invoke_kwargs: False)
- assembly = SimpleNamespace(create_model_type_instance=lambda **_factory_kwargs: moderation_model)
- mocker.patch("core.helper.moderation.create_plugin_model_assembly", return_value=assembly)
-
- assert (
- check_moderation(
- "tenant-1",
- cast(ModelConfigWithCredentialsEntity, _build_model_config()),
- "abc",
- )
- is False
+ mocker.patch.object(PluginService, "fetch_plugin_model_providers", return_value=[declaration])
+ mocker.patch.object(PluginService, "is_plugin_verified", return_value=True)
+ return declaration
+
+
+def invoke(mocker: MockerFixture) -> MagicMock:
+ return mocker.patch.object(PluginModelClient, "invoke_moderation", return_value=False)
+
+
[email protected]("result", [False, True])
+def test_trusted_moderation_receives_hosted_credentials(
+ hosting: HostingConfiguration,
+ model_config: ModelConfigWithCredentialsEntity,
+ invoke: MagicMock,
+ provider_declaration: PluginModelProviderDeclaration,
+ mocker: MockerFixture,
+ result: bool,
+) -> None:
+ verified = mocker.patch.object(PluginService, "is_plugin_verified", return_value=True)
+ invoke.return_value = result
+
+ assert check_moderation("tenant-1", model_config, "hello") is result
+
+ verified.assert_called_once_with("tenant-1", provider_declaration.plugin_unique_identifier)
+ invoke.assert_called_once_with(
+ tenant_id="tenant-1",
+ user_id=None,
+ plugin_id="langgenius/openai",
+ provider="openai",
+ model="omni-moderation-latest",
+ credentials=hosting.provider_map[OPENAI_PROVIDER].credentials,
+ text="hello",
)
-def test_check_moderation_raises_bad_request_when_provider_call_fails(mocker: MockerFixture) -> None:
- openai_provider = "langgenius/openai/openai"
- hosting_openai = SimpleNamespace(enabled=True, credentials={"api_key": "k"})
- mocker.patch(
- "core.helper.moderation.hosting_configuration",
- SimpleNamespace(
- moderation_config=SimpleNamespace(enabled=True, providers={"openai"}),
- provider_map={openai_provider: hosting_openai},
- ),
- )
- mocker.patch("core.helper.moderation.secrets.choice", return_value="chunk")
-
- failing_model = SimpleNamespace(
- invoke=lambda **_invoke_kwargs: (_ for _ in ()).throw(RuntimeError("boom")),
- )
- assembly = SimpleNamespace(create_model_type_instance=lambda **_factory_kwargs: failing_model)
- mocker.patch("core.helper.moderation.create_plugin_model_assembly", return_value=assembly)
-
- with pytest.raises(InvokeBadRequestError, match="Rate limit exceeded, please try again later."):
- check_moderation(
- "tenant-1",
- cast(ModelConfigWithCredentialsEntity, _build_model_config()),
- "abc",
- )
+ "case", ["package", "github", "remote", "missing_source", "unverified", "verification_error", "invalid_schema"]
+)
+def test_provider_validation_fails_before_moderation_invocation(
+ model_config: ModelConfigWithCredentialsEntity,
+ provider_declaration: PluginModelProviderDeclaration,
+ invoke: MagicMock,
+ mocker: MockerFixture,
+ case: str,
+) -> None:
+ if case in {"package", "github", "remote"}:
+ provider_declaration.installation_source = PluginInstallationSource(case)
+ elif case == "missing_source":
+ provider_declaration.installation_source = None
+ elif case == "unverified":
+ mocker.patch.object(PluginService, "is_plugin_verified", return_value=False)
+ elif case == "verification_error":
+ mocker.patch.object(PluginService, "is_plugin_verified", side_effect=RuntimeError("private daemon detail"))
+ elif case == "invalid_schema":
+ schema = ProviderEntity.model_validate(provider_declaration.model_dump())
+ mocker.patch.object(ModelProviderFactory, "get_provider_schema", return_value=schema)
+
+ with pytest.raises(InvokeAuthorizationError, match="^Untrusted hosted moderation provider\\.$"):
+ check_moderation("tenant-1", model_config, "hello")
+
+ invoke.assert_not_called()
+
+
[email protected]("disabled", ["feature", "credentials", "allowlist", "custom_provider"])
+def test_check_moderation_skips_inapplicable_requests(
+ hosting: HostingConfiguration,
+ model_config: ModelConfigWithCredentialsEntity,
+ invoke: MagicMock,
+ mocker: MockerFixture,
+ disabled: str,
+) -> None:
+ if disabled == "feature":
+ hosting.moderation_config = None
+ elif disabled == "credentials":
+ hosting.provider_map[OPENAI_PROVIDER].credentials = None
+ elif disabled == "allowlist":
+ hosting.moderation_config = HostedModerationConfig(enabled=True, providers=[OPENAI_PROVIDER])
+ else:
+ model_config.provider_model_bundle.configuration.using_provider_type = ProviderType.CUSTOM
+ factory = mocker.spy(ModelProviderFactory, "get_provider_schema")
+
+ assert check_moderation("tenant-1", model_config, "hello") is False
+
+ factory.assert_not_called()
+ invoke.assert_not_called()
+
+
+def test_check_moderation_returns_true_when_text_is_empty(
+ model_config: ModelConfigWithCredentialsEntity, invoke: MagicMock
+) -> None:
+ assert check_moderation("tenant-1", model_config, "") is True
+ invoke.assert_not_called()
+
+
+def test_check_moderation_only_sends_selected_text_chunk(
+ model_config: ModelConfigWithCredentialsEntity,
+ invoke: MagicMock,
+ mocker: MockerFixture,
+) -> None:
+ choice = mocker.patch("core.helper.moderation.secrets.choice", return_value="tail")
+
+ assert check_moderation("tenant-1", model_config, "a" * 2000 + "tail") is False
+
+ choice.assert_called_once_with(["a" * 2000, "tail"])
+ assert invoke.call_args.kwargs["text"] == "tail"
+
+
+def test_check_moderation_raises_bad_request_when_provider_call_fails(
+ model_config: ModelConfigWithCredentialsEntity, invoke: MagicMock
+) -> None:
+ invoke.side_effect = RuntimeError("boom")
+
+ with pytest.raises(InvokeBadRequestError, match="Rate limit exceeded, please try again later"):
+ check_moderation("tenant-1", model_config, "hello")