dify

dify/api/controllers/console/workspace/__init__.py

@@ -0,0 +1,62 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import ParamSpec, TypeVar
+
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import Forbidden
+
+from extensions.ext_database import db
+from libs.login import current_account_with_tenant
+from models.account import TenantPluginPermission
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def plugin_permission_required(
+    install_required: bool = False,
+    debug_required: bool = False,
+):
+    def interceptor(view: Callable[P, R]):
+        @wraps(view)
+        def decorated(*args: P.args, **kwargs: P.kwargs):
+            current_user, current_tenant_id = current_account_with_tenant()
+            user = current_user
+            tenant_id = current_tenant_id
+
+            with Session(db.engine) as session:
+                permission = (
+                    session.query(TenantPluginPermission)
+                    .where(
+                        TenantPluginPermission.tenant_id == tenant_id,
+                    )
+                    .first()
+                )
+
+                if not permission:
+                    # no permission set, allow access for everyone
+                    return view(*args, **kwargs)
+
+                if install_required:
+                    if permission.install_permission == TenantPluginPermission.InstallPermission.NOBODY:
+                        raise Forbidden()
+                    if permission.install_permission == TenantPluginPermission.InstallPermission.ADMINS:
+                        if not user.is_admin_or_owner:
+                            raise Forbidden()
+                    if permission.install_permission == TenantPluginPermission.InstallPermission.EVERYONE:
+                        pass
+
+                if debug_required:
+                    if permission.debug_permission == TenantPluginPermission.DebugPermission.NOBODY:
+                        raise Forbidden()
+                    if permission.debug_permission == TenantPluginPermission.DebugPermission.ADMINS:
+                        if not user.is_admin_or_owner:
+                            raise Forbidden()
+                    if permission.debug_permission == TenantPluginPermission.DebugPermission.EVERYONE:
+                        pass
+
+            return view(*args, **kwargs)
+
+        return decorated
+
+    return interceptor

dify/api/controllers/console/workspace/account.py

@@ -0,0 +1,614 @@
+from datetime import datetime
+
+import pytz
+from flask import request
+from flask_restx import Resource, fields, marshal_with, reqparse
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from configs import dify_config
+from constants.languages import supported_language
+from controllers.console import console_ns
+from controllers.console.auth.error import (
+    EmailAlreadyInUseError,
+    EmailChangeLimitError,
+    EmailCodeError,
+    InvalidEmailError,
+    InvalidTokenError,
+)
+from controllers.console.error import AccountInFreezeError, AccountNotFound, EmailSendIpLimitError
+from controllers.console.workspace.error import (
+    AccountAlreadyInitedError,
+    CurrentPasswordIncorrectError,
+    InvalidAccountDeletionCodeError,
+    InvalidInvitationCodeError,
+    RepeatPasswordNotMatchError,
+)
+from controllers.console.wraps import (
+    account_initialization_required,
+    cloud_edition_billing_enabled,
+    enable_change_email,
+    enterprise_license_required,
+    only_edition_cloud,
+    setup_required,
+)
+from extensions.ext_database import db
+from fields.member_fields import account_fields
+from libs.datetime_utils import naive_utc_now
+from libs.helper import TimestampField, email, extract_remote_ip, timezone
+from libs.login import current_account_with_tenant, login_required
+from models import Account, AccountIntegrate, InvitationCode
+from services.account_service import AccountService
+from services.billing_service import BillingService
+from services.errors.account import CurrentPasswordIncorrectError as ServiceCurrentPasswordIncorrectError
+
+
+def _init_parser():
+    parser = reqparse.RequestParser()
+    if dify_config.EDITION == "CLOUD":
+        parser.add_argument("invitation_code", type=str, location="json")
+    parser.add_argument("interface_language", type=supported_language, required=True, location="json").add_argument(
+        "timezone", type=timezone, required=True, location="json"
+    )
+    return parser
+
+
+@console_ns.route("/account/init")
+class AccountInitApi(Resource):
+    @console_ns.expect(_init_parser())
+    @setup_required
+    @login_required
+    def post(self):
+        account, _ = current_account_with_tenant()
+
+        if account.status == "active":
+            raise AccountAlreadyInitedError()
+
+        args = _init_parser().parse_args()
+
+        if dify_config.EDITION == "CLOUD":
+            if not args["invitation_code"]:
+                raise ValueError("invitation_code is required")
+
+            # check invitation code
+            invitation_code = (
+                db.session.query(InvitationCode)
+                .where(
+                    InvitationCode.code == args["invitation_code"],
+                    InvitationCode.status == "unused",
+                )
+                .first()
+            )
+
+            if not invitation_code:
+                raise InvalidInvitationCodeError()
+
+            invitation_code.status = "used"
+            invitation_code.used_at = naive_utc_now()
+            invitation_code.used_by_tenant_id = account.current_tenant_id
+            invitation_code.used_by_account_id = account.id
+
+        account.interface_language = args["interface_language"]
+        account.timezone = args["timezone"]
+        account.interface_theme = "light"
+        account.status = "active"
+        account.initialized_at = naive_utc_now()
+        db.session.commit()
+
+        return {"result": "success"}
+
+
+@console_ns.route("/account/profile")
+class AccountProfileApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    @enterprise_license_required
+    def get(self):
+        current_user, _ = current_account_with_tenant()
+        return current_user
+
+
+parser_name = reqparse.RequestParser().add_argument("name", type=str, required=True, location="json")
+
+
+@console_ns.route("/account/name")
+class AccountNameApi(Resource):
+    @console_ns.expect(parser_name)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        args = parser_name.parse_args()
+
+        # Validate account name length
+        if len(args["name"]) < 3 or len(args["name"]) > 30:
+            raise ValueError("Account name must be between 3 and 30 characters.")
+
+        updated_account = AccountService.update_account(current_user, name=args["name"])
+
+        return updated_account
+
+
+parser_avatar = reqparse.RequestParser().add_argument("avatar", type=str, required=True, location="json")
+
+
+@console_ns.route("/account/avatar")
+class AccountAvatarApi(Resource):
+    @console_ns.expect(parser_avatar)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        args = parser_avatar.parse_args()
+
+        updated_account = AccountService.update_account(current_user, avatar=args["avatar"])
+
+        return updated_account
+
+
+parser_interface = reqparse.RequestParser().add_argument(
+    "interface_language", type=supported_language, required=True, location="json"
+)
+
+
+@console_ns.route("/account/interface-language")
+class AccountInterfaceLanguageApi(Resource):
+    @console_ns.expect(parser_interface)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        args = parser_interface.parse_args()
+
+        updated_account = AccountService.update_account(current_user, interface_language=args["interface_language"])
+
+        return updated_account
+
+
+parser_theme = reqparse.RequestParser().add_argument(
+    "interface_theme", type=str, choices=["light", "dark"], required=True, location="json"
+)
+
+
+@console_ns.route("/account/interface-theme")
+class AccountInterfaceThemeApi(Resource):
+    @console_ns.expect(parser_theme)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        args = parser_theme.parse_args()
+
+        updated_account = AccountService.update_account(current_user, interface_theme=args["interface_theme"])
+
+        return updated_account
+
+
+parser_timezone = reqparse.RequestParser().add_argument("timezone", type=str, required=True, location="json")
+
+
+@console_ns.route("/account/timezone")
+class AccountTimezoneApi(Resource):
+    @console_ns.expect(parser_timezone)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        args = parser_timezone.parse_args()
+
+        # Validate timezone string, e.g. America/New_York, Asia/Shanghai
+        if args["timezone"] not in pytz.all_timezones:
+            raise ValueError("Invalid timezone string.")
+
+        updated_account = AccountService.update_account(current_user, timezone=args["timezone"])
+
+        return updated_account
+
+
+parser_pw = (
+    reqparse.RequestParser()
+    .add_argument("password", type=str, required=False, location="json")
+    .add_argument("new_password", type=str, required=True, location="json")
+    .add_argument("repeat_new_password", type=str, required=True, location="json")
+)
+
+
+@console_ns.route("/account/password")
+class AccountPasswordApi(Resource):
+    @console_ns.expect(parser_pw)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        args = parser_pw.parse_args()
+
+        if args["new_password"] != args["repeat_new_password"]:
+            raise RepeatPasswordNotMatchError()
+
+        try:
+            AccountService.update_account_password(current_user, args["password"], args["new_password"])
+        except ServiceCurrentPasswordIncorrectError:
+            raise CurrentPasswordIncorrectError()
+
+        return {"result": "success"}
+
+
+@console_ns.route("/account/integrates")
+class AccountIntegrateApi(Resource):
+    integrate_fields = {
+        "provider": fields.String,
+        "created_at": TimestampField,
+        "is_bound": fields.Boolean,
+        "link": fields.String,
+    }
+
+    integrate_list_fields = {
+        "data": fields.List(fields.Nested(integrate_fields)),
+    }
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(integrate_list_fields)
+    def get(self):
+        account, _ = current_account_with_tenant()
+
+        account_integrates = db.session.scalars(
+            select(AccountIntegrate).where(AccountIntegrate.account_id == account.id)
+        ).all()
+
+        base_url = request.url_root.rstrip("/")
+        oauth_base_path = "/console/api/oauth/login"
+        providers = ["github", "google"]
+
+        integrate_data = []
+        for provider in providers:
+            existing_integrate = next((ai for ai in account_integrates if ai.provider == provider), None)
+            if existing_integrate:
+                integrate_data.append(
+                    {
+                        "id": existing_integrate.id,
+                        "provider": provider,
+                        "created_at": existing_integrate.created_at,
+                        "is_bound": True,
+                        "link": None,
+                    }
+                )
+            else:
+                integrate_data.append(
+                    {
+                        "id": None,
+                        "provider": provider,
+                        "created_at": None,
+                        "is_bound": False,
+                        "link": f"{base_url}{oauth_base_path}/{provider}",
+                    }
+                )
+
+        return {"data": integrate_data}
+
+
+@console_ns.route("/account/delete/verify")
+class AccountDeleteVerifyApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        account, _ = current_account_with_tenant()
+
+        token, code = AccountService.generate_account_deletion_verification_code(account)
+        AccountService.send_account_deletion_verification_email(account, code)
+
+        return {"result": "success", "data": token}
+
+
+parser_delete = (
+    reqparse.RequestParser()
+    .add_argument("token", type=str, required=True, location="json")
+    .add_argument("code", type=str, required=True, location="json")
+)
+
+
+@console_ns.route("/account/delete")
+class AccountDeleteApi(Resource):
+    @console_ns.expect(parser_delete)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        account, _ = current_account_with_tenant()
+
+        args = parser_delete.parse_args()
+
+        if not AccountService.verify_account_deletion_code(args["token"], args["code"]):
+            raise InvalidAccountDeletionCodeError()
+
+        AccountService.delete_account(account)
+
+        return {"result": "success"}
+
+
+parser_feedback = (
+    reqparse.RequestParser()
+    .add_argument("email", type=str, required=True, location="json")
+    .add_argument("feedback", type=str, required=True, location="json")
+)
+
+
+@console_ns.route("/account/delete/feedback")
+class AccountDeleteUpdateFeedbackApi(Resource):
+    @console_ns.expect(parser_feedback)
+    @setup_required
+    def post(self):
+        args = parser_feedback.parse_args()
+
+        BillingService.update_account_deletion_feedback(args["email"], args["feedback"])
+
+        return {"result": "success"}
+
+
+@console_ns.route("/account/education/verify")
+class EducationVerifyApi(Resource):
+    verify_fields = {
+        "token": fields.String,
+    }
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @only_edition_cloud
+    @cloud_edition_billing_enabled
+    @marshal_with(verify_fields)
+    def get(self):
+        account, _ = current_account_with_tenant()
+
+        return BillingService.EducationIdentity.verify(account.id, account.email)
+
+
+parser_edu = (
+    reqparse.RequestParser()
+    .add_argument("token", type=str, required=True, location="json")
+    .add_argument("institution", type=str, required=True, location="json")
+    .add_argument("role", type=str, required=True, location="json")
+)
+
+
+@console_ns.route("/account/education")
+class EducationApi(Resource):
+    status_fields = {
+        "result": fields.Boolean,
+        "is_student": fields.Boolean,
+        "expire_at": TimestampField,
+        "allow_refresh": fields.Boolean,
+    }
+
+    @console_ns.expect(parser_edu)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @only_edition_cloud
+    @cloud_edition_billing_enabled
+    def post(self):
+        account, _ = current_account_with_tenant()
+
+        args = parser_edu.parse_args()
+
+        return BillingService.EducationIdentity.activate(account, args["token"], args["institution"], args["role"])
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @only_edition_cloud
+    @cloud_edition_billing_enabled
+    @marshal_with(status_fields)
+    def get(self):
+        account, _ = current_account_with_tenant()
+
+        res = BillingService.EducationIdentity.status(account.id)
+        # convert expire_at to UTC timestamp from isoformat
+        if res and "expire_at" in res:
+            res["expire_at"] = datetime.fromisoformat(res["expire_at"]).astimezone(pytz.utc)
+        return res
+
+
+parser_autocomplete = (
+    reqparse.RequestParser()
+    .add_argument("keywords", type=str, required=True, location="args")
+    .add_argument("page", type=int, required=False, location="args", default=0)
+    .add_argument("limit", type=int, required=False, location="args", default=20)
+)
+
+
+@console_ns.route("/account/education/autocomplete")
+class EducationAutoCompleteApi(Resource):
+    data_fields = {
+        "data": fields.List(fields.String),
+        "curr_page": fields.Integer,
+        "has_next": fields.Boolean,
+    }
+
+    @console_ns.expect(parser_autocomplete)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @only_edition_cloud
+    @cloud_edition_billing_enabled
+    @marshal_with(data_fields)
+    def get(self):
+        args = parser_autocomplete.parse_args()
+
+        return BillingService.EducationIdentity.autocomplete(args["keywords"], args["page"], args["limit"])
+
+
+parser_change_email = (
+    reqparse.RequestParser()
+    .add_argument("email", type=email, required=True, location="json")
+    .add_argument("language", type=str, required=False, location="json")
+    .add_argument("phase", type=str, required=False, location="json")
+    .add_argument("token", type=str, required=False, location="json")
+)
+
+
+@console_ns.route("/account/change-email")
+class ChangeEmailSendEmailApi(Resource):
+    @console_ns.expect(parser_change_email)
+    @enable_change_email
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        args = parser_change_email.parse_args()
+
+        ip_address = extract_remote_ip(request)
+        if AccountService.is_email_send_ip_limit(ip_address):
+            raise EmailSendIpLimitError()
+
+        if args["language"] is not None and args["language"] == "zh-Hans":
+            language = "zh-Hans"
+        else:
+            language = "en-US"
+        account = None
+        user_email = args["email"]
+        if args["phase"] is not None and args["phase"] == "new_email":
+            if args["token"] is None:
+                raise InvalidTokenError()
+
+            reset_data = AccountService.get_change_email_data(args["token"])
+            if reset_data is None:
+                raise InvalidTokenError()
+            user_email = reset_data.get("email", "")
+
+            if user_email != current_user.email:
+                raise InvalidEmailError()
+        else:
+            with Session(db.engine) as session:
+                account = session.execute(select(Account).filter_by(email=args["email"])).scalar_one_or_none()
+            if account is None:
+                raise AccountNotFound()
+
+        token = AccountService.send_change_email_email(
+            account=account, email=args["email"], old_email=user_email, language=language, phase=args["phase"]
+        )
+        return {"result": "success", "data": token}
+
+
+parser_validity = (
+    reqparse.RequestParser()
+    .add_argument("email", type=email, required=True, location="json")
+    .add_argument("code", type=str, required=True, location="json")
+    .add_argument("token", type=str, required=True, nullable=False, location="json")
+)
+
+
+@console_ns.route("/account/change-email/validity")
+class ChangeEmailCheckApi(Resource):
+    @console_ns.expect(parser_validity)
+    @enable_change_email
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        args = parser_validity.parse_args()
+
+        user_email = args["email"]
+
+        is_change_email_error_rate_limit = AccountService.is_change_email_error_rate_limit(args["email"])
+        if is_change_email_error_rate_limit:
+            raise EmailChangeLimitError()
+
+        token_data = AccountService.get_change_email_data(args["token"])
+        if token_data is None:
+            raise InvalidTokenError()
+
+        if user_email != token_data.get("email"):
+            raise InvalidEmailError()
+
+        if args["code"] != token_data.get("code"):
+            AccountService.add_change_email_error_rate_limit(args["email"])
+            raise EmailCodeError()
+
+        # Verified, revoke the first token
+        AccountService.revoke_change_email_token(args["token"])
+
+        # Refresh token data by generating a new token
+        _, new_token = AccountService.generate_change_email_token(
+            user_email, code=args["code"], old_email=token_data.get("old_email"), additional_data={}
+        )
+
+        AccountService.reset_change_email_error_rate_limit(args["email"])
+        return {"is_valid": True, "email": token_data.get("email"), "token": new_token}
+
+
+parser_reset = (
+    reqparse.RequestParser()
+    .add_argument("new_email", type=email, required=True, location="json")
+    .add_argument("token", type=str, required=True, nullable=False, location="json")
+)
+
+
+@console_ns.route("/account/change-email/reset")
+class ChangeEmailResetApi(Resource):
+    @console_ns.expect(parser_reset)
+    @enable_change_email
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        args = parser_reset.parse_args()
+
+        if AccountService.is_account_in_freeze(args["new_email"]):
+            raise AccountInFreezeError()
+
+        if not AccountService.check_email_unique(args["new_email"]):
+            raise EmailAlreadyInUseError()
+
+        reset_data = AccountService.get_change_email_data(args["token"])
+        if not reset_data:
+            raise InvalidTokenError()
+
+        AccountService.revoke_change_email_token(args["token"])
+
+        old_email = reset_data.get("old_email", "")
+        current_user, _ = current_account_with_tenant()
+        if current_user.email != old_email:
+            raise AccountNotFound()
+
+        updated_account = AccountService.update_account_email(current_user, email=args["new_email"])
+
+        AccountService.send_change_email_completed_notify_email(
+            email=args["new_email"],
+        )
+
+        return updated_account
+
+
+parser_check = reqparse.RequestParser().add_argument("email", type=email, required=True, location="json")
+
+
+@console_ns.route("/account/change-email/check-email-unique")
+class CheckEmailUnique(Resource):
+    @console_ns.expect(parser_check)
+    @setup_required
+    def post(self):
+        args = parser_check.parse_args()
+        if AccountService.is_account_in_freeze(args["email"]):
+            raise AccountInFreezeError()
+        if not AccountService.check_email_unique(args["email"]):
+            raise EmailAlreadyInUseError()
+        return {"result": "success"}

