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.

refactor(api): inject plugin dynamic option queries (#44576)

非法操作a83ce881a128
diff --git a/api/controllers/console/workspace/plugin.py b/api/controllers/console/workspace/plugin.py
index a9e4f964d93..6102f946a16 100644
--- a/api/controllers/console/workspace/plugin.py
+++ b/api/controllers/console/workspace/plugin.py
@@ -20,12 +20,12 @@ from controllers.common.schema import (
register_schema_models,
)
from controllers.console import console_ns
+from controllers.console.flask_admission import console_account_admission
from controllers.console.workspace import plugin_permission_required
from controllers.console.workspace.error import PluginOperationError
from controllers.console.wraps import (
RBACPermission,
account_initialization_required,
- is_admin_or_owner_required,
model_validate,
rbac_permission_required,
setup_required,
@@ -58,8 +58,10 @@ from libs.external_api import error_responses
from libs.flask_restx_compat import BINARY_RESPONSE_MEDIA_TYPES_VENDOR_KEY
from libs.helper import dump_response
from libs.login import login_required
+from machinery.context import RequestContext
from models.account import (
Account,
+ TenantAccountRole,
TenantPluginAutoUpgradeCategory,
TenantPluginAutoUpgradeMode,
TenantPluginAutoUpgradeStrategy,
@@ -70,7 +72,6 @@ from models.account import (
from models.provider_ids import ToolProviderID
from services.entities.model_provider_entities import ProviderEntityResponse
from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
-from services.plugin.plugin_parameter_service import PluginParameterService
from services.plugin.plugin_permission_service import PluginPermissionService
from services.tools.tools_transform_service import ToolTransformService
@@ -1158,26 +1159,22 @@ class PluginFetchDynamicSelectOptionsApi(Resource):
@error_responses(PluginOperationError)
@console_ns.doc(params=query_params_from_model(ParserDynamicOptions))
@console_ns.response(200, "Success", console_ns.models[PluginDynamicOptionsResponse.__name__])
- @setup_required
- @login_required
- @is_admin_or_owner_required
- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_MODEL_CONFIG, Workspace()))
- @account_initialization_required
- @with_current_user
- @with_current_tenant_id
+ @console_account_admission(
+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN}),
+ rbac_checks=(RBACCheck(RBACPermission.PLUGIN_MODEL_CONFIG, Workspace()),),
+ )
@model_validate(ParserDynamicOptions)
- def get(self, req_data: ParserDynamicOptions, tenant_id: str, current_user: Account):
+ def get(self, req_data: ParserDynamicOptions, context: RequestContext) -> dict[str, Any]:
try:
- options = PluginParameterService.get_dynamic_select_options(
- tenant_id=tenant_id,
- user_id=current_user.id,
+ options = application_services().workspaces.plugin_parameters.get_dynamic_select_options(
+ tenant_id=context.active_workspace_id,
+ user_id=context.account_id,
plugin_id=req_data.plugin_id,
provider=req_data.provider,
action=req_data.action,
parameter=req_data.parameter,
credential_id=req_data.credential_id,
provider_type=req_data.provider_type,
- builders=application_services().workspaces.trigger_builders,
)
except PluginDaemonClientSideError as e:
raise PluginOperationError(e.description) from e
@@ -1190,21 +1187,18 @@ class PluginFetchDynamicSelectOptionsWithCredentialsApi(Resource):
@error_responses(PluginOperationError)
@console_ns.expect(console_ns.models[ParserDynamicOptionsWithCredentials.__name__])
@console_ns.response(200, "Success", console_ns.models[PluginDynamicOptionsResponse.__name__])
- @setup_required
- @login_required
- @is_admin_or_owner_required
- @rbac_permission_required(RBACCheck(RBACPermission.CREDENTIAL_MANAGE, Workspace()))
- @account_initialization_required
- @with_current_user
- @with_current_tenant_id
+ @console_account_admission(
+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN}),
+ rbac_checks=(RBACCheck(RBACPermission.CREDENTIAL_MANAGE, Workspace()),),
+ )
@model_validate(ParserDynamicOptionsWithCredentials)
- def post(self, req_data: ParserDynamicOptionsWithCredentials, tenant_id: str, current_user: Account):
+ def post(self, req_data: ParserDynamicOptionsWithCredentials, context: RequestContext) -> dict[str, Any]:
"""Fetch dynamic options using credentials directly (for edit mode)."""
try:
- options = PluginParameterService.get_dynamic_select_options_with_credentials(
- tenant_id=tenant_id,
- user_id=current_user.id,
+ options = application_services().workspaces.plugin_parameters.get_dynamic_select_options_with_credentials(
+ tenant_id=context.active_workspace_id,
+ user_id=context.account_id,
plugin_id=req_data.plugin_id,
provider=req_data.provider,
action=req_data.action,
diff --git a/api/extensions/application_services/workspace.py b/api/extensions/application_services/workspace.py
index 8a55c787158..994b0588b58 100644
--- a/api/extensions/application_services/workspace.py
+++ b/api/extensions/application_services/workspace.py
@@ -10,6 +10,7 @@ from core.trigger.utils.encryption import delete_cache_for_subscription
from extensions.ext_redis import RedisClientWrapper
from repositories.account.repository import SQLAlchemyAccountRepository
from repositories.app.console_repository import ConsoleAppRepository
+from repositories.credentials.query_repository import CredentialQueryRepository
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository
from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
@@ -17,8 +18,9 @@ from repositories.trigger.subscription_repository import RedisTriggerSubscriptio
from repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepository
from repositories.workspace.workspace_repository import WorkspaceRepository
from services.account.adapters import RedisInvitationTokenStore
-from services.credentials.query import CredentialQuery
from services.file_service import FileService
+from services.plugin.plugin_parameter_gateway import DaemonPluginParameterGateway
+from services.plugin.plugin_parameter_service import PluginParameterService
from services.trigger.endpoint_gateway import PluginTriggerEndpointGateway, enqueue_triggered_workflows
from services.trigger.endpoint_service import TriggerEndpointService
from services.trigger.oauth_client_service import TriggerOAuthClientService
@@ -71,6 +73,7 @@ class WorkspaceServices:
invitations: WorkspaceInvitationService
identity: WorkspaceIdentityGateway
resource_cleanup: WorkspaceResourceCleanupService
+ plugin_parameters: PluginParameterService
trigger_providers: TriggerProviderQuery
trigger_subscriptions: TriggerSubscriptionQueryService
trigger_subscription_management: TriggerSubscriptionService
@@ -113,7 +116,7 @@ def build_workspace_services(
provisioning: WorkspaceProvisioningService,
registration: InvitedAccountRegistration,
invitation_tokens: RedisInvitationTokenStore,
- credentials: CredentialQuery,
+ credentials: CredentialQueryRepository,
) -> WorkspaceServices:
trigger_providers = PluginTriggerProviderQuery()
subscriptions = TriggerSubscriptionRepository(session_factory=database_client)
@@ -167,6 +170,12 @@ def build_workspace_services(
datasets=SQLAlchemyDatasetRepository(session_factory=database_client),
agent_resources=WorkspaceResourceCleanupRepository(session_factory=database_client),
),
+ plugin_parameters=PluginParameterService(
+ credentials=credentials,
+ subscriptions=subscriptions,
+ builders=trigger_builders,
+ plugins=DaemonPluginParameterGateway(),
+ ),
trigger_providers=trigger_providers,
trigger_subscriptions=TriggerSubscriptionQueryService(credentials=credentials, schemas=trigger_providers),
trigger_subscription_management=trigger_subscription_management,
diff --git a/api/repositories/credentials/query_repository.py b/api/repositories/credentials/query_repository.py
index 89605c4e85d..e0a8559aef1 100644
--- a/api/repositories/credentials/query_repository.py
+++ b/api/repositories/credentials/query_repository.py
@@ -1,6 +1,7 @@
"""Persistence-owned credential queries and visibility filtering shared across domains."""
from collections.abc import Sequence
+from copy import deepcopy
from typing import override
from sqlalchemy import and_, func, or_, select, update
@@ -20,6 +21,7 @@ from services.credentials.query import (
DatasourceCredentialListItem,
ModelCredentialRecord,
ToolCredentialRecord,
+ ToolCredentialSnapshot,
TriggerSubscriptionRecord,
)
from services.credentials.tool_runtime import ToolRuntimeCredential
@@ -64,7 +66,7 @@ def apply_credential_visibility_filter_for_actor(
class CredentialQueryRepository(CredentialQuery):
- """Load complete credential lists without exposing ORM objects or SQL to callers."""
+ """Load stored credentials without exposing ORM objects or SQL to callers."""
def __init__(self, *, session_factory: sessionmaker[Session]) -> None:
self._session_factory = session_factory
@@ -118,6 +120,25 @@ class CredentialQueryRepository(CredentialQuery):
assert isinstance(result, CursorResult)
return result.rowcount == 1
+ def get_tool(self, *, workspace_id: str, provider: str, credential_id: str | None) -> ToolCredentialSnapshot | None:
+ """Load one credential, using the configured default when its ID is absent or empty."""
+ query = select(BuiltinToolProvider).where(
+ BuiltinToolProvider.tenant_id == workspace_id, BuiltinToolProvider.provider == provider
+ )
+ if credential_id:
+ query = query.where(BuiltinToolProvider.id == credential_id)
+ else:
+ query = query.order_by(BuiltinToolProvider.is_default.desc(), BuiltinToolProvider.created_at.asc())
+ with self._session_factory() as session:
+ row = session.scalar(query.limit(1))
+ if row is None:
+ return None
+ return ToolCredentialSnapshot(
+ id=row.id,
+ credential_type=row.credential_type.value,
+ credentials=deepcopy(row.credentials),
+ )
+
@override
def list_models(self, *, workspace_id: str, provider: str, actor_id: str | None) -> Sequence[ModelCredentialRecord]:
names = [provider]
diff --git a/api/repositories/trigger/subscription_repository.py b/api/repositories/trigger/subscription_repository.py
index da7b3710545..964c3d54fab 100644
--- a/api/repositories/trigger/subscription_repository.py
+++ b/api/repositories/trigger/subscription_repository.py
@@ -76,6 +76,19 @@ class TriggerSubscriptionRepository(TriggerSubscriptionStore):
row = session.scalar(select(TriggerSubscription).where(TriggerSubscription.endpoint_id == endpoint_id))
return self._snapshot(row) if row is not None else None
+ def get_for_provider(
+ self, *, tenant_id: str, provider_id: TriggerProviderID, subscription_id: str | None
+ ) -> TriggerSubscriptionSnapshot | None:
+ """Load a provider subscription; an absent or empty ID preserves the legacy first-match lookup."""
+ query = select(TriggerSubscription).where(
+ TriggerSubscription.tenant_id == tenant_id, TriggerSubscription.provider_id == str(provider_id)
+ )
+ if subscription_id:
+ query = query.where(TriggerSubscription.id == subscription_id)
+ with self._session_factory() as session:
+ row = session.scalar(query.limit(1))
+ return self._snapshot(row) if row is not None else None
+
@override
def create(self, *, subscription: TriggerSubscriptionSnapshot, max_count: int) -> None:
try:
diff --git a/api/services/credentials/query.py b/api/services/credentials/query.py
index 54fb193b107..3ddddea98e9 100644
--- a/api/services/credentials/query.py
+++ b/api/services/credentials/query.py
@@ -1,4 +1,4 @@
-"""Consumer-owned read contracts for credential lists and their visibility policy."""
+"""Consumer-owned credential snapshots, lists, and visibility contracts."""
from collections.abc import Mapping, Sequence
from dataclasses import dataclass
@@ -37,6 +37,15 @@ class ToolCredentialRecord:
from_other_member: bool
+@dataclass(frozen=True, slots=True)
+class ToolCredentialSnapshot:
+ """Stored credentials for a tenant- and provider-scoped invocation."""
+
+ id: str
+ credential_type: str
+ credentials: Mapping[str, object]
+
+
@dataclass(frozen=True, slots=True)
class TriggerSubscriptionRecord:
id: str
diff --git a/api/services/plugin/plugin_parameter_gateway.py b/api/services/plugin/plugin_parameter_gateway.py
new file mode 100644
index 00000000000..c3617e0a29a
--- /dev/null
+++ b/api/services/plugin/plugin_parameter_gateway.py
@@ -0,0 +1,51 @@
+"""Resolve plugin providers and dispatch dynamic option requests to their package."""
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from core.plugin.entities.parameters import PluginParameterOption
+from core.plugin.impl.dynamic_select import DynamicSelectClient
+from core.tools.plugin_tool.provider import PluginToolProviderController
+from core.tools.tool_manager import ToolManager
+from core.trigger.provider import PluginTriggerProviderController
+from core.trigger.trigger_manager import TriggerManager
+from models.provider_ids import TriggerProviderID
+
+
+class DaemonPluginParameterGateway:
+ def get_tool_provider(self, *, tenant_id: str, provider: str) -> PluginToolProviderController:
+ return ToolManager.get_plugin_provider(provider=provider, tenant_id=tenant_id)
+
+ def get_trigger_provider(
+ self, *, tenant_id: str, provider_id: TriggerProviderID
+ ) -> PluginTriggerProviderController:
+ return TriggerManager.get_trigger_provider(tenant_id=tenant_id, provider_id=provider_id)
+
+ def fetch_options(
+ self,
+ *,
+ tenant_id: str,
+ user_id: str,
+ plugin_id: str,
+ provider: str,
+ action: str,
+ parameter: str,
+ credentials: Mapping[str, Any],
+ credential_type: str,
+ plugin_unique_identifier: str,
+ ) -> Sequence[PluginParameterOption]:
+ return (
+ DynamicSelectClient()
+ .fetch_dynamic_select_options(
+ tenant_id=tenant_id,
+ user_id=user_id,
+ plugin_id=plugin_id,
+ provider=provider,
+ action=action,
+ credentials=credentials,
+ credential_type=credential_type,
+ parameter=parameter,
+ plugin_unique_identifier=plugin_unique_identifier,
+ )
+ .options
+ )
diff --git a/api/services/plugin/plugin_parameter_service.py b/api/services/plugin/plugin_parameter_service.py
index b43f5bfea3d..6bdaea6e42d 100644
--- a/api/services/plugin/plugin_parameter_service.py
+++ b/api/services/plugin/plugin_parameter_service.py
@@ -1,27 +1,78 @@
-from collections.abc import Mapping, Sequence
-from typing import Any, Literal
+"""Resolve dynamic parameter credentials before invoking the plugin daemon."""
-from sqlalchemy import select
-from sqlalchemy.orm import Session
+from collections.abc import Mapping, Sequence
+from typing import Any, Literal, Protocol
+from constants import HIDDEN_VALUE
from core.plugin.entities.parameters import PluginParameterOption
from core.plugin.entities.plugin_daemon import CredentialType
-from core.plugin.impl.dynamic_select import DynamicSelectClient
-from core.tools.tool_manager import ToolManager
+from core.tools.plugin_tool.provider import PluginToolProviderController
from core.tools.utils.encryption import create_tool_provider_encrypter
-from core.trigger.entities.api_entities import TriggerProviderSubscriptionApiEntity
-from core.trigger.entities.entities import SubscriptionBuilder
-from core.trigger.trigger_manager import TriggerManager
-from extensions.ext_database import db
+from core.trigger.provider import PluginTriggerProviderController
+from core.trigger.utils.encryption import create_trigger_provider_encrypter
from models.provider_ids import TriggerProviderID
-from models.tools import BuiltinToolProvider
-from services.trigger.trigger_provider_service import TriggerProviderService
+from services.credentials.query import ToolCredentialSnapshot
+from services.trigger.subscription_service import TriggerSubscriptionSnapshot
from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderQuery
+class PluginParameterCredentials(Protocol):
+ def get_tool(
+ self, *, workspace_id: str, provider: str, credential_id: str | None
+ ) -> ToolCredentialSnapshot | None: ...
+
+
+class PluginParameterSubscriptions(Protocol):
+ def get_for_provider(
+ self, *, tenant_id: str, provider_id: TriggerProviderID, subscription_id: str | None
+ ) -> TriggerSubscriptionSnapshot | None: ...
+
+
+class PluginParameterGateway(Protocol):
+ def get_tool_provider(self, *, tenant_id: str, provider: str) -> PluginToolProviderController: ...
+
+ def get_trigger_provider(
+ self, *, tenant_id: str, provider_id: TriggerProviderID
+ ) -> PluginTriggerProviderController: ...
+
+ def fetch_options(
+ self,
+ *,
+ tenant_id: str,
+ user_id: str,
+ plugin_id: str,
+ provider: str,
+ action: str,
+ parameter: str,
+ credentials: Mapping[str, Any],
+ credential_type: str,
+ plugin_unique_identifier: str,
+ ) -> Sequence[PluginParameterOption]: ...
+
+
class PluginParameterService:
- @staticmethod
+ """Keep plugin and credential I/O outside repository-owned read sessions.
+
+ TODO: The shared RSA key provider still owns a scoped database session;
+ remove that dependency when its tenant key reads return detached values.
+ """
+
+ def __init__(
+ self,
+ *,
+ credentials: PluginParameterCredentials,
+ subscriptions: PluginParameterSubscriptions,
+ builders: TriggerSubscriptionBuilderQuery,
+ plugins: PluginParameterGateway,
+ ) -> None:
+ self._credentials = credentials
+ self._subscriptions = subscriptions
+ self._builders = builders
+ self._plugins = plugins
+
def get_dynamic_select_options(
+ self,
+ *,
tenant_id: str,
user_id: str,
plugin_id: str,
@@ -30,111 +81,77 @@ class PluginParameterService:
parameter: str,
credential_id: str | None,
provider_type: Literal["tool", "trigger"],
- *,
- builders: TriggerSubscriptionBuilderQuery,
) -> Sequence[PluginParameterOption]:
+ """Use a selected credential, or the provider's existing default lookup.
+
+ A trigger credential ID may also identify a builder owned by this user.
+ Only a missing/expired builder falls back to a persisted subscription.
"""
- Get dynamic select options for a plugin parameter.
-
- Args:
- tenant_id: The tenant ID.
- plugin_id: The plugin ID.
- provider: The provider name.
- action: The action name.
- parameter: The parameter name.
- """
- credentials: Mapping[str, Any] = {}
- credential_type: str = CredentialType.UNAUTHORIZED.value
provider_name = provider if "/" in provider else f"{plugin_id}/{provider}"
- match provider_type:
- case "tool":
- provider_controller = ToolManager.get_plugin_provider(provider_name, tenant_id)
- plugin_unique_identifier = provider_controller.plugin_unique_identifier
- credential_provider = provider_controller.entity.identity.name
- # init tool configuration
- encrypter, _ = create_tool_provider_encrypter(
+ credentials: Mapping[str, Any] = {}
+ credential_type = CredentialType.UNAUTHORIZED.value
+ if provider_type == "tool":
+ tool = self._plugins.get_tool_provider(tenant_id=tenant_id, provider=provider_name)
+ plugin_unique_identifier = tool.plugin_unique_identifier
+ if tool.need_credentials:
+ record = self._credentials.get_tool(
+ workspace_id=tenant_id, provider=tool.entity.identity.name, credential_id=credential_id
+ )
+ if record is None:
+ raise ValueError(f"Builtin provider {provider} not found when fetching credentials")
+ encrypter, _ = create_tool_provider_encrypter(tenant_id=tenant_id, controller=tool)
+ credentials = encrypter.decrypt(record.credentials)
+ credential_type = record.credential_type
+ else:
+ provider_id = TriggerProviderID(provider_name)
+ builder = (
+ self._builders.get_subscription_builder(
tenant_id=tenant_id,
- controller=provider_controller,
+ user_id=user_id,
+ provider_id=provider_id,
+ subscription_builder_id=credential_id,
)
-
- # check if credentials are required
- if not provider_controller.need_credentials:
- credentials = {}
- else:
- # fetch credentials from db
- with Session(db.engine) as session:
- if credential_id:
- db_record = session.scalar(
- select(BuiltinToolProvider)
- .where(
- BuiltinToolProvider.tenant_id == tenant_id,
- BuiltinToolProvider.provider == credential_provider,
- BuiltinToolProvider.id == credential_id,
- )
- .limit(1)
- )
- else:
- db_record = session.scalar(
- select(BuiltinToolProvider)
- .where(
- BuiltinToolProvider.tenant_id == tenant_id,
- BuiltinToolProvider.provider == credential_provider,
- )
- .order_by(BuiltinToolProvider.is_default.desc(), BuiltinToolProvider.created_at.asc())
- .limit(1)
- )
-
- if db_record is None:
- raise ValueError(f"Builtin provider {provider} not found when fetching credentials")
-
- credentials = encrypter.decrypt(db_record.credentials)
- credential_type = db_record.credential_type
- case "trigger":
- subscription: TriggerProviderSubscriptionApiEntity | SubscriptionBuilder | None
- if credential_id:
- subscription = builders.get_subscription_builder(
- tenant_id=tenant_id,
- user_id=user_id,
- provider_id=TriggerProviderID(provider_name),
- subscription_builder_id=credential_id,
- )
- if not subscription:
- trigger_subscription = TriggerProviderService.get_subscription_by_id(
- tenant_id, credential_id, provider_id=TriggerProviderID(provider_name)
- )
- subscription = trigger_subscription.to_api_entity() if trigger_subscription else None
- else:
- trigger_subscription = TriggerProviderService.get_subscription_by_id(
- tenant_id, provider_id=TriggerProviderID(provider_name)
- )
- subscription = trigger_subscription.to_api_entity() if trigger_subscription else None
-
- if subscription is None:
- raise ValueError(f"Subscription {credential_id} not found")
-
- trigger_controller = TriggerManager.get_trigger_provider(tenant_id, TriggerProviderID(provider_name))
- plugin_unique_identifier = trigger_controller.plugin_unique_identifier
- credentials = subscription.credentials
- credential_type = subscription.credential_type or CredentialType.UNAUTHORIZED
-
- return (
- DynamicSelectClient()
- .fetch_dynamic_select_options(
- tenant_id,
- user_id,
- plugin_id,
- provider_name,
- action,
- credentials,
- credential_type,
- parameter,
- plugin_unique_identifier=plugin_unique_identifier,
+ if credential_id
+ else None
)
- .options
+ subscription = (
+ None
+ if builder is not None
+ else self._require_subscription(
+ tenant_id=tenant_id, provider_id=provider_id, subscription_id=credential_id
+ )
+ )
+ trigger = self._plugins.get_trigger_provider(tenant_id=tenant_id, provider_id=provider_id)
+ plugin_unique_identifier = trigger.plugin_unique_identifier
+ if builder is not None:
+ credentials = builder.credentials
+ credential_type = builder.credential_type or CredentialType.UNAUTHORIZED.value
+ else:
+ assert subscription is not None
+ encrypter, _ = create_trigger_provider_encrypter(
+ tenant_id=tenant_id,
+ controller=trigger,
+ credential_id=subscription.id,
+ credential_type=subscription.credential_type,
+ )
+ credentials = encrypter.decrypt(subscription.credentials)
+ credential_type = subscription.credential_type or CredentialType.UNAUTHORIZED.value
+
+ return self._plugins.fetch_options(
+ tenant_id=tenant_id,
+ user_id=user_id,
+ plugin_id=plugin_id,
+ provider=provider_name,
+ action=action,
+ credentials=credentials,
+ credential_type=credential_type,
+ parameter=parameter,
+ plugin_unique_identifier=plugin_unique_identifier,
)
- @staticmethod
def get_dynamic_select_options_with_credentials(
+ self,
+ *,
tenant_id: str,
user_id: str,
plugin_id: str,
@@ -144,43 +161,41 @@ class PluginParameterService:
credential_id: str,
credentials: Mapping[str, Any],
) -> Sequence[PluginParameterOption]:
- """
- Get dynamic select options using provided credentials directly.
- Used for edit mode when credentials have been modified but not yet saved.
-
- Security: credential_id is validated against tenant_id to ensure
- users can only access their own credentials.
- """
- from constants import HIDDEN_VALUE
-
+ """Resolve hidden values from the owned subscription without persisting edits."""
provider_name = provider if "/" in provider else f"{plugin_id}/{provider}"
- # Get original subscription to replace hidden values (with tenant_id check for security)
- original_subscription = TriggerProviderService.get_subscription_by_id(
- tenant_id, credential_id, provider_id=TriggerProviderID(provider_name)
+ provider_id = TriggerProviderID(provider_name)
+ subscription = self._require_subscription(
+ tenant_id=tenant_id, provider_id=provider_id, subscription_id=credential_id
)
- if not original_subscription:
- raise ValueError(f"Subscription {credential_id} not found")
-
- provider_controller = TriggerManager.get_trigger_provider(tenant_id, TriggerProviderID(provider_name))
-
- # Replace [__HIDDEN__] with original values
- resolved_credentials: dict[str, Any] = {
- key: (original_subscription.credentials.get(key) if value == HIDDEN_VALUE else value)
- for key, value in credentials.items()
+ trigger = self._plugins.get_trigger_provider(tenant_id=tenant_id, provider_id=provider_id)
+ encrypter, _ = create_trigger_provider_encrypter(
+ tenant_id=tenant_id,
+ controller=trigger,
+ credential_id=subscription.id,
+ credential_type=subscription.credential_type,
+ )
+ original_credentials = encrypter.decrypt(subscription.credentials)
+ resolved_credentials = {
+ key: original_credentials.get(key) if value == HIDDEN_VALUE else value for key, value in credentials.items()
}
+ return self._plugins.fetch_options(
+ tenant_id=tenant_id,
+ user_id=user_id,
+ plugin_id=plugin_id,
+ provider=provider_name,
+ action=action,
+ credentials=resolved_credentials,
+ credential_type=subscription.credential_type or CredentialType.UNAUTHORIZED.value,
+ parameter=parameter,
+ plugin_unique_identifier=trigger.plugin_unique_identifier,
+ )
- return (
- DynamicSelectClient()
- .fetch_dynamic_select_options(
- tenant_id,
- user_id,
- plugin_id,
- provider_name,
- action,
- resolved_credentials,
- original_subscription.credential_type or CredentialType.UNAUTHORIZED.value,
- parameter,
- plugin_unique_identifier=provider_controller.plugin_unique_identifier,
- )
- .options
+ def _require_subscription(
+ self, *, tenant_id: str, provider_id: TriggerProviderID, subscription_id: str | None
+ ) -> TriggerSubscriptionSnapshot:
+ subscription = self._subscriptions.get_for_provider(
+ tenant_id=tenant_id, provider_id=provider_id, subscription_id=subscription_id
)
+ if subscription is None:
+ raise ValueError(f"Subscription {subscription_id} not found")
+ return subscription
diff --git a/api/tests/e2e_tests/containers/services/test_plugin_parameter.py b/api/tests/e2e_tests/containers/services/test_plugin_parameter.py
new file mode 100644
index 00000000000..6f0686a9fdd
--- /dev/null
+++ b/api/tests/e2e_tests/containers/services/test_plugin_parameter.py
@@ -0,0 +1,243 @@
+"""Dynamic-option credentials use real Redis, RSA, SQLite and daemon HTTP."""
+
+import json
+from collections.abc import Iterator
+from contextvars import Context
+from datetime import datetime, timedelta
+from http import HTTPStatus
+from urllib.parse import urlencode
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import select
+
+from constants import HIDDEN_VALUE
+from core.helper.encrypter import encrypt_token
+from core.helper.provider_cache import SingletonProviderCredentialsCache
+from core.plugin.entities.plugin_daemon import CredentialType
+from core.trigger.utils.encryption import TriggerProviderCredentialsCache
+from extensions.ext_redis import redis_client
+from models.tools import BuiltinToolProvider
+from models.trigger import TriggerSubscription
+from tests.e2e_tests.containers.services import test_trigger_builder_callers
+from tests.e2e_tests.containers.services.test_trigger_subscription_query import _provider_with_secrets
+from tests.unit_tests.controllers.console.workspace.test_plugin_parameter import (
+ _PAYLOAD,
+ _URL,
+ _options_response,
+ _tool_provider,
+)
+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness
+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_builder import _Daemon
+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_query import _add_subscription
+
+sqlite_engine = test_trigger_builder_callers.sqlite_engine
+sqlite_session_factory = test_trigger_builder_callers.sqlite_session_factory
+application_redis = test_trigger_builder_callers.application_redis
+harness = test_trigger_builder_callers.harness
+daemon = test_trigger_builder_callers.daemon
+runtime = test_trigger_builder_callers.runtime
+
+
[email protected](autouse=True)
+def credential_cache_cleanup(harness: _Harness) -> Iterator[None]:
+ yield
+ with harness.session_factory() as session:
+ subscription_ids = session.scalars(
+ select(TriggerSubscription.id).where(TriggerSubscription.tenant_id == harness.tenant_id)
+ ).all()
+ keys = [
+ SingletonProviderCredentialsCache(
+ tenant_id=harness.tenant_id, provider_type="plugin", provider_identity=_PROVIDER
+ ).cache_key,
+ *[
+ TriggerProviderCredentialsCache(
+ tenant_id=harness.tenant_id, provider_id=_PROVIDER, credential_id=subscription_id
+ ).cache_key
+ for subscription_id in subscription_ids
+ ],
+ ]
+ redis_client.delete(*keys)
+
+
+def _add_tool_credentials(
+ harness: _Harness,
+ *,
+ token: str,
+ tenant_id: str | None = None,
+ provider: str = _PROVIDER,
+ is_default: bool = False,
+ created_at: datetime | None = None,
+) -> BuiltinToolProvider:
+ with harness.app.app_context():
+ ciphertext = encrypt_token(harness.tenant_id, token)
+ credential = BuiltinToolProvider(
+ tenant_id=tenant_id or harness.tenant_id,
+ user_id=harness.account_id,
+ provider=provider,
+ name=token,
+ encrypted_credentials=json.dumps({"token": ciphertext}),
+ credential_type=CredentialType.API_KEY,
+ is_default=is_default,
+ )
+ if created_at is not None:
+ credential.created_at = created_at
+ with harness.session_factory.begin() as session:
+ session.add(credential)
+ return credential
+
+
+def _get_url(provider_type: str, credential_id: str | None = None) -> str:
+ params = {**_PAYLOAD, "provider_type": provider_type}
+ if credential_id is not None:
+ params["credential_id"] = credential_id
+ return f"{_URL}?{urlencode(params)}"
+
+
+def _assert_dispatch(daemon: _Daemon, harness: _Harness, credentials: dict[str, object]) -> None:
+ dispatch = [request for request in daemon.requests if request.method == "POST"]
+ assert len(dispatch) == 1
+ assert all(not request.open_transactions for request in daemon.requests)
+ sent = dispatch[0]
+ assert sent.path == f"/plugin/{harness.tenant_id}/dispatch/dynamic_select/fetch_parameter_options"
+ assert sent.headers["X-Plugin-ID"] == "langgenius/github"
+ assert sent.headers["X-Plugin-Unique-Identifier"] == daemon.provider["plugin_unique_identifier"]
+ assert sent.payload == {
+ "user_id": harness.account_id,
+ "data": {
+ "provider": "github",
+ "credentials": credentials,
+ "credential_type": CredentialType.API_KEY,
+ "provider_action": "push",
+ "parameter": "branch",
+ },
+ }
+
+
[email protected]("selection", ["explicit", "default", "oldest"])
+def test_tool_credentials_select_owned_record_and_decrypt_after_repository_close(
+ harness: _Harness, daemon: _Daemon, selection: str
+) -> None:
+ daemon.provider = _tool_provider(credentials=True)
+ _options_response(daemon)
+ now = datetime(2026, 1, 1)
+ _add_tool_credentials(harness, token="foreign-tenant", tenant_id=str(uuid4()), is_default=True)
+ _add_tool_credentials(harness, token="foreign-provider", provider="langgenius/github/other", is_default=True)
+ oldest = _add_tool_credentials(harness, token="oldest", created_at=now)
+ newer = _add_tool_credentials(
+ harness, token="newer", created_at=now + timedelta(days=1), is_default=selection == "default"
+ )
+ chosen = oldest if selection == "oldest" else newer
+
+ response = Context().run(harness.call, "GET", url=_get_url("tool", chosen.id if selection == "explicit" else None))
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json()["options"][0]["value"] == "101"
+ _assert_dispatch(daemon, harness, {"token": chosen.name})
+ with harness.session_factory() as session:
+ saved = session.get(BuiltinToolProvider, chosen.id)
+ assert saved is not None
+ assert saved.credentials["token"] != chosen.name
+
+
[email protected]("scope", ["tenant", "provider"])
+def test_tool_explicit_credential_cannot_fall_back_to_an_owned_record(
+ harness: _Harness, daemon: _Daemon, scope: str
+) -> None:
+ daemon.provider = _tool_provider(credentials=True)
+ _add_tool_credentials(harness, token="owned", is_default=True)
+ foreign = _add_tool_credentials(
+ harness,
+ token="foreign",
+ tenant_id=str(uuid4()) if scope == "tenant" else None,
+ provider="langgenius/github/other" if scope == "provider" else _PROVIDER,
+ )
+
+ response = Context().run(harness.call, "GET", url=_get_url("tool", foreign.id))
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "invalid_param"
+ assert [request.method for request in daemon.requests] == ["GET"]
+
+
[email protected]("explicit", [False, True])
+def test_trigger_credentials_use_owned_subscription_and_package(
+ harness: _Harness, daemon: _Daemon, explicit: bool
+) -> None:
+ daemon.provider = _provider_with_secrets()
+ _options_response(daemon)
+ _add_subscription(harness, tenant_id=str(uuid4()), credentials={"token": "foreign"})
+ _add_subscription(harness, provider_id="langgenius/github/other", credentials={"token": "foreign"})
+ ciphertext = encrypt_token(harness.tenant_id, "trigger-secret")
+ owned = _add_subscription(harness, credentials={"token": ciphertext})
+
+ response = Context().run(harness.call, "GET", url=_get_url("trigger", owned.id if explicit else None))
+
+ assert response.status_code == HTTPStatus.OK
+ _assert_dispatch(daemon, harness, {"token": "trigger-secret"})
+ with harness.session_factory() as session:
+ saved = session.get(TriggerSubscription, owned.id)
+ assert saved is not None
+ assert saved.credentials["token"] == ciphertext
+
+
[email protected]("method", ["GET", "POST"])
[email protected]("scope", ["tenant", "provider", "missing"])
+def test_trigger_credentials_are_scoped_to_provider_and_workspace(
+ harness: _Harness, daemon: _Daemon, method: str, scope: str
+) -> None:
+ _add_subscription(harness, credentials={"token": "owned"})
+ foreign = _add_subscription(
+ harness,
+ name="candidate",
+ tenant_id=str(uuid4()) if scope == "tenant" else None,
+ provider_id="langgenius/github/other" if scope == "provider" else _PROVIDER,
+ )
+ credential_id = str(uuid4()) if scope == "missing" else foreign.id
+ response = Context().run(
+ harness.call,
+ method,
+ url=_get_url("trigger", credential_id) if method == "GET" else f"{_URL}-with-credentials",
+ payload={**_PAYLOAD, "credential_id": credential_id, "credentials": {}} if method == "POST" else None,
+ )
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "invalid_param"
+ assert "not found" in response.get_json()["message"]
+ assert daemon.requests == []
+
+
+def test_supplied_trigger_credentials_only_replace_hidden_keys_and_never_persist(
+ harness: _Harness, daemon: _Daemon
+) -> None:
+ daemon.provider = _provider_with_secrets()
+ _options_response(daemon)
+ with harness.app.app_context():
+ ciphertext = encrypt_token(harness.tenant_id, "stored-secret")
+ stored_credentials = {"token": ciphertext, "username": "old-user", "omitted": "stored-only"}
+ owned = _add_subscription(harness, credentials=stored_credentials)
+ request_credentials: dict[str, object] = {
+ "token": HIDDEN_VALUE,
+ "username": "new-user",
+ "empty": "",
+ "zero": 0,
+ "false": False,
+ "null": None,
+ "unknown_hidden": HIDDEN_VALUE,
+ }
+
+ response = Context().run(
+ harness.call,
+ "POST",
+ url=f"{_URL}-with-credentials",
+ payload={**_PAYLOAD, "credential_id": owned.id, "credentials": request_credentials},
+ )
+
+ assert response.status_code == HTTPStatus.OK
+ _assert_dispatch(daemon, harness, {**request_credentials, "token": "stored-secret", "unknown_hidden": None})
+ with harness.session_factory() as session:
+ saved = session.get(TriggerSubscription, owned.id)
+ assert saved is not None
+ assert saved.credentials == stored_credentials
diff --git a/api/tests/e2e_tests/containers/services/test_trigger_builder_callers.py b/api/tests/e2e_tests/containers/services/test_trigger_builder_callers.py
index 035b8604ed3..88d2470195a 100644
--- a/api/tests/e2e_tests/containers/services/test_trigger_builder_callers.py
+++ b/api/tests/e2e_tests/containers/services/test_trigger_builder_callers.py
@@ -19,7 +19,6 @@ from extensions.ext_redis import RedisClientWrapper, redis_client
from models.provider_ids import TriggerProviderID
from models.trigger import TriggerSubscription
from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
-from services.plugin.plugin_parameter_service import PluginParameterService
from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
from tests.e2e_tests.containers.services import test_trigger_subscription_query
from tests.unit_tests.controllers.console.workspace import test_trigger_subscription_builder
@@ -120,7 +119,7 @@ def test_dynamic_select_uses_owned_builder_credentials_and_package(
_options_response(daemon)
daemon.requests.clear()
- options = PluginParameterService.get_dynamic_select_options(
+ options = application_services().workspaces.plugin_parameters.get_dynamic_select_options(
tenant_id=harness.tenant_id,
user_id=harness.account_id,
plugin_id=_PROVIDER_ID.plugin_id,
@@ -129,7 +128,6 @@ def test_dynamic_select_uses_owned_builder_credentials_and_package(
parameter="branch",
credential_id=builder_id,
provider_type="trigger",
- builders=runtime.builders,
)
assert [(option.value, option.label.en_US) for option in options] == [("main", "Main branch")]
@@ -170,7 +168,7 @@ def test_dynamic_select_rejects_builder_owner_mismatch_before_persisted_fallback
daemon.requests.clear()
with pytest.raises(ValueError, match="not found"):
- PluginParameterService.get_dynamic_select_options(
+ application_services().workspaces.plugin_parameters.get_dynamic_select_options(
tenant_id=tenant_id,
user_id=user_id,
plugin_id=provider_id.plugin_id,
@@ -179,15 +177,13 @@ def test_dynamic_select_rejects_builder_owner_mismatch_before_persisted_fallback
parameter="branch",
credential_id=builder_id,
provider_type="trigger",
- builders=runtime.builders,
)
assert daemon.requests == []
-def test_dynamic_select_uses_persisted_subscription_after_builder_expires(
- harness: _Harness, runtime: _Runtime, daemon: _Daemon
-) -> None:
+def test_dynamic_select_uses_persisted_subscription_after_builder_expires(harness: _Harness, daemon: _Daemon) -> None:
subscription_id = str(uuid4())
_persist_subscription(
harness,
@@ -198,7 +194,7 @@ def test_dynamic_select_uses_persisted_subscription_after_builder_expires(
)
_options_response(daemon)
- options = PluginParameterService.get_dynamic_select_options(
+ options = application_services().workspaces.plugin_parameters.get_dynamic_select_options(
tenant_id=harness.tenant_id,
user_id=harness.account_id,
plugin_id=_PROVIDER_ID.plugin_id,
@@ -207,7 +203,6 @@ def test_dynamic_select_uses_persisted_subscription_after_builder_expires(
parameter="branch",
credential_id=subscription_id,
provider_type="trigger",
- builders=runtime.builders,
)
assert [option.value for option in options] == ["main"]
@@ -222,11 +217,10 @@ def test_dynamic_select_uses_persisted_subscription_after_builder_expires(
}
-def test_dynamic_select_rejects_missing_builder_and_subscription(
- harness: _Harness, runtime: _Runtime, daemon: _Daemon
-) -> None:
+def test_dynamic_select_rejects_missing_builder_and_subscription(harness: _Harness, daemon: _Daemon) -> None:
with pytest.raises(ValueError, match="not found"):
- PluginParameterService.get_dynamic_select_options(
+ application_services().workspaces.plugin_parameters.get_dynamic_select_options(
tenant_id=harness.tenant_id,
user_id=harness.account_id,
plugin_id=_PROVIDER_ID.plugin_id,
@@ -235,7 +229,6 @@ def test_dynamic_select_rejects_missing_builder_and_subscription(
parameter="branch",
credential_id=str(uuid4()),
provider_type="trigger",
- builders=runtime.builders,
)
assert daemon.requests == []
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_plugin.py b/api/tests/unit_tests/controllers/console/workspace/test_plugin.py
index be3519629a1..9650c4cefa6 100644
--- a/api/tests/unit_tests/controllers/console/workspace/test_plugin.py
+++ b/api/tests/unit_tests/controllers/console/workspace/test_plugin.py
@@ -6,7 +6,6 @@ from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
-from sqlalchemy.orm import Session, sessionmaker
from werkzeug.datastructures import FileStorage
from werkzeug.exceptions import Forbidden
@@ -14,8 +13,6 @@ from controllers.console.workspace.plugin import (
ParserAsset,
ParserAutoUpgradeChange,
ParserAutoUpgradeFetch,
- ParserDynamicOptions,
- ParserDynamicOptionsWithCredentials,
ParserExcludePlugin,
ParserGithubInstall,
ParserGithubUpgrade,
@@ -40,8 +37,6 @@ from controllers.console.workspace.plugin import (
PluginDeleteInstallTaskApi,
PluginDeleteInstallTaskItemApi,
PluginFetchAutoUpgradeApi,
- PluginFetchDynamicSelectOptionsApi,
- PluginFetchDynamicSelectOptionsWithCredentialsApi,
PluginFetchInstallTaskApi,
PluginFetchInstallTasksApi,
PluginFetchManifestApi,
@@ -65,7 +60,6 @@ from controllers.console.workspace.plugin import (
PluginUploadFromPkgApi,
_list_hardcoded_builtin_tool_providers,
)
-from core.plugin.entities.parameters import PluginParameterOption
from core.plugin.entities.plugin import PluginCategory, PluginDeclaration, PluginEntity, PluginInstallation
from core.plugin.entities.plugin_daemon import PluginInstallTask
from core.plugin.impl.exc import PluginDaemonClientSideError
@@ -73,9 +67,6 @@ from core.plugin.plugin_service import PluginService
from core.tools.entities.api_entities import ToolProviderApiEntity
from core.tools.entities.common_entities import I18nObject
from core.tools.entities.tool_entities import ToolProviderType
-from enums import DeploymentEdition
-from extensions.ext_application_services import build_application_services
-from extensions.ext_redis import RedisClientWrapper
from models.account import (
Account,
TenantAccountRole,
@@ -89,9 +80,6 @@ from models.account import (
from tests.helpers.unit.config_override import config_overrides_context
from tests.helpers.unit.controllers.error_body import raised_error
from tests.helpers.unit.model_factories import make_account
-from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client
-
-application_redis = test_trigger_oauth_client.application_redis
def _plugin_category_list_item(category: str = "tool") -> dict[str, Any]:
@@ -348,24 +336,6 @@ def _expected_latest_plugin_cache_dump() -> dict[str, str]:
}
-def _dynamic_option() -> PluginParameterOption:
- return PluginParameterOption.model_validate(
- {
- "value": 101,
- "label": {"en_US": "Dataset 101"},
- "icon": None,
- }
- )
-
-
-def _expected_dynamic_option_dump() -> dict[str, Any]:
- return {
- "value": "101",
- "label": _expected_i18n("Dataset 101"),
- "icon": None,
- }
-
-
def _account(role: TenantAccountRole = TenantAccountRole.OWNER) -> Account:
return make_account(account_id="u1", name="Test User", email="[email protected]", role=role)
@@ -766,44 +736,6 @@ class TestPluginFetchPermissionApi:
assert result["debug_permission"] == TenantPluginDebugPermission.EVERYONE
-class TestPluginFetchDynamicSelectOptionsApi:
- def test_fetch_dynamic_options(
- self,
- user: Account,
- sqlite_session_factory: sessionmaker[Session],
- application_redis: RedisClientWrapper,
- ) -> None:
- app = Flask(__name__)
- services = build_application_services(
- database_client=sqlite_session_factory,
- deployment_edition=DeploymentEdition.COMMUNITY,
- initialization_password="",
- redis=application_redis,
- )
- app.extensions["application_services"] = services
- api = PluginFetchDynamicSelectOptionsApi()
- method = unwrap(api.get)
-
- with (
- app.test_request_context("/?plugin_id=p&provider=x&action=y&parameter=z&provider_type=tool"),
- patch(
- "controllers.console.workspace.plugin.PluginParameterService.get_dynamic_select_options",
- return_value=[_dynamic_option()],
- ) as get_options,
- ):
- result = method(
- api,
- ParserDynamicOptions.model_validate(
- {"plugin_id": "p", "provider": "x", "action": "y", "parameter": "z", "provider_type": "tool"}
- ),
- "t1",
- user,
- )
-
- assert result == {"options": [_expected_dynamic_option_dump()]}
- assert get_options.call_args.kwargs["builders"] is services.workspaces.trigger_builders
-
-
class TestPluginReadmeApi:
def test_fetch_readme(self, app: Flask):
api = PluginReadmeApi()
@@ -1362,57 +1294,6 @@ class TestPluginUpgradeFromGithubApi:
assert result == ({"code": "plugin_error", "message": "error"}, 400)
-class TestPluginFetchDynamicSelectOptionsWithCredentialsApi:
- def test_success(self, app: Flask, user):
- api = PluginFetchDynamicSelectOptionsWithCredentialsApi()
- method = unwrap(api.post)
-
- payload = {
- "plugin_id": "p",
- "provider": "x",
- "action": "y",
- "parameter": "z",
- "credential_id": "c",
- "credentials": {"k": "v"},
- }
-
- with (
- app.test_request_context("/", json=payload),
- patch(
- "controllers.console.workspace.plugin.PluginParameterService.get_dynamic_select_options_with_credentials",
- return_value=[_dynamic_option()],
- ),
- ):
- result = method(api, ParserDynamicOptionsWithCredentials.model_validate(payload), "t1", user)
-
- assert result == {"options": [_expected_dynamic_option_dump()]}
-
- def test_daemon_error(self, app: Flask, user):
- api = PluginFetchDynamicSelectOptionsWithCredentialsApi()
- method = unwrap(api.post)
-
- payload = {
- "plugin_id": "p",
- "provider": "x",
- "action": "y",
- "parameter": "z",
- "credential_id": "c",
- "credentials": {"k": "v"},
- }
-
- with (
- app.test_request_context("/", json=payload),
- patch(
- "controllers.console.workspace.plugin.PluginParameterService.get_dynamic_select_options_with_credentials",
- side_effect=PluginDaemonClientSideError("error"),
- ),
- ):
- result = raised_error(
- lambda: method(api, ParserDynamicOptionsWithCredentials.model_validate(payload), "t1", user)
- )
- assert result == ({"code": "plugin_error", "message": "error"}, 400)
-
-
class TestPluginChangeAutoUpgradeApi:
def test_success(self, app: Flask):
api = PluginChangeAutoUpgradeApi()
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_plugin_parameter.py b/api/tests/unit_tests/controllers/console/workspace/test_plugin_parameter.py
new file mode 100644
index 00000000000..dd3ae52fb1d
--- /dev/null
+++ b/api/tests/unit_tests/controllers/console/workspace/test_plugin_parameter.py
@@ -0,0 +1,222 @@
+"""Dynamic options run through real admission, SQL and plugin HTTP transport.
+
+Credential decryption and builder lookup use Redis and are covered separately by
+container tests. These cases never require the unit suite's global Redis double.
+"""
+
+from contextvars import Context
+from http import HTTPStatus
+from urllib.parse import urlencode
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import delete
+
+from core.entities.provider_entities import ProviderConfig, ProviderConfigType
+from models import TenantAccountJoin
+from models.account import TenantAccountRole
+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client, test_trigger_subscription_builder
+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _Harness
+from tests.unit_tests.controllers.console.workspace.test_trigger_provider_query import _provider
+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_builder import _Daemon
+
+application_redis = test_trigger_oauth_client.application_redis
+harness = test_trigger_oauth_client.harness
+daemon = test_trigger_subscription_builder.daemon
+
+_URL = "/console/api/workspaces/current/plugin/parameters/dynamic-options"
+_PAYLOAD: dict[str, object] = {
+ "plugin_id": "langgenius/github",
+ "provider": "github",
+ "action": "push",
+ "parameter": "branch",
+}
+
+
+def _tool_provider(*, credentials: bool = False) -> dict[str, object]:
+ provider = _provider()
+ declaration = provider["declaration"]
+ assert isinstance(declaration, dict)
+ declaration.pop("events")
+ identity = declaration["identity"]
+ assert isinstance(identity, dict)
+ identity["tags"] = ["other"]
+ if credentials:
+ declaration["credentials_schema"] = [
+ ProviderConfig(name="token", type=ProviderConfigType.SECRET_INPUT).model_dump(mode="json")
+ ]
+ return provider
+
+
+def _options_response(daemon: _Daemon) -> None:
+ daemon.response_data = {"options": [{"value": 101, "label": {"en_US": "Branch 101"}, "icon": None}]}
+
+
+def _url(method: str, *, credential_id: str | None = None) -> str:
+ if method == "POST":
+ return f"{_URL}-with-credentials"
+ params = {**_PAYLOAD, "provider_type": "tool"}
+ if credential_id is not None:
+ params["credential_id"] = credential_id
+ return f"{_URL}?{urlencode(params)}"
+
+
+def _payload(method: str) -> dict[str, object] | None:
+ if method == "POST":
+ return {**_PAYLOAD, "credential_id": "subscription-id", "credentials": {}}
+ return None
+
+
[email protected]("method", ["GET", "POST"])
+def test_options_require_login_before_plugin_io(harness: _Harness, daemon: _Daemon, method: str) -> None:
+ response = harness.client.open(_url(method), method=method, json=_payload(method))
+
+ assert response.status_code == HTTPStatus.UNAUTHORIZED
+ assert response.get_json()["code"] == "unauthorized"
+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'
+ assert daemon.requests == []
+
+
[email protected]("method", ["GET", "POST"])
+ "role", [TenantAccountRole.EDITOR, TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR]
+)
+def test_options_require_admin_or_owner_before_plugin_io(
+ harness: _Harness, daemon: _Daemon, method: str, role: TenantAccountRole
+) -> None:
+ harness.set_role(role)
+
+ response = Context().run(harness.call, method, url=_url(method), payload=_payload(method))
+
+ assert response.status_code == HTTPStatus.FORBIDDEN
+ assert response.get_json()["code"] == "forbidden"
+ assert daemon.requests == []
+
+
[email protected]("method", ["GET", "POST"])
+def test_options_require_active_workspace(harness: _Harness, daemon: _Daemon, method: str) -> None:
+ with harness.session_factory.begin() as session:
+ session.execute(delete(TenantAccountJoin).where(TenantAccountJoin.account_id == harness.account_id))
+
+ response = Context().run(harness.call, method, url=_url(method), payload=_payload(method))
+
+ assert response.status_code == HTTPStatus.UNAUTHORIZED
+ assert response.get_json()["code"] == "unauthorized"
+ assert daemon.requests == []
+
+
[email protected]("method", ["GET", "POST"])
+def test_options_validate_input_before_plugin_io(harness: _Harness, daemon: _Daemon, method: str) -> None:
+ url = _URL if method == "GET" else _url(method)
+ response = Context().run(harness.call, method, url=url, payload={} if method == "POST" else None)
+
+ assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
+ assert daemon.requests == []
+
+
[email protected]("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN])
+def test_anonymous_tool_preserves_response_and_dispatch_after_repository_sessions_close(
+ harness: _Harness, daemon: _Daemon, role: TenantAccountRole
+) -> None:
+ harness.set_role(role)
+ daemon.provider = _tool_provider()
+ _options_response(daemon)
+
+ response = Context().run(harness.call, "GET", url=f"{_url('GET')}&tenant_id={uuid4()}")
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.content_type == "application/json"
+ assert response.get_json() == {
+ "options": [
+ {
+ "value": "101",
+ "label": dict.fromkeys(("en_US", "zh_Hans", "pt_BR", "ja_JP"), "Branch 101"),
+ "icon": None,
+ }
+ ]
+ }
+ assert len(daemon.requests) == 2
+ assert harness.metadata.sessions
+ assert all(not request.open_transactions for request in daemon.requests)
+ sent = daemon.requests[-1]
+ assert sent.path == f"/plugin/{harness.tenant_id}/dispatch/dynamic_select/fetch_parameter_options"
+ assert sent.headers["X-Plugin-ID"] == "langgenius/github"
+ assert sent.headers["X-Plugin-Unique-Identifier"] == daemon.provider["plugin_unique_identifier"]
+ assert sent.payload == {
+ "user_id": harness.account_id,
+ "data": {
+ "provider": "github",
+ "provider_action": "push",
+ "parameter": "branch",
+ "credentials": {},
+ "credential_type": "unauthorized",
+ },
+ }
+
+
+def test_empty_options_remain_a_successful_array(harness: _Harness, daemon: _Daemon) -> None:
+ daemon.provider = _tool_provider()
+ daemon.response_data = {"options": []}
+
+ response = Context().run(harness.call, "GET", url=_url("GET"))
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json() == {"options": []}
+
+
[email protected]("explicit_credential", [False, True])
+def test_missing_tool_credentials_do_not_dispatch(
+ harness: _Harness, daemon: _Daemon, explicit_credential: bool
+) -> None:
+ daemon.provider = _tool_provider(credentials=True)
+ credential_id = str(uuid4()) if explicit_credential else None
+
+ response = Context().run(harness.call, "GET", url=_url("GET", credential_id=credential_id))
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "invalid_param"
+ assert "not found" in response.get_json()["message"]
+ assert [request.method for request in daemon.requests] == ["GET"]
+ assert not daemon.requests[0].open_transactions
+
+
+def test_provider_metadata_rejection_keeps_plugin_error_contract(harness: _Harness, daemon: _Daemon) -> None:
+ daemon.provider = _tool_provider()
+ daemon.status = HTTPStatus.BAD_REQUEST
+
+ response = Context().run(harness.call, "GET", url=_url("GET"))
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "plugin_error"
+ assert response.get_json()["message"]
+ assert all(not request.open_transactions for request in daemon.requests)
+
+
+def test_dynamic_option_rejection_preserves_plugin_message(harness: _Harness, daemon: _Daemon) -> None:
+ daemon.provider = _tool_provider()
+ daemon.response_code = 1
+ daemon.response_message = "branch permission denied"
+ daemon.response_data = None
+
+ response = Context().run(harness.call, "GET", url=_url("GET"))
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "invalid_param"
+ assert response.get_json()["message"] == "plugin daemon: branch permission denied, code: 1"
+ assert [request.method for request in daemon.requests] == ["GET", "POST"]
+ assert all(not request.open_transactions for request in daemon.requests)
+
+
+def test_package_mismatch_rejects_dispatch_before_sending_credentials(harness: _Harness, daemon: _Daemon) -> None:
+ daemon.provider = _tool_provider()
+ query = urlencode(
+ {**_PAYLOAD, "provider": "langgenius/github/github", "plugin_id": "langgenius/other", "provider_type": "tool"}
+ )
+
+ response = Context().run(harness.call, "GET", url=f"{_URL}?{query}")
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "invalid_param"
+ assert response.get_json()["message"] == "Plugin unique identifier does not match X-Plugin-ID"
+ assert [request.method for request in daemon.requests] == ["GET"]
+ assert not daemon.requests[0].open_transactions
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py
index cf918ea3ab0..9265d41024b 100644
--- a/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py
+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py
@@ -16,6 +16,10 @@ from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.test import TestResponse
from constants import HEADER_NAME_CSRF_TOKEN, HIDDEN_VALUE, UNKNOWN_VALUE
+from controllers.console.workspace.plugin import (
+ PluginFetchDynamicSelectOptionsApi,
+ PluginFetchDynamicSelectOptionsWithCredentialsApi,
+)
from controllers.console.workspace.trigger_providers import (
TriggerOAuthAuthorizeApi,
TriggerOAuthCallbackApi,
@@ -237,6 +241,11 @@ def harness(
login_manager.init_app(app)
blueprint = Blueprint("console", __name__, url_prefix="/console/api")
api = ExternalApi(blueprint)
+ api.add_resource(PluginFetchDynamicSelectOptionsApi, "/workspaces/current/plugin/parameters/dynamic-options")
+ api.add_resource(
+ PluginFetchDynamicSelectOptionsWithCredentialsApi,
+ "/workspaces/current/plugin/parameters/dynamic-options-with-credentials",
+ )
api.add_resource(TriggerProviderListApi, "/workspaces/current/triggers")
api.add_resource(TriggerProviderInfoApi, "/workspaces/current/trigger-provider/<path:provider>/info")
api.add_resource(TriggerProviderIconApi, "/workspaces/current/trigger-provider/<path:provider>/icon")
diff --git a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py
index 9319375962a..7e372e2b2a2 100644
--- a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py
+++ b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py
@@ -33,6 +33,8 @@ from services.errors.workspace import (
WorkspaceOwnerNotFoundError,
WorkspacesLimitExceededError,
)
+from services.plugin.plugin_parameter_gateway import DaemonPluginParameterGateway
+from services.plugin.plugin_parameter_service import PluginParameterService
from services.trigger.endpoint_gateway import PluginTriggerEndpointGateway, enqueue_triggered_workflows
from services.trigger.endpoint_service import TriggerEndpointService
from services.trigger.oauth_client_service import TriggerOAuthClientService
@@ -148,6 +150,12 @@ class TestWorkspaceCases:
invitations=Mock(),
identity=Mock(),
resource_cleanup=Mock(),
+ plugin_parameters=PluginParameterService(
+ credentials=CredentialQueryRepository(session_factory=sqlite_session_factory),
+ subscriptions=TriggerSubscriptionRepository(session_factory=sqlite_session_factory),
+ builders=builders,
+ plugins=DaemonPluginParameterGateway(),
+ ),
trigger_providers=PluginTriggerProviderQuery(),
trigger_subscriptions=TriggerSubscriptionQueryService(
credentials=CredentialQueryRepository(session_factory=sqlite_session_factory),
diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.py
index cba507722fe..1551db14a10 100644
--- a/api/tests/unit_tests/extensions/test_ext_application_services.py
+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py
@@ -1120,6 +1120,12 @@ def test_build_application_services_wires_credential_query(
assert [(record.id, record.name) for record in records] == [(credential_id, "Team")]
assert services.workspaces.trigger_subscriptions._credentials is services.credential_queries
+ assert services.workspaces.plugin_parameters._credentials is services.credential_queries
+ assert services.workspaces.plugin_parameters._builders is services.workspaces.trigger_builders
+ assert (
+ services.workspaces.plugin_parameters._subscriptions
+ is services.workspaces.trigger_subscription_management._subscriptions
+ )
assert services.workspaces.trigger_subscriptions._schemas is services.workspaces.trigger_providers
gateway = services.workspaces.trigger_oauth._builders
assert isinstance(gateway, TriggerOAuthBuilderGateway)
diff --git a/api/tests/unit_tests/repositories/credentials/test_query_repository.py b/api/tests/unit_tests/repositories/credentials/test_query_repository.py
index 2d1b2cf44e4..81f68b471ec 100644
--- a/api/tests/unit_tests/repositories/credentials/test_query_repository.py
+++ b/api/tests/unit_tests/repositories/credentials/test_query_repository.py
@@ -8,8 +8,9 @@ from datetime import datetime
from uuid import uuid4
import pytest
-from sqlalchemy import delete, select, update
+from sqlalchemy import Engine, delete, select, update
from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy.pool import QueuePool
from core.plugin.entities.plugin_daemon import CredentialType as TriggerCredentialType
from models.account import Account, TenantAccountRole
@@ -224,6 +225,107 @@ def test_tool_borrowing_members_and_default_do_not_escape_scope_or_write_state(
assert visible.is_default is False
[email protected]("credential_id", [None, ""])
[email protected]("has_default", [False, True])
+def test_tool_lookup_prefers_configured_default_then_oldest_credential(
+ sqlite_session_factory: sessionmaker[Session],
+ repository: CredentialQueryRepository,
+ credential_id: str | None,
+ has_default: bool,
+) -> None:
+ tenant, actor = str(uuid4()), str(uuid4())
+ rows = [
+ BuiltinToolProvider(
+ name=name,
+ tenant_id=owner,
+ user_id=actor,
+ provider=provider,
+ is_default=default,
+ )
+ for name, owner, provider, default in [
+ ("foreign", str(uuid4()), "tool", True),
+ ("other-provider", tenant, "other", True),
+ ("oldest", tenant, "tool", False),
+ ("newer", tenant, "tool", has_default),
+ ("newest", tenant, "tool", has_default),
+ ]
+ ]
+ for index, row in enumerate(rows):
+ row.created_at = datetime(2026, 1, index + 1)
+ with sqlite_session_factory.begin() as session:
+ session.add_all(rows)
+
+ result = repository.get_tool(workspace_id=tenant, provider="tool", credential_id=credential_id)
+
+ assert result is not None
+ assert result.id == rows[3 if has_default else 2].id
+
+
[email protected]("requested", ["target", "foreign", "other-provider", "missing"])
+def test_tool_lookup_requires_matching_id_tenant_and_provider(
+ sqlite_session_factory: sessionmaker[Session],
+ repository: CredentialQueryRepository,
+ requested: str,
+) -> None:
+ tenant, actor = str(uuid4()), str(uuid4())
+ rows = {
+ name: BuiltinToolProvider(name=name, tenant_id=owner, user_id=actor, provider=provider)
+ for name, owner, provider in [
+ ("target", tenant, "tool"),
+ ("foreign", str(uuid4()), "tool"),
+ ("other-provider", tenant, "other"),
+ ]
+ }
+ with sqlite_session_factory.begin() as session:
+ session.add_all(rows.values())
+ credential_id = str(uuid4()) if requested == "missing" else rows[requested].id
+
+ result = repository.get_tool(workspace_id=tenant, provider="tool", credential_id=credential_id)
+
+ if requested == "target":
+ assert result is not None
+ assert result.id == rows[requested].id
+ else:
+ assert result is None
+
+
+def test_tool_lookup_returns_detached_values_without_writes_or_held_connections(
+ sqlite_session_factory: sessionmaker[Session],
+ sqlite_engine: Engine,
+ repository: CredentialQueryRepository,
+) -> None:
+ tenant = str(uuid4())
+ row = BuiltinToolProvider(
+ name="stored",
+ tenant_id=tenant,
+ user_id=str(uuid4()),
+ provider="tool",
+ encrypted_credentials='{"api_key": "ciphertext", "nested": {"values": [0, false, ""]}}',
+ credential_type=TriggerCredentialType.OAUTH2,
+ )
+ with sqlite_session_factory.begin() as session:
+ session.add(row)
+ pool = sqlite_engine.pool
+ assert isinstance(pool, QueuePool)
+
+ result = repository.get_tool(workspace_id=tenant, provider="tool", credential_id=row.id)
+
+ assert pool.checkedout() == 0
+ assert result is not None
+ assert result.credential_type == "oauth2"
+ assert result.credentials == {"api_key": "ciphertext", "nested": {"values": [0, False, ""]}}
+ nested = result.credentials["nested"]
+ assert isinstance(nested, dict)
+ nested["values"].append("caller-only")
+ with sqlite_session_factory() as session:
+ stored = session.get(BuiltinToolProvider, row.id)
+ assert stored is not None
+ assert stored.encrypted_credentials == row.encrypted_credentials
+ assert stored.is_default is False
+ assert repository.get_tool(workspace_id=str(uuid4()), provider="tool", credential_id=row.id) is None
+ assert pool.checkedout() == 0
+
+
def test_trigger_visibility_and_usage_counts_are_tenant_scoped(
sqlite_session: Session, repository: CredentialQueryRepository
) -> None:
diff --git a/api/tests/unit_tests/repositories/test_trigger_subscription_repository.py b/api/tests/unit_tests/repositories/test_trigger_subscription_repository.py
new file mode 100644
index 00000000000..71e9aeb2047
--- /dev/null
+++ b/api/tests/unit_tests/repositories/test_trigger_subscription_repository.py
@@ -0,0 +1,91 @@
+"""Provider-scoped subscription reads use real rows and release their SQL sessions."""
+
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import Engine
+from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy.pool import QueuePool
+
+from core.plugin.entities.plugin_daemon import CredentialType
+from models.provider_ids import TriggerProviderID
+from models.trigger import TriggerSubscription
+from repositories.trigger.subscription_repository import TriggerSubscriptionRepository
+
+
[email protected]("requested", [None, "", "target", "foreign", "other-provider", "missing"])
+def test_provider_lookup_requires_tenant_provider_and_optional_subscription_id(
+ sqlite_session_factory: sessionmaker[Session], requested: str | None
+) -> None:
+ tenant = str(uuid4())
+ provider = TriggerProviderID("langgenius/github/github")
+ rows = {
+ name: TriggerSubscription(
+ name=name,
+ tenant_id=owner,
+ user_id=str(uuid4()),
+ provider_id=provider_id,
+ endpoint_id=str(uuid4()),
+ parameters={},
+ properties={},
+ credentials={"token": f"{name}-ciphertext"},
+ credential_type=CredentialType.API_KEY,
+ )
+ for name, owner, provider_id in [
+ ("foreign", str(uuid4()), str(provider)),
+ ("other-provider", tenant, "langgenius/github/other"),
+ ("target", tenant, str(provider)),
+ ]
+ }
+ with sqlite_session_factory.begin() as session:
+ session.add_all(rows.values())
+ subscription_id = str(uuid4()) if requested == "missing" else rows[requested].id if requested else requested
+ repository = TriggerSubscriptionRepository(session_factory=sqlite_session_factory)
+
+ result = repository.get_for_provider(tenant_id=tenant, provider_id=provider, subscription_id=subscription_id)
+
+ if requested in (None, "", "target"):
+ assert result is not None
+ assert (result.id, result.tenant_id, result.provider_id) == (rows["target"].id, tenant, str(provider))
+ assert result.credentials == {"token": "target-ciphertext"}
+ else:
+ assert result is None
+
+
+def test_provider_lookup_returns_detached_values_without_writes_or_held_connections(
+ sqlite_session_factory: sessionmaker[Session], sqlite_engine: Engine
+) -> None:
+ tenant = str(uuid4())
+ provider = TriggerProviderID("langgenius/github/github")
+ row = TriggerSubscription(
+ name="stored",
+ tenant_id=tenant,
+ user_id=str(uuid4()),
+ provider_id=str(provider),
+ endpoint_id=str(uuid4()),
+ parameters={"events": ["push"]},
+ properties={"remote_id": "remote"},
+ credentials={"token": "ciphertext"},
+ credential_type=CredentialType.OAUTH2,
+ )
+ with sqlite_session_factory.begin() as session:
+ session.add(row)
+ repository = TriggerSubscriptionRepository(session_factory=sqlite_session_factory)
+ pool = sqlite_engine.pool
+ assert isinstance(pool, QueuePool)
+
+ result = repository.get_for_provider(tenant_id=tenant, provider_id=provider, subscription_id=row.id)
+
+ assert pool.checkedout() == 0
+ assert result is not None
+ assert result.credential_type == CredentialType.OAUTH2
+ assert result.credentials == {"token": "ciphertext"}
+ result.parameters["events"].append("caller-only")
+ with sqlite_session_factory() as session:
+ stored = session.get(TriggerSubscription, row.id)
+ assert stored is not None
+ assert stored.parameters == {"events": ["push"]}
+ assert stored.properties == {"remote_id": "remote"}
+ assert stored.credentials == {"token": "ciphertext"}
+ assert repository.get_for_provider(tenant_id=str(uuid4()), provider_id=provider, subscription_id=row.id) is None
+ assert pool.checkedout() == 0
diff --git a/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py b/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py
deleted file mode 100644
index 28b2ea965c8..00000000000
--- a/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py
+++ /dev/null
@@ -1,238 +0,0 @@
-"""Unit tests for services.plugin.plugin_parameter_service.PluginParameterService.
-
-Covers: dynamic select options via tool and trigger credential paths,
-HIDDEN_VALUE replacement, and error handling for missing records.
-"""
-
-from __future__ import annotations
-
-import json
-from collections.abc import Iterator
-from threading import Lock
-from unittest.mock import MagicMock, patch
-from uuid import uuid4
-
-import pytest
-from flask import Flask
-from redis import Redis
-from sqlalchemy.orm import Session, sessionmaker
-
-import contexts
-from core.plugin.entities.plugin_daemon import CredentialType
-from core.trigger.trigger_manager import TriggerManager
-from core.trigger.utils.encryption import delete_cache_for_subscription
-from extensions.ext_redis import RedisClientWrapper
-from models.engine import db
-from models.provider_ids import TriggerProviderID
-from models.tools import BuiltinToolProvider
-from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
-from repositories.trigger.subscription_repository import RedisTriggerSubscriptionLocks, TriggerSubscriptionRepository
-from services.plugin.plugin_parameter_service import PluginParameterService
-from services.trigger.subscription_codec import ProviderTriggerSubscriptionCodec
-from services.trigger.subscription_gateway import PluginTriggerSubscriptionGateway
-from services.trigger.subscription_service import TriggerSubscriptionService
-from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
-from tests.unit_tests.core.trigger.conftest import make_controller
-
-
[email protected](autouse=True)
-def trigger_declaration() -> Iterator[None]:
- provider_id = TriggerProviderID("org/plugin/github")
- controller = make_controller(tenant_id="t1", provider_id=str(provider_id))
- controller.plugin_id = provider_id.plugin_id
- controller.plugin_unique_identifier = f"{provider_id.plugin_id}:1.0.0@{'a' * 32}"
- previous_providers = contexts.plugin_trigger_providers.get({})
- previous_lock = contexts.plugin_trigger_providers_lock.get(Lock())
- contexts.plugin_trigger_providers.set({str(provider_id): controller})
- contexts.plugin_trigger_providers_lock.set(Lock())
- try:
- yield
- finally:
- contexts.plugin_trigger_providers.set(previous_providers)
- contexts.plugin_trigger_providers_lock.set(previous_lock)
-
-
-def builders(sqlite_session_factory: sessionmaker[Session]) -> Iterator[TriggerSubscriptionBuilderService]:
- # Tool-provider paths receive the real dependency but must not query builder Redis.
- with Redis(socket_connect_timeout=0.1) as client:
- redis = RedisClientWrapper()
- redis.initialize(client)
- subscription_management = TriggerSubscriptionService(
- subscriptions=TriggerSubscriptionRepository(session_factory=sqlite_session_factory),
- providers=PluginTriggerSubscriptionGateway(),
- locks=RedisTriggerSubscriptionLocks(redis=redis),
- codec=ProviderTriggerSubscriptionCodec(),
- invalidate_cache=delete_cache_for_subscription,
- )
- yield TriggerSubscriptionBuilderService(
- builders=RedisTriggerSubscriptionBuilderRepository(redis=redis),
- get_provider=TriggerManager.get_trigger_provider,
- subscribe=TriggerManager.subscribe_trigger,
- create_subscription=subscription_management.create,
- )
-
-
-def plugin_parameter_db() -> Iterator[Session]:
- """Provide the production database extension with an isolated SQLite credential table."""
- app = Flask(__name__)
- app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
- db.init_app(app)
-
- with app.app_context():
- BuiltinToolProvider.__table__.create(db.engine)
- with Session(db.engine, expire_on_commit=False) as session:
- yield session
-
-
-class TestGetDynamicSelectOptionsTool:
- @patch("services.plugin.plugin_parameter_service.DynamicSelectClient")
- @patch("services.plugin.plugin_parameter_service.ToolManager")
- def test_no_credentials_needed(
- self, mock_tool_mgr: MagicMock, mock_client_cls: MagicMock, builders: TriggerSubscriptionBuilderService
- ) -> None:
- provider_ctrl = MagicMock()
- provider_ctrl.entity.identity.name = "google"
- provider_ctrl.plugin_unique_identifier = "org/plugin:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
- provider_ctrl.need_credentials = False
- mock_tool_mgr.get_plugin_provider.return_value = provider_ctrl
- mock_client_cls.return_value.fetch_dynamic_select_options.return_value.options = ["opt1"]
-
- result = PluginParameterService.get_dynamic_select_options(
- tenant_id="t1",
- user_id="u1",
- plugin_id="org/plugin",
- provider="google",
- action="search",
- parameter="engine",
- credential_id=None,
- provider_type="tool",
- builders=builders,
- )
-
- assert result == ["opt1"]
- call_kwargs = mock_client_cls.return_value.fetch_dynamic_select_options.call_args
- assert call_kwargs[0][5] == {} # empty credentials
-
- @patch("services.plugin.plugin_parameter_service.DynamicSelectClient")
- @patch("services.plugin.plugin_parameter_service.create_tool_provider_encrypter")
- @patch("services.plugin.plugin_parameter_service.ToolManager")
- def test_fetches_credentials_with_credential_id(
- self,
- mock_tool_mgr: MagicMock,
- mock_encrypter_fn: MagicMock,
- mock_client_cls: MagicMock,
- plugin_parameter_db: Session,
- builders: TriggerSubscriptionBuilderService,
- ) -> None:
- tenant_id = str(uuid4())
- provider_ctrl = MagicMock()
- provider_ctrl.entity.identity.name = "google"
- provider_ctrl.plugin_unique_identifier = "org/plugin:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
- provider_ctrl.need_credentials = True
- mock_tool_mgr.get_plugin_provider.return_value = provider_ctrl
- encrypter = MagicMock()
- encrypter.decrypt.return_value = {"api_key": "decrypted"}
- mock_encrypter_fn.return_value = (encrypter, None)
- mock_client_cls.return_value.fetch_dynamic_select_options.return_value.options = ["opt1"]
-
- db_record = BuiltinToolProvider(
- tenant_id=tenant_id,
- user_id=str(uuid4()),
- provider="google",
- name="API KEY 1",
- encrypted_credentials=json.dumps({"api_key": "encrypted"}),
- credential_type=CredentialType.API_KEY,
- )
- plugin_parameter_db.add(db_record)
- plugin_parameter_db.commit()
-
- result = PluginParameterService.get_dynamic_select_options(
- tenant_id=tenant_id,
- user_id="u1",
- plugin_id="org/plugin",
- provider="google",
- action="search",
- parameter="engine",
- credential_id=db_record.id,
- provider_type="tool",
- builders=builders,
- )
-
- assert result == ["opt1"]
-
- @patch("services.plugin.plugin_parameter_service.create_tool_provider_encrypter")
- @patch("services.plugin.plugin_parameter_service.ToolManager")
- def test_raises_when_tool_provider_not_found(
- self,
- mock_tool_mgr: MagicMock,
- mock_encrypter_fn: MagicMock,
- plugin_parameter_db: Session,
- builders: TriggerSubscriptionBuilderService,
- ) -> None:
- provider_ctrl = MagicMock()
- provider_ctrl.entity.identity.name = "google"
- provider_ctrl.plugin_unique_identifier = "org/plugin:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
- provider_ctrl.need_credentials = True
- mock_tool_mgr.get_plugin_provider.return_value = provider_ctrl
- mock_encrypter_fn.return_value = (MagicMock(), None)
-
- with pytest.raises(ValueError, match="not found"):
- PluginParameterService.get_dynamic_select_options(
- tenant_id=str(uuid4()),
- user_id="u1",
- plugin_id="org/plugin",
- provider="google",
- action="search",
- parameter="engine",
- credential_id=None,
- provider_type="tool",
- builders=builders,
- )
-
-
-class TestGetDynamicSelectOptionsWithCredentials:
- @patch("services.plugin.plugin_parameter_service.DynamicSelectClient")
- @patch("services.plugin.plugin_parameter_service.TriggerProviderService")
- def test_replaces_hidden_values(self, mock_provider_svc, mock_client_cls):
- from constants import HIDDEN_VALUE
-
- original = MagicMock()
- original.credentials = {"token": "real-secret", "name": "real-name"}
- original.credential_type = "api_key"
- mock_provider_svc.get_subscription_by_id.return_value = original
- mock_client_cls.return_value.fetch_dynamic_select_options.return_value.options = ["opt"]
-
- result = PluginParameterService.get_dynamic_select_options_with_credentials(
- tenant_id="t1",
- user_id="u1",
- plugin_id="org/plugin",
- provider="github",
- action="on_push",
- parameter="branch",
- credential_id="cred-1",
- credentials={"token": HIDDEN_VALUE, "name": "new-name"},
- )
-
- assert result == ["opt"]
- call_args = mock_client_cls.return_value.fetch_dynamic_select_options.call_args[0]
- resolved = call_args[5]
- assert resolved["token"] == "real-secret" # replaced
- assert resolved["name"] == "new-name" # kept as-is
-
- @patch("services.plugin.plugin_parameter_service.TriggerProviderService")
- def test_raises_when_subscription_not_found(self, mock_provider_svc):
- mock_provider_svc.get_subscription_by_id.return_value = None
-
- with pytest.raises(ValueError, match="not found"):
- PluginParameterService.get_dynamic_select_options_with_credentials(
- tenant_id="t1",
- user_id="u1",
- plugin_id="org/plugin",
- provider="github",
- action="on_push",
- parameter="branch",
- credential_id="nonexistent",
- credentials={"token": "val"},
- )