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
fix(api): validate builtin tool credentials outside the create lock (#44371)
Miyar9f5a7033c609
diff --git a/api/services/tools/builtin_tools_manage_service.py b/api/services/tools/builtin_tools_manage_service.pyindex 51727d68c85..df418c0f4e0 100644--- a/api/services/tools/builtin_tools_manage_service.py+++ b/api/services/tools/builtin_tools_manage_service.py@@ -232,14 +232,21 @@ class BuiltinToolManageService:"""add builtin tool provider"""- with sessionmaker(bind=db.engine).begin() as session:- try:- lock = f"builtin_tool_provider_create_lock:{tenant_id}_{provider}"- with redis_client.lock(lock, timeout=20):- provider_controller = ToolManager.get_builtin_provider(provider, tenant_id)- if not provider_controller.need_credentials:- raise ValueError(f"provider {provider} does not need credentials")-+ try:+ provider_controller = ToolManager.get_builtin_provider(provider, tenant_id)+ if not provider_controller.need_credentials:+ raise ValueError(f"provider {provider} does not need credentials")++ # Validation may call external services, so it runs before the lock is taken+ # to keep its duration independent of the lock timeout.+ if CredentialType.of(api_type).is_validate_allowed():+ provider_controller.validate_credentials(user_id, credentials)++ lock = f"builtin_tool_provider_create_lock:{tenant_id}_{provider}"+ # The transaction commits before the lock is released, so concurrent requests+ # see this credential when they check the count limit and the name.+ with redis_client.lock(lock, timeout=20):+ with sessionmaker(bind=db.engine).begin() as session:provider_count = (session.scalar(select(func.count(BuiltinToolProvider.id)).where(@@ -254,10 +261,6 @@ class BuiltinToolManageService:if provider_count >= BuiltinToolManageService.__MAX_BUILTIN_TOOL_PROVIDER_COUNT__:raise ValueError(f"you have reached the maximum number of providers for {provider}")- # validate credentials if allowed- if CredentialType.of(api_type).is_validate_allowed():- provider_controller.validate_credentials(user_id, credentials)-# generate name if not providedif name is None or name == "":name = BuiltinToolManageService.generate_builtin_tool_provider_name(@@ -306,8 +309,8 @@ class BuiltinToolManageService:session.add(db_provider)session.flush()credential_id = db_provider.id- except Exception as e:- raise ValueError(str(e)) from e+ except Exception as e:+ raise ValueError(str(e)) from ereturn {"result": "success", "id": credential_id}diff --git a/api/tests/unit_tests/services/tools/test_builtin_tools_manage_service.py b/api/tests/unit_tests/services/tools/test_builtin_tools_manage_service.pyindex f057ed4d425..4345014bf6e 100644--- a/api/tests/unit_tests/services/tools/test_builtin_tools_manage_service.py+++ b/api/tests/unit_tests/services/tools/test_builtin_tools_manage_service.py@@ -1,6 +1,7 @@"""Unit tests for built-in tool management and its persisted credential state."""import json+from collections.abc import Callablefrom types import SimpleNamespacefrom unittest.mock import MagicMock@@ -10,12 +11,14 @@ from sqlalchemy import event, selectfrom sqlalchemy.engine import Connectionfrom sqlalchemy.orm import Session, sessionmaker+from core.entities.provider_entities import ProviderConfig, ProviderConfigTypefrom core.plugin.entities.oauth import OAuthSchemafrom core.plugin.entities.plugin_daemon import CredentialTypefrom core.plugin.impl import base as client_modulefrom core.plugin.impl.oauth import OAuthHandlerfrom core.tools.entities.common_entities import I18nObjectfrom core.tools.entities.tool_entities import ToolProviderEntityWithPlugin, ToolProviderIdentity+from core.tools.plugin_tool.provider import PluginToolProviderControllerfrom models.tools import BuiltinToolProvider, ToolOAuthSystemClient, ToolOAuthTenantClientfrom repositories.credentials.query_repository import CredentialQueryRepositoryfrom services.tools import builtin_tools_manage_service as service_module@@ -195,6 +198,167 @@ class TestIsOauthCustomClientEnabled:assert BuiltinToolManageService.is_oauth_custom_client_enabled("tenant-1", "google") is False+class _RecordingLock:+ """Redis lock stand-in that records when it is held and runs a hook just before release."""++ def __init__(self, events: list[str], on_release: Callable[[], None] | None = None) -> None:+ self._events = events+ self._on_release = on_release++ def __enter__(self) -> "_RecordingLock":+ self._events.append("acquire")+ return self++ def __exit__(self, *exc_info: object) -> None:+ if self._on_release is not None:+ self._on_release()+ self._events.append("release")+++class TestAddBuiltinToolProvider:+ @pytest.fixture+ def events(self) -> list[str]:+ return []++ @pytest.fixture+ def controller(self, monkeypatch: pytest.MonkeyPatch, events: list[str]) -> PluginToolProviderController:+ controller = PluginToolProviderController(+ entity=ToolProviderEntityWithPlugin(+ identity=ToolProviderIdentity(+ author="author",+ name="google",+ description=I18nObject(en_US="Google"),+ icon="icon.svg",+ label=I18nObject(en_US="Google"),+ ),+ credentials_schema=[ProviderConfig(name="key", type=ProviderConfigType.TEXT_INPUT)],+ plugin_id="langgenius/google",+ tools=[],+ ),+ plugin_id="langgenius/google",+ plugin_unique_identifier="langgenius/google:0.0.1",+ tenant_id="tenant-1",+ )++ def validate_credentials(user_id: str, credentials: dict[str, str]) -> None:+ assert user_id == "u"+ assert credentials == {"key": "value"}+ events.append("validate")++ monkeypatch.setattr(controller, "_validate_credentials", validate_credentials)+ monkeypatch.setattr(service_module.ToolManager, "get_builtin_provider", lambda *_: controller)+ return controller++ def _install_lock(+ self,+ monkeypatch: pytest.MonkeyPatch,+ events: list[str],+ on_release: Callable[[], None] | None = None,+ ) -> None:+ lock = _RecordingLock(events, on_release)+ monkeypatch.setattr(service_module.redis_client, "lock", lambda *_, **__: lock)++ def _count_providers(self, repository_session: Session) -> int:+ with Session(repository_session.get_bind()) as session:+ return len(session.scalars(select(BuiltinToolProvider)).all())++ def test_validates_credentials_before_acquiring_lock(+ self,+ monkeypatch: pytest.MonkeyPatch,+ repository_session: Session,+ controller: PluginToolProviderController,+ events: list[str],+ ) -> None:+ self._install_lock(monkeypatch, events)++ result = BuiltinToolManageService.add_builtin_tool_provider(+ "u", CredentialType.API_KEY, "tenant-1", "google", {"key": "value"}, name="Google 1"+ )++ assert result["result"] == "success"+ assert events == ["validate", "acquire", "release"]+ provider = repository_session.get(BuiltinToolProvider, result["id"])+ assert provider is not None+ assert provider.credentials == {"key": "value"}++ def test_commits_credential_before_releasing_lock(+ self,+ monkeypatch: pytest.MonkeyPatch,+ repository_session: Session,+ controller: PluginToolProviderController,+ events: list[str],+ ) -> None:+ counts_at_release: list[int] = []+ self._install_lock(+ monkeypatch, events, on_release=lambda: counts_at_release.append(self._count_providers(repository_session))+ )++ BuiltinToolManageService.add_builtin_tool_provider(+ "u", CredentialType.API_KEY, "tenant-1", "google", {"key": "value"}, name="Google 1"+ )++ assert counts_at_release == [1]++ def test_does_not_lock_or_save_when_validation_fails(+ self,+ monkeypatch: pytest.MonkeyPatch,+ repository_session: Session,+ controller: PluginToolProviderController,+ events: list[str],+ ) -> None:+ self._install_lock(monkeypatch, events)++ def reject_credentials(user_id: str, credentials: dict[str, str]) -> None:+ raise ValueError("invalid api key")++ monkeypatch.setattr(controller, "_validate_credentials", reject_credentials)++ with pytest.raises(ValueError, match="invalid api key"):+ BuiltinToolManageService.add_builtin_tool_provider(+ "u", CredentialType.API_KEY, "tenant-1", "google", {"key": "bad"}+ )++ assert events == []+ assert self._count_providers(repository_session) == 0++ def test_checks_count_limit_inside_lock(+ self,+ monkeypatch: pytest.MonkeyPatch,+ repository_session: Session,+ controller: PluginToolProviderController,+ events: list[str],+ ) -> None:+ _persist_provider(repository_session, credential_id="cred-1")+ monkeypatch.setattr(BuiltinToolManageService, "__MAX_BUILTIN_TOOL_PROVIDER_COUNT__", 1)+ self._install_lock(monkeypatch, events)++ with pytest.raises(ValueError, match="maximum number of providers"):+ BuiltinToolManageService.add_builtin_tool_provider(+ "u", CredentialType.API_KEY, "tenant-1", "google", {"key": "value"}+ )++ assert events == ["validate", "acquire", "release"]+ assert self._count_providers(repository_session) == 1++ def test_rejects_duplicate_name_inside_lock(+ self,+ monkeypatch: pytest.MonkeyPatch,+ repository_session: Session,+ controller: PluginToolProviderController,+ events: list[str],+ ) -> None:+ _persist_provider(repository_session, credential_id="cred-1", name="Google 1")+ self._install_lock(monkeypatch, events)++ with pytest.raises(ValueError, match="already used"):+ BuiltinToolManageService.add_builtin_tool_provider(+ "u", CredentialType.API_KEY, "tenant-1", "google", {"key": "value"}, name="Google 1"+ )++ assert events == ["validate", "acquire", "release"]+ assert self._count_providers(repository_session) == 1++class TestDeleteBuiltinToolProvider:def test_raises_when_not_found(self, repository_session: Session) -> None:with pytest.raises(ValueError, match="you have not added provider"):