dify/api/controllers/console/workspace/agent_providers.py

@@ -0,0 +1,47 @@
+from flask_restx import Resource, fields
+
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, setup_required
+from core.model_runtime.utils.encoders import jsonable_encoder
+from libs.login import current_account_with_tenant, login_required
+from services.agent_service import AgentService
+
+
+@console_ns.route("/workspaces/current/agent-providers")
+class AgentProviderListApi(Resource):
+    @console_ns.doc("list_agent_providers")
+    @console_ns.doc(description="Get list of available agent providers")
+    @console_ns.response(
+        200,
+        "Success",
+        fields.List(fields.Raw(description="Agent provider information")),
+    )
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        current_user, current_tenant_id = current_account_with_tenant()
+        user = current_user
+
+        user_id = user.id
+        tenant_id = current_tenant_id
+
+        return jsonable_encoder(AgentService.list_agent_providers(user_id, tenant_id))
+
+
+@console_ns.route("/workspaces/current/agent-provider/<path:provider_name>")
+class AgentProviderApi(Resource):
+    @console_ns.doc("get_agent_provider")
+    @console_ns.doc(description="Get specific agent provider details")
+    @console_ns.doc(params={"provider_name": "Agent provider name"})
+    @console_ns.response(
+        200,
+        "Success",
+        fields.Raw(description="Agent provider details"),
+    )
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider_name: str):
+        current_user, current_tenant_id = current_account_with_tenant()
+        return jsonable_encoder(AgentService.get_agent_provider(current_user.id, current_tenant_id, provider_name))

dify/api/controllers/console/workspace/endpoint.py

@@ -0,0 +1,299 @@
+from flask_restx import Resource, fields, reqparse
+
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, is_admin_or_owner_required, setup_required
+from core.model_runtime.utils.encoders import jsonable_encoder
+from core.plugin.impl.exc import PluginPermissionDeniedError
+from libs.login import current_account_with_tenant, login_required
+from services.plugin.endpoint_service import EndpointService
+
+
+@console_ns.route("/workspaces/current/endpoints/create")
+class EndpointCreateApi(Resource):
+    @console_ns.doc("create_endpoint")
+    @console_ns.doc(description="Create a new plugin endpoint")
+    @console_ns.expect(
+        console_ns.model(
+            "EndpointCreateRequest",
+            {
+                "plugin_unique_identifier": fields.String(required=True, description="Plugin unique identifier"),
+                "settings": fields.Raw(required=True, description="Endpoint settings"),
+                "name": fields.String(required=True, description="Endpoint name"),
+            },
+        )
+    )
+    @console_ns.response(
+        200,
+        "Endpoint created successfully",
+        console_ns.model("EndpointCreateResponse", {"success": fields.Boolean(description="Operation success")}),
+    )
+    @console_ns.response(403, "Admin privileges required")
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self):
+        user, tenant_id = current_account_with_tenant()
+
+        parser = (
+            reqparse.RequestParser()
+            .add_argument("plugin_unique_identifier", type=str, required=True)
+            .add_argument("settings", type=dict, required=True)
+            .add_argument("name", type=str, required=True)
+        )
+        args = parser.parse_args()
+
+        plugin_unique_identifier = args["plugin_unique_identifier"]
+        settings = args["settings"]
+        name = args["name"]
+
+        try:
+            return {
+                "success": EndpointService.create_endpoint(
+                    tenant_id=tenant_id,
+                    user_id=user.id,
+                    plugin_unique_identifier=plugin_unique_identifier,
+                    name=name,
+                    settings=settings,
+                )
+            }
+        except PluginPermissionDeniedError as e:
+            raise ValueError(e.description) from e
+
+
+@console_ns.route("/workspaces/current/endpoints/list")
+class EndpointListApi(Resource):
+    @console_ns.doc("list_endpoints")
+    @console_ns.doc(description="List plugin endpoints with pagination")
+    @console_ns.expect(
+        console_ns.parser()
+        .add_argument("page", type=int, required=True, location="args", help="Page number")
+        .add_argument("page_size", type=int, required=True, location="args", help="Page size")
+    )
+    @console_ns.response(
+        200,
+        "Success",
+        console_ns.model(
+            "EndpointListResponse", {"endpoints": fields.List(fields.Raw(description="Endpoint information"))}
+        ),
+    )
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        user, tenant_id = current_account_with_tenant()
+
+        parser = (
+            reqparse.RequestParser()
+            .add_argument("page", type=int, required=True, location="args")
+            .add_argument("page_size", type=int, required=True, location="args")
+        )
+        args = parser.parse_args()
+
+        page = args["page"]
+        page_size = args["page_size"]
+
+        return jsonable_encoder(
+            {
+                "endpoints": EndpointService.list_endpoints(
+                    tenant_id=tenant_id,
+                    user_id=user.id,
+                    page=page,
+                    page_size=page_size,
+                )
+            }
+        )
+
+
+@console_ns.route("/workspaces/current/endpoints/list/plugin")
+class EndpointListForSinglePluginApi(Resource):
+    @console_ns.doc("list_plugin_endpoints")
+    @console_ns.doc(description="List endpoints for a specific plugin")
+    @console_ns.expect(
+        console_ns.parser()
+        .add_argument("page", type=int, required=True, location="args", help="Page number")
+        .add_argument("page_size", type=int, required=True, location="args", help="Page size")
+        .add_argument("plugin_id", type=str, required=True, location="args", help="Plugin ID")
+    )
+    @console_ns.response(
+        200,
+        "Success",
+        console_ns.model(
+            "PluginEndpointListResponse", {"endpoints": fields.List(fields.Raw(description="Endpoint information"))}
+        ),
+    )
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        user, tenant_id = current_account_with_tenant()
+
+        parser = (
+            reqparse.RequestParser()
+            .add_argument("page", type=int, required=True, location="args")
+            .add_argument("page_size", type=int, required=True, location="args")
+            .add_argument("plugin_id", type=str, required=True, location="args")
+        )
+        args = parser.parse_args()
+
+        page = args["page"]
+        page_size = args["page_size"]
+        plugin_id = args["plugin_id"]
+
+        return jsonable_encoder(
+            {
+                "endpoints": EndpointService.list_endpoints_for_single_plugin(
+                    tenant_id=tenant_id,
+                    user_id=user.id,
+                    plugin_id=plugin_id,
+                    page=page,
+                    page_size=page_size,
+                )
+            }
+        )
+
+
+@console_ns.route("/workspaces/current/endpoints/delete")
+class EndpointDeleteApi(Resource):
+    @console_ns.doc("delete_endpoint")
+    @console_ns.doc(description="Delete a plugin endpoint")
+    @console_ns.expect(
+        console_ns.model(
+            "EndpointDeleteRequest", {"endpoint_id": fields.String(required=True, description="Endpoint ID")}
+        )
+    )
+    @console_ns.response(
+        200,
+        "Endpoint deleted successfully",
+        console_ns.model("EndpointDeleteResponse", {"success": fields.Boolean(description="Operation success")}),
+    )
+    @console_ns.response(403, "Admin privileges required")
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self):
+        user, tenant_id = current_account_with_tenant()
+
+        parser = reqparse.RequestParser().add_argument("endpoint_id", type=str, required=True)
+        args = parser.parse_args()
+
+        endpoint_id = args["endpoint_id"]
+
+        return {
+            "success": EndpointService.delete_endpoint(tenant_id=tenant_id, user_id=user.id, endpoint_id=endpoint_id)
+        }
+
+
+@console_ns.route("/workspaces/current/endpoints/update")
+class EndpointUpdateApi(Resource):
+    @console_ns.doc("update_endpoint")
+    @console_ns.doc(description="Update a plugin endpoint")
+    @console_ns.expect(
+        console_ns.model(
+            "EndpointUpdateRequest",
+            {
+                "endpoint_id": fields.String(required=True, description="Endpoint ID"),
+                "settings": fields.Raw(required=True, description="Updated settings"),
+                "name": fields.String(required=True, description="Updated name"),
+            },
+        )
+    )
+    @console_ns.response(
+        200,
+        "Endpoint updated successfully",
+        console_ns.model("EndpointUpdateResponse", {"success": fields.Boolean(description="Operation success")}),
+    )
+    @console_ns.response(403, "Admin privileges required")
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self):
+        user, tenant_id = current_account_with_tenant()
+
+        parser = (
+            reqparse.RequestParser()
+            .add_argument("endpoint_id", type=str, required=True)
+            .add_argument("settings", type=dict, required=True)
+            .add_argument("name", type=str, required=True)
+        )
+        args = parser.parse_args()
+
+        endpoint_id = args["endpoint_id"]
+        settings = args["settings"]
+        name = args["name"]
+
+        return {
+            "success": EndpointService.update_endpoint(
+                tenant_id=tenant_id,
+                user_id=user.id,
+                endpoint_id=endpoint_id,
+                name=name,
+                settings=settings,
+            )
+        }
+
+
+@console_ns.route("/workspaces/current/endpoints/enable")
+class EndpointEnableApi(Resource):
+    @console_ns.doc("enable_endpoint")
+    @console_ns.doc(description="Enable a plugin endpoint")
+    @console_ns.expect(
+        console_ns.model(
+            "EndpointEnableRequest", {"endpoint_id": fields.String(required=True, description="Endpoint ID")}
+        )
+    )
+    @console_ns.response(
+        200,
+        "Endpoint enabled successfully",
+        console_ns.model("EndpointEnableResponse", {"success": fields.Boolean(description="Operation success")}),
+    )
+    @console_ns.response(403, "Admin privileges required")
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self):
+        user, tenant_id = current_account_with_tenant()
+
+        parser = reqparse.RequestParser().add_argument("endpoint_id", type=str, required=True)
+        args = parser.parse_args()
+
+        endpoint_id = args["endpoint_id"]
+
+        return {
+            "success": EndpointService.enable_endpoint(tenant_id=tenant_id, user_id=user.id, endpoint_id=endpoint_id)
+        }
+
+
+@console_ns.route("/workspaces/current/endpoints/disable")
+class EndpointDisableApi(Resource):
+    @console_ns.doc("disable_endpoint")
+    @console_ns.doc(description="Disable a plugin endpoint")
+    @console_ns.expect(
+        console_ns.model(
+            "EndpointDisableRequest", {"endpoint_id": fields.String(required=True, description="Endpoint ID")}
+        )
+    )
+    @console_ns.response(
+        200,
+        "Endpoint disabled successfully",
+        console_ns.model("EndpointDisableResponse", {"success": fields.Boolean(description="Operation success")}),
+    )
+    @console_ns.response(403, "Admin privileges required")
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self):
+        user, tenant_id = current_account_with_tenant()
+
+        parser = reqparse.RequestParser().add_argument("endpoint_id", type=str, required=True)
+        args = parser.parse_args()
+
+        endpoint_id = args["endpoint_id"]
+
+        return {
+            "success": EndpointService.disable_endpoint(tenant_id=tenant_id, user_id=user.id, endpoint_id=endpoint_id)
+        }

