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
import io
import logging
from collections.abc import Iterable, Mapping
from datetime import datetime
from typing import Any, Literal, cast
from urllib.parse import urlparse
from flask import make_response, redirect, request, send_file
from flask_restx import Resource
from pydantic import (
BaseModel,
Field,
HttpUrl,
RootModel,
field_validator,
model_validator,
)
from sqlalchemy.orm import sessionmaker
from werkzeug.exceptions import Forbidden
from configs import dify_config
from controllers.common.fields import SimpleResultResponse
from controllers.common.rbac import RBACCheck, Workspace
from controllers.common.schema import (
query_params_from_model,
query_params_from_request,
register_response_schema_models,
register_schema_models,
)
from controllers.console import console_ns
from controllers.console.wraps import (
RBACPermission,
account_initialization_required,
enterprise_license_required,
is_admin_or_owner_required,
model_validate,
rbac_permission_required,
setup_required,
with_current_tenant_id,
with_current_user,
)
from core.db.session_factory import session_factory
from core.entities.mcp_provider import IdentityMode, MCPAuthentication, MCPConfiguration
from core.entities.provider_entities import ProviderConfig
from core.mcp.auth.auth_flow import auth, handle_callback
from core.mcp.error import MCPAuthError, MCPError, MCPRefreshTokenError
from core.mcp.mcp_client import MCPClient
from core.plugin.entities.plugin_daemon import CredentialType, PluginOAuthAuthorizationUrlResponse
from core.plugin.impl.oauth import OAuthHandler
from core.tools.entities.api_entities import (
ToolApiEntity,
ToolProviderCredentialApiEntity,
ToolProviderCredentialInfoApiEntity,
ToolProviderTypeApiLiteral,
)
from core.tools.entities.common_entities import I18nObject
from core.tools.entities.tool_bundle import ApiToolBundle
from core.tools.entities.tool_entities import (
ApiProviderSchemaType,
ToolLabel,
ToolProviderType,
WorkflowToolParameterConfiguration,
)
from enums import DeploymentEdition
from extensions.ext_application_services import application_services
from extensions.ext_database import db
from fields.base import ResponseModel
from libs.helper import alphanumeric, dump_response, uuid_value
from libs.login import login_required
from models import Account
from models.enums import PermissionEnum
from models.provider_ids import ToolProviderID
# from models.provider_ids import ToolProviderID
from services.plugin.oauth_service import OAuthProxyService
from services.tools.api_tools_manage_service import ApiToolManageService, ApiToolPreviewResult
from services.tools.builtin_tools_manage_service import BuiltinToolManageService
from services.tools.mcp_tools_manage_service import MCPToolManageService, OAuthDataType
from services.tools.tool_labels_service import ToolLabelsService
from services.tools.tools_manage_service import ToolCommonService
from services.tools.tools_transform_service import ToolTransformService
from services.tools.workflow_tools_manage_service import WorkflowToolManageService
logger = logging.getLogger(__name__)
def is_valid_url(url: str) -> bool:
if not url:
return False
try:
parsed = urlparse(url)
return all([parsed.scheme, parsed.netloc]) and parsed.scheme in ["http", "https"]
except (ValueError, TypeError):
return False
class ToolProviderListQuery(BaseModel):
type: Literal["builtin", "model", "api", "workflow", "mcp"] | None = None
class ToolOAuthAuthorizationQuery(BaseModel):
visibility: Literal["only_me", "all_team_members"] | None = Field(
default=None,
description="Visibility for the OAuth credential. Defaults to 'only_me'.",
)
class BuiltinToolCredentialDeletePayload(BaseModel):
credential_id: str
class BuiltinToolAddPayload(BaseModel):
credentials: dict[str, Any]
name: str | None = Field(default=None, max_length=30)
type: CredentialType
visibility: str | None = None
class BuiltinToolUpdatePayload(BaseModel):
credential_id: str
credentials: dict[str, Any] | None = None
name: str | None = Field(default=None, max_length=30)
class ToolEmojiIcon(BaseModel):
background: str
content: str
class ApiToolProviderBasePayload(BaseModel):
credentials: dict[str, Any]
schema_type: ApiProviderSchemaType
schema_: str = Field(alias="schema")
provider: str
icon: ToolEmojiIcon
privacy_policy: str | None = None
labels: list[str] | None = None
custom_disclaimer: str = ""
class ApiToolProviderAddPayload(ApiToolProviderBasePayload):
pass
class ApiToolProviderUpdatePayload(ApiToolProviderBasePayload):
original_provider: str
class UrlQuery(BaseModel):
url: HttpUrl
class ProviderQuery(BaseModel):
provider: str
class BuiltinCredentialListQuery(BaseModel):
include_credential_ids: list[str] = Field(
default_factory=list,
description="Credential IDs to include even if visibility would hide them",
)
class ApiToolProviderDeletePayload(BaseModel):
provider: str
class ApiToolSchemaPayload(BaseModel):
schema_: str = Field(alias="schema")
class ApiToolTestPayload(BaseModel):
tool_name: str
provider_name: str | None = None
credentials: dict[str, Any]
parameters: dict[str, Any]
schema_type: ApiProviderSchemaType
schema_: str = Field(alias="schema")
class WorkflowToolBasePayload(BaseModel):
name: str
label: str
description: str
icon: ToolEmojiIcon
parameters: list[WorkflowToolParameterConfiguration] = Field(default_factory=list)
privacy_policy: str | None = ""
labels: list[str] | None = None
@field_validator("name")
@classmethod
def validate_name(cls, value: str) -> str:
return alphanumeric(value)
class WorkflowToolCreatePayload(WorkflowToolBasePayload):
workflow_app_id: str
@field_validator("workflow_app_id")
@classmethod
def validate_workflow_app_id(cls, value: str) -> str:
return uuid_value(value)
class WorkflowToolUpdatePayload(WorkflowToolBasePayload):
workflow_tool_id: str
@field_validator("workflow_tool_id")
@classmethod
def validate_workflow_tool_id(cls, value: str) -> str:
return uuid_value(value)
class WorkflowToolDeletePayload(BaseModel):
workflow_tool_id: str
@field_validator("workflow_tool_id")
@classmethod
def validate_workflow_tool_id(cls, value: str) -> str:
return uuid_value(value)
class WorkflowToolGetQuery(BaseModel):
workflow_tool_id: str | None = None
workflow_app_id: str | None = None
@field_validator("workflow_tool_id", "workflow_app_id")
@classmethod
def validate_ids(cls, value: str | None) -> str | None:
if value is None:
return value
return uuid_value(value)
@model_validator(mode="after")
def ensure_one(self) -> "WorkflowToolGetQuery":
if not self.workflow_tool_id and not self.workflow_app_id:
raise ValueError("workflow_tool_id or workflow_app_id is required")
return self
class WorkflowToolListQuery(BaseModel):
workflow_tool_id: str
@field_validator("workflow_tool_id")
@classmethod
def validate_workflow_tool_id(cls, value: str) -> str:
return uuid_value(value)
class BuiltinProviderDefaultCredentialPayload(BaseModel):
id: str
class ToolOAuthCustomClientPayload(BaseModel):
client_params: dict[str, Any] | None = None
enable_oauth_custom_client: bool | None = True
class MCPProviderBasePayload(BaseModel):
server_url: str
name: str
icon: str
icon_type: str
icon_background: str = ""
server_identifier: str
configuration: MCPConfiguration | None = None
headers: dict[str, str] | None = None
authentication: MCPAuthentication | None = None
# None means "leave unchanged" on update; the controller resolves it to a
# concrete IdentityMode before calling the service (see _resolve_identity_mode).
identity_mode: IdentityMode | None = None
@field_validator("authentication", "configuration", mode="before")
@classmethod
def empty_to_none(cls, value: object) -> object:
if value == {}:
return None
return value
def _resolve_identity_mode(requested: IdentityMode | None, *, current: IdentityMode) -> IdentityMode:
"""Resolve the effective MCP identity_mode for a create/update request.
Keeps two API-layer concerns out of the service so the service always
receives a concrete value:
* ``None`` means "leave unchanged" (update semantics) — fall back to
``current`` (``IdentityMode.OFF`` for a brand-new provider).
* Identity forwarding is an enterprise-only capability. On non-enterprise
deployments any non-OFF value is coerced back to OFF so a persisted row
can never imply forwarding that the runtime won't perform. This gates the
API surface to match the backend gate in
``MCPTool._forwarding_requested`` — both the API and the backend
invocation must be gated on the Enterprise deployment edition.
"""
mode = current if requested is None else requested
if mode != IdentityMode.OFF and dify_config.DEPLOYMENT_EDITION != DeploymentEdition.ENTERPRISE:
return IdentityMode.OFF
return mode
class MCPProviderCreatePayload(MCPProviderBasePayload):
pass
class MCPProviderUpdatePayload(MCPProviderBasePayload):
provider_id: str
class MCPProviderDeletePayload(BaseModel):
provider_id: str
class MCPAuthPayload(BaseModel):
provider_id: str
authorization_code: str | None = None
class MCPCallbackQuery(BaseModel):
code: str
state: str
class ApiProviderDetailResponse(ResponseModel):
schema_type: ApiProviderSchemaType
schema_: str = Field(alias="schema")
tools: list[ApiToolBundle]
icon: ToolEmojiIcon
description: str | None = None
credentials: Mapping[str, object] = Field(default_factory=dict)
privacy_policy: str | None = None
custom_disclaimer: str | None = None
labels: list[str] = Field(default_factory=list)
class ApiSchemaParseResponse(ResponseModel):
schema_type: ApiProviderSchemaType
parameters_schema: list[ApiToolBundle]
credentials_schema: list[ProviderConfig]
warning: dict[str, str]
class ApiProviderRemoteSchemaResponse(ResponseModel):
schema_: str = Field(alias="schema")
class ApiToolPreviewResponse(RootModel[ApiToolPreviewResult]):
pass
class BuiltinProviderOAuthClientSchemaResponse(ResponseModel):
schema_: list[ProviderConfig] = Field(alias="schema")
is_oauth_custom_client_enabled: bool
is_system_oauth_params_exists: bool
client_params: Mapping[str, object] | None = None
redirect_uri: str
class MCPAuthResponse(ResponseModel):
result: Literal["success"] | None = None
authorization_url: str | None = None
class ToolApiListResponse(RootModel[list[ToolApiEntity]]):
pass
# TODO: This duplicates core.tools.entities.api_entities.ToolProviderApiEntity's
# public response projection. Consolidate the core entity and controller response
# shape when the tool-provider API serialization boundary is cleaned up.
class ToolProviderApiEntityResponse(ResponseModel):
id: str
author: str
name: str
description: I18nObject
icon: str | Mapping[str, str]
icon_dark: str | Mapping[str, str] = ""
label: I18nObject
type: ToolProviderType
team_credentials: Mapping[str, object] = Field(default_factory=dict)
is_team_authorization: bool = False
allow_delete: bool = True
plugin_id: str | None = Field(default="", description="The plugin id of the tool")
plugin_unique_identifier: str | None = Field(default="", description="The unique identifier of the tool")
tools: list[ToolApiEntity] = Field(default_factory=list)
labels: list[str] = Field(default_factory=list)
server_url: str | None = Field(default="", description="The server url of the tool")
updated_at: int = Field(default_factory=lambda: int(datetime.now().timestamp()))
server_identifier: str | None = Field(default="", description="The server identifier of the MCP tool")
masked_headers: dict[str, str] | None = Field(default=None, description="The masked headers of the MCP tool")
original_headers: dict[str, str] | None = Field(default=None, description="The original headers of the MCP tool")
authentication: MCPAuthentication | None = Field(default=None, description="The OAuth config of the MCP tool")
is_dynamic_registration: bool = Field(default=True, description="Whether the MCP tool is dynamically registered")
configuration: MCPConfiguration | None = Field(
default=None, description="The timeout and sse_read_timeout of the MCP tool"
)
identity_mode: str = Field(default="off", description="Identity-forwarding mechanism: 'off' or 'idp_token'")
workflow_app_id: str | None = Field(default=None, description="The app id of the workflow tool")
@field_validator("tools", mode="before")
@classmethod
def convert_none_to_empty_list(cls, value: list[ToolApiEntity] | None) -> list[ToolApiEntity]:
return value if value is not None else []
class ToolProviderListResponse(RootModel[list[ToolProviderApiEntityResponse]]):
pass
def _dump_tool_provider_payload(payload: Mapping[str, Any]) -> dict[str, Any]:
return ToolProviderApiEntityResponse.model_validate(payload).model_dump(mode="json", exclude_unset=True)
def _dump_tool_provider_payload_list(payloads: Iterable[Mapping[str, Any]]) -> list[dict[str, Any]]:
return [_dump_tool_provider_payload(payload) for payload in payloads]
class ToolProviderCredentialListResponse(RootModel[list[ToolProviderCredentialApiEntity]]):
pass
class ProviderConfigListResponse(RootModel[list[ProviderConfig]]):
pass
class ToolLabelListResponse(RootModel[list[ToolLabel]]):
pass
class WorkflowToolDetailResponse(ResponseModel):
name: str
label: str
workflow_tool_id: str
workflow_app_id: str
icon: ToolEmojiIcon
description: str
parameters: list[WorkflowToolParameterConfiguration]
output_schema: Mapping[str, object] = Field(default_factory=dict)
tool: ToolApiEntity
synced: bool
privacy_policy: str | None = None
register_schema_models(
console_ns,
ToolProviderListQuery,
ToolOAuthAuthorizationQuery,
UrlQuery,
ProviderQuery,
BuiltinCredentialListQuery,
WorkflowToolGetQuery,
WorkflowToolListQuery,
MCPCallbackQuery,
ToolEmojiIcon,
BuiltinToolCredentialDeletePayload,
BuiltinToolAddPayload,
BuiltinToolUpdatePayload,
ApiToolProviderAddPayload,
ApiToolProviderUpdatePayload,
ApiToolProviderDeletePayload,
ApiToolSchemaPayload,
ApiToolTestPayload,
WorkflowToolCreatePayload,
WorkflowToolUpdatePayload,
WorkflowToolDeletePayload,
BuiltinProviderDefaultCredentialPayload,
ToolOAuthCustomClientPayload,
MCPProviderCreatePayload,
MCPProviderUpdatePayload,
MCPProviderDeletePayload,
MCPAuthPayload,
)
register_response_schema_models(
console_ns,
SimpleResultResponse,
ApiProviderDetailResponse,
ApiSchemaParseResponse,
ApiProviderRemoteSchemaResponse,
ApiToolPreviewResponse,
BuiltinProviderOAuthClientSchemaResponse,
ToolApiListResponse,
ToolProviderApiEntityResponse,
ToolProviderCredentialInfoApiEntity,
ToolProviderCredentialListResponse,
ToolProviderListResponse,
ProviderConfigListResponse,
PluginOAuthAuthorizationUrlResponse,
ToolLabelListResponse,
MCPAuthResponse,
WorkflowToolDetailResponse,
)
@console_ns.route("/workspaces/current/tool-providers")
class ToolProviderListApi(Resource):
@console_ns.doc(params=query_params_from_model(ToolProviderListQuery))
@console_ns.response(
200, "Tool providers retrieved successfully", console_ns.models[ToolProviderListResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_user
@with_current_tenant_id
def get(self, tenant_id: str, user: Account):
query = query_params_from_request(ToolProviderListQuery)
return _dump_tool_provider_payload_list(
ToolCommonService.list_tool_providers(
user.id, tenant_id, cast(ToolProviderTypeApiLiteral | None, query.type)
),
)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/tools")
class ToolBuiltinProviderListToolsApi(Resource):
@console_ns.response(
200,
"Builtin provider tools retrieved successfully",
console_ns.models[ToolApiListResponse.__name__],
)
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
def get(self, tenant_id: str, provider: str):
return dump_response(
ToolApiListResponse,
BuiltinToolManageService.list_builtin_tool_provider_tools(
tenant_id,
provider,
),
)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/info")
class ToolBuiltinProviderInfoApi(Resource):
@console_ns.response(
200,
"Builtin provider info retrieved successfully",
console_ns.models[ToolProviderApiEntityResponse.__name__],
)
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
def get(self, tenant_id: str, provider: str):
return _dump_tool_provider_payload(
BuiltinToolManageService.get_builtin_tool_provider_info(tenant_id, provider).to_dict()
)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/delete")
class ToolBuiltinProviderDeleteApi(Resource):
@console_ns.expect(console_ns.models[BuiltinToolCredentialDeletePayload.__name__])
@console_ns.response(
200,
"Builtin provider credential deleted successfully",
console_ns.models[SimpleResultResponse.__name__],
)
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.CREDENTIAL_MANAGE, Workspace()))
@account_initialization_required
@with_current_tenant_id
@model_validate(BuiltinToolCredentialDeletePayload)
def post(self, req_data: BuiltinToolCredentialDeletePayload, tenant_id: str, provider: str):
return dump_response(
SimpleResultResponse,
BuiltinToolManageService.delete_builtin_tool_provider(
tenant_id,
provider,
req_data.credential_id,
),
)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/add")
class ToolBuiltinProviderAddApi(Resource):
@console_ns.expect(console_ns.models[BuiltinToolAddPayload.__name__])
@console_ns.response(
200,
"Builtin provider added successfully",
console_ns.models[SimpleResultResponse.__name__],
)
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.CREDENTIAL_CREATE, Workspace()))
@account_initialization_required
@with_current_user
@with_current_tenant_id
@model_validate(BuiltinToolAddPayload)
def post(self, req_data: BuiltinToolAddPayload, tenant_id: str, user: Account, provider: str):
return dump_response(
SimpleResultResponse,
BuiltinToolManageService.add_builtin_tool_provider(
user_id=user.id,
tenant_id=tenant_id,
provider=provider,
credentials=req_data.credentials,
name=req_data.name,
api_type=CredentialType.of(req_data.type),
visibility=req_data.visibility,
),
)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/update")
class ToolBuiltinProviderUpdateApi(Resource):
@console_ns.expect(console_ns.models[BuiltinToolUpdatePayload.__name__])
@console_ns.response(
200,
"Builtin provider updated successfully",
console_ns.models[SimpleResultResponse.__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
@model_validate(BuiltinToolUpdatePayload)
def post(self, req_data: BuiltinToolUpdatePayload, tenant_id: str, user: Account, provider: str):
result = BuiltinToolManageService.update_builtin_tool_provider(
user_id=user.id,
tenant_id=tenant_id,
provider=provider,
credential_id=req_data.credential_id,
credentials=req_data.credentials,
name=req_data.name or "",
)
return dump_response(SimpleResultResponse, result)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/credentials")
class ToolBuiltinProviderGetCredentialsApi(Resource):
@console_ns.doc(params=query_params_from_model(BuiltinCredentialListQuery))
@console_ns.response(
200,
"Builtin provider credentials retrieved successfully",
console_ns.models[ToolProviderCredentialListResponse.__name__],
)
@setup_required
@login_required
@account_initialization_required
@with_current_user
@with_current_tenant_id
def get(self, tenant_id: str, user: Account, provider: str):
# Optional list of credential IDs to include even if visibility would hide them
# (used when a workflow/agent node still references another member's only_me credential).
query = query_params_from_request(
BuiltinCredentialListQuery,
list_fields=("include_credential_ids",),
)
return dump_response(
ToolProviderCredentialListResponse,
BuiltinToolManageService.get_builtin_tool_provider_credentials(
tenant_id=tenant_id,
provider_name=provider,
user=user,
include_credential_ids=query.include_credential_ids or None,
credential_query=application_services().credential_queries,
),
)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/icon")
class ToolBuiltinProviderIconApi(Resource):
@console_ns.response(200, "Builtin provider icon")
@setup_required
def get(self, provider: str):
icon_bytes, mimetype = BuiltinToolManageService.get_builtin_tool_provider_icon(provider)
icon_cache_max_age = dify_config.TOOL_ICON_CACHE_MAX_AGE
# response-contract:ignore binary send_file response
return send_file(io.BytesIO(icon_bytes), mimetype=mimetype, max_age=icon_cache_max_age)
@console_ns.route("/workspaces/current/tool-provider/api/add")
class ToolApiProviderAddApi(Resource):
@console_ns.expect(console_ns.models[ApiToolProviderAddPayload.__name__])
@console_ns.response(200, "API provider added successfully", console_ns.models[SimpleResultResponse.__name__])
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.TOOL_MANAGE, Workspace()))
@account_initialization_required
@with_current_user
@with_current_tenant_id
@model_validate(ApiToolProviderAddPayload)
def post(self, req_data: ApiToolProviderAddPayload, tenant_id: str, user: Account):
return dump_response(
SimpleResultResponse,
ApiToolManageService.create_api_tool_provider(
user.id,
tenant_id,
req_data.provider,
req_data.icon.model_dump(mode="json"),
req_data.credentials,
req_data.schema_type,
req_data.schema_,
req_data.privacy_policy or "",
req_data.custom_disclaimer or "",
req_data.labels or [],
),
)
@console_ns.route("/workspaces/current/tool-provider/api/remote")
class ToolApiProviderGetRemoteSchemaApi(Resource):
@console_ns.doc(params=query_params_from_model(UrlQuery))
@console_ns.response(
200,
"Remote API provider schema retrieved successfully",
console_ns.models[ApiProviderRemoteSchemaResponse.__name__],
)
@setup_required
@login_required
@account_initialization_required
@with_current_user
@with_current_tenant_id
def get(self, tenant_id: str, user: Account):
query = query_params_from_request(UrlQuery)
return dump_response(
ApiProviderRemoteSchemaResponse,
ApiToolManageService.get_api_tool_provider_remote_schema(
user.id,
tenant_id,
str(query.url),
),
)
@console_ns.route("/workspaces/current/tool-provider/api/tools")
class ToolApiProviderListToolsApi(Resource):
@console_ns.doc(params=query_params_from_model(ProviderQuery))
@console_ns.response(
200, "API provider tools retrieved successfully", console_ns.models[ToolApiListResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_user
@with_current_tenant_id
def get(self, tenant_id: str, user: Account):
query = query_params_from_request(ProviderQuery)
return dump_response(
ToolApiListResponse,
ApiToolManageService.list_api_tool_provider_tools(
user.id,
tenant_id,
query.provider,
),
)
@console_ns.route("/workspaces/current/tool-provider/api/update")
class ToolApiProviderUpdateApi(Resource):
@console_ns.expect(console_ns.models[ApiToolProviderUpdatePayload.__name__])
@console_ns.response(200, "API provider updated successfully", console_ns.models[SimpleResultResponse.__name__])
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.TOOL_MANAGE, Workspace()))
@account_initialization_required
@with_current_user
@with_current_tenant_id
@model_validate(ApiToolProviderUpdatePayload)
def post(self, req_data: ApiToolProviderUpdatePayload, tenant_id: str, user: Account):
return dump_response(
SimpleResultResponse,
ApiToolManageService.update_api_tool_provider(
user.id,
tenant_id,
req_data.provider,
req_data.original_provider,
req_data.icon.model_dump(mode="json"),
req_data.credentials,
req_data.schema_type,
req_data.schema_,
req_data.privacy_policy,
req_data.custom_disclaimer,
req_data.labels or [],
),
)
@console_ns.route("/workspaces/current/tool-provider/api/delete")
class ToolApiProviderDeleteApi(Resource):
@console_ns.expect(console_ns.models[ApiToolProviderDeletePayload.__name__])
@console_ns.response(200, "API provider deleted successfully", console_ns.models[SimpleResultResponse.__name__])
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.TOOL_MANAGE, Workspace()))
@account_initialization_required
@with_current_user
@with_current_tenant_id
@model_validate(ApiToolProviderDeletePayload)
def post(self, req_data: ApiToolProviderDeletePayload, tenant_id: str, user: Account):
return dump_response(
SimpleResultResponse,
ApiToolManageService.delete_api_tool_provider(
user.id,
tenant_id,
req_data.provider,
),
)
@console_ns.route("/workspaces/current/tool-provider/api/get")
class ToolApiProviderGetApi(Resource):
@console_ns.doc(params=query_params_from_model(ProviderQuery))
@console_ns.response(
200, "API provider retrieved successfully", console_ns.models[ApiProviderDetailResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_user
@with_current_tenant_id
def get(self, tenant_id: str, user: Account):
query = query_params_from_request(ProviderQuery)
return dump_response(
ApiProviderDetailResponse,
ApiToolManageService.get_api_tool_provider(
user.id,
tenant_id,
query.provider,
),
)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/credential/schema/<path:credential_type>")
class ToolBuiltinProviderCredentialsSchemaApi(Resource):
@console_ns.response(
200,
"Builtin provider credential schema retrieved successfully",
console_ns.models[ProviderConfigListResponse.__name__],
)
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
def get(self, tenant_id: str, provider, credential_type):
return dump_response(
ProviderConfigListResponse,
BuiltinToolManageService.list_builtin_provider_credentials_schema(
provider, CredentialType.of(credential_type), tenant_id
),
)
@console_ns.route("/workspaces/current/tool-provider/api/schema")
class ToolApiProviderSchemaApi(Resource):
@console_ns.expect(console_ns.models[ApiToolSchemaPayload.__name__])
@console_ns.response(200, "API schema parsed successfully", console_ns.models[ApiSchemaParseResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@model_validate(ApiToolSchemaPayload)
def post(self, req_data: ApiToolSchemaPayload):
return dump_response(ApiSchemaParseResponse, ApiToolManageService.parser_api_schema(schema=req_data.schema_))
@console_ns.route("/workspaces/current/tool-provider/api/test/pre")
class ToolApiProviderPreviousTestApi(Resource):
@console_ns.expect(console_ns.models[ApiToolTestPayload.__name__])
@console_ns.response(
200,
"API tool test preview completed successfully",
console_ns.models[ApiToolPreviewResponse.__name__],
)
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
@model_validate(ApiToolTestPayload)
def post(self, req_data: ApiToolTestPayload, current_tenant_id: str):
return dump_response(
ApiToolPreviewResponse,
ApiToolManageService.test_api_tool_preview(
current_tenant_id,
req_data.provider_name or "",
req_data.tool_name,
req_data.credentials,
req_data.parameters,
req_data.schema_type,
req_data.schema_,
),
)
@console_ns.route("/workspaces/current/tool-provider/workflow/create")
class ToolWorkflowProviderCreateApi(Resource):
@console_ns.expect(console_ns.models[WorkflowToolCreatePayload.__name__])
@console_ns.response(200, "Workflow tool created successfully", console_ns.models[SimpleResultResponse.__name__])
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.TOOL_MANAGE, Workspace()))
@account_initialization_required
@with_current_user
@with_current_tenant_id
@model_validate(WorkflowToolCreatePayload)
def post(self, req_data: WorkflowToolCreatePayload, tenant_id: str, user: Account):
return dump_response(
SimpleResultResponse,
WorkflowToolManageService.create_workflow_tool(
user_id=user.id,
tenant_id=tenant_id,
workflow_app_id=req_data.workflow_app_id,
name=req_data.name,
label=req_data.label,
icon=req_data.icon.model_dump(mode="json"),
description=req_data.description,
parameters=req_data.parameters,
privacy_policy=req_data.privacy_policy or "",
labels=req_data.labels or [],
),
)
@console_ns.route("/workspaces/current/tool-provider/workflow/update")
class ToolWorkflowProviderUpdateApi(Resource):
@console_ns.expect(console_ns.models[WorkflowToolUpdatePayload.__name__])
@console_ns.response(200, "Workflow tool updated successfully", console_ns.models[SimpleResultResponse.__name__])
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.TOOL_MANAGE, Workspace()))
@account_initialization_required
@with_current_user
@with_current_tenant_id
@model_validate(WorkflowToolUpdatePayload)
def post(self, req_data: WorkflowToolUpdatePayload, tenant_id: str, user: Account):
return dump_response(
SimpleResultResponse,
WorkflowToolManageService.update_workflow_tool(
user.id,
tenant_id,
req_data.workflow_tool_id,
req_data.name,
req_data.label,
req_data.icon.model_dump(mode="json"),
req_data.description,
req_data.parameters,
req_data.privacy_policy or "",
req_data.labels or [],
),
)
@console_ns.route("/workspaces/current/tool-provider/workflow/delete")
class ToolWorkflowProviderDeleteApi(Resource):
@console_ns.expect(console_ns.models[WorkflowToolDeletePayload.__name__])
@console_ns.response(200, "Workflow tool deleted successfully", console_ns.models[SimpleResultResponse.__name__])
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.TOOL_MANAGE, Workspace()))
@account_initialization_required
@with_current_user
@with_current_tenant_id
@model_validate(WorkflowToolDeletePayload)
def post(self, req_data: WorkflowToolDeletePayload, tenant_id: str, user: Account):
return dump_response(
SimpleResultResponse,
WorkflowToolManageService.delete_workflow_tool(
user.id,
tenant_id,
req_data.workflow_tool_id,
),
)
@console_ns.route("/workspaces/current/tool-provider/workflow/get")
class ToolWorkflowProviderGetApi(Resource):
@console_ns.doc(params=query_params_from_model(WorkflowToolGetQuery))
@console_ns.response(
200, "Workflow tool retrieved successfully", console_ns.models[WorkflowToolDetailResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_user
@with_current_tenant_id
def get(self, tenant_id: str, user: Account):
query = query_params_from_request(WorkflowToolGetQuery)
if query.workflow_tool_id:
tool = WorkflowToolManageService.get_workflow_tool_by_tool_id(
user.id,
tenant_id,
query.workflow_tool_id,
)
elif query.workflow_app_id:
tool = WorkflowToolManageService.get_workflow_tool_by_app_id(
user.id,
tenant_id,
query.workflow_app_id,
)
else:
raise ValueError("incorrect workflow_tool_id or workflow_app_id")
return dump_response(WorkflowToolDetailResponse, tool)
@console_ns.route("/workspaces/current/tool-provider/workflow/tools")
class ToolWorkflowProviderListToolApi(Resource):
@console_ns.doc(params=query_params_from_model(WorkflowToolListQuery))
@console_ns.response(
200, "Workflow provider tools retrieved successfully", console_ns.models[ToolApiListResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_user
@with_current_tenant_id
def get(self, tenant_id: str, user: Account):
query = query_params_from_request(WorkflowToolListQuery)
return dump_response(
ToolApiListResponse,
WorkflowToolManageService.list_single_workflow_tools(
user.id,
tenant_id,
query.workflow_tool_id,
),
)
@console_ns.route("/workspaces/current/tools/builtin")
class ToolBuiltinListApi(Resource):
@console_ns.response(
200, "Builtin tools retrieved successfully", console_ns.models[ToolProviderListResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_user
@with_current_tenant_id
def get(self, tenant_id: str, user: Account):
return _dump_tool_provider_payload_list(
[
provider.to_dict()
for provider in BuiltinToolManageService.list_builtin_tools(
user.id,
tenant_id,
)
],
)
@console_ns.route("/workspaces/current/tools/api")
class ToolApiListApi(Resource):
@console_ns.response(200, "API tools retrieved successfully", console_ns.models[ToolProviderListResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
def get(self, tenant_id: str):
return _dump_tool_provider_payload_list(
[
provider.to_dict()
for provider in ApiToolManageService.list_api_tools(
tenant_id,
)
],
)
@console_ns.route("/workspaces/current/tools/workflow")
class ToolWorkflowListApi(Resource):
@console_ns.response(
200, "Workflow tools retrieved successfully", console_ns.models[ToolProviderListResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_user
@with_current_tenant_id
def get(self, tenant_id: str, user: Account):
return _dump_tool_provider_payload_list(
[
provider.to_dict()
for provider in WorkflowToolManageService.list_tenant_workflow_tools(
user.id,
tenant_id,
)
],
)
@console_ns.route("/workspaces/current/tool-labels")
class ToolLabelsApi(Resource):
@console_ns.response(200, "Tool labels retrieved successfully", console_ns.models[ToolLabelListResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@enterprise_license_required
def get(self):
return dump_response(ToolLabelListResponse, ToolLabelsService.list_tool_labels())
@console_ns.route("/oauth/plugin/<path:provider>/tool/authorization-url")
class ToolPluginOAuthApi(Resource):
@console_ns.doc(params=query_params_from_model(ToolOAuthAuthorizationQuery))
@console_ns.response(
200,
"Tool OAuth authorization URL generated successfully",
console_ns.models[PluginOAuthAuthorizationUrlResponse.__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
def get(self, tenant_id: str, user: Account, provider: str):
tool_provider = ToolProviderID(provider)
plugin_id = tool_provider.plugin_id
provider_name = tool_provider.provider_name
oauth_client_params = BuiltinToolManageService.get_oauth_client(tenant_id=tenant_id, provider=provider)
if oauth_client_params is None:
raise Forbidden("no oauth available client config found for this tool provider")
# Visibility is chosen by the user in the frontend before the redirect,
# then read back in the callback below when the credential is created.
# Only ONLY_ME / ALL_TEAM are accepted; anything else falls back to
# ONLY_ME (OAuth tokens are personal by nature).
raw_visibility = request.args.get("visibility")
try:
requested_visibility = PermissionEnum(raw_visibility) if raw_visibility else PermissionEnum.ONLY_ME
except ValueError:
requested_visibility = PermissionEnum.ONLY_ME
if requested_visibility not in (PermissionEnum.ONLY_ME, PermissionEnum.ALL_TEAM):
requested_visibility = PermissionEnum.ONLY_ME
oauth_handler = OAuthHandler()
context_id = OAuthProxyService.create_proxy_context(
user_id=user.id,
tenant_id=tenant_id,
plugin_id=plugin_id,
provider=provider_name,
extra_data={
"visibility": requested_visibility.value,
"plugin_unique_identifier": oauth_client_params.plugin_unique_identifier,
},
)
redirect_uri = f"{dify_config.CONSOLE_API_URL}/console/api/oauth/plugin/{provider}/tool/callback"
authorization_url_response = oauth_handler.get_authorization_url(
tenant_id=tenant_id,
user_id=user.id,
plugin_id=plugin_id,
provider=provider_name,
redirect_uri=redirect_uri,
system_credentials=dict(oauth_client_params.credentials),
plugin_unique_identifier=oauth_client_params.plugin_unique_identifier,
)
# response-contract:ignore cookie-bearing Flask response
response = make_response(dump_response(PluginOAuthAuthorizationUrlResponse, authorization_url_response))
response.set_cookie(
"context_id",
context_id,
httponly=True,
samesite="Lax",
max_age=OAuthProxyService.__MAX_AGE__,
)
return response
@console_ns.route("/oauth/plugin/<path:provider>/tool/callback")
class ToolOAuthCallback(Resource):
@console_ns.response(302, "Redirect to OAuth callback page")
@setup_required
def get(self, provider: str):
context_id = request.cookies.get("context_id")
if not context_id:
raise Forbidden("context_id not found")
context = OAuthProxyService.use_proxy_context(context_id)
if context is None:
raise Forbidden("Invalid context_id")
tool_provider = ToolProviderID(provider)
plugin_id = tool_provider.plugin_id
provider_name = tool_provider.provider_name
user_id: str = context["user_id"]
tenant_id: str = context["tenant_id"]
oauth_handler = OAuthHandler()
oauth_client_params = BuiltinToolManageService.get_oauth_client(tenant_id, provider)
if oauth_client_params is None:
raise Forbidden("no oauth available client config found for this tool provider")
try:
OAuthProxyService.validate_plugin_context(
context,
plugin_id=plugin_id,
provider=provider_name,
plugin_unique_identifier=oauth_client_params.plugin_unique_identifier,
)
except ValueError as error:
raise Forbidden(str(error)) from error
redirect_uri = f"{dify_config.CONSOLE_API_URL}/console/api/oauth/plugin/{provider}/tool/callback"
credentials_response = oauth_handler.get_credentials(
tenant_id=tenant_id,
user_id=user_id,
plugin_id=plugin_id,
provider=provider_name,
redirect_uri=redirect_uri,
system_credentials=dict(oauth_client_params.credentials),
plugin_unique_identifier=oauth_client_params.plugin_unique_identifier,
request=request,
)
credentials = credentials_response.credentials
expires_at = credentials_response.expires_at
if not credentials:
raise Exception("the plugin credentials failed")
# Visibility was chosen by the user before the redirect and stashed in
# the proxy context. Fall back to ONLY_ME for older cookies (or for
# anything that somehow wrote an unexpected value) — OAuth tokens are
# personal by default.
stored_visibility = context.get("visibility")
try:
visibility = PermissionEnum(stored_visibility) if stored_visibility else PermissionEnum.ONLY_ME
except ValueError:
visibility = PermissionEnum.ONLY_ME
if visibility not in (PermissionEnum.ONLY_ME, PermissionEnum.ALL_TEAM):
visibility = PermissionEnum.ONLY_ME
BuiltinToolManageService.add_builtin_tool_provider(
user_id=user_id,
tenant_id=tenant_id,
provider=provider,
credentials=dict(credentials),
expires_at=expires_at,
api_type=CredentialType.OAUTH2,
visibility=visibility.value,
)
# response-contract:ignore redirect response
return redirect(f"{dify_config.CONSOLE_WEB_URL}/oauth-callback")
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/default-credential")
class ToolBuiltinProviderSetDefaultApi(Resource):
@console_ns.expect(console_ns.models[BuiltinProviderDefaultCredentialPayload.__name__])
@console_ns.response(200, "Default credential set successfully", console_ns.models[SimpleResultResponse.__name__])
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.CREDENTIAL_USE, Workspace()))
@account_initialization_required
@with_current_tenant_id
@model_validate(BuiltinProviderDefaultCredentialPayload)
def post(self, req_data: BuiltinProviderDefaultCredentialPayload, current_tenant_id: str, provider: str):
return dump_response(
SimpleResultResponse,
BuiltinToolManageService.set_default_provider(
tenant_id=current_tenant_id, provider=provider, id=req_data.id
),
)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/oauth/custom-client")
class ToolOAuthCustomClient(Resource):
@console_ns.expect(console_ns.models[ToolOAuthCustomClientPayload.__name__])
@console_ns.response(
200, "Custom OAuth client saved successfully", console_ns.models[SimpleResultResponse.__name__]
)
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.CREDENTIAL_MANAGE, Workspace()))
@account_initialization_required
@with_current_tenant_id
@model_validate(ToolOAuthCustomClientPayload)
def post(self, req_data: ToolOAuthCustomClientPayload, tenant_id: str, provider: str):
return dump_response(
SimpleResultResponse,
BuiltinToolManageService.save_custom_oauth_client_params(
tenant_id=tenant_id,
provider=provider,
client_params=req_data.client_params or {},
enable_oauth_custom_client=req_data.enable_oauth_custom_client
if req_data.enable_oauth_custom_client is not None
else True,
),
)
@console_ns.response(
200,
"Custom OAuth client retrieved successfully",
)
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.CREDENTIAL_MANAGE, Workspace()))
@account_initialization_required
@with_current_tenant_id
def get(self, current_tenant_id: str, provider: str):
return BuiltinToolManageService.get_custom_oauth_client_params(tenant_id=current_tenant_id, provider=provider)
@console_ns.response(
200, "Custom OAuth client deleted successfully", console_ns.models[SimpleResultResponse.__name__]
)
@setup_required
@login_required
@is_admin_or_owner_required
@rbac_permission_required(RBACCheck(RBACPermission.CREDENTIAL_MANAGE, Workspace()))
@account_initialization_required
@with_current_tenant_id
def delete(self, current_tenant_id: str, provider: str):
return dump_response(
SimpleResultResponse,
BuiltinToolManageService.delete_custom_oauth_client_params(tenant_id=current_tenant_id, provider=provider),
)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/oauth/client-schema")
class ToolBuiltinProviderGetOauthClientSchemaApi(Resource):
@console_ns.response(
200,
"Builtin provider OAuth client schema retrieved successfully",
console_ns.models[BuiltinProviderOAuthClientSchemaResponse.__name__],
)
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
def get(self, current_tenant_id: str, provider: str):
return dump_response(
BuiltinProviderOAuthClientSchemaResponse,
BuiltinToolManageService.get_builtin_tool_provider_oauth_client_schema(
tenant_id=current_tenant_id, provider_name=provider
),
)
@console_ns.route("/workspaces/current/tool-provider/builtin/<path:provider>/credential/info")
class ToolBuiltinProviderGetCredentialInfoApi(Resource):
@console_ns.doc(params=query_params_from_model(BuiltinCredentialListQuery))
@console_ns.response(
200,
"Builtin provider credential info retrieved successfully",
console_ns.models[ToolProviderCredentialInfoApiEntity.__name__],
)
@setup_required
@login_required
@account_initialization_required
@with_current_user
@with_current_tenant_id
def get(self, tenant_id: str, user: Account, provider: str):
query = query_params_from_request(
BuiltinCredentialListQuery,
list_fields=("include_credential_ids",),
)
return dump_response(
ToolProviderCredentialInfoApiEntity,
BuiltinToolManageService.get_builtin_tool_provider_credential_info(
tenant_id=tenant_id,
provider=provider,
user=user,
include_credential_ids=query.include_credential_ids or None,
credential_query=application_services().credential_queries,
),
)
@console_ns.route("/workspaces/current/tool-provider/mcp")
class ToolProviderMCPApi(Resource):
@console_ns.expect(console_ns.models[MCPProviderCreatePayload.__name__])
@console_ns.response(
200, "MCP provider created successfully", console_ns.models[ToolProviderApiEntityResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@rbac_permission_required(RBACCheck(RBACPermission.MCP_MANAGE, Workspace()))
@with_current_user
@with_current_tenant_id
@model_validate(MCPProviderCreatePayload)
def post(self, req_data: MCPProviderCreatePayload, tenant_id: str, user: Account):
configuration = req_data.configuration or MCPConfiguration()
authentication = req_data.authentication
# 1) Create provider in a short transaction (no network I/O inside)
with session_factory.create_session() as session, session.begin():
service = MCPToolManageService(session=session)
result = service.create_provider(
tenant_id=tenant_id,
user_id=user.id,
server_url=req_data.server_url,
name=req_data.name,
icon=req_data.icon,
icon_type=req_data.icon_type,
icon_background=req_data.icon_background,
server_identifier=req_data.server_identifier,
headers=req_data.headers or {},
configuration=configuration,
authentication=authentication,
identity_mode=_resolve_identity_mode(req_data.identity_mode, current=IdentityMode.OFF),
)
# 2) Try to fetch tools immediately after creation so they appear without a second save.
# Perform network I/O outside any DB session to avoid holding locks.
try:
reconnect = MCPToolManageService.reconnect_with_url(
server_url=req_data.server_url,
headers=req_data.headers or {},
timeout=configuration.timeout,
sse_read_timeout=configuration.sse_read_timeout,
)
# Update just-created provider with authed/tools in a new short transaction
with session_factory.create_session() as session, session.begin():
service = MCPToolManageService(session=session)
db_provider = service.get_provider_by_id(provider_id=result.id, tenant_id=tenant_id)
db_provider.authed = reconnect.authed
db_provider.tools = reconnect.tools
result = ToolTransformService.mcp_provider_to_user_provider(db_provider)
except Exception:
# Best-effort: if initial fetch fails (e.g., auth required), return created provider as-is
logger.warning("Failed to fetch MCP tools after creation", exc_info=True)
return _dump_tool_provider_payload(result.to_dict())
@console_ns.expect(console_ns.models[MCPProviderUpdatePayload.__name__])
@console_ns.response(200, "MCP provider updated successfully", console_ns.models[SimpleResultResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@rbac_permission_required(RBACCheck(RBACPermission.MCP_MANAGE, Workspace()))
@with_current_tenant_id
@model_validate(MCPProviderUpdatePayload)
def put(self, req_data: MCPProviderUpdatePayload, current_tenant_id: str):
configuration = req_data.configuration or MCPConfiguration()
authentication = req_data.authentication
# Step 1: Get provider data for URL validation (short-lived session, no network I/O)
validation_data = None
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
validation_data = service.get_provider_for_url_validation(
tenant_id=current_tenant_id, provider_id=req_data.provider_id
)
# Step 2: Perform URL validation with network I/O OUTSIDE of any database session
# This prevents holding database locks during potentially slow network operations
validation_result = MCPToolManageService.validate_server_url_standalone(
tenant_id=current_tenant_id,
new_server_url=req_data.server_url,
validation_data=validation_data,
)
# Step 3: Perform database update in a transaction
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
# Resolve "leave unchanged" (None) against the stored value, and gate
# the result on the Enterprise edition — both are API-layer concerns, so
# the service receives a concrete IdentityMode.
existing = service.get_provider_by_id(provider_id=req_data.provider_id, tenant_id=current_tenant_id)
identity_mode = _resolve_identity_mode(req_data.identity_mode, current=IdentityMode(existing.identity_mode))
service.update_provider(
tenant_id=current_tenant_id,
provider_id=req_data.provider_id,
server_url=req_data.server_url,
name=req_data.name,
icon=req_data.icon,
icon_type=req_data.icon_type,
icon_background=req_data.icon_background,
server_identifier=req_data.server_identifier,
headers=req_data.headers or {},
configuration=configuration,
authentication=authentication,
validation_result=validation_result,
identity_mode=identity_mode,
)
return SimpleResultResponse(result="success").model_dump(mode="json")
@console_ns.expect(console_ns.models[MCPProviderDeletePayload.__name__])
@console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@rbac_permission_required(RBACCheck(RBACPermission.MCP_MANAGE, Workspace()))
@with_current_tenant_id
@model_validate(MCPProviderDeletePayload)
def delete(self, req_data: MCPProviderDeletePayload, current_tenant_id: str):
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
service.delete_provider(tenant_id=current_tenant_id, provider_id=req_data.provider_id)
return SimpleResultResponse(result="success").model_dump(mode="json")
@console_ns.route("/workspaces/current/tool-provider/mcp/auth")
class ToolMCPAuthApi(Resource):
@console_ns.expect(console_ns.models[MCPAuthPayload.__name__])
@console_ns.response(200, "MCP provider authorized successfully", console_ns.models[MCPAuthResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@rbac_permission_required(RBACCheck(RBACPermission.MCP_MANAGE, Workspace()))
@with_current_tenant_id
@model_validate(MCPAuthPayload)
def post(self, req_data: MCPAuthPayload, tenant_id: str):
provider_id = req_data.provider_id
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
db_provider = service.get_provider_by_id(provider_id=provider_id, tenant_id=tenant_id)
if not db_provider:
raise ValueError("provider not found")
# Convert to entity
provider_entity = db_provider.to_entity()
server_url = provider_entity.decrypt_server_url()
headers = provider_entity.decrypt_authentication()
# Try to connect without active transaction
try:
# Use MCPClientWithAuthRetry to handle authentication automatically
with MCPClient(
server_url=server_url,
headers=headers,
timeout=provider_entity.timeout,
sse_read_timeout=provider_entity.sse_read_timeout,
):
# Update credentials in new transaction
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
service.update_provider_credentials(
provider_id=provider_id,
tenant_id=tenant_id,
credentials=provider_entity.credentials,
authed=True,
)
return MCPAuthResponse(result="success").model_dump(mode="json")
except MCPAuthError as e:
try:
# Pass the extracted OAuth metadata hints to auth()
auth_result = auth(
provider_entity,
req_data.authorization_code,
resource_metadata_url=e.resource_metadata_url,
scope_hint=e.scope_hint,
)
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
response = service.execute_auth_actions(auth_result)
return dump_response(MCPAuthResponse, response)
except MCPRefreshTokenError as e:
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
service.clear_provider_credentials(provider_id=provider_id, tenant_id=tenant_id)
raise ValueError(f"Failed to refresh token, please try to authorize again: {e}") from e
except (MCPError, ValueError) as e:
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
service.clear_provider_credentials(provider_id=provider_id, tenant_id=tenant_id)
parsed = urlparse(server_url)
sanitized_url = f"{parsed.scheme}://{parsed.hostname}{parsed.path}"
logger.warning(
"MCP authorization failed for provider %s (url=%s)",
provider_id,
sanitized_url,
exc_info=True,
)
raise ValueError(f"Failed to connect to MCP server: {e}") from e
@console_ns.route("/workspaces/current/tool-provider/mcp/tools/<path:provider_id>")
class ToolMCPDetailApi(Resource):
@console_ns.response(
200, "MCP provider retrieved successfully", console_ns.models[ToolProviderApiEntityResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@rbac_permission_required(RBACCheck(RBACPermission.MCP_MANAGE, Workspace()))
@with_current_tenant_id
def get(self, tenant_id: str, provider_id: str):
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
provider = service.get_provider_by_id(provider_id=provider_id, tenant_id=tenant_id)
return _dump_tool_provider_payload(ToolTransformService.mcp_provider_to_user_provider(provider).to_dict())
@console_ns.route("/workspaces/current/tools/mcp")
class ToolMCPListAllApi(Resource):
@console_ns.response(200, "MCP tools retrieved successfully", console_ns.models[ToolProviderListResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
def get(self, tenant_id: str):
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
# Skip sensitive data decryption for list view to improve performance
tools = service.list_providers(tenant_id=tenant_id, include_sensitive=False)
return _dump_tool_provider_payload_list([tool.to_dict() for tool in tools])
@console_ns.route("/workspaces/current/tool-provider/mcp/update/<path:provider_id>")
class ToolMCPUpdateApi(Resource):
@console_ns.response(
200, "MCP provider tools refreshed successfully", console_ns.models[ToolProviderApiEntityResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@rbac_permission_required(RBACCheck(RBACPermission.MCP_MANAGE, Workspace()))
@with_current_tenant_id
def get(self, tenant_id: str, provider_id: str):
with sessionmaker(db.engine).begin() as session:
service = MCPToolManageService(session=session)
tools = service.list_provider_tools(
tenant_id=tenant_id,
provider_id=provider_id,
)
return _dump_tool_provider_payload(tools.to_dict())
@console_ns.route("/mcp/oauth/callback")
class ToolMCPCallbackApi(Resource):
@console_ns.doc(params=query_params_from_model(MCPCallbackQuery))
@console_ns.response(302, "Redirect to OAuth callback page")
def get(self):
query = query_params_from_request(MCPCallbackQuery)
state_key = query.state
authorization_code = query.code
# Create service instance for handle_callback
with sessionmaker(db.engine).begin() as session:
mcp_service = MCPToolManageService(session=session)
# handle_callback now returns state data and tokens
state_data, tokens = handle_callback(state_key, authorization_code)
# Save tokens using the service layer
mcp_service.save_oauth_data(
state_data.provider_id, state_data.tenant_id, tokens.model_dump(), OAuthDataType.TOKENS
)
# response-contract:ignore redirect response
return redirect(f"{dify_config.CONSOLE_WEB_URL}/oauth-callback")