Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): inject plugin dynamic option queries (#44576)
非法操作a83ce881a128
diff --git a/api/controllers/console/workspace/plugin.py b/api/controllers/console/workspace/plugin.pyindex 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_admissionfrom controllers.console.workspace import plugin_permission_requiredfrom controllers.console.workspace.error import PluginOperationErrorfrom 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_responsesfrom libs.flask_restx_compat import BINARY_RESPONSE_MEDIA_TYPES_VENDOR_KEYfrom libs.helper import dump_responsefrom libs.login import login_required+from machinery.context import RequestContextfrom models.account import (Account,+ TenantAccountRole,TenantPluginAutoUpgradeCategory,TenantPluginAutoUpgradeMode,TenantPluginAutoUpgradeStrategy,@@ -70,7 +72,6 @@ from models.account import (from models.provider_ids import ToolProviderIDfrom services.entities.model_provider_entities import ProviderEntityResponsefrom services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService-from services.plugin.plugin_parameter_service import PluginParameterServicefrom services.plugin.plugin_permission_service import PluginPermissionServicefrom 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.pyindex 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_subscriptionfrom extensions.ext_redis import RedisClientWrapperfrom repositories.account.repository import SQLAlchemyAccountRepositoryfrom repositories.app.console_repository import ConsoleAppRepository+from repositories.credentials.query_repository import CredentialQueryRepositoryfrom repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepositoryfrom repositories.trigger.oauth_client_repository import TriggerOAuthClientRepositoryfrom repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository@@ -17,8 +18,9 @@ from repositories.trigger.subscription_repository import RedisTriggerSubscriptiofrom repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepositoryfrom repositories.workspace.workspace_repository import WorkspaceRepositoryfrom services.account.adapters import RedisInvitationTokenStore-from services.credentials.query import CredentialQueryfrom services.file_service import FileService+from services.plugin.plugin_parameter_gateway import DaemonPluginParameterGateway+from services.plugin.plugin_parameter_service import PluginParameterServicefrom services.trigger.endpoint_gateway import PluginTriggerEndpointGateway, enqueue_triggered_workflowsfrom services.trigger.endpoint_service import TriggerEndpointServicefrom services.trigger.oauth_client_service import TriggerOAuthClientService@@ -71,6 +73,7 @@ class WorkspaceServices:invitations: WorkspaceInvitationServiceidentity: WorkspaceIdentityGatewayresource_cleanup: WorkspaceResourceCleanupService+ plugin_parameters: PluginParameterServicetrigger_providers: TriggerProviderQuerytrigger_subscriptions: TriggerSubscriptionQueryServicetrigger_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.pyindex 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 deepcopyfrom typing import overridefrom 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),+ )+@overridedef 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.pyindex 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+@overridedef create(self, *, subscription: TriggerSubscriptionSnapshot, max_count: int) -> None:try:diff --git a/api/services/credentials/query.py b/api/services/credentials/query.pyindex 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, Sequencefrom 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: strdiff --git a/api/services/plugin/plugin_parameter_gateway.py b/api/services/plugin/plugin_parameter_gateway.pynew file mode 100644index 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.pyindex 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_VALUEfrom core.plugin.entities.parameters import PluginParameterOptionfrom 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 PluginToolProviderControllerfrom 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_encrypterfrom 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 TriggerSubscriptionSnapshotfrom 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.valueprovider_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,)- @staticmethoddef 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 subscriptiondiff --git a/api/tests/e2e_tests/containers/services/test_plugin_parameter.py b/api/tests/e2e_tests/containers/services/test_plugin_parameter.pynew file mode 100644index 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]("runtime")[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]("runtime")[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_credentialsdiff --git a/api/tests/e2e_tests/containers/services/test_trigger_builder_callers.py b/api/tests/e2e_tests/containers/services/test_trigger_builder_callers.pyindex 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_clientfrom models.provider_ids import TriggerProviderIDfrom models.trigger import TriggerSubscriptionfrom repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository-from services.plugin.plugin_parameter_service import PluginParameterServicefrom services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderServicefrom tests.e2e_tests.containers.services import test_trigger_subscription_queryfrom 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_fallbackdaemon.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_fallbackparameter="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:[email protected]("runtime")+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:[email protected]("runtime")+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.pyindex 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, patchimport pytestfrom flask import Flask-from sqlalchemy.orm import Session, sessionmakerfrom werkzeug.datastructures import FileStoragefrom 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 PluginParameterOptionfrom core.plugin.entities.plugin import PluginCategory, PluginDeclaration, PluginEntity, PluginInstallationfrom core.plugin.entities.plugin_daemon import PluginInstallTaskfrom core.plugin.impl.exc import PluginDaemonClientSideError@@ -73,9 +67,6 @@ from core.plugin.plugin_service import PluginServicefrom core.tools.entities.api_entities import ToolProviderApiEntityfrom core.tools.entities.common_entities import I18nObjectfrom 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 RedisClientWrapperfrom models.account import (Account,TenantAccountRole,@@ -89,9 +80,6 @@ from models.account import (from tests.helpers.unit.config_override import config_overrides_contextfrom tests.helpers.unit.controllers.error_body import raised_errorfrom 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_redisdef _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¶meter=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.pynew file mode 100644index 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_transactionsdiff --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.pyindex 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, sessionmakerfrom werkzeug.test import TestResponsefrom 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.pyindex 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 PluginParameterServicefrom services.trigger.endpoint_gateway import PluginTriggerEndpointGateway, enqueue_triggered_workflowsfrom services.trigger.endpoint_service import TriggerEndpointServicefrom 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.pyindex 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_providersgateway = services.workspaces.trigger_oauth._buildersassert 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.pyindex 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 datetimefrom uuid import uuid4import pytest-from sqlalchemy import delete, select, update+from sqlalchemy import Engine, delete, select, updatefrom sqlalchemy.orm import Session, sessionmaker+from sqlalchemy.pool import QueuePoolfrom core.plugin.entities.plugin_daemon import CredentialType as TriggerCredentialTypefrom 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.pynew file mode 100644index 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() == 0diff --git a/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py b/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.pydeleted file mode 100644index 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"},- )