dify/api/controllers/console/workspace/error.py

@@ -0,0 +1,37 @@
+from libs.exception import BaseHTTPException
+
+
+class RepeatPasswordNotMatchError(BaseHTTPException):
+    error_code = "repeat_password_not_match"
+    description = "New password and repeat password does not match."
+    code = 400
+
+
+class CurrentPasswordIncorrectError(BaseHTTPException):
+    error_code = "current_password_incorrect"
+    description = "Current password is incorrect."
+    code = 400
+
+
+class InvalidInvitationCodeError(BaseHTTPException):
+    error_code = "invalid_invitation_code"
+    description = "Invalid invitation code."
+    code = 400
+
+
+class AccountAlreadyInitedError(BaseHTTPException):
+    error_code = "account_already_inited"
+    description = "The account has been initialized. Please refresh the page."
+    code = 400
+
+
+class AccountNotInitializedError(BaseHTTPException):
+    error_code = "account_not_initialized"
+    description = "The account has not been initialized yet. Please proceed with the initialization process first."
+    code = 400
+
+
+class InvalidAccountDeletionCodeError(BaseHTTPException):
+    error_code = "invalid_account_deletion_code"
+    description = "Invalid account deletion code."
+    code = 400

dify/api/controllers/console/workspace/load_balancing_config.py

@@ -0,0 +1,121 @@
+from flask_restx import Resource, reqparse
+from werkzeug.exceptions import Forbidden
+
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, setup_required
+from core.model_runtime.entities.model_entities import ModelType
+from core.model_runtime.errors.validate import CredentialsValidateFailedError
+from libs.login import current_account_with_tenant, login_required
+from models import TenantAccountRole
+from services.model_load_balancing_service import ModelLoadBalancingService
+
+
+@console_ns.route(
+    "/workspaces/current/model-providers/<path:provider>/models/load-balancing-configs/credentials-validate"
+)
+class LoadBalancingCredentialsValidateApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, provider: str):
+        current_user, current_tenant_id = current_account_with_tenant()
+        if not TenantAccountRole.is_privileged_role(current_user.current_role):
+            raise Forbidden()
+
+        tenant_id = current_tenant_id
+
+        parser = (
+            reqparse.RequestParser()
+            .add_argument("model", type=str, required=True, nullable=False, location="json")
+            .add_argument(
+                "model_type",
+                type=str,
+                required=True,
+                nullable=False,
+                choices=[mt.value for mt in ModelType],
+                location="json",
+            )
+            .add_argument("credentials", type=dict, required=True, nullable=False, location="json")
+        )
+        args = parser.parse_args()
+
+        # validate model load balancing credentials
+        model_load_balancing_service = ModelLoadBalancingService()
+
+        result = True
+        error = ""
+
+        try:
+            model_load_balancing_service.validate_load_balancing_credentials(
+                tenant_id=tenant_id,
+                provider=provider,
+                model=args["model"],
+                model_type=args["model_type"],
+                credentials=args["credentials"],
+            )
+        except CredentialsValidateFailedError as ex:
+            result = False
+            error = str(ex)
+
+        response = {"result": "success" if result else "error"}
+
+        if not result:
+            response["error"] = error
+
+        return response
+
+
+@console_ns.route(
+    "/workspaces/current/model-providers/<path:provider>/models/load-balancing-configs/<string:config_id>/credentials-validate"
+)
+class LoadBalancingConfigCredentialsValidateApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, provider: str, config_id: str):
+        current_user, current_tenant_id = current_account_with_tenant()
+        if not TenantAccountRole.is_privileged_role(current_user.current_role):
+            raise Forbidden()
+
+        tenant_id = current_tenant_id
+
+        parser = (
+            reqparse.RequestParser()
+            .add_argument("model", type=str, required=True, nullable=False, location="json")
+            .add_argument(
+                "model_type",
+                type=str,
+                required=True,
+                nullable=False,
+                choices=[mt.value for mt in ModelType],
+                location="json",
+            )
+            .add_argument("credentials", type=dict, required=True, nullable=False, location="json")
+        )
+        args = parser.parse_args()
+
+        # validate model load balancing config credentials
+        model_load_balancing_service = ModelLoadBalancingService()
+
+        result = True
+        error = ""
+
+        try:
+            model_load_balancing_service.validate_load_balancing_credentials(
+                tenant_id=tenant_id,
+                provider=provider,
+                model=args["model"],
+                model_type=args["model_type"],
+                credentials=args["credentials"],
+                config_id=config_id,
+            )
+        except CredentialsValidateFailedError as ex:
+            result = False
+            error = str(ex)
+
+        response = {"result": "success" if result else "error"}
+
+        if not result:
+            response["error"] = error
+
+        return response

dify/api/controllers/console/workspace/members.py

@@ -0,0 +1,355 @@
+from urllib import parse
+
+from flask import abort, request
+from flask_restx import Resource, marshal_with, reqparse
+
+import services
+from configs import dify_config
+from controllers.console import console_ns
+from controllers.console.auth.error import (
+    CannotTransferOwnerToSelfError,
+    EmailCodeError,
+    InvalidEmailError,
+    InvalidTokenError,
+    MemberNotInTenantError,
+    NotOwnerError,
+    OwnerTransferLimitError,
+)
+from controllers.console.error import EmailSendIpLimitError, WorkspaceMembersLimitExceeded
+from controllers.console.wraps import (
+    account_initialization_required,
+    cloud_edition_billing_resource_check,
+    is_allow_transfer_owner,
+    setup_required,
+)
+from extensions.ext_database import db
+from fields.member_fields import account_with_role_list_fields
+from libs.helper import extract_remote_ip
+from libs.login import current_account_with_tenant, login_required
+from models.account import Account, TenantAccountRole
+from services.account_service import AccountService, RegisterService, TenantService
+from services.errors.account import AccountAlreadyInTenantError
+from services.feature_service import FeatureService
+
+
+@console_ns.route("/workspaces/current/members")
+class MemberListApi(Resource):
+    """List all members of current tenant."""
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_with_role_list_fields)
+    def get(self):
+        current_user, _ = current_account_with_tenant()
+        if not current_user.current_tenant:
+            raise ValueError("No current tenant")
+        members = TenantService.get_tenant_members(current_user.current_tenant)
+        return {"result": "success", "accounts": members}, 200
+
+
+parser_invite = (
+    reqparse.RequestParser()
+    .add_argument("emails", type=list, required=True, location="json")
+    .add_argument("role", type=str, required=True, default="admin", location="json")
+    .add_argument("language", type=str, required=False, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/members/invite-email")
+class MemberInviteEmailApi(Resource):
+    """Invite a new member by email."""
+
+    @console_ns.expect(parser_invite)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("members")
+    def post(self):
+        args = parser_invite.parse_args()
+
+        invitee_emails = args["emails"]
+        invitee_role = args["role"]
+        interface_language = args["language"]
+        if not TenantAccountRole.is_non_owner_role(invitee_role):
+            return {"code": "invalid-role", "message": "Invalid role"}, 400
+        current_user, _ = current_account_with_tenant()
+        inviter = current_user
+        if not inviter.current_tenant:
+            raise ValueError("No current tenant")
+        invitation_results = []
+        console_web_url = dify_config.CONSOLE_WEB_URL
+
+        workspace_members = FeatureService.get_features(tenant_id=inviter.current_tenant.id).workspace_members
+
+        if not workspace_members.is_available(len(invitee_emails)):
+            raise WorkspaceMembersLimitExceeded()
+
+        for invitee_email in invitee_emails:
+            try:
+                if not inviter.current_tenant:
+                    raise ValueError("No current tenant")
+                token = RegisterService.invite_new_member(
+                    inviter.current_tenant, invitee_email, interface_language, role=invitee_role, inviter=inviter
+                )
+                encoded_invitee_email = parse.quote(invitee_email)
+                invitation_results.append(
+                    {
+                        "status": "success",
+                        "email": invitee_email,
+                        "url": f"{console_web_url}/activate?email={encoded_invitee_email}&token={token}",
+                    }
+                )
+            except AccountAlreadyInTenantError:
+                invitation_results.append(
+                    {"status": "success", "email": invitee_email, "url": f"{console_web_url}/signin"}
+                )
+            except Exception as e:
+                invitation_results.append({"status": "failed", "email": invitee_email, "message": str(e)})
+
+        return {
+            "result": "success",
+            "invitation_results": invitation_results,
+            "tenant_id": str(inviter.current_tenant.id) if inviter.current_tenant else "",
+        }, 201
+
+
+@console_ns.route("/workspaces/current/members/<uuid:member_id>")
+class MemberCancelInviteApi(Resource):
+    """Cancel an invitation by member id."""
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def delete(self, member_id):
+        current_user, _ = current_account_with_tenant()
+        if not current_user.current_tenant:
+            raise ValueError("No current tenant")
+        member = db.session.query(Account).where(Account.id == str(member_id)).first()
+        if member is None:
+            abort(404)
+        else:
+            try:
+                TenantService.remove_member_from_tenant(current_user.current_tenant, member, current_user)
+            except services.errors.account.CannotOperateSelfError as e:
+                return {"code": "cannot-operate-self", "message": str(e)}, 400
+            except services.errors.account.NoPermissionError as e:
+                return {"code": "forbidden", "message": str(e)}, 403
+            except services.errors.account.MemberNotInTenantError as e:
+                return {"code": "member-not-found", "message": str(e)}, 404
+            except Exception as e:
+                raise ValueError(str(e))
+
+        return {
+            "result": "success",
+            "tenant_id": str(current_user.current_tenant.id) if current_user.current_tenant else "",
+        }, 200
+
+
+parser_update = reqparse.RequestParser().add_argument("role", type=str, required=True, location="json")
+
+
+@console_ns.route("/workspaces/current/members/<uuid:member_id>/update-role")
+class MemberUpdateRoleApi(Resource):
+    """Update member role."""
+
+    @console_ns.expect(parser_update)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def put(self, member_id):
+        args = parser_update.parse_args()
+        new_role = args["role"]
+
+        if not TenantAccountRole.is_valid_role(new_role):
+            return {"code": "invalid-role", "message": "Invalid role"}, 400
+        current_user, _ = current_account_with_tenant()
+        if not current_user.current_tenant:
+            raise ValueError("No current tenant")
+        member = db.session.get(Account, str(member_id))
+        if not member:
+            abort(404)
+
+        try:
+            assert member is not None, "Member not found"
+            TenantService.update_member_role(current_user.current_tenant, member, new_role, current_user)
+        except Exception as e:
+            raise ValueError(str(e))
+
+        # todo: 403
+
+        return {"result": "success"}
+
+
+@console_ns.route("/workspaces/current/dataset-operators")
+class DatasetOperatorMemberListApi(Resource):
+    """List all members of current tenant."""
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_with_role_list_fields)
+    def get(self):
+        current_user, _ = current_account_with_tenant()
+        if not current_user.current_tenant:
+            raise ValueError("No current tenant")
+        members = TenantService.get_dataset_operator_members(current_user.current_tenant)
+        return {"result": "success", "accounts": members}, 200
+
+
+parser_send = reqparse.RequestParser().add_argument("language", type=str, required=False, location="json")
+
+
+@console_ns.route("/workspaces/current/members/send-owner-transfer-confirm-email")
+class SendOwnerTransferEmailApi(Resource):
+    """Send owner transfer email."""
+
+    @console_ns.expect(parser_send)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @is_allow_transfer_owner
+    def post(self):
+        args = parser_send.parse_args()
+        ip_address = extract_remote_ip(request)
+        if AccountService.is_email_send_ip_limit(ip_address):
+            raise EmailSendIpLimitError()
+        current_user, _ = current_account_with_tenant()
+        # check if the current user is the owner of the workspace
+        if not current_user.current_tenant:
+            raise ValueError("No current tenant")
+        if not TenantService.is_owner(current_user, current_user.current_tenant):
+            raise NotOwnerError()
+
+        if args["language"] is not None and args["language"] == "zh-Hans":
+            language = "zh-Hans"
+        else:
+            language = "en-US"
+
+        email = current_user.email
+
+        token = AccountService.send_owner_transfer_email(
+            account=current_user,
+            email=email,
+            language=language,
+            workspace_name=current_user.current_tenant.name if current_user.current_tenant else "",
+        )
+
+        return {"result": "success", "data": token}
+
+
+parser_owner = (
+    reqparse.RequestParser()
+    .add_argument("code", type=str, required=True, location="json")
+    .add_argument("token", type=str, required=True, nullable=False, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/members/owner-transfer-check")
+class OwnerTransferCheckApi(Resource):
+    @console_ns.expect(parser_owner)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @is_allow_transfer_owner
+    def post(self):
+        args = parser_owner.parse_args()
+        # check if the current user is the owner of the workspace
+        current_user, _ = current_account_with_tenant()
+        if not current_user.current_tenant:
+            raise ValueError("No current tenant")
+        if not TenantService.is_owner(current_user, current_user.current_tenant):
+            raise NotOwnerError()
+
+        user_email = current_user.email
+
+        is_owner_transfer_error_rate_limit = AccountService.is_owner_transfer_error_rate_limit(user_email)
+        if is_owner_transfer_error_rate_limit:
+            raise OwnerTransferLimitError()
+
+        token_data = AccountService.get_owner_transfer_data(args["token"])
+        if token_data is None:
+            raise InvalidTokenError()
+
+        if user_email != token_data.get("email"):
+            raise InvalidEmailError()
+
+        if args["code"] != token_data.get("code"):
+            AccountService.add_owner_transfer_error_rate_limit(user_email)
+            raise EmailCodeError()
+
+        # Verified, revoke the first token
+        AccountService.revoke_owner_transfer_token(args["token"])
+
+        # Refresh token data by generating a new token
+        _, new_token = AccountService.generate_owner_transfer_token(user_email, code=args["code"], additional_data={})
+
+        AccountService.reset_owner_transfer_error_rate_limit(user_email)
+        return {"is_valid": True, "email": token_data.get("email"), "token": new_token}
+
+
+parser_owner_transfer = reqparse.RequestParser().add_argument(
+    "token", type=str, required=True, nullable=False, location="json"
+)
+
+
+@console_ns.route("/workspaces/current/members/<uuid:member_id>/owner-transfer")
+class OwnerTransfer(Resource):
+    @console_ns.expect(parser_owner_transfer)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @is_allow_transfer_owner
+    def post(self, member_id):
+        args = parser_owner_transfer.parse_args()
+
+        # check if the current user is the owner of the workspace
+        current_user, _ = current_account_with_tenant()
+        if not current_user.current_tenant:
+            raise ValueError("No current tenant")
+        if not TenantService.is_owner(current_user, current_user.current_tenant):
+            raise NotOwnerError()
+
+        if current_user.id == str(member_id):
+            raise CannotTransferOwnerToSelfError()
+
+        transfer_token_data = AccountService.get_owner_transfer_data(args["token"])
+        if not transfer_token_data:
+            raise InvalidTokenError()
+
+        if transfer_token_data.get("email") != current_user.email:
+            raise InvalidEmailError()
+
+        AccountService.revoke_owner_transfer_token(args["token"])
+
+        member = db.session.get(Account, str(member_id))
+        if not member:
+            abort(404)
+            return  # Never reached, but helps type checker
+
+        if not current_user.current_tenant:
+            raise ValueError("No current tenant")
+        if not TenantService.is_member(member, current_user.current_tenant):
+            raise MemberNotInTenantError()
+
+        try:
+            assert member is not None, "Member not found"
+            TenantService.update_member_role(current_user.current_tenant, member, "owner", current_user)
+
+            AccountService.send_new_owner_transfer_notify_email(
+                account=member,
+                email=member.email,
+                workspace_name=current_user.current_tenant.name if current_user.current_tenant else "",
+            )
+
+            AccountService.send_old_owner_transfer_notify_email(
+                account=current_user,
+                email=current_user.email,
+                workspace_name=current_user.current_tenant.name if current_user.current_tenant else "",
+                new_owner_email=member.email,
+            )
+
+        except Exception as e:
+            raise ValueError(str(e))
+
+        return {"result": "success"}

dify/api/controllers/console/workspace/model_providers.py

@@ -0,0 +1,279 @@
+import io
+
+from flask import send_file
+from flask_restx import Resource, reqparse
+
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, is_admin_or_owner_required, setup_required
+from core.model_runtime.entities.model_entities import ModelType
+from core.model_runtime.errors.validate import CredentialsValidateFailedError
+from core.model_runtime.utils.encoders import jsonable_encoder
+from libs.helper import StrLen, uuid_value
+from libs.login import current_account_with_tenant, login_required
+from services.billing_service import BillingService
+from services.model_provider_service import ModelProviderService
+
+parser_model = reqparse.RequestParser().add_argument(
+    "model_type",
+    type=str,
+    required=False,
+    nullable=True,
+    choices=[mt.value for mt in ModelType],
+    location="args",
+)
+
+
+@console_ns.route("/workspaces/current/model-providers")
+class ModelProviderListApi(Resource):
+    @console_ns.expect(parser_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, current_tenant_id = current_account_with_tenant()
+        tenant_id = current_tenant_id
+
+        args = parser_model.parse_args()
+
+        model_provider_service = ModelProviderService()
+        provider_list = model_provider_service.get_provider_list(tenant_id=tenant_id, model_type=args.get("model_type"))
+
+        return jsonable_encoder({"data": provider_list})
+
+
+parser_cred = reqparse.RequestParser().add_argument(
+    "credential_id", type=uuid_value, required=False, nullable=True, location="args"
+)
+parser_post_cred = (
+    reqparse.RequestParser()
+    .add_argument("credentials", type=dict, required=True, nullable=False, location="json")
+    .add_argument("name", type=StrLen(30), required=False, nullable=True, location="json")
+)
+
+parser_put_cred = (
+    reqparse.RequestParser()
+    .add_argument("credential_id", type=uuid_value, required=True, nullable=False, location="json")
+    .add_argument("credentials", type=dict, required=True, nullable=False, location="json")
+    .add_argument("name", type=StrLen(30), required=False, nullable=True, location="json")
+)
+
+parser_delete_cred = reqparse.RequestParser().add_argument(
+    "credential_id", type=uuid_value, required=True, nullable=False, location="json"
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/credentials")
+class ModelProviderCredentialApi(Resource):
+    @console_ns.expect(parser_cred)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        tenant_id = current_tenant_id
+        # if credential_id is not provided, return current used credential
+        args = parser_cred.parse_args()
+
+        model_provider_service = ModelProviderService()
+        credentials = model_provider_service.get_provider_credential(
+            tenant_id=tenant_id, provider=provider, credential_id=args.get("credential_id")
+        )
+
+        return {"credentials": credentials}
+
+    @console_ns.expect(parser_post_cred)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        args = parser_post_cred.parse_args()
+
+        model_provider_service = ModelProviderService()
+
+        try:
+            model_provider_service.create_provider_credential(
+                tenant_id=current_tenant_id,
+                provider=provider,
+                credentials=args["credentials"],
+                credential_name=args["name"],
+            )
+        except CredentialsValidateFailedError as ex:
+            raise ValueError(str(ex))
+
+        return {"result": "success"}, 201
+
+    @console_ns.expect(parser_put_cred)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def put(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        args = parser_put_cred.parse_args()
+
+        model_provider_service = ModelProviderService()
+
+        try:
+            model_provider_service.update_provider_credential(
+                tenant_id=current_tenant_id,
+                provider=provider,
+                credentials=args["credentials"],
+                credential_id=args["credential_id"],
+                credential_name=args["name"],
+            )
+        except CredentialsValidateFailedError as ex:
+            raise ValueError(str(ex))
+
+        return {"result": "success"}
+
+    @console_ns.expect(parser_delete_cred)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def delete(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        args = parser_delete_cred.parse_args()
+
+        model_provider_service = ModelProviderService()
+        model_provider_service.remove_provider_credential(
+            tenant_id=current_tenant_id, provider=provider, credential_id=args["credential_id"]
+        )
+
+        return {"result": "success"}, 204
+
+
+parser_switch = reqparse.RequestParser().add_argument(
+    "credential_id", type=str, required=True, nullable=False, location="json"
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/credentials/switch")
+class ModelProviderCredentialSwitchApi(Resource):
+    @console_ns.expect(parser_switch)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        args = parser_switch.parse_args()
+
+        service = ModelProviderService()
+        service.switch_active_provider_credential(
+            tenant_id=current_tenant_id,
+            provider=provider,
+            credential_id=args["credential_id"],
+        )
+        return {"result": "success"}
+
+
+parser_validate = reqparse.RequestParser().add_argument(
+    "credentials", type=dict, required=True, nullable=False, location="json"
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/credentials/validate")
+class ModelProviderValidateApi(Resource):
+    @console_ns.expect(parser_validate)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        args = parser_validate.parse_args()
+
+        tenant_id = current_tenant_id
+
+        model_provider_service = ModelProviderService()
+
+        result = True
+        error = ""
+
+        try:
+            model_provider_service.validate_provider_credentials(
+                tenant_id=tenant_id, provider=provider, credentials=args["credentials"]
+            )
+        except CredentialsValidateFailedError as ex:
+            result = False
+            error = str(ex)
+
+        response = {"result": "success" if result else "error"}
+
+        if not result:
+            response["error"] = error or "Unknown error"
+
+        return response
+
+
+@console_ns.route("/workspaces/<string:tenant_id>/model-providers/<path:provider>/<string:icon_type>/<string:lang>")
+class ModelProviderIconApi(Resource):
+    """
+    Get model provider icon
+    """
+
+    def get(self, tenant_id: str, provider: str, icon_type: str, lang: str):
+        model_provider_service = ModelProviderService()
+        icon, mimetype = model_provider_service.get_model_provider_icon(
+            tenant_id=tenant_id,
+            provider=provider,
+            icon_type=icon_type,
+            lang=lang,
+        )
+        if icon is None:
+            raise ValueError(f"icon not found for provider {provider}, icon_type {icon_type}, lang {lang}")
+        return send_file(io.BytesIO(icon), mimetype=mimetype)
+
+
+parser_preferred = reqparse.RequestParser().add_argument(
+    "preferred_provider_type",
+    type=str,
+    required=True,
+    nullable=False,
+    choices=["system", "custom"],
+    location="json",
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/preferred-provider-type")
+class PreferredProviderTypeUpdateApi(Resource):
+    @console_ns.expect(parser_preferred)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        tenant_id = current_tenant_id
+
+        args = parser_preferred.parse_args()
+
+        model_provider_service = ModelProviderService()
+        model_provider_service.switch_preferred_provider(
+            tenant_id=tenant_id, provider=provider, preferred_provider_type=args["preferred_provider_type"]
+        )
+
+        return {"result": "success"}
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/checkout-url")
+class ModelProviderPaymentCheckoutUrlApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider: str):
+        if provider != "anthropic":
+            raise ValueError(f"provider name {provider} is invalid")
+        current_user, current_tenant_id = current_account_with_tenant()
+        BillingService.is_tenant_owner_or_admin(current_user)
+        data = BillingService.get_model_provider_payment_link(
+            provider_name=provider,
+            tenant_id=current_tenant_id,
+            account_id=current_user.id,
+            prefilled_email=current_user.email,
+        )
+        return data

dify/api/controllers/console/workspace/models.py

@@ -0,0 +1,564 @@
+import logging
+
+from flask_restx import Resource, reqparse
+
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, is_admin_or_owner_required, setup_required
+from core.model_runtime.entities.model_entities import ModelType
+from core.model_runtime.errors.validate import CredentialsValidateFailedError
+from core.model_runtime.utils.encoders import jsonable_encoder
+from libs.helper import StrLen, uuid_value
+from libs.login import current_account_with_tenant, login_required
+from services.model_load_balancing_service import ModelLoadBalancingService
+from services.model_provider_service import ModelProviderService
+
+logger = logging.getLogger(__name__)
+
+
+parser_get_default = reqparse.RequestParser().add_argument(
+    "model_type",
+    type=str,
+    required=True,
+    nullable=False,
+    choices=[mt.value for mt in ModelType],
+    location="args",
+)
+parser_post_default = reqparse.RequestParser().add_argument(
+    "model_settings", type=list, required=True, nullable=False, location="json"
+)
+
+
+@console_ns.route("/workspaces/current/default-model")
+class DefaultModelApi(Resource):
+    @console_ns.expect(parser_get_default)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_get_default.parse_args()
+
+        model_provider_service = ModelProviderService()
+        default_model_entity = model_provider_service.get_default_model_of_model_type(
+            tenant_id=tenant_id, model_type=args["model_type"]
+        )
+
+        return jsonable_encoder({"data": default_model_entity})
+
+    @console_ns.expect(parser_post_default)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_post_default.parse_args()
+        model_provider_service = ModelProviderService()
+        model_settings = args["model_settings"]
+        for model_setting in model_settings:
+            if "model_type" not in model_setting or model_setting["model_type"] not in [mt.value for mt in ModelType]:
+                raise ValueError("invalid model type")
+
+            if "provider" not in model_setting:
+                continue
+
+            if "model" not in model_setting:
+                raise ValueError("invalid model")
+
+            try:
+                model_provider_service.update_default_model_of_model_type(
+                    tenant_id=tenant_id,
+                    model_type=model_setting["model_type"],
+                    provider=model_setting["provider"],
+                    model=model_setting["model"],
+                )
+            except Exception as ex:
+                logger.exception(
+                    "Failed to update default model, model type: %s, model: %s",
+                    model_setting["model_type"],
+                    model_setting.get("model"),
+                )
+                raise ex
+
+        return {"result": "success"}
+
+
+parser_post_models = (
+    reqparse.RequestParser()
+    .add_argument("model", type=str, required=True, nullable=False, location="json")
+    .add_argument(
+        "model_type",
+        type=str,
+        required=True,
+        nullable=False,
+        choices=[mt.value for mt in ModelType],
+        location="json",
+    )
+    .add_argument("load_balancing", type=dict, required=False, nullable=True, location="json")
+    .add_argument("config_from", type=str, required=False, nullable=True, location="json")
+    .add_argument("credential_id", type=uuid_value, required=False, nullable=True, location="json")
+)
+parser_delete_models = (
+    reqparse.RequestParser()
+    .add_argument("model", type=str, required=True, nullable=False, location="json")
+    .add_argument(
+        "model_type",
+        type=str,
+        required=True,
+        nullable=False,
+        choices=[mt.value for mt in ModelType],
+        location="json",
+    )
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/models")
+class ModelProviderModelApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider):
+        _, tenant_id = current_account_with_tenant()
+
+        model_provider_service = ModelProviderService()
+        models = model_provider_service.get_models_by_provider(tenant_id=tenant_id, provider=provider)
+
+        return jsonable_encoder({"data": models})
+
+    @console_ns.expect(parser_post_models)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider: str):
+        # To save the model's load balance configs
+        _, tenant_id = current_account_with_tenant()
+        args = parser_post_models.parse_args()
+
+        if args.get("config_from", "") == "custom-model":
+            if not args.get("credential_id"):
+                raise ValueError("credential_id is required when configuring a custom-model")
+            service = ModelProviderService()
+            service.switch_active_custom_model_credential(
+                tenant_id=tenant_id,
+                provider=provider,
+                model_type=args["model_type"],
+                model=args["model"],
+                credential_id=args["credential_id"],
+            )
+
+        model_load_balancing_service = ModelLoadBalancingService()
+
+        if "load_balancing" in args and args["load_balancing"] and "configs" in args["load_balancing"]:
+            # save load balancing configs
+            model_load_balancing_service.update_load_balancing_configs(
+                tenant_id=tenant_id,
+                provider=provider,
+                model=args["model"],
+                model_type=args["model_type"],
+                configs=args["load_balancing"]["configs"],
+                config_from=args.get("config_from", ""),
+            )
+
+            if args.get("load_balancing", {}).get("enabled"):
+                model_load_balancing_service.enable_model_load_balancing(
+                    tenant_id=tenant_id, provider=provider, model=args["model"], model_type=args["model_type"]
+                )
+            else:
+                model_load_balancing_service.disable_model_load_balancing(
+                    tenant_id=tenant_id, provider=provider, model=args["model"], model_type=args["model_type"]
+                )
+
+        return {"result": "success"}, 200
+
+    @console_ns.expect(parser_delete_models)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def delete(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_delete_models.parse_args()
+
+        model_provider_service = ModelProviderService()
+        model_provider_service.remove_model(
+            tenant_id=tenant_id, provider=provider, model=args["model"], model_type=args["model_type"]
+        )
+
+        return {"result": "success"}, 204
+
+
+parser_get_credentials = (
+    reqparse.RequestParser()
+    .add_argument("model", type=str, required=True, nullable=False, location="args")
+    .add_argument(
+        "model_type",
+        type=str,
+        required=True,
+        nullable=False,
+        choices=[mt.value for mt in ModelType],
+        location="args",
+    )
+    .add_argument("config_from", type=str, required=False, nullable=True, location="args")
+    .add_argument("credential_id", type=uuid_value, required=False, nullable=True, location="args")
+)
+
+
+parser_post_cred = (
+    reqparse.RequestParser()
+    .add_argument("model", type=str, required=True, nullable=False, location="json")
+    .add_argument(
+        "model_type",
+        type=str,
+        required=True,
+        nullable=False,
+        choices=[mt.value for mt in ModelType],
+        location="json",
+    )
+    .add_argument("name", type=StrLen(30), required=False, nullable=True, location="json")
+    .add_argument("credentials", type=dict, required=True, nullable=False, location="json")
+)
+parser_put_cred = (
+    reqparse.RequestParser()
+    .add_argument("model", type=str, required=True, nullable=False, location="json")
+    .add_argument(
+        "model_type",
+        type=str,
+        required=True,
+        nullable=False,
+        choices=[mt.value for mt in ModelType],
+        location="json",
+    )
+    .add_argument("credential_id", type=uuid_value, required=True, nullable=False, location="json")
+    .add_argument("credentials", type=dict, required=True, nullable=False, location="json")
+    .add_argument("name", type=StrLen(30), required=False, nullable=True, location="json")
+)
+parser_delete_cred = (
+    reqparse.RequestParser()
+    .add_argument("model", type=str, required=True, nullable=False, location="json")
+    .add_argument(
+        "model_type",
+        type=str,
+        required=True,
+        nullable=False,
+        choices=[mt.value for mt in ModelType],
+        location="json",
+    )
+    .add_argument("credential_id", type=uuid_value, required=True, nullable=False, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/models/credentials")
+class ModelProviderModelCredentialApi(Resource):
+    @console_ns.expect(parser_get_credentials)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_get_credentials.parse_args()
+
+        model_provider_service = ModelProviderService()
+        current_credential = model_provider_service.get_model_credential(
+            tenant_id=tenant_id,
+            provider=provider,
+            model_type=args["model_type"],
+            model=args["model"],
+            credential_id=args.get("credential_id"),
+        )
+
+        model_load_balancing_service = ModelLoadBalancingService()
+        is_load_balancing_enabled, load_balancing_configs = model_load_balancing_service.get_load_balancing_configs(
+            tenant_id=tenant_id,
+            provider=provider,
+            model=args["model"],
+            model_type=args["model_type"],
+            config_from=args.get("config_from", ""),
+        )
+
+        if args.get("config_from", "") == "predefined-model":
+            available_credentials = model_provider_service.provider_manager.get_provider_available_credentials(
+                tenant_id=tenant_id, provider_name=provider
+            )
+        else:
+            model_type = ModelType.value_of(args["model_type"]).to_origin_model_type()
+            available_credentials = model_provider_service.provider_manager.get_provider_model_available_credentials(
+                tenant_id=tenant_id, provider_name=provider, model_type=model_type, model_name=args["model"]
+            )
+
+        return jsonable_encoder(
+            {
+                "credentials": current_credential.get("credentials") if current_credential else {},
+                "current_credential_id": current_credential.get("current_credential_id")
+                if current_credential
+                else None,
+                "current_credential_name": current_credential.get("current_credential_name")
+                if current_credential
+                else None,
+                "load_balancing": {"enabled": is_load_balancing_enabled, "configs": load_balancing_configs},
+                "available_credentials": available_credentials,
+            }
+        )
+
+    @console_ns.expect(parser_post_cred)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_post_cred.parse_args()
+
+        model_provider_service = ModelProviderService()
+
+        try:
+            model_provider_service.create_model_credential(
+                tenant_id=tenant_id,
+                provider=provider,
+                model=args["model"],
+                model_type=args["model_type"],
+                credentials=args["credentials"],
+                credential_name=args["name"],
+            )
+        except CredentialsValidateFailedError as ex:
+            logger.exception(
+                "Failed to save model credentials, tenant_id: %s, model: %s, model_type: %s",
+                tenant_id,
+                args.get("model"),
+                args.get("model_type"),
+            )
+            raise ValueError(str(ex))
+
+        return {"result": "success"}, 201
+
+    @console_ns.expect(parser_put_cred)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def put(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        args = parser_put_cred.parse_args()
+
+        model_provider_service = ModelProviderService()
+
+        try:
+            model_provider_service.update_model_credential(
+                tenant_id=current_tenant_id,
+                provider=provider,
+                model_type=args["model_type"],
+                model=args["model"],
+                credentials=args["credentials"],
+                credential_id=args["credential_id"],
+                credential_name=args["name"],
+            )
+        except CredentialsValidateFailedError as ex:
+            raise ValueError(str(ex))
+
+        return {"result": "success"}
+
+    @console_ns.expect(parser_delete_cred)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def delete(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        args = parser_delete_cred.parse_args()
+
+        model_provider_service = ModelProviderService()
+        model_provider_service.remove_model_credential(
+            tenant_id=current_tenant_id,
+            provider=provider,
+            model_type=args["model_type"],
+            model=args["model"],
+            credential_id=args["credential_id"],
+        )
+
+        return {"result": "success"}, 204
+
+
+parser_switch = (
+    reqparse.RequestParser()
+    .add_argument("model", type=str, required=True, nullable=False, location="json")
+    .add_argument(
+        "model_type",
+        type=str,
+        required=True,
+        nullable=False,
+        choices=[mt.value for mt in ModelType],
+        location="json",
+    )
+    .add_argument("credential_id", type=str, required=True, nullable=False, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/models/credentials/switch")
+class ModelProviderModelCredentialSwitchApi(Resource):
+    @console_ns.expect(parser_switch)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        args = parser_switch.parse_args()
+
+        service = ModelProviderService()
+        service.add_model_credential_to_model_list(
+            tenant_id=current_tenant_id,
+            provider=provider,
+            model_type=args["model_type"],
+            model=args["model"],
+            credential_id=args["credential_id"],
+        )
+        return {"result": "success"}
+
+
+parser_model_enable_disable = (
+    reqparse.RequestParser()
+    .add_argument("model", type=str, required=True, nullable=False, location="json")
+    .add_argument(
+        "model_type",
+        type=str,
+        required=True,
+        nullable=False,
+        choices=[mt.value for mt in ModelType],
+        location="json",
+    )
+)
+
+
+@console_ns.route(
+    "/workspaces/current/model-providers/<path:provider>/models/enable", endpoint="model-provider-model-enable"
+)
+class ModelProviderModelEnableApi(Resource):
+    @console_ns.expect(parser_model_enable_disable)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def patch(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_model_enable_disable.parse_args()
+
+        model_provider_service = ModelProviderService()
+        model_provider_service.enable_model(
+            tenant_id=tenant_id, provider=provider, model=args["model"], model_type=args["model_type"]
+        )
+
+        return {"result": "success"}
+
+
+@console_ns.route(
+    "/workspaces/current/model-providers/<path:provider>/models/disable", endpoint="model-provider-model-disable"
+)
+class ModelProviderModelDisableApi(Resource):
+    @console_ns.expect(parser_model_enable_disable)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def patch(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_model_enable_disable.parse_args()
+
+        model_provider_service = ModelProviderService()
+        model_provider_service.disable_model(
+            tenant_id=tenant_id, provider=provider, model=args["model"], model_type=args["model_type"]
+        )
+
+        return {"result": "success"}
+
+
+parser_validate = (
+    reqparse.RequestParser()
+    .add_argument("model", type=str, required=True, nullable=False, location="json")
+    .add_argument(
+        "model_type",
+        type=str,
+        required=True,
+        nullable=False,
+        choices=[mt.value for mt in ModelType],
+        location="json",
+    )
+    .add_argument("credentials", type=dict, required=True, nullable=False, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/models/credentials/validate")
+class ModelProviderModelValidateApi(Resource):
+    @console_ns.expect(parser_validate)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_validate.parse_args()
+
+        model_provider_service = ModelProviderService()
+
+        result = True
+        error = ""
+
+        try:
+            model_provider_service.validate_model_credentials(
+                tenant_id=tenant_id,
+                provider=provider,
+                model=args["model"],
+                model_type=args["model_type"],
+                credentials=args["credentials"],
+            )
+        except CredentialsValidateFailedError as ex:
+            result = False
+            error = str(ex)
+
+        response = {"result": "success" if result else "error"}
+
+        if not result:
+            response["error"] = error or ""
+
+        return response
+
+
+parser_parameter = reqparse.RequestParser().add_argument(
+    "model", type=str, required=True, nullable=False, location="args"
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/models/parameter-rules")
+class ModelProviderModelParameterRuleApi(Resource):
+    @console_ns.expect(parser_parameter)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider: str):
+        args = parser_parameter.parse_args()
+        _, tenant_id = current_account_with_tenant()
+
+        model_provider_service = ModelProviderService()
+        parameter_rules = model_provider_service.get_model_parameter_rules(
+            tenant_id=tenant_id, provider=provider, model=args["model"]
+        )
+
+        return jsonable_encoder({"data": parameter_rules})
+
+
+@console_ns.route("/workspaces/current/models/model-types/<string:model_type>")
+class ModelProviderAvailableModelApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, model_type):
+        _, tenant_id = current_account_with_tenant()
+        model_provider_service = ModelProviderService()
+        models = model_provider_service.get_models_by_model_type(tenant_id=tenant_id, model_type=model_type)
+
+        return jsonable_encoder({"data": models})

dify/api/controllers/console/workspace/plugin.py

@@ -0,0 +1,784 @@
+import io
+
+from flask import request, send_file
+from flask_restx import Resource, reqparse
+from werkzeug.exceptions import Forbidden
+
+from configs import dify_config
+from controllers.console import console_ns
+from controllers.console.workspace import plugin_permission_required
+from controllers.console.wraps import account_initialization_required, is_admin_or_owner_required, setup_required
+from core.model_runtime.utils.encoders import jsonable_encoder
+from core.plugin.impl.exc import PluginDaemonClientSideError
+from libs.login import current_account_with_tenant, login_required
+from models.account import TenantPluginAutoUpgradeStrategy, TenantPluginPermission
+from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
+from services.plugin.plugin_parameter_service import PluginParameterService
+from services.plugin.plugin_permission_service import PluginPermissionService
+from services.plugin.plugin_service import PluginService
+
+
+@console_ns.route("/workspaces/current/plugin/debugging-key")
+class PluginDebuggingKeyApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(debug_required=True)
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+
+        try:
+            return {
+                "key": PluginService.get_debugging_key(tenant_id),
+                "host": dify_config.PLUGIN_REMOTE_INSTALL_HOST,
+                "port": dify_config.PLUGIN_REMOTE_INSTALL_PORT,
+            }
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+parser_list = (
+    reqparse.RequestParser()
+    .add_argument("page", type=int, required=False, location="args", default=1)
+    .add_argument("page_size", type=int, required=False, location="args", default=256)
+)
+
+
+@console_ns.route("/workspaces/current/plugin/list")
+class PluginListApi(Resource):
+    @console_ns.expect(parser_list)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+        args = parser_list.parse_args()
+        try:
+            plugins_with_total = PluginService.list_with_total(tenant_id, args["page"], args["page_size"])
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder({"plugins": plugins_with_total.list, "total": plugins_with_total.total})
+
+
+parser_latest = reqparse.RequestParser().add_argument("plugin_ids", type=list, required=True, location="json")
+
+
+@console_ns.route("/workspaces/current/plugin/list/latest-versions")
+class PluginListLatestVersionsApi(Resource):
+    @console_ns.expect(parser_latest)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        args = parser_latest.parse_args()
+
+        try:
+            versions = PluginService.list_latest_versions(args["plugin_ids"])
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder({"versions": versions})
+
+
+parser_ids = reqparse.RequestParser().add_argument("plugin_ids", type=list, required=True, location="json")
+
+
+@console_ns.route("/workspaces/current/plugin/list/installations/ids")
+class PluginListInstallationsFromIdsApi(Resource):
+    @console_ns.expect(parser_ids)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_ids.parse_args()
+
+        try:
+            plugins = PluginService.list_installations_from_ids(tenant_id, args["plugin_ids"])
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder({"plugins": plugins})
+
+
+parser_icon = (
+    reqparse.RequestParser()
+    .add_argument("tenant_id", type=str, required=True, location="args")
+    .add_argument("filename", type=str, required=True, location="args")
+)
+
+
+@console_ns.route("/workspaces/current/plugin/icon")
+class PluginIconApi(Resource):
+    @console_ns.expect(parser_icon)
+    @setup_required
+    def get(self):
+        args = parser_icon.parse_args()
+
+        try:
+            icon_bytes, mimetype = PluginService.get_asset(args["tenant_id"], args["filename"])
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        icon_cache_max_age = dify_config.TOOL_ICON_CACHE_MAX_AGE
+        return send_file(io.BytesIO(icon_bytes), mimetype=mimetype, max_age=icon_cache_max_age)
+
+
+@console_ns.route("/workspaces/current/plugin/asset")
+class PluginAssetApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        req = (
+            reqparse.RequestParser()
+            .add_argument("plugin_unique_identifier", type=str, required=True, location="args")
+            .add_argument("file_name", type=str, required=True, location="args")
+        )
+        args = req.parse_args()
+
+        _, tenant_id = current_account_with_tenant()
+        try:
+            binary = PluginService.extract_asset(tenant_id, args["plugin_unique_identifier"], args["file_name"])
+            return send_file(io.BytesIO(binary), mimetype="application/octet-stream")
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+@console_ns.route("/workspaces/current/plugin/upload/pkg")
+class PluginUploadFromPkgApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        file = request.files["pkg"]
+
+        # check file size
+        if file.content_length > dify_config.PLUGIN_MAX_PACKAGE_SIZE:
+            raise ValueError("File size exceeds the maximum allowed size")
+
+        content = file.read()
+        try:
+            response = PluginService.upload_pkg(tenant_id, content)
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder(response)
+
+
+parser_github = (
+    reqparse.RequestParser()
+    .add_argument("repo", type=str, required=True, location="json")
+    .add_argument("version", type=str, required=True, location="json")
+    .add_argument("package", type=str, required=True, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/plugin/upload/github")
+class PluginUploadFromGithubApi(Resource):
+    @console_ns.expect(parser_github)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_github.parse_args()
+
+        try:
+            response = PluginService.upload_pkg_from_github(tenant_id, args["repo"], args["version"], args["package"])
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder(response)
+
+
+@console_ns.route("/workspaces/current/plugin/upload/bundle")
+class PluginUploadFromBundleApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        file = request.files["bundle"]
+
+        # check file size
+        if file.content_length > dify_config.PLUGIN_MAX_BUNDLE_SIZE:
+            raise ValueError("File size exceeds the maximum allowed size")
+
+        content = file.read()
+        try:
+            response = PluginService.upload_bundle(tenant_id, content)
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder(response)
+
+
+parser_pkg = reqparse.RequestParser().add_argument(
+    "plugin_unique_identifiers", type=list, required=True, location="json"
+)
+
+
+@console_ns.route("/workspaces/current/plugin/install/pkg")
+class PluginInstallFromPkgApi(Resource):
+    @console_ns.expect(parser_pkg)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+        args = parser_pkg.parse_args()
+
+        # check if all plugin_unique_identifiers are valid string
+        for plugin_unique_identifier in args["plugin_unique_identifiers"]:
+            if not isinstance(plugin_unique_identifier, str):
+                raise ValueError("Invalid plugin unique identifier")
+
+        try:
+            response = PluginService.install_from_local_pkg(tenant_id, args["plugin_unique_identifiers"])
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder(response)
+
+
+parser_githubapi = (
+    reqparse.RequestParser()
+    .add_argument("repo", type=str, required=True, location="json")
+    .add_argument("version", type=str, required=True, location="json")
+    .add_argument("package", type=str, required=True, location="json")
+    .add_argument("plugin_unique_identifier", type=str, required=True, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/plugin/install/github")
+class PluginInstallFromGithubApi(Resource):
+    @console_ns.expect(parser_githubapi)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_githubapi.parse_args()
+
+        try:
+            response = PluginService.install_from_github(
+                tenant_id,
+                args["plugin_unique_identifier"],
+                args["repo"],
+                args["version"],
+                args["package"],
+            )
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder(response)
+
+
+parser_marketplace = reqparse.RequestParser().add_argument(
+    "plugin_unique_identifiers", type=list, required=True, location="json"
+)
+
+
+@console_ns.route("/workspaces/current/plugin/install/marketplace")
+class PluginInstallFromMarketplaceApi(Resource):
+    @console_ns.expect(parser_marketplace)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_marketplace.parse_args()
+
+        # check if all plugin_unique_identifiers are valid string
+        for plugin_unique_identifier in args["plugin_unique_identifiers"]:
+            if not isinstance(plugin_unique_identifier, str):
+                raise ValueError("Invalid plugin unique identifier")
+
+        try:
+            response = PluginService.install_from_marketplace_pkg(tenant_id, args["plugin_unique_identifiers"])
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder(response)
+
+
+parser_pkgapi = reqparse.RequestParser().add_argument(
+    "plugin_unique_identifier", type=str, required=True, location="args"
+)
+
+
+@console_ns.route("/workspaces/current/plugin/marketplace/pkg")
+class PluginFetchMarketplacePkgApi(Resource):
+    @console_ns.expect(parser_pkgapi)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+        args = parser_pkgapi.parse_args()
+
+        try:
+            return jsonable_encoder(
+                {
+                    "manifest": PluginService.fetch_marketplace_pkg(
+                        tenant_id,
+                        args["plugin_unique_identifier"],
+                    )
+                }
+            )
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+parser_fetch = reqparse.RequestParser().add_argument(
+    "plugin_unique_identifier", type=str, required=True, location="args"
+)
+
+
+@console_ns.route("/workspaces/current/plugin/fetch-manifest")
+class PluginFetchManifestApi(Resource):
+    @console_ns.expect(parser_fetch)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_fetch.parse_args()
+
+        try:
+            return jsonable_encoder(
+                {
+                    "manifest": PluginService.fetch_plugin_manifest(
+                        tenant_id, args["plugin_unique_identifier"]
+                    ).model_dump()
+                }
+            )
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+parser_tasks = (
+    reqparse.RequestParser()
+    .add_argument("page", type=int, required=True, location="args")
+    .add_argument("page_size", type=int, required=True, location="args")
+)
+
+
+@console_ns.route("/workspaces/current/plugin/tasks")
+class PluginFetchInstallTasksApi(Resource):
+    @console_ns.expect(parser_tasks)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_tasks.parse_args()
+
+        try:
+            return jsonable_encoder(
+                {"tasks": PluginService.fetch_install_tasks(tenant_id, args["page"], args["page_size"])}
+            )
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+@console_ns.route("/workspaces/current/plugin/tasks/<task_id>")
+class PluginFetchInstallTaskApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def get(self, task_id: str):
+        _, tenant_id = current_account_with_tenant()
+
+        try:
+            return jsonable_encoder({"task": PluginService.fetch_install_task(tenant_id, task_id)})
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+@console_ns.route("/workspaces/current/plugin/tasks/<task_id>/delete")
+class PluginDeleteInstallTaskApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self, task_id: str):
+        _, tenant_id = current_account_with_tenant()
+
+        try:
+            return {"success": PluginService.delete_install_task(tenant_id, task_id)}
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+@console_ns.route("/workspaces/current/plugin/tasks/delete_all")
+class PluginDeleteAllInstallTaskItemsApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        try:
+            return {"success": PluginService.delete_all_install_task_items(tenant_id)}
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+@console_ns.route("/workspaces/current/plugin/tasks/<task_id>/delete/<path:identifier>")
+class PluginDeleteInstallTaskItemApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self, task_id: str, identifier: str):
+        _, tenant_id = current_account_with_tenant()
+
+        try:
+            return {"success": PluginService.delete_install_task_item(tenant_id, task_id, identifier)}
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+parser_marketplace_api = (
+    reqparse.RequestParser()
+    .add_argument("original_plugin_unique_identifier", type=str, required=True, location="json")
+    .add_argument("new_plugin_unique_identifier", type=str, required=True, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/plugin/upgrade/marketplace")
+class PluginUpgradeFromMarketplaceApi(Resource):
+    @console_ns.expect(parser_marketplace_api)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_marketplace_api.parse_args()
+
+        try:
+            return jsonable_encoder(
+                PluginService.upgrade_plugin_with_marketplace(
+                    tenant_id, args["original_plugin_unique_identifier"], args["new_plugin_unique_identifier"]
+                )
+            )
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+parser_github_post = (
+    reqparse.RequestParser()
+    .add_argument("original_plugin_unique_identifier", type=str, required=True, location="json")
+    .add_argument("new_plugin_unique_identifier", type=str, required=True, location="json")
+    .add_argument("repo", type=str, required=True, location="json")
+    .add_argument("version", type=str, required=True, location="json")
+    .add_argument("package", type=str, required=True, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/plugin/upgrade/github")
+class PluginUpgradeFromGithubApi(Resource):
+    @console_ns.expect(parser_github_post)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_github_post.parse_args()
+
+        try:
+            return jsonable_encoder(
+                PluginService.upgrade_plugin_with_github(
+                    tenant_id,
+                    args["original_plugin_unique_identifier"],
+                    args["new_plugin_unique_identifier"],
+                    args["repo"],
+                    args["version"],
+                    args["package"],
+                )
+            )
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+parser_uninstall = reqparse.RequestParser().add_argument(
+    "plugin_installation_id", type=str, required=True, location="json"
+)
+
+
+@console_ns.route("/workspaces/current/plugin/uninstall")
+class PluginUninstallApi(Resource):
+    @console_ns.expect(parser_uninstall)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        args = parser_uninstall.parse_args()
+
+        _, tenant_id = current_account_with_tenant()
+
+        try:
+            return {"success": PluginService.uninstall(tenant_id, args["plugin_installation_id"])}
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+parser_change_post = (
+    reqparse.RequestParser()
+    .add_argument("install_permission", type=str, required=True, location="json")
+    .add_argument("debug_permission", type=str, required=True, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/plugin/permission/change")
+class PluginChangePermissionApi(Resource):
+    @console_ns.expect(parser_change_post)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        current_user, current_tenant_id = current_account_with_tenant()
+        user = current_user
+        if not user.is_admin_or_owner:
+            raise Forbidden()
+
+        args = parser_change_post.parse_args()
+
+        install_permission = TenantPluginPermission.InstallPermission(args["install_permission"])
+        debug_permission = TenantPluginPermission.DebugPermission(args["debug_permission"])
+
+        tenant_id = current_tenant_id
+
+        return {"success": PluginPermissionService.change_permission(tenant_id, install_permission, debug_permission)}
+
+
+@console_ns.route("/workspaces/current/plugin/permission/fetch")
+class PluginFetchPermissionApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+
+        permission = PluginPermissionService.get_permission(tenant_id)
+        if not permission:
+            return jsonable_encoder(
+                {
+                    "install_permission": TenantPluginPermission.InstallPermission.EVERYONE,
+                    "debug_permission": TenantPluginPermission.DebugPermission.EVERYONE,
+                }
+            )
+
+        return jsonable_encoder(
+            {
+                "install_permission": permission.install_permission,
+                "debug_permission": permission.debug_permission,
+            }
+        )
+
+
+parser_dynamic = (
+    reqparse.RequestParser()
+    .add_argument("plugin_id", type=str, required=True, location="args")
+    .add_argument("provider", type=str, required=True, location="args")
+    .add_argument("action", type=str, required=True, location="args")
+    .add_argument("parameter", type=str, required=True, location="args")
+    .add_argument("credential_id", type=str, required=False, location="args")
+    .add_argument("provider_type", type=str, required=True, location="args")
+)
+
+
+@console_ns.route("/workspaces/current/plugin/parameters/dynamic-options")
+class PluginFetchDynamicSelectOptionsApi(Resource):
+    @console_ns.expect(parser_dynamic)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def get(self):
+        current_user, tenant_id = current_account_with_tenant()
+        user_id = current_user.id
+
+        args = parser_dynamic.parse_args()
+
+        try:
+            options = PluginParameterService.get_dynamic_select_options(
+                tenant_id=tenant_id,
+                user_id=user_id,
+                plugin_id=args["plugin_id"],
+                provider=args["provider"],
+                action=args["action"],
+                parameter=args["parameter"],
+                credential_id=args["credential_id"],
+                provider_type=args["provider_type"],
+            )
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder({"options": options})
+
+
+parser_change = (
+    reqparse.RequestParser()
+    .add_argument("permission", type=dict, required=True, location="json")
+    .add_argument("auto_upgrade", type=dict, required=True, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/plugin/preferences/change")
+class PluginChangePreferencesApi(Resource):
+    @console_ns.expect(parser_change)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        user, tenant_id = current_account_with_tenant()
+        if not user.is_admin_or_owner:
+            raise Forbidden()
+
+        args = parser_change.parse_args()
+
+        permission = args["permission"]
+
+        install_permission = TenantPluginPermission.InstallPermission(permission.get("install_permission", "everyone"))
+        debug_permission = TenantPluginPermission.DebugPermission(permission.get("debug_permission", "everyone"))
+
+        auto_upgrade = args["auto_upgrade"]
+
+        strategy_setting = TenantPluginAutoUpgradeStrategy.StrategySetting(
+            auto_upgrade.get("strategy_setting", "fix_only")
+        )
+        upgrade_time_of_day = auto_upgrade.get("upgrade_time_of_day", 0)
+        upgrade_mode = TenantPluginAutoUpgradeStrategy.UpgradeMode(auto_upgrade.get("upgrade_mode", "exclude"))
+        exclude_plugins = auto_upgrade.get("exclude_plugins", [])
+        include_plugins = auto_upgrade.get("include_plugins", [])
+
+        # set permission
+        set_permission_result = PluginPermissionService.change_permission(
+            tenant_id,
+            install_permission,
+            debug_permission,
+        )
+        if not set_permission_result:
+            return jsonable_encoder({"success": False, "message": "Failed to set permission"})
+
+        # set auto upgrade strategy
+        set_auto_upgrade_strategy_result = PluginAutoUpgradeService.change_strategy(
+            tenant_id,
+            strategy_setting,
+            upgrade_time_of_day,
+            upgrade_mode,
+            exclude_plugins,
+            include_plugins,
+        )
+        if not set_auto_upgrade_strategy_result:
+            return jsonable_encoder({"success": False, "message": "Failed to set auto upgrade strategy"})
+
+        return jsonable_encoder({"success": True})
+
+
+@console_ns.route("/workspaces/current/plugin/preferences/fetch")
+class PluginFetchPreferencesApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+
+        permission = PluginPermissionService.get_permission(tenant_id)
+        permission_dict = {
+            "install_permission": TenantPluginPermission.InstallPermission.EVERYONE,
+            "debug_permission": TenantPluginPermission.DebugPermission.EVERYONE,
+        }
+
+        if permission:
+            permission_dict["install_permission"] = permission.install_permission
+            permission_dict["debug_permission"] = permission.debug_permission
+
+        auto_upgrade = PluginAutoUpgradeService.get_strategy(tenant_id)
+        auto_upgrade_dict = {
+            "strategy_setting": TenantPluginAutoUpgradeStrategy.StrategySetting.DISABLED,
+            "upgrade_time_of_day": 0,
+            "upgrade_mode": TenantPluginAutoUpgradeStrategy.UpgradeMode.EXCLUDE,
+            "exclude_plugins": [],
+            "include_plugins": [],
+        }
+
+        if auto_upgrade:
+            auto_upgrade_dict = {
+                "strategy_setting": auto_upgrade.strategy_setting,
+                "upgrade_time_of_day": auto_upgrade.upgrade_time_of_day,
+                "upgrade_mode": auto_upgrade.upgrade_mode,
+                "exclude_plugins": auto_upgrade.exclude_plugins,
+                "include_plugins": auto_upgrade.include_plugins,
+            }
+
+        return jsonable_encoder({"permission": permission_dict, "auto_upgrade": auto_upgrade_dict})
+
+
+parser_exclude = reqparse.RequestParser().add_argument("plugin_id", type=str, required=True, location="json")
+
+
+@console_ns.route("/workspaces/current/plugin/preferences/autoupgrade/exclude")
+class PluginAutoUpgradeExcludePluginApi(Resource):
+    @console_ns.expect(parser_exclude)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        # exclude one single plugin
+        _, tenant_id = current_account_with_tenant()
+
+        args = parser_exclude.parse_args()
+
+        return jsonable_encoder({"success": PluginAutoUpgradeService.exclude_plugin(tenant_id, args["plugin_id"])})
+
+
+@console_ns.route("/workspaces/current/plugin/readme")
+class PluginReadmeApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+        parser = (
+            reqparse.RequestParser()
+            .add_argument("plugin_unique_identifier", type=str, required=True, location="args")
+            .add_argument("language", type=str, required=False, location="args")
+        )
+        args = parser.parse_args()
+        return jsonable_encoder(
+            {
+                "readme": PluginService.fetch_plugin_readme(
+                    tenant_id, args["plugin_unique_identifier"], args.get("language", "en-US")
+                )
+            }
+        )

dify/api/controllers/console/workspace/trigger_providers.py

@@ -0,0 +1,570 @@
+import logging
+
+from flask import make_response, redirect, request
+from flask_restx import Resource, reqparse
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import BadRequest, Forbidden
+
+from configs import dify_config
+from controllers.web.error import NotFoundError
+from core.model_runtime.utils.encoders import jsonable_encoder
+from core.plugin.entities.plugin_daemon import CredentialType
+from core.plugin.impl.oauth import OAuthHandler
+from core.trigger.entities.entities import SubscriptionBuilderUpdater
+from core.trigger.trigger_manager import TriggerManager
+from extensions.ext_database import db
+from libs.login import current_user, login_required
+from models.account import Account
+from models.provider_ids import TriggerProviderID
+from services.plugin.oauth_service import OAuthProxyService
+from services.trigger.trigger_provider_service import TriggerProviderService
+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
+from services.trigger.trigger_subscription_operator_service import TriggerSubscriptionOperatorService
+
+from .. import console_ns
+from ..wraps import account_initialization_required, is_admin_or_owner_required, setup_required
+
+logger = logging.getLogger(__name__)
+
+
+@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/icon")
+class TriggerProviderIconApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider):
+        user = current_user
+        assert isinstance(user, Account)
+        assert user.current_tenant_id is not None
+
+        return TriggerManager.get_trigger_plugin_icon(tenant_id=user.current_tenant_id, provider_id=provider)
+
+
+@console_ns.route("/workspaces/current/triggers")
+class TriggerProviderListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        """List all trigger providers for the current tenant"""
+        user = current_user
+        assert isinstance(user, Account)
+        assert user.current_tenant_id is not None
+        return jsonable_encoder(TriggerProviderService.list_trigger_providers(user.current_tenant_id))
+
+
+@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/info")
+class TriggerProviderInfoApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider):
+        """Get info for a trigger provider"""
+        user = current_user
+        assert isinstance(user, Account)
+        assert user.current_tenant_id is not None
+        return jsonable_encoder(
+            TriggerProviderService.get_trigger_provider(user.current_tenant_id, TriggerProviderID(provider))
+        )
+
+
+@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/subscriptions/list")
+class TriggerSubscriptionListApi(Resource):
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def get(self, provider):
+        """List all trigger subscriptions for the current tenant's provider"""
+        user = current_user
+        assert user.current_tenant_id is not None
+
+        try:
+            return jsonable_encoder(
+                TriggerProviderService.list_trigger_provider_subscriptions(
+                    tenant_id=user.current_tenant_id, provider_id=TriggerProviderID(provider)
+                )
+            )
+        except ValueError as e:
+            return jsonable_encoder({"error": str(e)}), 404
+        except Exception as e:
+            logger.exception("Error listing trigger providers", exc_info=e)
+            raise
+
+
+parser = reqparse.RequestParser().add_argument(
+    "credential_type", type=str, required=False, nullable=True, location="json"
+)
+
+
+@console_ns.route(
+    "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/create",
+)
+class TriggerSubscriptionBuilderCreateApi(Resource):
+    @console_ns.expect(parser)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider):
+        """Add a new subscription instance for a trigger provider"""
+        user = current_user
+        assert user.current_tenant_id is not None
+
+        args = parser.parse_args()
+
+        try:
+            credential_type = CredentialType.of(args.get("credential_type") or CredentialType.UNAUTHORIZED.value)
+            subscription_builder = TriggerSubscriptionBuilderService.create_trigger_subscription_builder(
+                tenant_id=user.current_tenant_id,
+                user_id=user.id,
+                provider_id=TriggerProviderID(provider),
+                credential_type=credential_type,
+            )
+            return jsonable_encoder({"subscription_builder": subscription_builder})
+        except Exception as e:
+            logger.exception("Error adding provider credential", exc_info=e)
+            raise
+
+
+@console_ns.route(
+    "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/<path:subscription_builder_id>",
+)
+class TriggerSubscriptionBuilderGetApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider, subscription_builder_id):
+        """Get a subscription instance for a trigger provider"""
+        return jsonable_encoder(
+            TriggerSubscriptionBuilderService.get_subscription_builder_by_id(subscription_builder_id)
+        )
+
+
+parser_api = (
+    reqparse.RequestParser()
+    # The credentials of the subscription builder
+    .add_argument("credentials", type=dict, required=False, nullable=True, location="json")
+)
+
+
+@console_ns.route(
+    "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/verify/<path:subscription_builder_id>",
+)
+class TriggerSubscriptionBuilderVerifyApi(Resource):
+    @console_ns.expect(parser_api)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider, subscription_builder_id):
+        """Verify a subscription instance for a trigger provider"""
+        user = current_user
+        assert user.current_tenant_id is not None
+
+        args = parser_api.parse_args()
+
+        try:
+            # Use atomic update_and_verify to prevent race conditions
+            return TriggerSubscriptionBuilderService.update_and_verify_builder(
+                tenant_id=user.current_tenant_id,
+                user_id=user.id,
+                provider_id=TriggerProviderID(provider),
+                subscription_builder_id=subscription_builder_id,
+                subscription_builder_updater=SubscriptionBuilderUpdater(
+                    credentials=args.get("credentials", None),
+                ),
+            )
+        except Exception as e:
+            logger.exception("Error verifying provider credential", exc_info=e)
+            raise ValueError(str(e)) from e
+
+
+parser_update_api = (
+    reqparse.RequestParser()
+    # The name of the subscription builder
+    .add_argument("name", type=str, required=False, nullable=True, location="json")
+    # The parameters of the subscription builder
+    .add_argument("parameters", type=dict, required=False, nullable=True, location="json")
+    # The properties of the subscription builder
+    .add_argument("properties", type=dict, required=False, nullable=True, location="json")
+    # The credentials of the subscription builder
+    .add_argument("credentials", type=dict, required=False, nullable=True, location="json")
+)
+
+
+@console_ns.route(
+    "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/update/<path:subscription_builder_id>",
+)
+class TriggerSubscriptionBuilderUpdateApi(Resource):
+    @console_ns.expect(parser_update_api)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, provider, subscription_builder_id):
+        """Update a subscription instance for a trigger provider"""
+        user = current_user
+        assert isinstance(user, Account)
+        assert user.current_tenant_id is not None
+
+        args = parser_update_api.parse_args()
+        try:
+            return jsonable_encoder(
+                TriggerSubscriptionBuilderService.update_trigger_subscription_builder(
+                    tenant_id=user.current_tenant_id,
+                    provider_id=TriggerProviderID(provider),
+                    subscription_builder_id=subscription_builder_id,
+                    subscription_builder_updater=SubscriptionBuilderUpdater(
+                        name=args.get("name", None),
+                        parameters=args.get("parameters", None),
+                        properties=args.get("properties", None),
+                        credentials=args.get("credentials", None),
+                    ),
+                )
+            )
+        except Exception as e:
+            logger.exception("Error updating provider credential", exc_info=e)
+            raise
+
+
+@console_ns.route(
+    "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/logs/<path:subscription_builder_id>",
+)
+class TriggerSubscriptionBuilderLogsApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider, subscription_builder_id):
+        """Get the request logs for a subscription instance for a trigger provider"""
+        user = current_user
+        assert isinstance(user, Account)
+        assert user.current_tenant_id is not None
+
+        try:
+            logs = TriggerSubscriptionBuilderService.list_logs(subscription_builder_id)
+            return jsonable_encoder({"logs": [log.model_dump(mode="json") for log in logs]})
+        except Exception as e:
+            logger.exception("Error getting request logs for subscription builder", exc_info=e)
+            raise
+
+
+@console_ns.route(
+    "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/build/<path:subscription_builder_id>",
+)
+class TriggerSubscriptionBuilderBuildApi(Resource):
+    @console_ns.expect(parser_update_api)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider, subscription_builder_id):
+        """Build a subscription instance for a trigger provider"""
+        user = current_user
+        assert user.current_tenant_id is not None
+        args = parser_update_api.parse_args()
+        try:
+            # Use atomic update_and_build to prevent race conditions
+            TriggerSubscriptionBuilderService.update_and_build_builder(
+                tenant_id=user.current_tenant_id,
+                user_id=user.id,
+                provider_id=TriggerProviderID(provider),
+                subscription_builder_id=subscription_builder_id,
+                subscription_builder_updater=SubscriptionBuilderUpdater(
+                    name=args.get("name", None),
+                    parameters=args.get("parameters", None),
+                    properties=args.get("properties", None),
+                ),
+            )
+            return 200
+        except Exception as e:
+            logger.exception("Error building provider credential", exc_info=e)
+            raise ValueError(str(e)) from e
+
+
+@console_ns.route(
+    "/workspaces/current/trigger-provider/<path:subscription_id>/subscriptions/delete",
+)
+class TriggerSubscriptionDeleteApi(Resource):
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, subscription_id: str):
+        """Delete a subscription instance"""
+        user = current_user
+        assert user.current_tenant_id is not None
+
+        try:
+            with Session(db.engine) as session:
+                # Delete trigger provider subscription
+                TriggerProviderService.delete_trigger_provider(
+                    session=session,
+                    tenant_id=user.current_tenant_id,
+                    subscription_id=subscription_id,
+                )
+                # Delete plugin triggers
+                TriggerSubscriptionOperatorService.delete_plugin_trigger_by_subscription(
+                    session=session,
+                    tenant_id=user.current_tenant_id,
+                    subscription_id=subscription_id,
+                )
+                session.commit()
+            return {"result": "success"}
+        except ValueError as e:
+            raise BadRequest(str(e))
+        except Exception as e:
+            logger.exception("Error deleting provider credential", exc_info=e)
+            raise
+
+
+@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/subscriptions/oauth/authorize")
+class TriggerOAuthAuthorizeApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider):
+        """Initiate OAuth authorization flow for a trigger provider"""
+        user = current_user
+        assert isinstance(user, Account)
+        assert user.current_tenant_id is not None
+
+        try:
+            provider_id = TriggerProviderID(provider)
+            plugin_id = provider_id.plugin_id
+            provider_name = provider_id.provider_name
+            tenant_id = user.current_tenant_id
+
+            # Get OAuth client configuration
+            oauth_client_params = TriggerProviderService.get_oauth_client(
+                tenant_id=tenant_id,
+                provider_id=provider_id,
+            )
+
+            if oauth_client_params is None:
+                raise NotFoundError("No OAuth client configuration found for this trigger provider")
+
+            # Create subscription builder
+            subscription_builder = TriggerSubscriptionBuilderService.create_trigger_subscription_builder(
+                tenant_id=tenant_id,
+                user_id=user.id,
+                provider_id=provider_id,
+                credential_type=CredentialType.OAUTH2,
+            )
+
+            # Create OAuth handler and proxy context
+            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={
+                    "subscription_builder_id": subscription_builder.id,
+                },
+            )
+
+            # Build redirect URI for callback
+            redirect_uri = f"{dify_config.CONSOLE_API_URL}/console/api/oauth/plugin/{provider}/trigger/callback"
+
+            # Get authorization URL
+            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=oauth_client_params,
+            )
+
+            # Create response with cookie
+            response = make_response(
+                jsonable_encoder(
+                    {
+                        "authorization_url": authorization_url_response.authorization_url,
+                        "subscription_builder_id": subscription_builder.id,
+                        "subscription_builder": subscription_builder,
+                    }
+                )
+            )
+            response.set_cookie(
+                "context_id",
+                context_id,
+                httponly=True,
+                samesite="Lax",
+                max_age=OAuthProxyService.__MAX_AGE__,
+            )
+
+            return response
+
+        except Exception as e:
+            logger.exception("Error initiating OAuth flow", exc_info=e)
+            raise
+
+
+@console_ns.route("/oauth/plugin/<path:provider>/trigger/callback")
+class TriggerOAuthCallbackApi(Resource):
+    @setup_required
+    def get(self, provider):
+        """Handle OAuth callback for trigger provider"""
+        context_id = request.cookies.get("context_id")
+        if not context_id:
+            raise Forbidden("context_id not found")
+
+        # Use and validate proxy context
+        context = OAuthProxyService.use_proxy_context(context_id)
+        if context is None:
+            raise Forbidden("Invalid context_id")
+
+        # Parse provider ID
+        provider_id = TriggerProviderID(provider)
+        plugin_id = provider_id.plugin_id
+        provider_name = provider_id.provider_name
+        user_id = context.get("user_id")
+        tenant_id = context.get("tenant_id")
+        subscription_builder_id = context.get("subscription_builder_id")
+
+        # Get OAuth client configuration
+        oauth_client_params = TriggerProviderService.get_oauth_client(
+            tenant_id=tenant_id,
+            provider_id=provider_id,
+        )
+
+        if oauth_client_params is None:
+            raise Forbidden("No OAuth client configuration found for this trigger provider")
+
+        # Get OAuth credentials from callback
+        oauth_handler = OAuthHandler()
+        redirect_uri = f"{dify_config.CONSOLE_API_URL}/console/api/oauth/plugin/{provider}/trigger/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=oauth_client_params,
+            request=request,
+        )
+
+        credentials = credentials_response.credentials
+        expires_at = credentials_response.expires_at
+
+        if not credentials:
+            raise ValueError("Failed to get OAuth credentials from the provider.")
+
+        # Update subscription builder
+        TriggerSubscriptionBuilderService.update_trigger_subscription_builder(
+            tenant_id=tenant_id,
+            provider_id=provider_id,
+            subscription_builder_id=subscription_builder_id,
+            subscription_builder_updater=SubscriptionBuilderUpdater(
+                credentials=credentials,
+                credential_expires_at=expires_at,
+            ),
+        )
+        # Redirect to OAuth callback page
+        return redirect(f"{dify_config.CONSOLE_WEB_URL}/oauth-callback")
+
+
+parser_oauth_client = (
+    reqparse.RequestParser()
+    .add_argument("client_params", type=dict, required=False, nullable=True, location="json")
+    .add_argument("enabled", type=bool, required=False, nullable=True, location="json")
+)
+
+
+@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/oauth/client")
+class TriggerOAuthClientManageApi(Resource):
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def get(self, provider):
+        """Get OAuth client configuration for a provider"""
+        user = current_user
+        assert user.current_tenant_id is not None
+
+        try:
+            provider_id = TriggerProviderID(provider)
+
+            # Get custom OAuth client params if exists
+            custom_params = TriggerProviderService.get_custom_oauth_client_params(
+                tenant_id=user.current_tenant_id,
+                provider_id=provider_id,
+            )
+
+            # Check if custom client is enabled
+            is_custom_enabled = TriggerProviderService.is_oauth_custom_client_enabled(
+                tenant_id=user.current_tenant_id,
+                provider_id=provider_id,
+            )
+            system_client_exists = TriggerProviderService.is_oauth_system_client_exists(
+                tenant_id=user.current_tenant_id,
+                provider_id=provider_id,
+            )
+            provider_controller = TriggerManager.get_trigger_provider(user.current_tenant_id, provider_id)
+            redirect_uri = f"{dify_config.CONSOLE_API_URL}/console/api/oauth/plugin/{provider}/trigger/callback"
+            return jsonable_encoder(
+                {
+                    "configured": bool(custom_params or system_client_exists),
+                    "system_configured": system_client_exists,
+                    "custom_configured": bool(custom_params),
+                    "oauth_client_schema": provider_controller.get_oauth_client_schema(),
+                    "custom_enabled": is_custom_enabled,
+                    "redirect_uri": redirect_uri,
+                    "params": custom_params or {},
+                }
+            )
+
+        except Exception as e:
+            logger.exception("Error getting OAuth client", exc_info=e)
+            raise
+
+    @console_ns.expect(parser_oauth_client)
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider):
+        """Configure custom OAuth client for a provider"""
+        user = current_user
+        assert user.current_tenant_id is not None
+
+        args = parser_oauth_client.parse_args()
+
+        try:
+            provider_id = TriggerProviderID(provider)
+            return TriggerProviderService.save_custom_oauth_client_params(
+                tenant_id=user.current_tenant_id,
+                provider_id=provider_id,
+                client_params=args.get("client_params"),
+                enabled=args.get("enabled"),
+            )
+
+        except ValueError as e:
+            raise BadRequest(str(e))
+        except Exception as e:
+            logger.exception("Error configuring OAuth client", exc_info=e)
+            raise
+
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def delete(self, provider):
+        """Remove custom OAuth client configuration"""
+        user = current_user
+        assert user.current_tenant_id is not None
+
+        try:
+            provider_id = TriggerProviderID(provider)
+
+            return TriggerProviderService.delete_custom_oauth_client_params(
+                tenant_id=user.current_tenant_id,
+                provider_id=provider_id,
+            )
+        except ValueError as e:
+            raise BadRequest(str(e))
+        except Exception as e:
+            logger.exception("Error removing OAuth client", exc_info=e)
+            raise

dify/api/controllers/console/workspace/workspace.py

@@ -0,0 +1,268 @@
+import logging
+
+from flask import request
+from flask_restx import Resource, fields, inputs, marshal, marshal_with, reqparse
+from sqlalchemy import select
+from werkzeug.exceptions import Unauthorized
+
+import services
+from controllers.common.errors import (
+    FilenameNotExistsError,
+    FileTooLargeError,
+    NoFileUploadedError,
+    TooManyFilesError,
+    UnsupportedFileTypeError,
+)
+from controllers.console import console_ns
+from controllers.console.admin import admin_required
+from controllers.console.error import AccountNotLinkTenantError
+from controllers.console.wraps import (
+    account_initialization_required,
+    cloud_edition_billing_resource_check,
+    setup_required,
+)
+from enums.cloud_plan import CloudPlan
+from extensions.ext_database import db
+from libs.helper import TimestampField
+from libs.login import current_account_with_tenant, login_required
+from models.account import Tenant, TenantStatus
+from services.account_service import TenantService
+from services.feature_service import FeatureService
+from services.file_service import FileService
+from services.workspace_service import WorkspaceService
+
+logger = logging.getLogger(__name__)
+
+
+provider_fields = {
+    "provider_name": fields.String,
+    "provider_type": fields.String,
+    "is_valid": fields.Boolean,
+    "token_is_set": fields.Boolean,
+}
+
+tenant_fields = {
+    "id": fields.String,
+    "name": fields.String,
+    "plan": fields.String,
+    "status": fields.String,
+    "created_at": TimestampField,
+    "role": fields.String,
+    "in_trial": fields.Boolean,
+    "trial_end_reason": fields.String,
+    "custom_config": fields.Raw(attribute="custom_config"),
+}
+
+tenants_fields = {
+    "id": fields.String,
+    "name": fields.String,
+    "plan": fields.String,
+    "status": fields.String,
+    "created_at": TimestampField,
+    "current": fields.Boolean,
+}
+
+workspace_fields = {"id": fields.String, "name": fields.String, "status": fields.String, "created_at": TimestampField}
+
+
+@console_ns.route("/workspaces")
+class TenantListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        current_user, current_tenant_id = current_account_with_tenant()
+        tenants = TenantService.get_join_tenants(current_user)
+        tenant_dicts = []
+
+        for tenant in tenants:
+            features = FeatureService.get_features(tenant.id)
+
+            # Create a dictionary with tenant attributes
+            tenant_dict = {
+                "id": tenant.id,
+                "name": tenant.name,
+                "status": tenant.status,
+                "created_at": tenant.created_at,
+                "plan": features.billing.subscription.plan if features.billing.enabled else CloudPlan.SANDBOX,
+                "current": tenant.id == current_tenant_id if current_tenant_id else False,
+            }
+
+            tenant_dicts.append(tenant_dict)
+
+        return {"workspaces": marshal(tenant_dicts, tenants_fields)}, 200
+
+
+@console_ns.route("/all-workspaces")
+class WorkspaceListApi(Resource):
+    @setup_required
+    @admin_required
+    def get(self):
+        parser = (
+            reqparse.RequestParser()
+            .add_argument("page", type=inputs.int_range(1, 99999), required=False, default=1, location="args")
+            .add_argument("limit", type=inputs.int_range(1, 100), required=False, default=20, location="args")
+        )
+        args = parser.parse_args()
+
+        stmt = select(Tenant).order_by(Tenant.created_at.desc())
+        tenants = db.paginate(select=stmt, page=args["page"], per_page=args["limit"], error_out=False)
+        has_more = False
+
+        if tenants.has_next:
+            has_more = True
+
+        return {
+            "data": marshal(tenants.items, workspace_fields),
+            "has_more": has_more,
+            "limit": args["limit"],
+            "page": args["page"],
+            "total": tenants.total,
+        }, 200
+
+
+@console_ns.route("/workspaces/current", endpoint="workspaces_current")
+@console_ns.route("/info", endpoint="info")  # Deprecated
+class TenantApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(tenant_fields)
+    def post(self):
+        if request.path == "/info":
+            logger.warning("Deprecated URL /info was used.")
+
+        current_user, _ = current_account_with_tenant()
+        tenant = current_user.current_tenant
+        if not tenant:
+            raise ValueError("No current tenant")
+
+        if tenant.status == TenantStatus.ARCHIVE:
+            tenants = TenantService.get_join_tenants(current_user)
+            # if there is any tenant, switch to the first one
+            if len(tenants) > 0:
+                TenantService.switch_tenant(current_user, tenants[0].id)
+                tenant = tenants[0]
+            # else, raise Unauthorized
+            else:
+                raise Unauthorized("workspace is archived")
+
+        return WorkspaceService.get_tenant_info(tenant), 200
+
+
+parser_switch = reqparse.RequestParser().add_argument("tenant_id", type=str, required=True, location="json")
+
+
+@console_ns.route("/workspaces/switch")
+class SwitchWorkspaceApi(Resource):
+    @console_ns.expect(parser_switch)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        args = parser_switch.parse_args()
+
+        # check if tenant_id is valid, 403 if not
+        try:
+            TenantService.switch_tenant(current_user, args["tenant_id"])
+        except Exception:
+            raise AccountNotLinkTenantError("Account not link tenant")
+
+        new_tenant = db.session.query(Tenant).get(args["tenant_id"])  # Get new tenant
+        if new_tenant is None:
+            raise ValueError("Tenant not found")
+
+        return {"result": "success", "new_tenant": marshal(WorkspaceService.get_tenant_info(new_tenant), tenant_fields)}
+
+
+@console_ns.route("/workspaces/custom-config")
+class CustomConfigWorkspaceApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("workspace_custom")
+    def post(self):
+        _, current_tenant_id = current_account_with_tenant()
+        parser = (
+            reqparse.RequestParser()
+            .add_argument("remove_webapp_brand", type=bool, location="json")
+            .add_argument("replace_webapp_logo", type=str, location="json")
+        )
+        args = parser.parse_args()
+        tenant = db.get_or_404(Tenant, current_tenant_id)
+
+        custom_config_dict = {
+            "remove_webapp_brand": args["remove_webapp_brand"],
+            "replace_webapp_logo": args["replace_webapp_logo"]
+            if args["replace_webapp_logo"] is not None
+            else tenant.custom_config_dict.get("replace_webapp_logo"),
+        }
+
+        tenant.custom_config_dict = custom_config_dict
+        db.session.commit()
+
+        return {"result": "success", "tenant": marshal(WorkspaceService.get_tenant_info(tenant), tenant_fields)}
+
+
+@console_ns.route("/workspaces/custom-config/webapp-logo/upload")
+class WebappLogoWorkspaceApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("workspace_custom")
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        # check file
+        if "file" not in request.files:
+            raise NoFileUploadedError()
+
+        if len(request.files) > 1:
+            raise TooManyFilesError()
+
+        # get file from request
+        file = request.files["file"]
+        if not file.filename:
+            raise FilenameNotExistsError
+
+        extension = file.filename.split(".")[-1]
+        if extension.lower() not in {"svg", "png"}:
+            raise UnsupportedFileTypeError()
+
+        try:
+            upload_file = FileService(db.engine).upload_file(
+                filename=file.filename,
+                content=file.read(),
+                mimetype=file.mimetype,
+                user=current_user,
+            )
+
+        except services.errors.file.FileTooLargeError as file_too_large_error:
+            raise FileTooLargeError(file_too_large_error.description)
+        except services.errors.file.UnsupportedFileTypeError:
+            raise UnsupportedFileTypeError()
+
+        return {"id": upload_file.id}, 201
+
+
+parser_info = reqparse.RequestParser().add_argument("name", type=str, required=True, location="json")
+
+
+@console_ns.route("/workspaces/info")
+class WorkspaceInfoApi(Resource):
+    @console_ns.expect(parser_info)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    # Change workspace name
+    def post(self):
+        _, current_tenant_id = current_account_with_tenant()
+        args = parser_info.parse_args()
+
+        if not current_tenant_id:
+            raise ValueError("No current tenant")
+        tenant = db.get_or_404(Tenant, current_tenant_id)
+        tenant.name = args["name"]
+        db.session.commit()
+
+        return {"result": "success", "tenant": marshal(WorkspaceService.get_tenant_info(tenant), tenant_fields)}