feat：新增dify1.11.1版本

dify_1.11.1/api/controllers/__init__.py

@@ -0,0 +1 @@
+

dify_1.11.1/api/controllers/common/errors.py

@@ -0,0 +1,43 @@
+from werkzeug.exceptions import HTTPException
+
+from libs.exception import BaseHTTPException
+
+
+class FilenameNotExistsError(HTTPException):
+    code = 400
+    description = "The specified filename does not exist."
+
+
+class RemoteFileUploadError(HTTPException):
+    code = 400
+    description = "Error uploading remote file."
+
+
+class FileTooLargeError(BaseHTTPException):
+    error_code = "file_too_large"
+    description = "File size exceeded. {message}"
+    code = 413
+
+
+class UnsupportedFileTypeError(BaseHTTPException):
+    error_code = "unsupported_file_type"
+    description = "File type not allowed."
+    code = 415
+
+
+class BlockedFileExtensionError(BaseHTTPException):
+    error_code = "file_extension_blocked"
+    description = "The file extension is blocked for security reasons."
+    code = 400
+
+
+class TooManyFilesError(BaseHTTPException):
+    error_code = "too_many_files"
+    description = "Only one file is allowed."
+    code = 400
+
+
+class NoFileUploadedError(BaseHTTPException):
+    error_code = "no_file_uploaded"
+    description = "Please upload your file."
+    code = 400

dify_1.11.1/api/controllers/common/fields.py

@@ -0,0 +1,62 @@
+from flask_restx import Api, Namespace, fields
+
+from libs.helper import AppIconUrlField
+
+parameters__system_parameters = {
+    "image_file_size_limit": fields.Integer,
+    "video_file_size_limit": fields.Integer,
+    "audio_file_size_limit": fields.Integer,
+    "file_size_limit": fields.Integer,
+    "workflow_file_upload_limit": fields.Integer,
+}
+
+
+def build_system_parameters_model(api_or_ns: Api | Namespace):
+    """Build the system parameters model for the API or Namespace."""
+    return api_or_ns.model("SystemParameters", parameters__system_parameters)
+
+
+parameters_fields = {
+    "opening_statement": fields.String,
+    "suggested_questions": fields.Raw,
+    "suggested_questions_after_answer": fields.Raw,
+    "speech_to_text": fields.Raw,
+    "text_to_speech": fields.Raw,
+    "retriever_resource": fields.Raw,
+    "annotation_reply": fields.Raw,
+    "more_like_this": fields.Raw,
+    "user_input_form": fields.Raw,
+    "sensitive_word_avoidance": fields.Raw,
+    "file_upload": fields.Raw,
+    "system_parameters": fields.Nested(parameters__system_parameters),
+}
+
+
+def build_parameters_model(api_or_ns: Api | Namespace):
+    """Build the parameters model for the API or Namespace."""
+    copied_fields = parameters_fields.copy()
+    copied_fields["system_parameters"] = fields.Nested(build_system_parameters_model(api_or_ns))
+    return api_or_ns.model("Parameters", copied_fields)
+
+
+site_fields = {
+    "title": fields.String,
+    "chat_color_theme": fields.String,
+    "chat_color_theme_inverted": fields.Boolean,
+    "icon_type": fields.String,
+    "icon": fields.String,
+    "icon_background": fields.String,
+    "icon_url": AppIconUrlField,
+    "description": fields.String,
+    "copyright": fields.String,
+    "privacy_policy": fields.String,
+    "custom_disclaimer": fields.String,
+    "default_language": fields.String,
+    "show_workflow_steps": fields.Boolean,
+    "use_icon_as_answer_icon": fields.Boolean,
+}
+
+
+def build_site_model(api_or_ns: Api | Namespace):
+    """Build the site model for the API or Namespace."""
+    return api_or_ns.model("Site", site_fields)

dify_1.11.1/api/controllers/common/helpers.py

@@ -0,0 +1,84 @@
+import contextlib
+import mimetypes
+import os
+import platform
+import re
+import urllib.parse
+import warnings
+from uuid import uuid4
+
+import httpx
+
+try:
+    import magic
+except ImportError:
+    if platform.system() == "Windows":
+        warnings.warn(
+            "To use python-magic guess MIMETYPE, you need to run `pip install python-magic-bin`", stacklevel=2
+        )
+    elif platform.system() == "Darwin":
+        warnings.warn("To use python-magic guess MIMETYPE, you need to run `brew install libmagic`", stacklevel=2)
+    elif platform.system() == "Linux":
+        warnings.warn(
+            "To use python-magic guess MIMETYPE, you need to run `sudo apt-get install libmagic1`", stacklevel=2
+        )
+    else:
+        warnings.warn("To use python-magic guess MIMETYPE, you need to install `libmagic`", stacklevel=2)
+    magic = None  # type: ignore[assignment]
+
+from pydantic import BaseModel
+
+
+class FileInfo(BaseModel):
+    filename: str
+    extension: str
+    mimetype: str
+    size: int
+
+
+def guess_file_info_from_response(response: httpx.Response):
+    url = str(response.url)
+    # Try to extract filename from URL
+    parsed_url = urllib.parse.urlparse(url)
+    url_path = parsed_url.path
+    filename = os.path.basename(url_path)
+
+    # If filename couldn't be extracted, use Content-Disposition header
+    if not filename:
+        content_disposition = response.headers.get("Content-Disposition")
+        if content_disposition:
+            filename_match = re.search(r'filename="?(.+)"?', content_disposition)
+            if filename_match:
+                filename = filename_match.group(1)
+
+    # If still no filename, generate a unique one
+    if not filename:
+        unique_name = str(uuid4())
+        filename = f"{unique_name}"
+
+    # Guess MIME type from filename first, then URL
+    mimetype, _ = mimetypes.guess_type(filename)
+    if mimetype is None:
+        mimetype, _ = mimetypes.guess_type(url)
+    if mimetype is None:
+        # If guessing fails, use Content-Type from response headers
+        mimetype = response.headers.get("Content-Type", "application/octet-stream")
+
+    # Use python-magic to guess MIME type if still unknown or generic
+    if mimetype == "application/octet-stream" and magic is not None:
+        with contextlib.suppress(magic.MagicException):
+            mimetype = magic.from_buffer(response.content[:1024], mime=True)
+
+    extension = os.path.splitext(filename)[1]
+
+    # Ensure filename has an extension
+    if not extension:
+        extension = mimetypes.guess_extension(mimetype) or ".bin"
+        filename = f"{filename}{extension}"
+
+    return FileInfo(
+        filename=filename,
+        extension=extension,
+        mimetype=mimetype,
+        size=int(response.headers.get("Content-Length", -1)),
+    )

dify_1.11.1/api/controllers/common/schema.py

@@ -0,0 +1,26 @@
+"""Helpers for registering Pydantic models with Flask-RESTX namespaces."""
+
+from flask_restx import Namespace
+from pydantic import BaseModel
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+def register_schema_model(namespace: Namespace, model: type[BaseModel]) -> None:
+    """Register a single BaseModel with a namespace for Swagger documentation."""
+
+    namespace.schema_model(model.__name__, model.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+def register_schema_models(namespace: Namespace, *models: type[BaseModel]) -> None:
+    """Register multiple BaseModels with a namespace."""
+
+    for model in models:
+        register_schema_model(namespace, model)
+
+
+__all__ = [
+    "DEFAULT_REF_TEMPLATE_SWAGGER_2_0",
+    "register_schema_model",
+    "register_schema_models",
+]

dify_1.11.1/api/controllers/console/__init__.py

@@ -0,0 +1,211 @@
+from importlib import import_module
+
+from flask import Blueprint
+from flask_restx import Namespace
+
+from libs.external_api import ExternalApi
+
+bp = Blueprint("console", __name__, url_prefix="/console/api")
+
+api = ExternalApi(
+    bp,
+    version="1.0",
+    title="Console API",
+    description="Console management APIs for app configuration, monitoring, and administration",
+)
+
+console_ns = Namespace("console", description="Console management API operations", path="/")
+
+RESOURCE_MODULES = (
+    "controllers.console.app.app_import",
+    "controllers.console.explore.audio",
+    "controllers.console.explore.completion",
+    "controllers.console.explore.conversation",
+    "controllers.console.explore.message",
+    "controllers.console.explore.workflow",
+    "controllers.console.files",
+    "controllers.console.remote_files",
+)
+
+for module_name in RESOURCE_MODULES:
+    import_module(module_name)
+
+# Ensure resource modules are imported so route decorators are evaluated.
+# Import other controllers
+from . import (
+    admin,
+    apikey,
+    extension,
+    feature,
+    init_validate,
+    ping,
+    setup,
+    spec,
+    version,
+)
+
+# Import app controllers
+from .app import (
+    advanced_prompt_template,
+    agent,
+    annotation,
+    app,
+    audio,
+    completion,
+    conversation,
+    conversation_variables,
+    generator,
+    mcp_server,
+    message,
+    model_config,
+    ops_trace,
+    site,
+    statistic,
+    workflow,
+    workflow_app_log,
+    workflow_draft_variable,
+    workflow_run,
+    workflow_statistic,
+    workflow_trigger,
+)
+
+# Import auth controllers
+from .auth import (
+    activate,
+    data_source_bearer_auth,
+    data_source_oauth,
+    email_register,
+    forgot_password,
+    login,
+    oauth,
+    oauth_server,
+)
+
+# Import billing controllers
+from .billing import billing, compliance
+
+# Import datasets controllers
+from .datasets import (
+    data_source,
+    datasets,
+    datasets_document,
+    datasets_segments,
+    external,
+    hit_testing,
+    metadata,
+    website,
+)
+from .datasets.rag_pipeline import (
+    datasource_auth,
+    datasource_content_preview,
+    rag_pipeline,
+    rag_pipeline_datasets,
+    rag_pipeline_draft_variable,
+    rag_pipeline_import,
+    rag_pipeline_workflow,
+)
+
+# Import explore controllers
+from .explore import (
+    installed_app,
+    parameter,
+    recommended_app,
+    saved_message,
+)
+
+# Import tag controllers
+from .tag import tags
+
+# Import workspace controllers
+from .workspace import (
+    account,
+    agent_providers,
+    endpoint,
+    load_balancing_config,
+    members,
+    model_providers,
+    models,
+    plugin,
+    tool_providers,
+    trigger_providers,
+    workspace,
+)
+
+api.add_namespace(console_ns)
+
+__all__ = [
+    "account",
+    "activate",
+    "admin",
+    "advanced_prompt_template",
+    "agent",
+    "agent_providers",
+    "annotation",
+    "api",
+    "apikey",
+    "app",
+    "audio",
+    "billing",
+    "bp",
+    "completion",
+    "compliance",
+    "console_ns",
+    "conversation",
+    "conversation_variables",
+    "data_source",
+    "data_source_bearer_auth",
+    "data_source_oauth",
+    "datasets",
+    "datasets_document",
+    "datasets_segments",
+    "datasource_auth",
+    "datasource_content_preview",
+    "email_register",
+    "endpoint",
+    "extension",
+    "external",
+    "feature",
+    "forgot_password",
+    "generator",
+    "hit_testing",
+    "init_validate",
+    "installed_app",
+    "load_balancing_config",
+    "login",
+    "mcp_server",
+    "members",
+    "message",
+    "metadata",
+    "model_config",
+    "model_providers",
+    "models",
+    "oauth",
+    "oauth_server",
+    "ops_trace",
+    "parameter",
+    "ping",
+    "plugin",
+    "rag_pipeline",
+    "rag_pipeline_datasets",
+    "rag_pipeline_draft_variable",
+    "rag_pipeline_import",
+    "rag_pipeline_workflow",
+    "recommended_app",
+    "saved_message",
+    "setup",
+    "site",
+    "spec",
+    "statistic",
+    "tags",
+    "tool_providers",
+    "trigger_providers",
+    "version",
+    "website",
+    "workflow",
+    "workflow_app_log",
+    "workflow_draft_variable",
+    "workflow_run",
+    "workflow_statistic",
+    "workflow_trigger",
+    "workspace",
+]

dify_1.11.1/api/controllers/console/admin.py

@@ -0,0 +1,173 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import ParamSpec, TypeVar
+
+from flask import request
+from flask_restx import Resource
+from pydantic import BaseModel, Field, field_validator
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import NotFound, Unauthorized
+
+P = ParamSpec("P")
+R = TypeVar("R")
+from configs import dify_config
+from constants.languages import supported_language
+from controllers.console import console_ns
+from controllers.console.wraps import only_edition_cloud
+from extensions.ext_database import db
+from libs.token import extract_access_token
+from models.model import App, InstalledApp, RecommendedApp
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class InsertExploreAppPayload(BaseModel):
+    app_id: str = Field(...)
+    desc: str | None = None
+    copyright: str | None = None
+    privacy_policy: str | None = None
+    custom_disclaimer: str | None = None
+    language: str = Field(...)
+    category: str = Field(...)
+    position: int = Field(...)
+
+    @field_validator("language")
+    @classmethod
+    def validate_language(cls, value: str) -> str:
+        return supported_language(value)
+
+
+console_ns.schema_model(
+    InsertExploreAppPayload.__name__,
+    InsertExploreAppPayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+
+def admin_required(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        if not dify_config.ADMIN_API_KEY:
+            raise Unauthorized("API key is invalid.")
+
+        auth_token = extract_access_token(request)
+        if not auth_token:
+            raise Unauthorized("Authorization header is missing.")
+        if auth_token != dify_config.ADMIN_API_KEY:
+            raise Unauthorized("API key is invalid.")
+
+        return view(*args, **kwargs)
+
+    return decorated
+
+
+@console_ns.route("/admin/insert-explore-apps")
+class InsertExploreAppListApi(Resource):
+    @console_ns.doc("insert_explore_app")
+    @console_ns.doc(description="Insert or update an app in the explore list")
+    @console_ns.expect(console_ns.models[InsertExploreAppPayload.__name__])
+    @console_ns.response(200, "App updated successfully")
+    @console_ns.response(201, "App inserted successfully")
+    @console_ns.response(404, "App not found")
+    @only_edition_cloud
+    @admin_required
+    def post(self):
+        payload = InsertExploreAppPayload.model_validate(console_ns.payload)
+
+        app = db.session.execute(select(App).where(App.id == payload.app_id)).scalar_one_or_none()
+        if not app:
+            raise NotFound(f"App '{payload.app_id}' is not found")
+
+        site = app.site
+        if not site:
+            desc = payload.desc or ""
+            copy_right = payload.copyright or ""
+            privacy_policy = payload.privacy_policy or ""
+            custom_disclaimer = payload.custom_disclaimer or ""
+        else:
+            desc = site.description or payload.desc or ""
+            copy_right = site.copyright or payload.copyright or ""
+            privacy_policy = site.privacy_policy or payload.privacy_policy or ""
+            custom_disclaimer = site.custom_disclaimer or payload.custom_disclaimer or ""
+
+        with Session(db.engine) as session:
+            recommended_app = session.execute(
+                select(RecommendedApp).where(RecommendedApp.app_id == payload.app_id)
+            ).scalar_one_or_none()
+
+            if not recommended_app:
+                recommended_app = RecommendedApp(
+                    app_id=app.id,
+                    description=desc,
+                    copyright=copy_right,
+                    privacy_policy=privacy_policy,
+                    custom_disclaimer=custom_disclaimer,
+                    language=payload.language,
+                    category=payload.category,
+                    position=payload.position,
+                )
+
+                db.session.add(recommended_app)
+
+                app.is_public = True
+                db.session.commit()
+
+                return {"result": "success"}, 201
+            else:
+                recommended_app.description = desc
+                recommended_app.copyright = copy_right
+                recommended_app.privacy_policy = privacy_policy
+                recommended_app.custom_disclaimer = custom_disclaimer
+                recommended_app.language = payload.language
+                recommended_app.category = payload.category
+                recommended_app.position = payload.position
+
+                app.is_public = True
+
+                db.session.commit()
+
+                return {"result": "success"}, 200
+
+
+@console_ns.route("/admin/insert-explore-apps/<uuid:app_id>")
+class InsertExploreAppApi(Resource):
+    @console_ns.doc("delete_explore_app")
+    @console_ns.doc(description="Remove an app from the explore list")
+    @console_ns.doc(params={"app_id": "Application ID to remove"})
+    @console_ns.response(204, "App removed successfully")
+    @only_edition_cloud
+    @admin_required
+    def delete(self, app_id):
+        with Session(db.engine) as session:
+            recommended_app = session.execute(
+                select(RecommendedApp).where(RecommendedApp.app_id == str(app_id))
+            ).scalar_one_or_none()
+
+        if not recommended_app:
+            return {"result": "success"}, 204
+
+        with Session(db.engine) as session:
+            app = session.execute(select(App).where(App.id == recommended_app.app_id)).scalar_one_or_none()
+
+        if app:
+            app.is_public = False
+
+        with Session(db.engine) as session:
+            installed_apps = (
+                session.execute(
+                    select(InstalledApp).where(
+                        InstalledApp.app_id == recommended_app.app_id,
+                        InstalledApp.tenant_id != InstalledApp.app_owner_tenant_id,
+                    )
+                )
+                .scalars()
+                .all()
+            )
+
+            for installed_app in installed_apps:
+                session.delete(installed_app)
+
+        db.session.delete(recommended_app)
+        db.session.commit()
+
+        return {"result": "success"}, 204

dify_1.11.1/api/controllers/console/apikey.py

@@ -0,0 +1,217 @@
+import flask_restx
+from flask_restx import Resource, fields, marshal_with
+from flask_restx._http import HTTPStatus
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import Forbidden
+
+from extensions.ext_database import db
+from libs.helper import TimestampField
+from libs.login import current_account_with_tenant, login_required
+from models.dataset import Dataset
+from models.model import ApiToken, App
+
+from . import console_ns
+from .wraps import account_initialization_required, edit_permission_required, setup_required
+
+api_key_fields = {
+    "id": fields.String,
+    "type": fields.String,
+    "token": fields.String,
+    "last_used_at": TimestampField,
+    "created_at": TimestampField,
+}
+
+api_key_list = {"data": fields.List(fields.Nested(api_key_fields), attribute="items")}
+
+api_key_item_model = console_ns.model("ApiKeyItem", api_key_fields)
+
+api_key_list_model = console_ns.model(
+    "ApiKeyList", {"data": fields.List(fields.Nested(api_key_item_model), attribute="items")}
+)
+
+
+def _get_resource(resource_id, tenant_id, resource_model):
+    if resource_model == App:
+        with Session(db.engine) as session:
+            resource = session.execute(
+                select(resource_model).filter_by(id=resource_id, tenant_id=tenant_id)
+            ).scalar_one_or_none()
+    else:
+        with Session(db.engine) as session:
+            resource = session.execute(
+                select(resource_model).filter_by(id=resource_id, tenant_id=tenant_id)
+            ).scalar_one_or_none()
+
+    if resource is None:
+        flask_restx.abort(HTTPStatus.NOT_FOUND, message=f"{resource_model.__name__} not found.")
+
+    return resource
+
+
+class BaseApiKeyListResource(Resource):
+    method_decorators = [account_initialization_required, login_required, setup_required]
+
+    resource_type: str | None = None
+    resource_model: type | None = None
+    resource_id_field: str | None = None
+    token_prefix: str | None = None
+    max_keys = 10
+
+    @marshal_with(api_key_list_model)
+    def get(self, resource_id):
+        assert self.resource_id_field is not None, "resource_id_field must be set"
+        resource_id = str(resource_id)
+        _, current_tenant_id = current_account_with_tenant()
+
+        _get_resource(resource_id, current_tenant_id, self.resource_model)
+        keys = db.session.scalars(
+            select(ApiToken).where(
+                ApiToken.type == self.resource_type, getattr(ApiToken, self.resource_id_field) == resource_id
+            )
+        ).all()
+        return {"items": keys}
+
+    @marshal_with(api_key_item_model)
+    @edit_permission_required
+    def post(self, resource_id):
+        assert self.resource_id_field is not None, "resource_id_field must be set"
+        resource_id = str(resource_id)
+        _, current_tenant_id = current_account_with_tenant()
+        _get_resource(resource_id, current_tenant_id, self.resource_model)
+        current_key_count = (
+            db.session.query(ApiToken)
+            .where(ApiToken.type == self.resource_type, getattr(ApiToken, self.resource_id_field) == resource_id)
+            .count()
+        )
+
+        if current_key_count >= self.max_keys:
+            flask_restx.abort(
+                HTTPStatus.BAD_REQUEST,
+                message=f"Cannot create more than {self.max_keys} API keys for this resource type.",
+                custom="max_keys_exceeded",
+            )
+
+        key = ApiToken.generate_api_key(self.token_prefix or "", 24)
+        api_token = ApiToken()
+        setattr(api_token, self.resource_id_field, resource_id)
+        api_token.tenant_id = current_tenant_id
+        api_token.token = key
+        api_token.type = self.resource_type
+        db.session.add(api_token)
+        db.session.commit()
+        return api_token, 201
+
+
+class BaseApiKeyResource(Resource):
+    method_decorators = [account_initialization_required, login_required, setup_required]
+
+    resource_type: str | None = None
+    resource_model: type | None = None
+    resource_id_field: str | None = None
+
+    def delete(self, resource_id: str, api_key_id: str):
+        assert self.resource_id_field is not None, "resource_id_field must be set"
+        current_user, current_tenant_id = current_account_with_tenant()
+        _get_resource(resource_id, current_tenant_id, self.resource_model)
+
+        if not current_user.is_admin_or_owner:
+            raise Forbidden()
+
+        key = (
+            db.session.query(ApiToken)
+            .where(
+                getattr(ApiToken, self.resource_id_field) == resource_id,
+                ApiToken.type == self.resource_type,
+                ApiToken.id == api_key_id,
+            )
+            .first()
+        )
+
+        if key is None:
+            flask_restx.abort(HTTPStatus.NOT_FOUND, message="API key not found")
+
+        db.session.query(ApiToken).where(ApiToken.id == api_key_id).delete()
+        db.session.commit()
+
+        return {"result": "success"}, 204
+
+
+@console_ns.route("/apps/<uuid:resource_id>/api-keys")
+class AppApiKeyListResource(BaseApiKeyListResource):
+    @console_ns.doc("get_app_api_keys")
+    @console_ns.doc(description="Get all API keys for an app")
+    @console_ns.doc(params={"resource_id": "App ID"})
+    @console_ns.response(200, "Success", api_key_list_model)
+    def get(self, resource_id):  # type: ignore
+        """Get all API keys for an app"""
+        return super().get(resource_id)
+
+    @console_ns.doc("create_app_api_key")
+    @console_ns.doc(description="Create a new API key for an app")
+    @console_ns.doc(params={"resource_id": "App ID"})
+    @console_ns.response(201, "API key created successfully", api_key_item_model)
+    @console_ns.response(400, "Maximum keys exceeded")
+    def post(self, resource_id):  # type: ignore
+        """Create a new API key for an app"""
+        return super().post(resource_id)
+
+    resource_type = "app"
+    resource_model = App
+    resource_id_field = "app_id"
+    token_prefix = "app-"
+
+
+@console_ns.route("/apps/<uuid:resource_id>/api-keys/<uuid:api_key_id>")
+class AppApiKeyResource(BaseApiKeyResource):
+    @console_ns.doc("delete_app_api_key")
+    @console_ns.doc(description="Delete an API key for an app")
+    @console_ns.doc(params={"resource_id": "App ID", "api_key_id": "API key ID"})
+    @console_ns.response(204, "API key deleted successfully")
+    def delete(self, resource_id, api_key_id):
+        """Delete an API key for an app"""
+        return super().delete(resource_id, api_key_id)
+
+    resource_type = "app"
+    resource_model = App
+    resource_id_field = "app_id"
+
+
+@console_ns.route("/datasets/<uuid:resource_id>/api-keys")
+class DatasetApiKeyListResource(BaseApiKeyListResource):
+    @console_ns.doc("get_dataset_api_keys")
+    @console_ns.doc(description="Get all API keys for a dataset")
+    @console_ns.doc(params={"resource_id": "Dataset ID"})
+    @console_ns.response(200, "Success", api_key_list_model)
+    def get(self, resource_id):  # type: ignore
+        """Get all API keys for a dataset"""
+        return super().get(resource_id)
+
+    @console_ns.doc("create_dataset_api_key")
+    @console_ns.doc(description="Create a new API key for a dataset")
+    @console_ns.doc(params={"resource_id": "Dataset ID"})
+    @console_ns.response(201, "API key created successfully", api_key_item_model)
+    @console_ns.response(400, "Maximum keys exceeded")
+    def post(self, resource_id):  # type: ignore
+        """Create a new API key for a dataset"""
+        return super().post(resource_id)
+
+    resource_type = "dataset"
+    resource_model = Dataset
+    resource_id_field = "dataset_id"
+    token_prefix = "ds-"
+
+
+@console_ns.route("/datasets/<uuid:resource_id>/api-keys/<uuid:api_key_id>")
+class DatasetApiKeyResource(BaseApiKeyResource):
+    @console_ns.doc("delete_dataset_api_key")
+    @console_ns.doc(description="Delete an API key for a dataset")
+    @console_ns.doc(params={"resource_id": "Dataset ID", "api_key_id": "API key ID"})
+    @console_ns.response(204, "API key deleted successfully")
+    def delete(self, resource_id, api_key_id):
+        """Delete an API key for a dataset"""
+        return super().delete(resource_id, api_key_id)
+
+    resource_type = "dataset"
+    resource_model = Dataset
+    resource_id_field = "dataset_id"

dify_1.11.1/api/controllers/console/app/advanced_prompt_template.py

@@ -0,0 +1,39 @@
+from flask import request
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field
+
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, setup_required
+from libs.login import login_required
+from services.advanced_prompt_template_service import AdvancedPromptTemplateService
+
+
+class AdvancedPromptTemplateQuery(BaseModel):
+    app_mode: str = Field(..., description="Application mode")
+    model_mode: str = Field(..., description="Model mode")
+    has_context: str = Field(default="true", description="Whether has context")
+    model_name: str = Field(..., description="Model name")
+
+
+console_ns.schema_model(
+    AdvancedPromptTemplateQuery.__name__,
+    AdvancedPromptTemplateQuery.model_json_schema(ref_template="#/definitions/{model}"),
+)
+
+
+@console_ns.route("/app/prompt-templates")
+class AdvancedPromptTemplateList(Resource):
+    @console_ns.doc("get_advanced_prompt_templates")
+    @console_ns.doc(description="Get advanced prompt templates based on app mode and model configuration")
+    @console_ns.expect(console_ns.models[AdvancedPromptTemplateQuery.__name__])
+    @console_ns.response(
+        200, "Prompt templates retrieved successfully", fields.List(fields.Raw(description="Prompt template data"))
+    )
+    @console_ns.response(400, "Invalid request parameters")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        args = AdvancedPromptTemplateQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        return AdvancedPromptTemplateService.get_prompt(args.model_dump())

dify_1.11.1/api/controllers/console/app/agent.py

@@ -0,0 +1,49 @@
+from flask import request
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field, field_validator
+
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, setup_required
+from libs.helper import uuid_value
+from libs.login import login_required
+from models.model import AppMode
+from services.agent_service import AgentService
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class AgentLogQuery(BaseModel):
+    message_id: str = Field(..., description="Message UUID")
+    conversation_id: str = Field(..., description="Conversation UUID")
+
+    @field_validator("message_id", "conversation_id")
+    @classmethod
+    def validate_uuid(cls, value: str) -> str:
+        return uuid_value(value)
+
+
+console_ns.schema_model(
+    AgentLogQuery.__name__, AgentLogQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+
+
+@console_ns.route("/apps/<uuid:app_id>/agent/logs")
+class AgentLogApi(Resource):
+    @console_ns.doc("get_agent_logs")
+    @console_ns.doc(description="Get agent execution logs for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[AgentLogQuery.__name__])
+    @console_ns.response(
+        200, "Agent logs retrieved successfully", fields.List(fields.Raw(description="Agent log entries"))
+    )
+    @console_ns.response(400, "Invalid request parameters")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.AGENT_CHAT])
+    def get(self, app_model):
+        """Get agent logs"""
+        args = AgentLogQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        return AgentService.get_agent_logs(app_model, args.conversation_id, args.message_id)

dify_1.11.1/api/controllers/console/app/annotation.py

@@ -0,0 +1,413 @@
+from typing import Any, Literal
+
+from flask import request
+from flask_restx import Resource, fields, marshal, marshal_with
+from pydantic import BaseModel, Field, field_validator
+
+from controllers.common.errors import NoFileUploadedError, TooManyFilesError
+from controllers.console import console_ns
+from controllers.console.wraps import (
+    account_initialization_required,
+    cloud_edition_billing_resource_check,
+    edit_permission_required,
+    setup_required,
+)
+from extensions.ext_redis import redis_client
+from fields.annotation_fields import (
+    annotation_fields,
+    annotation_hit_history_fields,
+    build_annotation_model,
+)
+from libs.helper import uuid_value
+from libs.login import login_required
+from services.annotation_service import AppAnnotationService
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class AnnotationReplyPayload(BaseModel):
+    score_threshold: float = Field(..., description="Score threshold for annotation matching")
+    embedding_provider_name: str = Field(..., description="Embedding provider name")
+    embedding_model_name: str = Field(..., description="Embedding model name")
+
+
+class AnnotationSettingUpdatePayload(BaseModel):
+    score_threshold: float = Field(..., description="Score threshold")
+
+
+class AnnotationListQuery(BaseModel):
+    page: int = Field(default=1, ge=1, description="Page number")
+    limit: int = Field(default=20, ge=1, description="Page size")
+    keyword: str = Field(default="", description="Search keyword")
+
+
+class CreateAnnotationPayload(BaseModel):
+    message_id: str | None = Field(default=None, description="Message ID")
+    question: str | None = Field(default=None, description="Question text")
+    answer: str | None = Field(default=None, description="Answer text")
+    content: str | None = Field(default=None, description="Content text")
+    annotation_reply: dict[str, Any] | None = Field(default=None, description="Annotation reply data")
+
+    @field_validator("message_id")
+    @classmethod
+    def validate_message_id(cls, value: str | None) -> str | None:
+        if value is None:
+            return value
+        return uuid_value(value)
+
+
+class UpdateAnnotationPayload(BaseModel):
+    question: str | None = None
+    answer: str | None = None
+    content: str | None = None
+    annotation_reply: dict[str, Any] | None = None
+
+
+class AnnotationReplyStatusQuery(BaseModel):
+    action: Literal["enable", "disable"]
+
+
+class AnnotationFilePayload(BaseModel):
+    message_id: str = Field(..., description="Message ID")
+
+    @field_validator("message_id")
+    @classmethod
+    def validate_message_id(cls, value: str) -> str:
+        return uuid_value(value)
+
+
+def reg(model: type[BaseModel]) -> None:
+    console_ns.schema_model(model.__name__, model.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(AnnotationReplyPayload)
+reg(AnnotationSettingUpdatePayload)
+reg(AnnotationListQuery)
+reg(CreateAnnotationPayload)
+reg(UpdateAnnotationPayload)
+reg(AnnotationReplyStatusQuery)
+reg(AnnotationFilePayload)
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotation-reply/<string:action>")
+class AnnotationReplyActionApi(Resource):
+    @console_ns.doc("annotation_reply_action")
+    @console_ns.doc(description="Enable or disable annotation reply for an app")
+    @console_ns.doc(params={"app_id": "Application ID", "action": "Action to perform (enable/disable)"})
+    @console_ns.expect(console_ns.models[AnnotationReplyPayload.__name__])
+    @console_ns.response(200, "Action completed successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("annotation")
+    @edit_permission_required
+    def post(self, app_id, action: Literal["enable", "disable"]):
+        app_id = str(app_id)
+        args = AnnotationReplyPayload.model_validate(console_ns.payload)
+        if action == "enable":
+            result = AppAnnotationService.enable_app_annotation(args.model_dump(), app_id)
+        elif action == "disable":
+            result = AppAnnotationService.disable_app_annotation(app_id)
+        return result, 200
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotation-setting")
+class AppAnnotationSettingDetailApi(Resource):
+    @console_ns.doc("get_annotation_setting")
+    @console_ns.doc(description="Get annotation settings for an app")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(200, "Annotation settings retrieved successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def get(self, app_id):
+        app_id = str(app_id)
+        result = AppAnnotationService.get_app_annotation_setting_by_app_id(app_id)
+        return result, 200
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotation-settings/<uuid:annotation_setting_id>")
+class AppAnnotationSettingUpdateApi(Resource):
+    @console_ns.doc("update_annotation_setting")
+    @console_ns.doc(description="Update annotation settings for an app")
+    @console_ns.doc(params={"app_id": "Application ID", "annotation_setting_id": "Annotation setting ID"})
+    @console_ns.expect(console_ns.models[AnnotationSettingUpdatePayload.__name__])
+    @console_ns.response(200, "Settings updated successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def post(self, app_id, annotation_setting_id):
+        app_id = str(app_id)
+        annotation_setting_id = str(annotation_setting_id)
+
+        args = AnnotationSettingUpdatePayload.model_validate(console_ns.payload)
+
+        result = AppAnnotationService.update_app_annotation_setting(app_id, annotation_setting_id, args.model_dump())
+        return result, 200
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotation-reply/<string:action>/status/<uuid:job_id>")
+class AnnotationReplyActionStatusApi(Resource):
+    @console_ns.doc("get_annotation_reply_action_status")
+    @console_ns.doc(description="Get status of annotation reply action job")
+    @console_ns.doc(params={"app_id": "Application ID", "job_id": "Job ID", "action": "Action type"})
+    @console_ns.response(200, "Job status retrieved successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("annotation")
+    @edit_permission_required
+    def get(self, app_id, job_id, action):
+        job_id = str(job_id)
+        app_annotation_job_key = f"{action}_app_annotation_job_{str(job_id)}"
+        cache_result = redis_client.get(app_annotation_job_key)
+        if cache_result is None:
+            raise ValueError("The job does not exist.")
+
+        job_status = cache_result.decode()
+        error_msg = ""
+        if job_status == "error":
+            app_annotation_error_key = f"{action}_app_annotation_error_{str(job_id)}"
+            error_msg = redis_client.get(app_annotation_error_key).decode()
+
+        return {"job_id": job_id, "job_status": job_status, "error_msg": error_msg}, 200
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotations")
+class AnnotationApi(Resource):
+    @console_ns.doc("list_annotations")
+    @console_ns.doc(description="Get annotations for an app with pagination")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[AnnotationListQuery.__name__])
+    @console_ns.response(200, "Annotations retrieved successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def get(self, app_id):
+        args = AnnotationListQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        page = args.page
+        limit = args.limit
+        keyword = args.keyword
+
+        app_id = str(app_id)
+        annotation_list, total = AppAnnotationService.get_annotation_list_by_app_id(app_id, page, limit, keyword)
+        response = {
+            "data": marshal(annotation_list, annotation_fields),
+            "has_more": len(annotation_list) == limit,
+            "limit": limit,
+            "total": total,
+            "page": page,
+        }
+        return response, 200
+
+    @console_ns.doc("create_annotation")
+    @console_ns.doc(description="Create a new annotation for an app")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[CreateAnnotationPayload.__name__])
+    @console_ns.response(201, "Annotation created successfully", build_annotation_model(console_ns))
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("annotation")
+    @marshal_with(annotation_fields)
+    @edit_permission_required
+    def post(self, app_id):
+        app_id = str(app_id)
+        args = CreateAnnotationPayload.model_validate(console_ns.payload)
+        data = args.model_dump(exclude_none=True)
+        annotation = AppAnnotationService.up_insert_app_annotation_from_message(data, app_id)
+        return annotation
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def delete(self, app_id):
+        app_id = str(app_id)
+
+        # Use request.args.getlist to get annotation_ids array directly
+        annotation_ids = request.args.getlist("annotation_id")
+
+        # If annotation_ids are provided, handle batch deletion
+        if annotation_ids:
+            # Check if any annotation_ids contain empty strings or invalid values
+            if not all(annotation_id.strip() for annotation_id in annotation_ids if annotation_id):
+                return {
+                    "code": "bad_request",
+                    "message": "annotation_ids are required if the parameter is provided.",
+                }, 400
+
+            result = AppAnnotationService.delete_app_annotations_in_batch(app_id, annotation_ids)
+            return result, 204
+        # If no annotation_ids are provided, handle clearing all annotations
+        else:
+            AppAnnotationService.clear_all_annotations(app_id)
+            return {"result": "success"}, 204
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotations/export")
+class AnnotationExportApi(Resource):
+    @console_ns.doc("export_annotations")
+    @console_ns.doc(description="Export all annotations for an app")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(
+        200,
+        "Annotations exported successfully",
+        console_ns.model("AnnotationList", {"data": fields.List(fields.Nested(build_annotation_model(console_ns)))}),
+    )
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def get(self, app_id):
+        app_id = str(app_id)
+        annotation_list = AppAnnotationService.export_annotation_list_by_app_id(app_id)
+        response = {"data": marshal(annotation_list, annotation_fields)}
+        return response, 200
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotations/<uuid:annotation_id>")
+class AnnotationUpdateDeleteApi(Resource):
+    @console_ns.doc("update_delete_annotation")
+    @console_ns.doc(description="Update or delete an annotation")
+    @console_ns.doc(params={"app_id": "Application ID", "annotation_id": "Annotation ID"})
+    @console_ns.response(200, "Annotation updated successfully", build_annotation_model(console_ns))
+    @console_ns.response(204, "Annotation deleted successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.expect(console_ns.models[UpdateAnnotationPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("annotation")
+    @edit_permission_required
+    @marshal_with(annotation_fields)
+    def post(self, app_id, annotation_id):
+        app_id = str(app_id)
+        annotation_id = str(annotation_id)
+        args = UpdateAnnotationPayload.model_validate(console_ns.payload)
+        annotation = AppAnnotationService.update_app_annotation_directly(
+            args.model_dump(exclude_none=True), app_id, annotation_id
+        )
+        return annotation
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def delete(self, app_id, annotation_id):
+        app_id = str(app_id)
+        annotation_id = str(annotation_id)
+        AppAnnotationService.delete_app_annotation(app_id, annotation_id)
+        return {"result": "success"}, 204
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotations/batch-import")
+class AnnotationBatchImportApi(Resource):
+    @console_ns.doc("batch_import_annotations")
+    @console_ns.doc(description="Batch import annotations from CSV file")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(200, "Batch import started successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.response(400, "No file uploaded or too many files")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("annotation")
+    @edit_permission_required
+    def post(self, app_id):
+        app_id = str(app_id)
+        # 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"]
+        # check file type
+        if not file.filename or not file.filename.lower().endswith(".csv"):
+            raise ValueError("Invalid file type. Only CSV files are allowed")
+        return AppAnnotationService.batch_import_app_annotations(app_id, file)
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotations/batch-import-status/<uuid:job_id>")
+class AnnotationBatchImportStatusApi(Resource):
+    @console_ns.doc("get_batch_import_status")
+    @console_ns.doc(description="Get status of batch import job")
+    @console_ns.doc(params={"app_id": "Application ID", "job_id": "Job ID"})
+    @console_ns.response(200, "Job status retrieved successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("annotation")
+    @edit_permission_required
+    def get(self, app_id, job_id):
+        job_id = str(job_id)
+        indexing_cache_key = f"app_annotation_batch_import_{str(job_id)}"
+        cache_result = redis_client.get(indexing_cache_key)
+        if cache_result is None:
+            raise ValueError("The job does not exist.")
+        job_status = cache_result.decode()
+        error_msg = ""
+        if job_status == "error":
+            indexing_error_msg_key = f"app_annotation_batch_import_error_msg_{str(job_id)}"
+            error_msg = redis_client.get(indexing_error_msg_key).decode()
+
+        return {"job_id": job_id, "job_status": job_status, "error_msg": error_msg}, 200
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotations/<uuid:annotation_id>/hit-histories")
+class AnnotationHitHistoryListApi(Resource):
+    @console_ns.doc("list_annotation_hit_histories")
+    @console_ns.doc(description="Get hit histories for an annotation")
+    @console_ns.doc(params={"app_id": "Application ID", "annotation_id": "Annotation ID"})
+    @console_ns.expect(
+        console_ns.parser()
+        .add_argument("page", type=int, location="args", default=1, help="Page number")
+        .add_argument("limit", type=int, location="args", default=20, help="Page size")
+    )
+    @console_ns.response(
+        200,
+        "Hit histories retrieved successfully",
+        console_ns.model(
+            "AnnotationHitHistoryList",
+            {
+                "data": fields.List(
+                    fields.Nested(console_ns.model("AnnotationHitHistoryItem", annotation_hit_history_fields))
+                )
+            },
+        ),
+    )
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def get(self, app_id, annotation_id):
+        page = request.args.get("page", default=1, type=int)
+        limit = request.args.get("limit", default=20, type=int)
+        app_id = str(app_id)
+        annotation_id = str(annotation_id)
+        annotation_hit_history_list, total = AppAnnotationService.get_annotation_hit_histories(
+            app_id, annotation_id, page, limit
+        )
+        response = {
+            "data": marshal(annotation_hit_history_list, annotation_hit_history_fields),
+            "has_more": len(annotation_hit_history_list) == limit,
+            "limit": limit,
+            "total": total,
+            "page": page,
+        }
+        return response

dify_1.11.1/api/controllers/console/app/app.py

@@ -0,0 +1,620 @@
+import uuid
+from typing import Literal
+
+from flask import request
+from flask_restx import Resource, fields, marshal, marshal_with
+from pydantic import BaseModel, Field, field_validator
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import BadRequest
+
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import (
+    account_initialization_required,
+    cloud_edition_billing_resource_check,
+    edit_permission_required,
+    enterprise_license_required,
+    is_admin_or_owner_required,
+    setup_required,
+)
+from core.ops.ops_trace_manager import OpsTraceManager
+from core.workflow.enums import NodeType
+from extensions.ext_database import db
+from fields.app_fields import (
+    deleted_tool_fields,
+    model_config_fields,
+    model_config_partial_fields,
+    site_fields,
+    tag_fields,
+)
+from fields.workflow_fields import workflow_partial_fields as _workflow_partial_fields_dict
+from libs.helper import AppIconUrlField, TimestampField
+from libs.login import current_account_with_tenant, login_required
+from models import App, Workflow
+from services.app_dsl_service import AppDslService, ImportMode
+from services.app_service import AppService
+from services.enterprise.enterprise_service import EnterpriseService
+from services.feature_service import FeatureService
+
+ALLOW_CREATE_APP_MODES = ["chat", "agent-chat", "advanced-chat", "workflow", "completion"]
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class AppListQuery(BaseModel):
+    page: int = Field(default=1, ge=1, le=99999, description="Page number (1-99999)")
+    limit: int = Field(default=20, ge=1, le=100, description="Page size (1-100)")
+    mode: Literal["completion", "chat", "advanced-chat", "workflow", "agent-chat", "channel", "all"] = Field(
+        default="all", description="App mode filter"
+    )
+    name: str | None = Field(default=None, description="Filter by app name")
+    tag_ids: list[str] | None = Field(default=None, description="Comma-separated tag IDs")
+    is_created_by_me: bool | None = Field(default=None, description="Filter by creator")
+
+    @field_validator("tag_ids", mode="before")
+    @classmethod
+    def validate_tag_ids(cls, value: str | list[str] | None) -> list[str] | None:
+        if not value:
+            return None
+
+        if isinstance(value, str):
+            items = [item.strip() for item in value.split(",") if item.strip()]
+        elif isinstance(value, list):
+            items = [str(item).strip() for item in value if item and str(item).strip()]
+        else:
+            raise TypeError("Unsupported tag_ids type.")
+
+        if not items:
+            return None
+
+        try:
+            return [str(uuid.UUID(item)) for item in items]
+        except ValueError as exc:
+            raise ValueError("Invalid UUID format in tag_ids.") from exc
+
+
+class CreateAppPayload(BaseModel):
+    name: str = Field(..., min_length=1, description="App name")
+    description: str | None = Field(default=None, description="App description (max 400 chars)", max_length=400)
+    mode: Literal["chat", "agent-chat", "advanced-chat", "workflow", "completion"] = Field(..., description="App mode")
+    icon_type: str | None = Field(default=None, description="Icon type")
+    icon: str | None = Field(default=None, description="Icon")
+    icon_background: str | None = Field(default=None, description="Icon background color")
+
+
+class UpdateAppPayload(BaseModel):
+    name: str = Field(..., min_length=1, description="App name")
+    description: str | None = Field(default=None, description="App description (max 400 chars)", max_length=400)
+    icon_type: str | None = Field(default=None, description="Icon type")
+    icon: str | None = Field(default=None, description="Icon")
+    icon_background: str | None = Field(default=None, description="Icon background color")
+    use_icon_as_answer_icon: bool | None = Field(default=None, description="Use icon as answer icon")
+    max_active_requests: int | None = Field(default=None, description="Maximum active requests")
+
+
+class CopyAppPayload(BaseModel):
+    name: str | None = Field(default=None, description="Name for the copied app")
+    description: str | None = Field(default=None, description="Description for the copied app", max_length=400)
+    icon_type: str | None = Field(default=None, description="Icon type")
+    icon: str | None = Field(default=None, description="Icon")
+    icon_background: str | None = Field(default=None, description="Icon background color")
+
+
+class AppExportQuery(BaseModel):
+    include_secret: bool = Field(default=False, description="Include secrets in export")
+    workflow_id: str | None = Field(default=None, description="Specific workflow ID to export")
+
+
+class AppNamePayload(BaseModel):
+    name: str = Field(..., min_length=1, description="Name to check")
+
+
+class AppIconPayload(BaseModel):
+    icon: str | None = Field(default=None, description="Icon data")
+    icon_background: str | None = Field(default=None, description="Icon background color")
+
+
+class AppSiteStatusPayload(BaseModel):
+    enable_site: bool = Field(..., description="Enable or disable site")
+
+
+class AppApiStatusPayload(BaseModel):
+    enable_api: bool = Field(..., description="Enable or disable API")
+
+
+class AppTracePayload(BaseModel):
+    enabled: bool = Field(..., description="Enable or disable tracing")
+    tracing_provider: str | None = Field(default=None, description="Tracing provider")
+
+    @field_validator("tracing_provider")
+    @classmethod
+    def validate_tracing_provider(cls, value: str | None, info) -> str | None:
+        if info.data.get("enabled") and not value:
+            raise ValueError("tracing_provider is required when enabled is True")
+        return value
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(AppListQuery)
+reg(CreateAppPayload)
+reg(UpdateAppPayload)
+reg(CopyAppPayload)
+reg(AppExportQuery)
+reg(AppNamePayload)
+reg(AppIconPayload)
+reg(AppSiteStatusPayload)
+reg(AppApiStatusPayload)
+reg(AppTracePayload)
+
+# Register models for flask_restx to avoid dict type issues in Swagger
+# Register base models first
+tag_model = console_ns.model("Tag", tag_fields)
+
+workflow_partial_model = console_ns.model("WorkflowPartial", _workflow_partial_fields_dict)
+
+model_config_model = console_ns.model("ModelConfig", model_config_fields)
+
+model_config_partial_model = console_ns.model("ModelConfigPartial", model_config_partial_fields)
+
+deleted_tool_model = console_ns.model("DeletedTool", deleted_tool_fields)
+
+site_model = console_ns.model("Site", site_fields)
+
+app_partial_model = console_ns.model(
+    "AppPartial",
+    {
+        "id": fields.String,
+        "name": fields.String,
+        "max_active_requests": fields.Raw(),
+        "description": fields.String(attribute="desc_or_prompt"),
+        "mode": fields.String(attribute="mode_compatible_with_agent"),
+        "icon_type": fields.String,
+        "icon": fields.String,
+        "icon_background": fields.String,
+        "icon_url": AppIconUrlField,
+        "model_config": fields.Nested(model_config_partial_model, attribute="app_model_config", allow_null=True),
+        "workflow": fields.Nested(workflow_partial_model, allow_null=True),
+        "use_icon_as_answer_icon": fields.Boolean,
+        "created_by": fields.String,
+        "created_at": TimestampField,
+        "updated_by": fields.String,
+        "updated_at": TimestampField,
+        "tags": fields.List(fields.Nested(tag_model)),
+        "access_mode": fields.String,
+        "create_user_name": fields.String,
+        "author_name": fields.String,
+        "has_draft_trigger": fields.Boolean,
+    },
+)
+
+app_detail_model = console_ns.model(
+    "AppDetail",
+    {
+        "id": fields.String,
+        "name": fields.String,
+        "description": fields.String,
+        "mode": fields.String(attribute="mode_compatible_with_agent"),
+        "icon": fields.String,
+        "icon_background": fields.String,
+        "enable_site": fields.Boolean,
+        "enable_api": fields.Boolean,
+        "model_config": fields.Nested(model_config_model, attribute="app_model_config", allow_null=True),
+        "workflow": fields.Nested(workflow_partial_model, allow_null=True),
+        "tracing": fields.Raw,
+        "use_icon_as_answer_icon": fields.Boolean,
+        "created_by": fields.String,
+        "created_at": TimestampField,
+        "updated_by": fields.String,
+        "updated_at": TimestampField,
+        "access_mode": fields.String,
+        "tags": fields.List(fields.Nested(tag_model)),
+    },
+)
+
+app_detail_with_site_model = console_ns.model(
+    "AppDetailWithSite",
+    {
+        "id": fields.String,
+        "name": fields.String,
+        "description": fields.String,
+        "mode": fields.String(attribute="mode_compatible_with_agent"),
+        "icon_type": fields.String,
+        "icon": fields.String,
+        "icon_background": fields.String,
+        "icon_url": AppIconUrlField,
+        "enable_site": fields.Boolean,
+        "enable_api": fields.Boolean,
+        "model_config": fields.Nested(model_config_model, attribute="app_model_config", allow_null=True),
+        "workflow": fields.Nested(workflow_partial_model, allow_null=True),
+        "api_base_url": fields.String,
+        "use_icon_as_answer_icon": fields.Boolean,
+        "max_active_requests": fields.Integer,
+        "created_by": fields.String,
+        "created_at": TimestampField,
+        "updated_by": fields.String,
+        "updated_at": TimestampField,
+        "deleted_tools": fields.List(fields.Nested(deleted_tool_model)),
+        "access_mode": fields.String,
+        "tags": fields.List(fields.Nested(tag_model)),
+        "site": fields.Nested(site_model),
+    },
+)
+
+app_pagination_model = console_ns.model(
+    "AppPagination",
+    {
+        "page": fields.Integer,
+        "limit": fields.Integer(attribute="per_page"),
+        "total": fields.Integer,
+        "has_more": fields.Boolean(attribute="has_next"),
+        "data": fields.List(fields.Nested(app_partial_model), attribute="items"),
+    },
+)
+
+
+@console_ns.route("/apps")
+class AppListApi(Resource):
+    @console_ns.doc("list_apps")
+    @console_ns.doc(description="Get list of applications with pagination and filtering")
+    @console_ns.expect(console_ns.models[AppListQuery.__name__])
+    @console_ns.response(200, "Success", app_pagination_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def get(self):
+        """Get app list"""
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        args = AppListQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        args_dict = args.model_dump()
+
+        # get app list
+        app_service = AppService()
+        app_pagination = app_service.get_paginate_apps(current_user.id, current_tenant_id, args_dict)
+        if not app_pagination:
+            return {"data": [], "total": 0, "page": 1, "limit": 20, "has_more": False}
+
+        if FeatureService.get_system_features().webapp_auth.enabled:
+            app_ids = [str(app.id) for app in app_pagination.items]
+            res = EnterpriseService.WebAppAuth.batch_get_app_access_mode_by_id(app_ids=app_ids)
+            if len(res) != len(app_ids):
+                raise BadRequest("Invalid app id in webapp auth")
+
+            for app in app_pagination.items:
+                if str(app.id) in res:
+                    app.access_mode = res[str(app.id)].access_mode
+
+        workflow_capable_app_ids = [
+            str(app.id) for app in app_pagination.items if app.mode in {"workflow", "advanced-chat"}
+        ]
+        draft_trigger_app_ids: set[str] = set()
+        if workflow_capable_app_ids:
+            draft_workflows = (
+                db.session.execute(
+                    select(Workflow).where(
+                        Workflow.version == Workflow.VERSION_DRAFT,
+                        Workflow.app_id.in_(workflow_capable_app_ids),
+                    )
+                )
+                .scalars()
+                .all()
+            )
+            trigger_node_types = {
+                NodeType.TRIGGER_WEBHOOK,
+                NodeType.TRIGGER_SCHEDULE,
+                NodeType.TRIGGER_PLUGIN,
+            }
+            for workflow in draft_workflows:
+                try:
+                    for _, node_data in workflow.walk_nodes():
+                        if node_data.get("type") in trigger_node_types:
+                            draft_trigger_app_ids.add(str(workflow.app_id))
+                            break
+                except Exception:
+                    continue
+
+        for app in app_pagination.items:
+            app.has_draft_trigger = str(app.id) in draft_trigger_app_ids
+
+        return marshal(app_pagination, app_pagination_model), 200
+
+    @console_ns.doc("create_app")
+    @console_ns.doc(description="Create a new application")
+    @console_ns.expect(console_ns.models[CreateAppPayload.__name__])
+    @console_ns.response(201, "App created successfully", app_detail_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.response(400, "Invalid request parameters")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(app_detail_model)
+    @cloud_edition_billing_resource_check("apps")
+    @edit_permission_required
+    def post(self):
+        """Create app"""
+        current_user, current_tenant_id = current_account_with_tenant()
+        args = CreateAppPayload.model_validate(console_ns.payload)
+
+        app_service = AppService()
+        app = app_service.create_app(current_tenant_id, args.model_dump(), current_user)
+
+        return app, 201
+
+
+@console_ns.route("/apps/<uuid:app_id>")
+class AppApi(Resource):
+    @console_ns.doc("get_app_detail")
+    @console_ns.doc(description="Get application details")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(200, "Success", app_detail_with_site_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    @get_app_model
+    @marshal_with(app_detail_with_site_model)
+    def get(self, app_model):
+        """Get app detail"""
+        app_service = AppService()
+
+        app_model = app_service.get_app(app_model)
+
+        if FeatureService.get_system_features().webapp_auth.enabled:
+            app_setting = EnterpriseService.WebAppAuth.get_app_access_mode_by_id(app_id=str(app_model.id))
+            app_model.access_mode = app_setting.access_mode
+
+        return app_model
+
+    @console_ns.doc("update_app")
+    @console_ns.doc(description="Update application details")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[UpdateAppPayload.__name__])
+    @console_ns.response(200, "App updated successfully", app_detail_with_site_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.response(400, "Invalid request parameters")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model
+    @edit_permission_required
+    @marshal_with(app_detail_with_site_model)
+    def put(self, app_model):
+        """Update app"""
+        args = UpdateAppPayload.model_validate(console_ns.payload)
+
+        app_service = AppService()
+
+        args_dict: AppService.ArgsDict = {
+            "name": args.name,
+            "description": args.description or "",
+            "icon_type": args.icon_type or "",
+            "icon": args.icon or "",
+            "icon_background": args.icon_background or "",
+            "use_icon_as_answer_icon": args.use_icon_as_answer_icon or False,
+            "max_active_requests": args.max_active_requests or 0,
+        }
+        app_model = app_service.update_app(app_model, args_dict)
+
+        return app_model
+
+    @console_ns.doc("delete_app")
+    @console_ns.doc(description="Delete application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(204, "App deleted successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def delete(self, app_model):
+        """Delete app"""
+        app_service = AppService()
+        app_service.delete_app(app_model)
+
+        return {"result": "success"}, 204
+
+
+@console_ns.route("/apps/<uuid:app_id>/copy")
+class AppCopyApi(Resource):
+    @console_ns.doc("copy_app")
+    @console_ns.doc(description="Create a copy of an existing application")
+    @console_ns.doc(params={"app_id": "Application ID to copy"})
+    @console_ns.expect(console_ns.models[CopyAppPayload.__name__])
+    @console_ns.response(201, "App copied successfully", app_detail_with_site_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model
+    @edit_permission_required
+    @marshal_with(app_detail_with_site_model)
+    def post(self, app_model):
+        """Copy app"""
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+
+        args = CopyAppPayload.model_validate(console_ns.payload or {})
+
+        with Session(db.engine) as session:
+            import_service = AppDslService(session)
+            yaml_content = import_service.export_dsl(app_model=app_model, include_secret=True)
+            result = import_service.import_app(
+                account=current_user,
+                import_mode=ImportMode.YAML_CONTENT,
+                yaml_content=yaml_content,
+                name=args.name,
+                description=args.description,
+                icon_type=args.icon_type,
+                icon=args.icon,
+                icon_background=args.icon_background,
+            )
+            session.commit()
+
+            stmt = select(App).where(App.id == result.app_id)
+            app = session.scalar(stmt)
+
+        return app, 201
+
+
+@console_ns.route("/apps/<uuid:app_id>/export")
+class AppExportApi(Resource):
+    @console_ns.doc("export_app")
+    @console_ns.doc(description="Export application configuration as DSL")
+    @console_ns.doc(params={"app_id": "Application ID to export"})
+    @console_ns.expect(console_ns.models[AppExportQuery.__name__])
+    @console_ns.response(
+        200,
+        "App exported successfully",
+        console_ns.model("AppExportResponse", {"data": fields.String(description="DSL export data")}),
+    )
+    @console_ns.response(403, "Insufficient permissions")
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def get(self, app_model):
+        """Export app"""
+        args = AppExportQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        return {
+            "data": AppDslService.export_dsl(
+                app_model=app_model,
+                include_secret=args.include_secret,
+                workflow_id=args.workflow_id,
+            )
+        }
+
+
+@console_ns.route("/apps/<uuid:app_id>/name")
+class AppNameApi(Resource):
+    @console_ns.doc("check_app_name")
+    @console_ns.doc(description="Check if app name is available")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[AppNamePayload.__name__])
+    @console_ns.response(200, "Name availability checked")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model
+    @marshal_with(app_detail_model)
+    @edit_permission_required
+    def post(self, app_model):
+        args = AppNamePayload.model_validate(console_ns.payload)
+
+        app_service = AppService()
+        app_model = app_service.update_app_name(app_model, args.name)
+
+        return app_model
+
+
+@console_ns.route("/apps/<uuid:app_id>/icon")
+class AppIconApi(Resource):
+    @console_ns.doc("update_app_icon")
+    @console_ns.doc(description="Update application icon")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[AppIconPayload.__name__])
+    @console_ns.response(200, "Icon updated successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model
+    @marshal_with(app_detail_model)
+    @edit_permission_required
+    def post(self, app_model):
+        args = AppIconPayload.model_validate(console_ns.payload or {})
+
+        app_service = AppService()
+        app_model = app_service.update_app_icon(app_model, args.icon or "", args.icon_background or "")
+
+        return app_model
+
+
+@console_ns.route("/apps/<uuid:app_id>/site-enable")
+class AppSiteStatus(Resource):
+    @console_ns.doc("update_app_site_status")
+    @console_ns.doc(description="Enable or disable app site")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[AppSiteStatusPayload.__name__])
+    @console_ns.response(200, "Site status updated successfully", app_detail_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model
+    @marshal_with(app_detail_model)
+    @edit_permission_required
+    def post(self, app_model):
+        args = AppSiteStatusPayload.model_validate(console_ns.payload)
+
+        app_service = AppService()
+        app_model = app_service.update_app_site_status(app_model, args.enable_site)
+
+        return app_model
+
+
+@console_ns.route("/apps/<uuid:app_id>/api-enable")
+class AppApiStatus(Resource):
+    @console_ns.doc("update_app_api_status")
+    @console_ns.doc(description="Enable or disable app API")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[AppApiStatusPayload.__name__])
+    @console_ns.response(200, "API status updated successfully", app_detail_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    @get_app_model
+    @marshal_with(app_detail_model)
+    def post(self, app_model):
+        args = AppApiStatusPayload.model_validate(console_ns.payload)
+
+        app_service = AppService()
+        app_model = app_service.update_app_api_status(app_model, args.enable_api)
+
+        return app_model
+
+
+@console_ns.route("/apps/<uuid:app_id>/trace")
+class AppTraceApi(Resource):
+    @console_ns.doc("get_app_trace")
+    @console_ns.doc(description="Get app tracing configuration")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(200, "Trace configuration retrieved successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_id):
+        """Get app trace"""
+        app_trace_config = OpsTraceManager.get_app_tracing_config(app_id=app_id)
+
+        return app_trace_config
+
+    @console_ns.doc("update_app_trace")
+    @console_ns.doc(description="Update app tracing configuration")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[AppTracePayload.__name__])
+    @console_ns.response(200, "Trace configuration updated successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def post(self, app_id):
+        # add app trace
+        args = AppTracePayload.model_validate(console_ns.payload)
+
+        OpsTraceManager.update_app_tracing_config(
+            app_id=app_id,
+            enabled=args.enabled,
+            tracing_provider=args.tracing_provider,
+        )
+
+        return {"result": "success"}

dify_1.11.1/api/controllers/console/app/app_import.py

@@ -0,0 +1,141 @@
+from flask_restx import Resource, fields, marshal_with
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import (
+    account_initialization_required,
+    cloud_edition_billing_resource_check,
+    edit_permission_required,
+    setup_required,
+)
+from extensions.ext_database import db
+from fields.app_fields import (
+    app_import_check_dependencies_fields,
+    app_import_fields,
+    leaked_dependency_fields,
+)
+from libs.login import current_account_with_tenant, login_required
+from models.model import App
+from services.app_dsl_service import AppDslService, ImportStatus
+from services.enterprise.enterprise_service import EnterpriseService
+from services.feature_service import FeatureService
+
+from .. import console_ns
+
+# Register models for flask_restx to avoid dict type issues in Swagger
+# Register base model first
+leaked_dependency_model = console_ns.model("LeakedDependency", leaked_dependency_fields)
+
+app_import_model = console_ns.model("AppImport", app_import_fields)
+
+# For nested models, need to replace nested dict with registered model
+app_import_check_dependencies_fields_copy = app_import_check_dependencies_fields.copy()
+app_import_check_dependencies_fields_copy["leaked_dependencies"] = fields.List(fields.Nested(leaked_dependency_model))
+app_import_check_dependencies_model = console_ns.model(
+    "AppImportCheckDependencies", app_import_check_dependencies_fields_copy
+)
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class AppImportPayload(BaseModel):
+    mode: str = Field(..., description="Import mode")
+    yaml_content: str | None = None
+    yaml_url: str | None = None
+    name: str | None = None
+    description: str | None = None
+    icon_type: str | None = None
+    icon: str | None = None
+    icon_background: str | None = None
+    app_id: str | None = None
+
+
+console_ns.schema_model(
+    AppImportPayload.__name__, AppImportPayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+
+
+@console_ns.route("/apps/imports")
+class AppImportApi(Resource):
+    @console_ns.expect(console_ns.models[AppImportPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(app_import_model)
+    @cloud_edition_billing_resource_check("apps")
+    @edit_permission_required
+    def post(self):
+        # Check user role first
+        current_user, _ = current_account_with_tenant()
+        args = AppImportPayload.model_validate(console_ns.payload)
+
+        # Create service with session
+        with Session(db.engine) as session:
+            import_service = AppDslService(session)
+            # Import app
+            account = current_user
+            result = import_service.import_app(
+                account=account,
+                import_mode=args.mode,
+                yaml_content=args.yaml_content,
+                yaml_url=args.yaml_url,
+                name=args.name,
+                description=args.description,
+                icon_type=args.icon_type,
+                icon=args.icon,
+                icon_background=args.icon_background,
+                app_id=args.app_id,
+            )
+            session.commit()
+        if result.app_id and FeatureService.get_system_features().webapp_auth.enabled:
+            # update web app setting as private
+            EnterpriseService.WebAppAuth.update_app_access_mode(result.app_id, "private")
+        # Return appropriate status code based on result
+        status = result.status
+        if status == ImportStatus.FAILED:
+            return result.model_dump(mode="json"), 400
+        elif status == ImportStatus.PENDING:
+            return result.model_dump(mode="json"), 202
+        return result.model_dump(mode="json"), 200
+
+
+@console_ns.route("/apps/imports/<string:import_id>/confirm")
+class AppImportConfirmApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(app_import_model)
+    @edit_permission_required
+    def post(self, import_id):
+        # Check user role first
+        current_user, _ = current_account_with_tenant()
+
+        # Create service with session
+        with Session(db.engine) as session:
+            import_service = AppDslService(session)
+            # Confirm import
+            account = current_user
+            result = import_service.confirm_import(import_id=import_id, account=account)
+            session.commit()
+
+        # Return appropriate status code based on result
+        if result.status == ImportStatus.FAILED:
+            return result.model_dump(mode="json"), 400
+        return result.model_dump(mode="json"), 200
+
+
+@console_ns.route("/apps/imports/<string:app_id>/check-dependencies")
+class AppImportCheckDependenciesApi(Resource):
+    @setup_required
+    @login_required
+    @get_app_model
+    @account_initialization_required
+    @marshal_with(app_import_check_dependencies_model)
+    @edit_permission_required
+    def get(self, app_model: App):
+        with Session(db.engine) as session:
+            import_service = AppDslService(session)
+            result = import_service.check_dependencies(app_model=app_model)
+
+        return result.model_dump(mode="json"), 200

dify_1.11.1/api/controllers/console/app/audio.py

@@ -0,0 +1,208 @@
+import logging
+
+from flask import request
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field
+from werkzeug.exceptions import InternalServerError
+
+import services
+from controllers.console import console_ns
+from controllers.console.app.error import (
+    AppUnavailableError,
+    AudioTooLargeError,
+    CompletionRequestError,
+    NoAudioUploadedError,
+    ProviderModelCurrentlyNotSupportError,
+    ProviderNotInitializeError,
+    ProviderNotSupportSpeechToTextError,
+    ProviderQuotaExceededError,
+    UnsupportedAudioTypeError,
+)
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, setup_required
+from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
+from core.model_runtime.errors.invoke import InvokeError
+from libs.login import login_required
+from models import App, AppMode
+from services.audio_service import AudioService
+from services.errors.audio import (
+    AudioTooLargeServiceError,
+    NoAudioUploadedServiceError,
+    ProviderNotSupportSpeechToTextServiceError,
+    UnsupportedAudioTypeServiceError,
+)
+
+logger = logging.getLogger(__name__)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class TextToSpeechPayload(BaseModel):
+    message_id: str | None = Field(default=None, description="Message ID")
+    text: str = Field(..., description="Text to convert")
+    voice: str | None = Field(default=None, description="Voice name")
+    streaming: bool | None = Field(default=None, description="Whether to stream audio")
+
+
+class TextToSpeechVoiceQuery(BaseModel):
+    language: str = Field(..., description="Language code")
+
+
+console_ns.schema_model(
+    TextToSpeechPayload.__name__, TextToSpeechPayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+console_ns.schema_model(
+    TextToSpeechVoiceQuery.__name__,
+    TextToSpeechVoiceQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+
+@console_ns.route("/apps/<uuid:app_id>/audio-to-text")
+class ChatMessageAudioApi(Resource):
+    @console_ns.doc("chat_message_audio_transcript")
+    @console_ns.doc(description="Transcript audio to text for chat messages")
+    @console_ns.doc(params={"app_id": "App ID"})
+    @console_ns.response(
+        200,
+        "Audio transcription successful",
+        console_ns.model("AudioTranscriptResponse", {"text": fields.String(description="Transcribed text from audio")}),
+    )
+    @console_ns.response(400, "Bad request - No audio uploaded or unsupported type")
+    @console_ns.response(413, "Audio file too large")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT])
+    def post(self, app_model):
+        file = request.files["file"]
+
+        try:
+            response = AudioService.transcript_asr(
+                app_model=app_model,
+                file=file,
+                end_user=None,
+            )
+
+            return response
+        except services.errors.app_model_config.AppModelConfigBrokenError:
+            logger.exception("App model config broken.")
+            raise AppUnavailableError()
+        except NoAudioUploadedServiceError:
+            raise NoAudioUploadedError()
+        except AudioTooLargeServiceError as e:
+            raise AudioTooLargeError(str(e))
+        except UnsupportedAudioTypeServiceError:
+            raise UnsupportedAudioTypeError()
+        except ProviderNotSupportSpeechToTextServiceError:
+            raise ProviderNotSupportSpeechToTextError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except ValueError as e:
+            raise e
+        except Exception as e:
+            logger.exception("Failed to handle post request to ChatMessageAudioApi")
+            raise InternalServerError()
+
+
+@console_ns.route("/apps/<uuid:app_id>/text-to-audio")
+class ChatMessageTextApi(Resource):
+    @console_ns.doc("chat_message_text_to_speech")
+    @console_ns.doc(description="Convert text to speech for chat messages")
+    @console_ns.doc(params={"app_id": "App ID"})
+    @console_ns.expect(console_ns.models[TextToSpeechPayload.__name__])
+    @console_ns.response(200, "Text to speech conversion successful")
+    @console_ns.response(400, "Bad request - Invalid parameters")
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, app_model: App):
+        try:
+            payload = TextToSpeechPayload.model_validate(console_ns.payload)
+
+            response = AudioService.transcript_tts(
+                app_model=app_model,
+                text=payload.text,
+                voice=payload.voice,
+                message_id=payload.message_id,
+                is_draft=True,
+            )
+            return response
+        except services.errors.app_model_config.AppModelConfigBrokenError:
+            logger.exception("App model config broken.")
+            raise AppUnavailableError()
+        except NoAudioUploadedServiceError:
+            raise NoAudioUploadedError()
+        except AudioTooLargeServiceError as e:
+            raise AudioTooLargeError(str(e))
+        except UnsupportedAudioTypeServiceError:
+            raise UnsupportedAudioTypeError()
+        except ProviderNotSupportSpeechToTextServiceError:
+            raise ProviderNotSupportSpeechToTextError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except ValueError as e:
+            raise e
+        except Exception as e:
+            logger.exception("Failed to handle post request to ChatMessageTextApi")
+            raise InternalServerError()
+
+
+@console_ns.route("/apps/<uuid:app_id>/text-to-audio/voices")
+class TextModesApi(Resource):
+    @console_ns.doc("get_text_to_speech_voices")
+    @console_ns.doc(description="Get available TTS voices for a specific language")
+    @console_ns.doc(params={"app_id": "App ID"})
+    @console_ns.expect(console_ns.models[TextToSpeechVoiceQuery.__name__])
+    @console_ns.response(
+        200, "TTS voices retrieved successfully", fields.List(fields.Raw(description="Available voices"))
+    )
+    @console_ns.response(400, "Invalid language parameter")
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        try:
+            args = TextToSpeechVoiceQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+            response = AudioService.transcript_tts_voices(
+                tenant_id=app_model.tenant_id,
+                language=args.language,
+            )
+
+            return response
+        except services.errors.audio.ProviderNotSupportTextToSpeechLanageServiceError:
+            raise AppUnavailableError("Text to audio voices language parameter loss.")
+        except NoAudioUploadedServiceError:
+            raise NoAudioUploadedError()
+        except AudioTooLargeServiceError as e:
+            raise AudioTooLargeError(str(e))
+        except UnsupportedAudioTypeServiceError:
+            raise UnsupportedAudioTypeError()
+        except ProviderNotSupportSpeechToTextServiceError:
+            raise ProviderNotSupportSpeechToTextError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except ValueError as e:
+            raise e
+        except Exception as e:
+            logger.exception("Failed to handle get request to TextModesApi")
+            raise InternalServerError()

dify_1.11.1/api/controllers/console/app/completion.py

@@ -0,0 +1,230 @@
+import logging
+from typing import Any, Literal
+
+from flask import request
+from flask_restx import Resource
+from pydantic import BaseModel, Field, field_validator
+from werkzeug.exceptions import InternalServerError, NotFound
+
+import services
+from controllers.console import console_ns
+from controllers.console.app.error import (
+    AppUnavailableError,
+    CompletionRequestError,
+    ConversationCompletedError,
+    ProviderModelCurrentlyNotSupportError,
+    ProviderNotInitializeError,
+    ProviderQuotaExceededError,
+)
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
+from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.errors.error import (
+    ModelCurrentlyNotSupportError,
+    ProviderTokenNotInitError,
+    QuotaExceededError,
+)
+from core.helper.trace_id_helper import get_external_trace_id
+from core.model_runtime.errors.invoke import InvokeError
+from libs import helper
+from libs.helper import uuid_value
+from libs.login import current_user, login_required
+from models import Account
+from models.model import AppMode
+from services.app_generate_service import AppGenerateService
+from services.app_task_service import AppTaskService
+from services.errors.llm import InvokeRateLimitError
+
+logger = logging.getLogger(__name__)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class BaseMessagePayload(BaseModel):
+    inputs: dict[str, Any]
+    model_config_data: dict[str, Any] = Field(..., alias="model_config")
+    files: list[Any] | None = Field(default=None, description="Uploaded files")
+    response_mode: Literal["blocking", "streaming"] = Field(default="blocking", description="Response mode")
+    retriever_from: str = Field(default="dev", description="Retriever source")
+
+
+class CompletionMessagePayload(BaseMessagePayload):
+    query: str = Field(default="", description="Query text")
+
+
+class ChatMessagePayload(BaseMessagePayload):
+    query: str = Field(..., description="User query")
+    conversation_id: str | None = Field(default=None, description="Conversation ID")
+    parent_message_id: str | None = Field(default=None, description="Parent message ID")
+
+    @field_validator("conversation_id", "parent_message_id")
+    @classmethod
+    def validate_uuid(cls, value: str | None) -> str | None:
+        if value is None:
+            return value
+        return uuid_value(value)
+
+
+console_ns.schema_model(
+    CompletionMessagePayload.__name__,
+    CompletionMessagePayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+console_ns.schema_model(
+    ChatMessagePayload.__name__, ChatMessagePayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+
+
+# define completion message api for user
+@console_ns.route("/apps/<uuid:app_id>/completion-messages")
+class CompletionMessageApi(Resource):
+    @console_ns.doc("create_completion_message")
+    @console_ns.doc(description="Generate completion message for debugging")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[CompletionMessagePayload.__name__])
+    @console_ns.response(200, "Completion generated successfully")
+    @console_ns.response(400, "Invalid request parameters")
+    @console_ns.response(404, "App not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=AppMode.COMPLETION)
+    def post(self, app_model):
+        args_model = CompletionMessagePayload.model_validate(console_ns.payload)
+        args = args_model.model_dump(exclude_none=True, by_alias=True)
+
+        streaming = args_model.response_mode != "blocking"
+        args["auto_generate_name"] = False
+
+        try:
+            if not isinstance(current_user, Account):
+                raise ValueError("current_user must be an Account or EndUser instance")
+            response = AppGenerateService.generate(
+                app_model=app_model, user=current_user, args=args, invoke_from=InvokeFrom.DEBUGGER, streaming=streaming
+            )
+
+            return helper.compact_generate_response(response)
+        except services.errors.conversation.ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+        except services.errors.conversation.ConversationCompletedError:
+            raise ConversationCompletedError()
+        except services.errors.app_model_config.AppModelConfigBrokenError:
+            logger.exception("App model config broken.")
+            raise AppUnavailableError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except ValueError as e:
+            raise e
+        except Exception as e:
+            logger.exception("internal server error.")
+            raise InternalServerError()
+
+
+@console_ns.route("/apps/<uuid:app_id>/completion-messages/<string:task_id>/stop")
+class CompletionMessageStopApi(Resource):
+    @console_ns.doc("stop_completion_message")
+    @console_ns.doc(description="Stop a running completion message generation")
+    @console_ns.doc(params={"app_id": "Application ID", "task_id": "Task ID to stop"})
+    @console_ns.response(200, "Task stopped successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=AppMode.COMPLETION)
+    def post(self, app_model, task_id):
+        if not isinstance(current_user, Account):
+            raise ValueError("current_user must be an Account instance")
+
+        AppTaskService.stop_task(
+            task_id=task_id,
+            invoke_from=InvokeFrom.DEBUGGER,
+            user_id=current_user.id,
+            app_mode=AppMode.value_of(app_model.mode),
+        )
+
+        return {"result": "success"}, 200
+
+
+@console_ns.route("/apps/<uuid:app_id>/chat-messages")
+class ChatMessageApi(Resource):
+    @console_ns.doc("create_chat_message")
+    @console_ns.doc(description="Generate chat message for debugging")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[ChatMessagePayload.__name__])
+    @console_ns.response(200, "Chat message generated successfully")
+    @console_ns.response(400, "Invalid request parameters")
+    @console_ns.response(404, "App or conversation not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT])
+    @edit_permission_required
+    def post(self, app_model):
+        args_model = ChatMessagePayload.model_validate(console_ns.payload)
+        args = args_model.model_dump(exclude_none=True, by_alias=True)
+
+        streaming = args_model.response_mode != "blocking"
+        args["auto_generate_name"] = False
+
+        external_trace_id = get_external_trace_id(request)
+        if external_trace_id:
+            args["external_trace_id"] = external_trace_id
+
+        try:
+            if not isinstance(current_user, Account):
+                raise ValueError("current_user must be an Account or EndUser instance")
+            response = AppGenerateService.generate(
+                app_model=app_model, user=current_user, args=args, invoke_from=InvokeFrom.DEBUGGER, streaming=streaming
+            )
+
+            return helper.compact_generate_response(response)
+        except services.errors.conversation.ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+        except services.errors.conversation.ConversationCompletedError:
+            raise ConversationCompletedError()
+        except services.errors.app_model_config.AppModelConfigBrokenError:
+            logger.exception("App model config broken.")
+            raise AppUnavailableError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeRateLimitError as ex:
+            raise InvokeRateLimitHttpError(ex.description)
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except ValueError as e:
+            raise e
+        except Exception as e:
+            logger.exception("internal server error.")
+            raise InternalServerError()
+
+
+@console_ns.route("/apps/<uuid:app_id>/chat-messages/<string:task_id>/stop")
+class ChatMessageStopApi(Resource):
+    @console_ns.doc("stop_chat_message")
+    @console_ns.doc(description="Stop a running chat message generation")
+    @console_ns.doc(params={"app_id": "Application ID", "task_id": "Task ID to stop"})
+    @console_ns.response(200, "Task stopped successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT])
+    def post(self, app_model, task_id):
+        if not isinstance(current_user, Account):
+            raise ValueError("current_user must be an Account instance")
+
+        AppTaskService.stop_task(
+            task_id=task_id,
+            invoke_from=InvokeFrom.DEBUGGER,
+            user_id=current_user.id,
+            app_mode=AppMode.value_of(app_model.mode),
+        )
+
+        return {"result": "success"}, 200

dify_1.11.1/api/controllers/console/app/conversation.py

@@ -0,0 +1,589 @@
+from typing import Literal
+
+import sqlalchemy as sa
+from flask import abort, request
+from flask_restx import Resource, fields, marshal_with
+from pydantic import BaseModel, Field, field_validator
+from sqlalchemy import func, or_
+from sqlalchemy.orm import joinedload
+from werkzeug.exceptions import NotFound
+
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
+from core.app.entities.app_invoke_entities import InvokeFrom
+from extensions.ext_database import db
+from fields.conversation_fields import MessageTextField
+from fields.raws import FilesContainedField
+from libs.datetime_utils import naive_utc_now, parse_time_range
+from libs.helper import TimestampField
+from libs.login import current_account_with_tenant, login_required
+from models import Conversation, EndUser, Message, MessageAnnotation
+from models.model import AppMode
+from services.conversation_service import ConversationService
+from services.errors.conversation import ConversationNotExistsError
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class BaseConversationQuery(BaseModel):
+    keyword: str | None = Field(default=None, description="Search keyword")
+    start: str | None = Field(default=None, description="Start date (YYYY-MM-DD HH:MM)")
+    end: str | None = Field(default=None, description="End date (YYYY-MM-DD HH:MM)")
+    annotation_status: Literal["annotated", "not_annotated", "all"] = Field(
+        default="all", description="Annotation status filter"
+    )
+    page: int = Field(default=1, ge=1, le=99999, description="Page number")
+    limit: int = Field(default=20, ge=1, le=100, description="Page size (1-100)")
+
+    @field_validator("start", "end", mode="before")
+    @classmethod
+    def blank_to_none(cls, value: str | None) -> str | None:
+        if value == "":
+            return None
+        return value
+
+
+class CompletionConversationQuery(BaseConversationQuery):
+    pass
+
+
+class ChatConversationQuery(BaseConversationQuery):
+    sort_by: Literal["created_at", "-created_at", "updated_at", "-updated_at"] = Field(
+        default="-updated_at", description="Sort field and direction"
+    )
+
+
+console_ns.schema_model(
+    CompletionConversationQuery.__name__,
+    CompletionConversationQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+console_ns.schema_model(
+    ChatConversationQuery.__name__,
+    ChatConversationQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+# Register models for flask_restx to avoid dict type issues in Swagger
+# Register in dependency order: base models first, then dependent models
+
+# Base models
+simple_account_model = console_ns.model(
+    "SimpleAccount",
+    {
+        "id": fields.String,
+        "name": fields.String,
+        "email": fields.String,
+    },
+)
+
+feedback_stat_model = console_ns.model(
+    "FeedbackStat",
+    {
+        "like": fields.Integer,
+        "dislike": fields.Integer,
+    },
+)
+
+status_count_model = console_ns.model(
+    "StatusCount",
+    {
+        "success": fields.Integer,
+        "failed": fields.Integer,
+        "partial_success": fields.Integer,
+    },
+)
+
+message_file_model = console_ns.model(
+    "MessageFile",
+    {
+        "id": fields.String,
+        "filename": fields.String,
+        "type": fields.String,
+        "url": fields.String,
+        "mime_type": fields.String,
+        "size": fields.Integer,
+        "transfer_method": fields.String,
+        "belongs_to": fields.String(default="user"),
+        "upload_file_id": fields.String(default=None),
+    },
+)
+
+agent_thought_model = console_ns.model(
+    "AgentThought",
+    {
+        "id": fields.String,
+        "chain_id": fields.String,
+        "message_id": fields.String,
+        "position": fields.Integer,
+        "thought": fields.String,
+        "tool": fields.String,
+        "tool_labels": fields.Raw,
+        "tool_input": fields.String,
+        "created_at": TimestampField,
+        "observation": fields.String,
+        "files": fields.List(fields.String),
+    },
+)
+
+simple_model_config_model = console_ns.model(
+    "SimpleModelConfig",
+    {
+        "model": fields.Raw(attribute="model_dict"),
+        "pre_prompt": fields.String,
+    },
+)
+
+model_config_model = console_ns.model(
+    "ModelConfig",
+    {
+        "opening_statement": fields.String,
+        "suggested_questions": fields.Raw,
+        "model": fields.Raw,
+        "user_input_form": fields.Raw,
+        "pre_prompt": fields.String,
+        "agent_mode": fields.Raw,
+    },
+)
+
+# Models that depend on simple_account_model
+feedback_model = console_ns.model(
+    "Feedback",
+    {
+        "rating": fields.String,
+        "content": fields.String,
+        "from_source": fields.String,
+        "from_end_user_id": fields.String,
+        "from_account": fields.Nested(simple_account_model, allow_null=True),
+    },
+)
+
+annotation_model = console_ns.model(
+    "Annotation",
+    {
+        "id": fields.String,
+        "question": fields.String,
+        "content": fields.String,
+        "account": fields.Nested(simple_account_model, allow_null=True),
+        "created_at": TimestampField,
+    },
+)
+
+annotation_hit_history_model = console_ns.model(
+    "AnnotationHitHistory",
+    {
+        "annotation_id": fields.String(attribute="id"),
+        "annotation_create_account": fields.Nested(simple_account_model, allow_null=True),
+        "created_at": TimestampField,
+    },
+)
+
+# Simple message detail model
+simple_message_detail_model = console_ns.model(
+    "SimpleMessageDetail",
+    {
+        "inputs": FilesContainedField,
+        "query": fields.String,
+        "message": MessageTextField,
+        "answer": fields.String,
+    },
+)
+
+# Message detail model that depends on multiple models
+message_detail_model = console_ns.model(
+    "MessageDetail",
+    {
+        "id": fields.String,
+        "conversation_id": fields.String,
+        "inputs": FilesContainedField,
+        "query": fields.String,
+        "message": fields.Raw,
+        "message_tokens": fields.Integer,
+        "answer": fields.String(attribute="re_sign_file_url_answer"),
+        "answer_tokens": fields.Integer,
+        "provider_response_latency": fields.Float,
+        "from_source": fields.String,
+        "from_end_user_id": fields.String,
+        "from_account_id": fields.String,
+        "feedbacks": fields.List(fields.Nested(feedback_model)),
+        "workflow_run_id": fields.String,
+        "annotation": fields.Nested(annotation_model, allow_null=True),
+        "annotation_hit_history": fields.Nested(annotation_hit_history_model, allow_null=True),
+        "created_at": TimestampField,
+        "agent_thoughts": fields.List(fields.Nested(agent_thought_model)),
+        "message_files": fields.List(fields.Nested(message_file_model)),
+        "metadata": fields.Raw(attribute="message_metadata_dict"),
+        "status": fields.String,
+        "error": fields.String,
+        "parent_message_id": fields.String,
+    },
+)
+
+# Conversation models
+conversation_fields_model = console_ns.model(
+    "Conversation",
+    {
+        "id": fields.String,
+        "status": fields.String,
+        "from_source": fields.String,
+        "from_end_user_id": fields.String,
+        "from_end_user_session_id": fields.String(),
+        "from_account_id": fields.String,
+        "from_account_name": fields.String,
+        "read_at": TimestampField,
+        "created_at": TimestampField,
+        "updated_at": TimestampField,
+        "annotation": fields.Nested(annotation_model, allow_null=True),
+        "model_config": fields.Nested(simple_model_config_model),
+        "user_feedback_stats": fields.Nested(feedback_stat_model),
+        "admin_feedback_stats": fields.Nested(feedback_stat_model),
+        "message": fields.Nested(simple_message_detail_model, attribute="first_message"),
+    },
+)
+
+conversation_pagination_model = console_ns.model(
+    "ConversationPagination",
+    {
+        "page": fields.Integer,
+        "limit": fields.Integer(attribute="per_page"),
+        "total": fields.Integer,
+        "has_more": fields.Boolean(attribute="has_next"),
+        "data": fields.List(fields.Nested(conversation_fields_model), attribute="items"),
+    },
+)
+
+conversation_message_detail_model = console_ns.model(
+    "ConversationMessageDetail",
+    {
+        "id": fields.String,
+        "status": fields.String,
+        "from_source": fields.String,
+        "from_end_user_id": fields.String,
+        "from_account_id": fields.String,
+        "created_at": TimestampField,
+        "model_config": fields.Nested(model_config_model),
+        "message": fields.Nested(message_detail_model, attribute="first_message"),
+    },
+)
+
+conversation_with_summary_model = console_ns.model(
+    "ConversationWithSummary",
+    {
+        "id": fields.String,
+        "status": fields.String,
+        "from_source": fields.String,
+        "from_end_user_id": fields.String,
+        "from_end_user_session_id": fields.String,
+        "from_account_id": fields.String,
+        "from_account_name": fields.String,
+        "name": fields.String,
+        "summary": fields.String(attribute="summary_or_query"),
+        "read_at": TimestampField,
+        "created_at": TimestampField,
+        "updated_at": TimestampField,
+        "annotated": fields.Boolean,
+        "model_config": fields.Nested(simple_model_config_model),
+        "message_count": fields.Integer,
+        "user_feedback_stats": fields.Nested(feedback_stat_model),
+        "admin_feedback_stats": fields.Nested(feedback_stat_model),
+        "status_count": fields.Nested(status_count_model),
+    },
+)
+
+conversation_with_summary_pagination_model = console_ns.model(
+    "ConversationWithSummaryPagination",
+    {
+        "page": fields.Integer,
+        "limit": fields.Integer(attribute="per_page"),
+        "total": fields.Integer,
+        "has_more": fields.Boolean(attribute="has_next"),
+        "data": fields.List(fields.Nested(conversation_with_summary_model), attribute="items"),
+    },
+)
+
+conversation_detail_model = console_ns.model(
+    "ConversationDetail",
+    {
+        "id": fields.String,
+        "status": fields.String,
+        "from_source": fields.String,
+        "from_end_user_id": fields.String,
+        "from_account_id": fields.String,
+        "created_at": TimestampField,
+        "updated_at": TimestampField,
+        "annotated": fields.Boolean,
+        "introduction": fields.String,
+        "model_config": fields.Nested(model_config_model),
+        "message_count": fields.Integer,
+        "user_feedback_stats": fields.Nested(feedback_stat_model),
+        "admin_feedback_stats": fields.Nested(feedback_stat_model),
+    },
+)
+
+
+@console_ns.route("/apps/<uuid:app_id>/completion-conversations")
+class CompletionConversationApi(Resource):
+    @console_ns.doc("list_completion_conversations")
+    @console_ns.doc(description="Get completion conversations with pagination and filtering")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[CompletionConversationQuery.__name__])
+    @console_ns.response(200, "Success", conversation_pagination_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=AppMode.COMPLETION)
+    @marshal_with(conversation_pagination_model)
+    @edit_permission_required
+    def get(self, app_model):
+        current_user, _ = current_account_with_tenant()
+        args = CompletionConversationQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        query = sa.select(Conversation).where(
+            Conversation.app_id == app_model.id, Conversation.mode == "completion", Conversation.is_deleted.is_(False)
+        )
+
+        if args.keyword:
+            query = query.join(Message, Message.conversation_id == Conversation.id).where(
+                or_(
+                    Message.query.ilike(f"%{args.keyword}%"),
+                    Message.answer.ilike(f"%{args.keyword}%"),
+                )
+            )
+
+        account = current_user
+        assert account.timezone is not None
+
+        try:
+            start_datetime_utc, end_datetime_utc = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        if start_datetime_utc:
+            query = query.where(Conversation.created_at >= start_datetime_utc)
+
+        if end_datetime_utc:
+            end_datetime_utc = end_datetime_utc.replace(second=59)
+            query = query.where(Conversation.created_at < end_datetime_utc)
+
+        # FIXME, the type ignore in this file
+        if args.annotation_status == "annotated":
+            query = query.options(joinedload(Conversation.message_annotations)).join(  # type: ignore
+                MessageAnnotation, MessageAnnotation.conversation_id == Conversation.id
+            )
+        elif args.annotation_status == "not_annotated":
+            query = (
+                query.outerjoin(MessageAnnotation, MessageAnnotation.conversation_id == Conversation.id)
+                .group_by(Conversation.id)
+                .having(func.count(MessageAnnotation.id) == 0)
+            )
+
+        query = query.order_by(Conversation.created_at.desc())
+
+        conversations = db.paginate(query, page=args.page, per_page=args.limit, error_out=False)
+
+        return conversations
+
+
+@console_ns.route("/apps/<uuid:app_id>/completion-conversations/<uuid:conversation_id>")
+class CompletionConversationDetailApi(Resource):
+    @console_ns.doc("get_completion_conversation")
+    @console_ns.doc(description="Get completion conversation details with messages")
+    @console_ns.doc(params={"app_id": "Application ID", "conversation_id": "Conversation ID"})
+    @console_ns.response(200, "Success", conversation_message_detail_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.response(404, "Conversation not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=AppMode.COMPLETION)
+    @marshal_with(conversation_message_detail_model)
+    @edit_permission_required
+    def get(self, app_model, conversation_id):
+        conversation_id = str(conversation_id)
+
+        return _get_conversation(app_model, conversation_id)
+
+    @console_ns.doc("delete_completion_conversation")
+    @console_ns.doc(description="Delete a completion conversation")
+    @console_ns.doc(params={"app_id": "Application ID", "conversation_id": "Conversation ID"})
+    @console_ns.response(204, "Conversation deleted successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.response(404, "Conversation not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=AppMode.COMPLETION)
+    @edit_permission_required
+    def delete(self, app_model, conversation_id):
+        current_user, _ = current_account_with_tenant()
+        conversation_id = str(conversation_id)
+
+        try:
+            ConversationService.delete(app_model, conversation_id, current_user)
+        except ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+
+        return {"result": "success"}, 204
+
+
+@console_ns.route("/apps/<uuid:app_id>/chat-conversations")
+class ChatConversationApi(Resource):
+    @console_ns.doc("list_chat_conversations")
+    @console_ns.doc(description="Get chat conversations with pagination, filtering and summary")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[ChatConversationQuery.__name__])
+    @console_ns.response(200, "Success", conversation_with_summary_pagination_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT])
+    @marshal_with(conversation_with_summary_pagination_model)
+    @edit_permission_required
+    def get(self, app_model):
+        current_user, _ = current_account_with_tenant()
+        args = ChatConversationQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        subquery = (
+            db.session.query(
+                Conversation.id.label("conversation_id"), EndUser.session_id.label("from_end_user_session_id")
+            )
+            .outerjoin(EndUser, Conversation.from_end_user_id == EndUser.id)
+            .subquery()
+        )
+
+        query = sa.select(Conversation).where(Conversation.app_id == app_model.id, Conversation.is_deleted.is_(False))
+
+        if args.keyword:
+            keyword_filter = f"%{args.keyword}%"
+            query = (
+                query.join(
+                    Message,
+                    Message.conversation_id == Conversation.id,
+                )
+                .join(subquery, subquery.c.conversation_id == Conversation.id)
+                .where(
+                    or_(
+                        Message.query.ilike(keyword_filter),
+                        Message.answer.ilike(keyword_filter),
+                        Conversation.name.ilike(keyword_filter),
+                        Conversation.introduction.ilike(keyword_filter),
+                        subquery.c.from_end_user_session_id.ilike(keyword_filter),
+                    ),
+                )
+                .group_by(Conversation.id)
+            )
+
+        account = current_user
+        assert account.timezone is not None
+
+        try:
+            start_datetime_utc, end_datetime_utc = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        if start_datetime_utc:
+            match args.sort_by:
+                case "updated_at" | "-updated_at":
+                    query = query.where(Conversation.updated_at >= start_datetime_utc)
+                case "created_at" | "-created_at" | _:
+                    query = query.where(Conversation.created_at >= start_datetime_utc)
+
+        if end_datetime_utc:
+            end_datetime_utc = end_datetime_utc.replace(second=59)
+            match args.sort_by:
+                case "updated_at" | "-updated_at":
+                    query = query.where(Conversation.updated_at <= end_datetime_utc)
+                case "created_at" | "-created_at" | _:
+                    query = query.where(Conversation.created_at <= end_datetime_utc)
+
+        if args.annotation_status == "annotated":
+            query = query.options(joinedload(Conversation.message_annotations)).join(  # type: ignore
+                MessageAnnotation, MessageAnnotation.conversation_id == Conversation.id
+            )
+        elif args.annotation_status == "not_annotated":
+            query = (
+                query.outerjoin(MessageAnnotation, MessageAnnotation.conversation_id == Conversation.id)
+                .group_by(Conversation.id)
+                .having(func.count(MessageAnnotation.id) == 0)
+            )
+
+        if app_model.mode == AppMode.ADVANCED_CHAT:
+            query = query.where(Conversation.invoke_from != InvokeFrom.DEBUGGER)
+
+        match args.sort_by:
+            case "created_at":
+                query = query.order_by(Conversation.created_at.asc())
+            case "-created_at":
+                query = query.order_by(Conversation.created_at.desc())
+            case "updated_at":
+                query = query.order_by(Conversation.updated_at.asc())
+            case "-updated_at":
+                query = query.order_by(Conversation.updated_at.desc())
+            case _:
+                query = query.order_by(Conversation.created_at.desc())
+
+        conversations = db.paginate(query, page=args.page, per_page=args.limit, error_out=False)
+
+        return conversations
+
+
+@console_ns.route("/apps/<uuid:app_id>/chat-conversations/<uuid:conversation_id>")
+class ChatConversationDetailApi(Resource):
+    @console_ns.doc("get_chat_conversation")
+    @console_ns.doc(description="Get chat conversation details")
+    @console_ns.doc(params={"app_id": "Application ID", "conversation_id": "Conversation ID"})
+    @console_ns.response(200, "Success", conversation_detail_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.response(404, "Conversation not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT])
+    @marshal_with(conversation_detail_model)
+    @edit_permission_required
+    def get(self, app_model, conversation_id):
+        conversation_id = str(conversation_id)
+
+        return _get_conversation(app_model, conversation_id)
+
+    @console_ns.doc("delete_chat_conversation")
+    @console_ns.doc(description="Delete a chat conversation")
+    @console_ns.doc(params={"app_id": "Application ID", "conversation_id": "Conversation ID"})
+    @console_ns.response(204, "Conversation deleted successfully")
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.response(404, "Conversation not found")
+    @setup_required
+    @login_required
+    @get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT])
+    @account_initialization_required
+    @edit_permission_required
+    def delete(self, app_model, conversation_id):
+        current_user, _ = current_account_with_tenant()
+        conversation_id = str(conversation_id)
+
+        try:
+            ConversationService.delete(app_model, conversation_id, current_user)
+        except ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+
+        return {"result": "success"}, 204
+
+
+def _get_conversation(app_model, conversation_id):
+    current_user, _ = current_account_with_tenant()
+    conversation = (
+        db.session.query(Conversation)
+        .where(Conversation.id == conversation_id, Conversation.app_id == app_model.id)
+        .first()
+    )
+
+    if not conversation:
+        raise NotFound("Conversation Not Exists.")
+
+    if not conversation.read_at:
+        conversation.read_at = naive_utc_now()
+        conversation.read_account_id = current_user.id
+        db.session.commit()
+
+    return conversation

dify_1.11.1/api/controllers/console/app/conversation_variables.py

@@ -0,0 +1,88 @@
+from flask import request
+from flask_restx import Resource, fields, marshal_with
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, setup_required
+from extensions.ext_database import db
+from fields.conversation_variable_fields import (
+    conversation_variable_fields,
+    paginated_conversation_variable_fields,
+)
+from libs.login import login_required
+from models import ConversationVariable
+from models.model import AppMode
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class ConversationVariablesQuery(BaseModel):
+    conversation_id: str = Field(..., description="Conversation ID to filter variables")
+
+
+console_ns.schema_model(
+    ConversationVariablesQuery.__name__,
+    ConversationVariablesQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+# Register models for flask_restx to avoid dict type issues in Swagger
+# Register base model first
+conversation_variable_model = console_ns.model("ConversationVariable", conversation_variable_fields)
+
+# For nested models, need to replace nested dict with registered model
+paginated_conversation_variable_fields_copy = paginated_conversation_variable_fields.copy()
+paginated_conversation_variable_fields_copy["data"] = fields.List(
+    fields.Nested(conversation_variable_model), attribute="data"
+)
+paginated_conversation_variable_model = console_ns.model(
+    "PaginatedConversationVariable", paginated_conversation_variable_fields_copy
+)
+
+
+@console_ns.route("/apps/<uuid:app_id>/conversation-variables")
+class ConversationVariablesApi(Resource):
+    @console_ns.doc("get_conversation_variables")
+    @console_ns.doc(description="Get conversation variables for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[ConversationVariablesQuery.__name__])
+    @console_ns.response(200, "Conversation variables retrieved successfully", paginated_conversation_variable_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=AppMode.ADVANCED_CHAT)
+    @marshal_with(paginated_conversation_variable_model)
+    def get(self, app_model):
+        args = ConversationVariablesQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        stmt = (
+            select(ConversationVariable)
+            .where(ConversationVariable.app_id == app_model.id)
+            .order_by(ConversationVariable.created_at)
+        )
+        stmt = stmt.where(ConversationVariable.conversation_id == args.conversation_id)
+
+        # NOTE: This is a temporary solution to avoid performance issues.
+        page = 1
+        page_size = 100
+        stmt = stmt.limit(page_size).offset((page - 1) * page_size)
+
+        with Session(db.engine) as session:
+            rows = session.scalars(stmt).all()
+
+        return {
+            "page": page,
+            "limit": page_size,
+            "total": len(rows),
+            "has_more": False,
+            "data": [
+                {
+                    "created_at": row.created_at,
+                    "updated_at": row.updated_at,
+                    **row.to_variable().model_dump(),
+                }
+                for row in rows
+            ],
+        }

dify_1.11.1/api/controllers/console/app/error.py

@@ -0,0 +1,117 @@
+from libs.exception import BaseHTTPException
+
+
+class AppNotFoundError(BaseHTTPException):
+    error_code = "app_not_found"
+    description = "App not found."
+    code = 404
+
+
+class ProviderNotInitializeError(BaseHTTPException):
+    error_code = "provider_not_initialize"
+    description = (
+        "No valid model provider credentials found. "
+        "Please go to Settings -> Model Provider to complete your provider credentials."
+    )
+    code = 400
+
+
+class ProviderQuotaExceededError(BaseHTTPException):
+    error_code = "provider_quota_exceeded"
+    description = (
+        "Your quota for Dify Hosted Model Provider has been exhausted. "
+        "Please go to Settings -> Model Provider to complete your own provider credentials."
+    )
+    code = 400
+
+
+class ProviderModelCurrentlyNotSupportError(BaseHTTPException):
+    error_code = "model_currently_not_support"
+    description = "Dify Hosted OpenAI trial currently not support the GPT-4 model."
+    code = 400
+
+
+class ConversationCompletedError(BaseHTTPException):
+    error_code = "conversation_completed"
+    description = "The conversation has ended. Please start a new conversation."
+    code = 400
+
+
+class AppUnavailableError(BaseHTTPException):
+    error_code = "app_unavailable"
+    description = "App unavailable, please check your app configurations."
+    code = 400
+
+
+class CompletionRequestError(BaseHTTPException):
+    error_code = "completion_request_error"
+    description = "Completion request failed."
+    code = 400
+
+
+class AppMoreLikeThisDisabledError(BaseHTTPException):
+    error_code = "app_more_like_this_disabled"
+    description = "The 'More like this' feature is disabled. Please refresh your page."
+    code = 403
+
+
+class NoAudioUploadedError(BaseHTTPException):
+    error_code = "no_audio_uploaded"
+    description = "Please upload your audio."
+    code = 400
+
+
+class AudioTooLargeError(BaseHTTPException):
+    error_code = "audio_too_large"
+    description = "Audio size exceeded. {message}"
+    code = 413
+
+
+class UnsupportedAudioTypeError(BaseHTTPException):
+    error_code = "unsupported_audio_type"
+    description = "Audio type not allowed."
+    code = 415
+
+
+class ProviderNotSupportSpeechToTextError(BaseHTTPException):
+    error_code = "provider_not_support_speech_to_text"
+    description = "Provider not support speech to text."
+    code = 400
+
+
+class DraftWorkflowNotExist(BaseHTTPException):
+    error_code = "draft_workflow_not_exist"
+    description = "Draft workflow need to be initialized."
+    code = 400
+
+
+class DraftWorkflowNotSync(BaseHTTPException):
+    error_code = "draft_workflow_not_sync"
+    description = "Workflow graph might have been modified, please refresh and resubmit."
+    code = 400
+
+
+class TracingConfigNotExist(BaseHTTPException):
+    error_code = "trace_config_not_exist"
+    description = "Trace config not exist."
+    code = 400
+
+
+class TracingConfigIsExist(BaseHTTPException):
+    error_code = "trace_config_is_exist"
+    description = "Trace config is exist."
+    code = 400
+
+
+class TracingConfigCheckError(BaseHTTPException):
+    error_code = "trace_config_check_error"
+    description = "Invalid Credentials."
+    code = 400
+
+
+class InvokeRateLimitError(BaseHTTPException):
+    """Raised when the Invoke returns rate limit error."""
+
+    error_code = "rate_limit_error"
+    description = "Rate Limit Error"
+    code = 429

dify_1.11.1/api/controllers/console/app/generator.py

@@ -0,0 +1,280 @@
+from collections.abc import Sequence
+from typing import Any
+
+from flask_restx import Resource
+from pydantic import BaseModel, Field
+
+from controllers.console import console_ns
+from controllers.console.app.error import (
+    CompletionRequestError,
+    ProviderModelCurrentlyNotSupportError,
+    ProviderNotInitializeError,
+    ProviderQuotaExceededError,
+)
+from controllers.console.wraps import account_initialization_required, setup_required
+from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
+from core.helper.code_executor.code_node_provider import CodeNodeProvider
+from core.helper.code_executor.javascript.javascript_code_provider import JavascriptCodeProvider
+from core.helper.code_executor.python3.python3_code_provider import Python3CodeProvider
+from core.llm_generator.llm_generator import LLMGenerator
+from core.model_runtime.errors.invoke import InvokeError
+from extensions.ext_database import db
+from libs.login import current_account_with_tenant, login_required
+from models import App
+from services.workflow_service import WorkflowService
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class RuleGeneratePayload(BaseModel):
+    instruction: str = Field(..., description="Rule generation instruction")
+    model_config_data: dict[str, Any] = Field(..., alias="model_config", description="Model configuration")
+    no_variable: bool = Field(default=False, description="Whether to exclude variables")
+
+
+class RuleCodeGeneratePayload(RuleGeneratePayload):
+    code_language: str = Field(default="javascript", description="Programming language for code generation")
+
+
+class RuleStructuredOutputPayload(BaseModel):
+    instruction: str = Field(..., description="Structured output generation instruction")
+    model_config_data: dict[str, Any] = Field(..., alias="model_config", description="Model configuration")
+
+
+class InstructionGeneratePayload(BaseModel):
+    flow_id: str = Field(..., description="Workflow/Flow ID")
+    node_id: str = Field(default="", description="Node ID for workflow context")
+    current: str = Field(default="", description="Current instruction text")
+    language: str = Field(default="javascript", description="Programming language (javascript/python)")
+    instruction: str = Field(..., description="Instruction for generation")
+    model_config_data: dict[str, Any] = Field(..., alias="model_config", description="Model configuration")
+    ideal_output: str = Field(default="", description="Expected ideal output")
+
+
+class InstructionTemplatePayload(BaseModel):
+    type: str = Field(..., description="Instruction template type")
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(RuleGeneratePayload)
+reg(RuleCodeGeneratePayload)
+reg(RuleStructuredOutputPayload)
+reg(InstructionGeneratePayload)
+reg(InstructionTemplatePayload)
+
+
+@console_ns.route("/rule-generate")
+class RuleGenerateApi(Resource):
+    @console_ns.doc("generate_rule_config")
+    @console_ns.doc(description="Generate rule configuration using LLM")
+    @console_ns.expect(console_ns.models[RuleGeneratePayload.__name__])
+    @console_ns.response(200, "Rule configuration generated successfully")
+    @console_ns.response(400, "Invalid request parameters")
+    @console_ns.response(402, "Provider quota exceeded")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        args = RuleGeneratePayload.model_validate(console_ns.payload)
+        _, current_tenant_id = current_account_with_tenant()
+
+        try:
+            rules = LLMGenerator.generate_rule_config(
+                tenant_id=current_tenant_id,
+                instruction=args.instruction,
+                model_config=args.model_config_data,
+                no_variable=args.no_variable,
+            )
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+
+        return rules
+
+
+@console_ns.route("/rule-code-generate")
+class RuleCodeGenerateApi(Resource):
+    @console_ns.doc("generate_rule_code")
+    @console_ns.doc(description="Generate code rules using LLM")
+    @console_ns.expect(console_ns.models[RuleCodeGeneratePayload.__name__])
+    @console_ns.response(200, "Code rules generated successfully")
+    @console_ns.response(400, "Invalid request parameters")
+    @console_ns.response(402, "Provider quota exceeded")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        args = RuleCodeGeneratePayload.model_validate(console_ns.payload)
+        _, current_tenant_id = current_account_with_tenant()
+
+        try:
+            code_result = LLMGenerator.generate_code(
+                tenant_id=current_tenant_id,
+                instruction=args.instruction,
+                model_config=args.model_config_data,
+                code_language=args.code_language,
+            )
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+
+        return code_result
+
+
+@console_ns.route("/rule-structured-output-generate")
+class RuleStructuredOutputGenerateApi(Resource):
+    @console_ns.doc("generate_structured_output")
+    @console_ns.doc(description="Generate structured output rules using LLM")
+    @console_ns.expect(console_ns.models[RuleStructuredOutputPayload.__name__])
+    @console_ns.response(200, "Structured output generated successfully")
+    @console_ns.response(400, "Invalid request parameters")
+    @console_ns.response(402, "Provider quota exceeded")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        args = RuleStructuredOutputPayload.model_validate(console_ns.payload)
+        _, current_tenant_id = current_account_with_tenant()
+
+        try:
+            structured_output = LLMGenerator.generate_structured_output(
+                tenant_id=current_tenant_id,
+                instruction=args.instruction,
+                model_config=args.model_config_data,
+            )
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+
+        return structured_output
+
+
+@console_ns.route("/instruction-generate")
+class InstructionGenerateApi(Resource):
+    @console_ns.doc("generate_instruction")
+    @console_ns.doc(description="Generate instruction for workflow nodes or general use")
+    @console_ns.expect(console_ns.models[InstructionGeneratePayload.__name__])
+    @console_ns.response(200, "Instruction generated successfully")
+    @console_ns.response(400, "Invalid request parameters or flow/workflow not found")
+    @console_ns.response(402, "Provider quota exceeded")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        args = InstructionGeneratePayload.model_validate(console_ns.payload)
+        _, current_tenant_id = current_account_with_tenant()
+        providers: list[type[CodeNodeProvider]] = [Python3CodeProvider, JavascriptCodeProvider]
+        code_provider: type[CodeNodeProvider] | None = next(
+            (p for p in providers if p.is_accept_language(args.language)), None
+        )
+        code_template = code_provider.get_default_code() if code_provider else ""
+        try:
+            # Generate from nothing for a workflow node
+            if (args.current in (code_template, "")) and args.node_id != "":
+                app = db.session.query(App).where(App.id == args.flow_id).first()
+                if not app:
+                    return {"error": f"app {args.flow_id} not found"}, 400
+                workflow = WorkflowService().get_draft_workflow(app_model=app)
+                if not workflow:
+                    return {"error": f"workflow {args.flow_id} not found"}, 400
+                nodes: Sequence = workflow.graph_dict["nodes"]
+                node = [node for node in nodes if node["id"] == args.node_id]
+                if len(node) == 0:
+                    return {"error": f"node {args.node_id} not found"}, 400
+                node_type = node[0]["data"]["type"]
+                match node_type:
+                    case "llm":
+                        return LLMGenerator.generate_rule_config(
+                            current_tenant_id,
+                            instruction=args.instruction,
+                            model_config=args.model_config_data,
+                            no_variable=True,
+                        )
+                    case "agent":
+                        return LLMGenerator.generate_rule_config(
+                            current_tenant_id,
+                            instruction=args.instruction,
+                            model_config=args.model_config_data,
+                            no_variable=True,
+                        )
+                    case "code":
+                        return LLMGenerator.generate_code(
+                            tenant_id=current_tenant_id,
+                            instruction=args.instruction,
+                            model_config=args.model_config_data,
+                            code_language=args.language,
+                        )
+                    case _:
+                        return {"error": f"invalid node type: {node_type}"}
+            if args.node_id == "" and args.current != "":  # For legacy app without a workflow
+                return LLMGenerator.instruction_modify_legacy(
+                    tenant_id=current_tenant_id,
+                    flow_id=args.flow_id,
+                    current=args.current,
+                    instruction=args.instruction,
+                    model_config=args.model_config_data,
+                    ideal_output=args.ideal_output,
+                )
+            if args.node_id != "" and args.current != "":  # For workflow node
+                return LLMGenerator.instruction_modify_workflow(
+                    tenant_id=current_tenant_id,
+                    flow_id=args.flow_id,
+                    node_id=args.node_id,
+                    current=args.current,
+                    instruction=args.instruction,
+                    model_config=args.model_config_data,
+                    ideal_output=args.ideal_output,
+                    workflow_service=WorkflowService(),
+                )
+            return {"error": "incompatible parameters"}, 400
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+
+
+@console_ns.route("/instruction-generate/template")
+class InstructionGenerationTemplateApi(Resource):
+    @console_ns.doc("get_instruction_template")
+    @console_ns.doc(description="Get instruction generation template")
+    @console_ns.expect(console_ns.models[InstructionTemplatePayload.__name__])
+    @console_ns.response(200, "Template retrieved successfully")
+    @console_ns.response(400, "Invalid request parameters")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        args = InstructionTemplatePayload.model_validate(console_ns.payload)
+        match args.type:
+            case "prompt":
+                from core.llm_generator.prompts import INSTRUCTION_GENERATE_TEMPLATE_PROMPT
+
+                return {"data": INSTRUCTION_GENERATE_TEMPLATE_PROMPT}
+            case "code":
+                from core.llm_generator.prompts import INSTRUCTION_GENERATE_TEMPLATE_CODE
+
+                return {"data": INSTRUCTION_GENERATE_TEMPLATE_CODE}
+            case _:
+                raise ValueError(f"Invalid type: {args.type}")

dify_1.11.1/api/controllers/console/app/mcp_server.py

@@ -0,0 +1,152 @@
+import json
+from enum import StrEnum
+
+from flask_restx import Resource, marshal_with
+from pydantic import BaseModel, Field
+from werkzeug.exceptions import NotFound
+
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
+from extensions.ext_database import db
+from fields.app_fields import app_server_fields
+from libs.login import current_account_with_tenant, login_required
+from models.model import AppMCPServer
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+# Register model for flask_restx to avoid dict type issues in Swagger
+app_server_model = console_ns.model("AppServer", app_server_fields)
+
+
+class AppMCPServerStatus(StrEnum):
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+
+
+class MCPServerCreatePayload(BaseModel):
+    description: str | None = Field(default=None, description="Server description")
+    parameters: dict = Field(..., description="Server parameters configuration")
+
+
+class MCPServerUpdatePayload(BaseModel):
+    id: str = Field(..., description="Server ID")
+    description: str | None = Field(default=None, description="Server description")
+    parameters: dict = Field(..., description="Server parameters configuration")
+    status: str | None = Field(default=None, description="Server status")
+
+
+for model in (MCPServerCreatePayload, MCPServerUpdatePayload):
+    console_ns.schema_model(model.__name__, model.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+@console_ns.route("/apps/<uuid:app_id>/server")
+class AppMCPServerController(Resource):
+    @console_ns.doc("get_app_mcp_server")
+    @console_ns.doc(description="Get MCP server configuration for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(200, "MCP server configuration retrieved successfully", app_server_model)
+    @login_required
+    @account_initialization_required
+    @setup_required
+    @get_app_model
+    @marshal_with(app_server_model)
+    def get(self, app_model):
+        server = db.session.query(AppMCPServer).where(AppMCPServer.app_id == app_model.id).first()
+        return server
+
+    @console_ns.doc("create_app_mcp_server")
+    @console_ns.doc(description="Create MCP server configuration for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[MCPServerCreatePayload.__name__])
+    @console_ns.response(201, "MCP server configuration created successfully", app_server_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @account_initialization_required
+    @get_app_model
+    @login_required
+    @setup_required
+    @marshal_with(app_server_model)
+    @edit_permission_required
+    def post(self, app_model):
+        _, current_tenant_id = current_account_with_tenant()
+        payload = MCPServerCreatePayload.model_validate(console_ns.payload or {})
+
+        description = payload.description
+        if not description:
+            description = app_model.description or ""
+
+        server = AppMCPServer(
+            name=app_model.name,
+            description=description,
+            parameters=json.dumps(payload.parameters, ensure_ascii=False),
+            status=AppMCPServerStatus.ACTIVE,
+            app_id=app_model.id,
+            tenant_id=current_tenant_id,
+            server_code=AppMCPServer.generate_server_code(16),
+        )
+        db.session.add(server)
+        db.session.commit()
+        return server
+
+    @console_ns.doc("update_app_mcp_server")
+    @console_ns.doc(description="Update MCP server configuration for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[MCPServerUpdatePayload.__name__])
+    @console_ns.response(200, "MCP server configuration updated successfully", app_server_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.response(404, "Server not found")
+    @get_app_model
+    @login_required
+    @setup_required
+    @account_initialization_required
+    @marshal_with(app_server_model)
+    @edit_permission_required
+    def put(self, app_model):
+        payload = MCPServerUpdatePayload.model_validate(console_ns.payload or {})
+        server = db.session.query(AppMCPServer).where(AppMCPServer.id == payload.id).first()
+        if not server:
+            raise NotFound()
+
+        description = payload.description
+        if description is None:
+            pass
+        elif not description:
+            server.description = app_model.description or ""
+        else:
+            server.description = description
+
+        server.parameters = json.dumps(payload.parameters, ensure_ascii=False)
+        if payload.status:
+            if payload.status not in [status.value for status in AppMCPServerStatus]:
+                raise ValueError("Invalid status")
+            server.status = payload.status
+        db.session.commit()
+        return server
+
+
+@console_ns.route("/apps/<uuid:server_id>/server/refresh")
+class AppMCPServerRefreshController(Resource):
+    @console_ns.doc("refresh_app_mcp_server")
+    @console_ns.doc(description="Refresh MCP server configuration and regenerate server code")
+    @console_ns.doc(params={"server_id": "Server ID"})
+    @console_ns.response(200, "MCP server refreshed successfully", app_server_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.response(404, "Server not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(app_server_model)
+    @edit_permission_required
+    def get(self, server_id):
+        _, current_tenant_id = current_account_with_tenant()
+        server = (
+            db.session.query(AppMCPServer)
+            .where(AppMCPServer.id == server_id)
+            .where(AppMCPServer.tenant_id == current_tenant_id)
+            .first()
+        )
+        if not server:
+            raise NotFound()
+        server.server_code = AppMCPServer.generate_server_code(16)
+        db.session.commit()
+        return server

dify_1.11.1/api/controllers/console/app/message.py

@@ -0,0 +1,477 @@
+import logging
+from typing import Literal
+
+from flask import request
+from flask_restx import Resource, fields, marshal_with
+from pydantic import BaseModel, Field, field_validator
+from sqlalchemy import exists, select
+from werkzeug.exceptions import InternalServerError, NotFound
+
+from controllers.console import console_ns
+from controllers.console.app.error import (
+    CompletionRequestError,
+    ProviderModelCurrentlyNotSupportError,
+    ProviderNotInitializeError,
+    ProviderQuotaExceededError,
+)
+from controllers.console.app.wraps import get_app_model
+from controllers.console.explore.error import AppSuggestedQuestionsAfterAnswerDisabledError
+from controllers.console.wraps import (
+    account_initialization_required,
+    edit_permission_required,
+    setup_required,
+)
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
+from core.model_runtime.errors.invoke import InvokeError
+from extensions.ext_database import db
+from fields.raws import FilesContainedField
+from libs.helper import TimestampField, uuid_value
+from libs.infinite_scroll_pagination import InfiniteScrollPagination
+from libs.login import current_account_with_tenant, login_required
+from models.model import AppMode, Conversation, Message, MessageAnnotation, MessageFeedback
+from services.errors.conversation import ConversationNotExistsError
+from services.errors.message import MessageNotExistsError, SuggestedQuestionsAfterAnswerDisabledError
+from services.message_service import MessageService
+
+logger = logging.getLogger(__name__)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class ChatMessagesQuery(BaseModel):
+    conversation_id: str = Field(..., description="Conversation ID")
+    first_id: str | None = Field(default=None, description="First message ID for pagination")
+    limit: int = Field(default=20, ge=1, le=100, description="Number of messages to return (1-100)")
+
+    @field_validator("first_id", mode="before")
+    @classmethod
+    def empty_to_none(cls, value: str | None) -> str | None:
+        if value == "":
+            return None
+        return value
+
+    @field_validator("conversation_id", "first_id")
+    @classmethod
+    def validate_uuid(cls, value: str | None) -> str | None:
+        if value is None:
+            return value
+        return uuid_value(value)
+
+
+class MessageFeedbackPayload(BaseModel):
+    message_id: str = Field(..., description="Message ID")
+    rating: Literal["like", "dislike"] | None = Field(default=None, description="Feedback rating")
+    content: str | None = Field(default=None, description="Feedback content")
+
+    @field_validator("message_id")
+    @classmethod
+    def validate_message_id(cls, value: str) -> str:
+        return uuid_value(value)
+
+
+class FeedbackExportQuery(BaseModel):
+    from_source: Literal["user", "admin"] | None = Field(default=None, description="Filter by feedback source")
+    rating: Literal["like", "dislike"] | None = Field(default=None, description="Filter by rating")
+    has_comment: bool | None = Field(default=None, description="Only include feedback with comments")
+    start_date: str | None = Field(default=None, description="Start date (YYYY-MM-DD)")
+    end_date: str | None = Field(default=None, description="End date (YYYY-MM-DD)")
+    format: Literal["csv", "json"] = Field(default="csv", description="Export format")
+
+    @field_validator("has_comment", mode="before")
+    @classmethod
+    def parse_bool(cls, value: bool | str | None) -> bool | None:
+        if isinstance(value, bool) or value is None:
+            return value
+        lowered = value.lower()
+        if lowered in {"true", "1", "yes", "on"}:
+            return True
+        if lowered in {"false", "0", "no", "off"}:
+            return False
+        raise ValueError("has_comment must be a boolean value")
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(ChatMessagesQuery)
+reg(MessageFeedbackPayload)
+reg(FeedbackExportQuery)
+
+# Register models for flask_restx to avoid dict type issues in Swagger
+# Register in dependency order: base models first, then dependent models
+
+# Base models
+simple_account_model = console_ns.model(
+    "SimpleAccount",
+    {
+        "id": fields.String,
+        "name": fields.String,
+        "email": fields.String,
+    },
+)
+
+message_file_model = console_ns.model(
+    "MessageFile",
+    {
+        "id": fields.String,
+        "filename": fields.String,
+        "type": fields.String,
+        "url": fields.String,
+        "mime_type": fields.String,
+        "size": fields.Integer,
+        "transfer_method": fields.String,
+        "belongs_to": fields.String(default="user"),
+        "upload_file_id": fields.String(default=None),
+    },
+)
+
+agent_thought_model = console_ns.model(
+    "AgentThought",
+    {
+        "id": fields.String,
+        "chain_id": fields.String,
+        "message_id": fields.String,
+        "position": fields.Integer,
+        "thought": fields.String,
+        "tool": fields.String,
+        "tool_labels": fields.Raw,
+        "tool_input": fields.String,
+        "created_at": TimestampField,
+        "observation": fields.String,
+        "files": fields.List(fields.String),
+    },
+)
+
+# Models that depend on simple_account_model
+feedback_model = console_ns.model(
+    "Feedback",
+    {
+        "rating": fields.String,
+        "content": fields.String,
+        "from_source": fields.String,
+        "from_end_user_id": fields.String,
+        "from_account": fields.Nested(simple_account_model, allow_null=True),
+    },
+)
+
+annotation_model = console_ns.model(
+    "Annotation",
+    {
+        "id": fields.String,
+        "question": fields.String,
+        "content": fields.String,
+        "account": fields.Nested(simple_account_model, allow_null=True),
+        "created_at": TimestampField,
+    },
+)
+
+annotation_hit_history_model = console_ns.model(
+    "AnnotationHitHistory",
+    {
+        "annotation_id": fields.String(attribute="id"),
+        "annotation_create_account": fields.Nested(simple_account_model, allow_null=True),
+        "created_at": TimestampField,
+    },
+)
+
+# Message detail model that depends on multiple models
+message_detail_model = console_ns.model(
+    "MessageDetail",
+    {
+        "id": fields.String,
+        "conversation_id": fields.String,
+        "inputs": FilesContainedField,
+        "query": fields.String,
+        "message": fields.Raw,
+        "message_tokens": fields.Integer,
+        "answer": fields.String(attribute="re_sign_file_url_answer"),
+        "answer_tokens": fields.Integer,
+        "provider_response_latency": fields.Float,
+        "from_source": fields.String,
+        "from_end_user_id": fields.String,
+        "from_account_id": fields.String,
+        "feedbacks": fields.List(fields.Nested(feedback_model)),
+        "workflow_run_id": fields.String,
+        "annotation": fields.Nested(annotation_model, allow_null=True),
+        "annotation_hit_history": fields.Nested(annotation_hit_history_model, allow_null=True),
+        "created_at": TimestampField,
+        "agent_thoughts": fields.List(fields.Nested(agent_thought_model)),
+        "message_files": fields.List(fields.Nested(message_file_model)),
+        "metadata": fields.Raw(attribute="message_metadata_dict"),
+        "status": fields.String,
+        "error": fields.String,
+        "parent_message_id": fields.String,
+    },
+)
+
+# Message infinite scroll pagination model
+message_infinite_scroll_pagination_model = console_ns.model(
+    "MessageInfiniteScrollPagination",
+    {
+        "limit": fields.Integer,
+        "has_more": fields.Boolean,
+        "data": fields.List(fields.Nested(message_detail_model)),
+    },
+)
+
+
+@console_ns.route("/apps/<uuid:app_id>/chat-messages")
+class ChatMessageListApi(Resource):
+    @console_ns.doc("list_chat_messages")
+    @console_ns.doc(description="Get chat messages for a conversation with pagination")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[ChatMessagesQuery.__name__])
+    @console_ns.response(200, "Success", message_infinite_scroll_pagination_model)
+    @console_ns.response(404, "Conversation not found")
+    @login_required
+    @account_initialization_required
+    @setup_required
+    @get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT])
+    @marshal_with(message_infinite_scroll_pagination_model)
+    @edit_permission_required
+    def get(self, app_model):
+        args = ChatMessagesQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        conversation = (
+            db.session.query(Conversation)
+            .where(Conversation.id == args.conversation_id, Conversation.app_id == app_model.id)
+            .first()
+        )
+
+        if not conversation:
+            raise NotFound("Conversation Not Exists.")
+
+        if args.first_id:
+            first_message = (
+                db.session.query(Message)
+                .where(Message.conversation_id == conversation.id, Message.id == args.first_id)
+                .first()
+            )
+
+            if not first_message:
+                raise NotFound("First message not found")
+
+            history_messages = (
+                db.session.query(Message)
+                .where(
+                    Message.conversation_id == conversation.id,
+                    Message.created_at < first_message.created_at,
+                    Message.id != first_message.id,
+                )
+                .order_by(Message.created_at.desc())
+                .limit(args.limit)
+                .all()
+            )
+        else:
+            history_messages = (
+                db.session.query(Message)
+                .where(Message.conversation_id == conversation.id)
+                .order_by(Message.created_at.desc())
+                .limit(args.limit)
+                .all()
+            )
+
+        # Initialize has_more based on whether we have a full page
+        if len(history_messages) == args.limit:
+            current_page_first_message = history_messages[-1]
+            # Check if there are more messages before the current page
+            has_more = db.session.scalar(
+                select(
+                    exists().where(
+                        Message.conversation_id == conversation.id,
+                        Message.created_at < current_page_first_message.created_at,
+                        Message.id != current_page_first_message.id,
+                    )
+                )
+            )
+        else:
+            # If we don't have a full page, there are no more messages
+            has_more = False
+
+        history_messages = list(reversed(history_messages))
+
+        return InfiniteScrollPagination(data=history_messages, limit=args.limit, has_more=has_more)
+
+
+@console_ns.route("/apps/<uuid:app_id>/feedbacks")
+class MessageFeedbackApi(Resource):
+    @console_ns.doc("create_message_feedback")
+    @console_ns.doc(description="Create or update message feedback (like/dislike)")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[MessageFeedbackPayload.__name__])
+    @console_ns.response(200, "Feedback updated successfully")
+    @console_ns.response(404, "Message not found")
+    @console_ns.response(403, "Insufficient permissions")
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, app_model):
+        current_user, _ = current_account_with_tenant()
+
+        args = MessageFeedbackPayload.model_validate(console_ns.payload)
+
+        message_id = str(args.message_id)
+
+        message = db.session.query(Message).where(Message.id == message_id, Message.app_id == app_model.id).first()
+
+        if not message:
+            raise NotFound("Message Not Exists.")
+
+        feedback = message.admin_feedback
+
+        if not args.rating and feedback:
+            db.session.delete(feedback)
+        elif args.rating and feedback:
+            feedback.rating = args.rating
+            feedback.content = args.content
+        elif not args.rating and not feedback:
+            raise ValueError("rating cannot be None when feedback not exists")
+        else:
+            rating_value = args.rating
+            if rating_value is None:
+                raise ValueError("rating is required to create feedback")
+            feedback = MessageFeedback(
+                app_id=app_model.id,
+                conversation_id=message.conversation_id,
+                message_id=message.id,
+                rating=rating_value,
+                content=args.content,
+                from_source="admin",
+                from_account_id=current_user.id,
+            )
+            db.session.add(feedback)
+
+        db.session.commit()
+
+        return {"result": "success"}
+
+
+@console_ns.route("/apps/<uuid:app_id>/annotations/count")
+class MessageAnnotationCountApi(Resource):
+    @console_ns.doc("get_annotation_count")
+    @console_ns.doc(description="Get count of message annotations for the app")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(
+        200,
+        "Annotation count retrieved successfully",
+        console_ns.model("AnnotationCountResponse", {"count": fields.Integer(description="Number of annotations")}),
+    )
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        count = db.session.query(MessageAnnotation).where(MessageAnnotation.app_id == app_model.id).count()
+
+        return {"count": count}
+
+
+@console_ns.route("/apps/<uuid:app_id>/chat-messages/<uuid:message_id>/suggested-questions")
+class MessageSuggestedQuestionApi(Resource):
+    @console_ns.doc("get_message_suggested_questions")
+    @console_ns.doc(description="Get suggested questions for a message")
+    @console_ns.doc(params={"app_id": "Application ID", "message_id": "Message ID"})
+    @console_ns.response(
+        200,
+        "Suggested questions retrieved successfully",
+        console_ns.model(
+            "SuggestedQuestionsResponse", {"data": fields.List(fields.String(description="Suggested question"))}
+        ),
+    )
+    @console_ns.response(404, "Message or conversation not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT])
+    def get(self, app_model, message_id):
+        current_user, _ = current_account_with_tenant()
+        message_id = str(message_id)
+
+        try:
+            questions = MessageService.get_suggested_questions_after_answer(
+                app_model=app_model, message_id=message_id, user=current_user, invoke_from=InvokeFrom.DEBUGGER
+            )
+        except MessageNotExistsError:
+            raise NotFound("Message not found")
+        except ConversationNotExistsError:
+            raise NotFound("Conversation not found")
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except SuggestedQuestionsAfterAnswerDisabledError:
+            raise AppSuggestedQuestionsAfterAnswerDisabledError()
+        except Exception:
+            logger.exception("internal server error.")
+            raise InternalServerError()
+
+        return {"data": questions}
+
+
+@console_ns.route("/apps/<uuid:app_id>/feedbacks/export")
+class MessageFeedbackExportApi(Resource):
+    @console_ns.doc("export_feedbacks")
+    @console_ns.doc(description="Export user feedback data for Google Sheets")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[FeedbackExportQuery.__name__])
+    @console_ns.response(200, "Feedback data exported successfully")
+    @console_ns.response(400, "Invalid parameters")
+    @console_ns.response(500, "Internal server error")
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        args = FeedbackExportQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        # Import the service function
+        from services.feedback_service import FeedbackService
+
+        try:
+            export_data = FeedbackService.export_feedbacks(
+                app_id=app_model.id,
+                from_source=args.from_source,
+                rating=args.rating,
+                has_comment=args.has_comment,
+                start_date=args.start_date,
+                end_date=args.end_date,
+                format_type=args.format,
+            )
+
+            return export_data
+
+        except ValueError as e:
+            logger.exception("Parameter validation error in feedback export")
+            return {"error": f"Parameter validation error: {str(e)}"}, 400
+        except Exception as e:
+            logger.exception("Error exporting feedback data")
+            raise InternalServerError(str(e))
+
+
+@console_ns.route("/apps/<uuid:app_id>/messages/<uuid:message_id>")
+class MessageApi(Resource):
+    @console_ns.doc("get_message")
+    @console_ns.doc(description="Get message details by ID")
+    @console_ns.doc(params={"app_id": "Application ID", "message_id": "Message ID"})
+    @console_ns.response(200, "Message retrieved successfully", message_detail_model)
+    @console_ns.response(404, "Message not found")
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(message_detail_model)
+    def get(self, app_model, message_id: str):
+        message_id = str(message_id)
+
+        message = db.session.query(Message).where(Message.id == message_id, Message.app_id == app_model.id).first()
+
+        if not message:
+            raise NotFound("Message Not Exists.")
+
+        return message

dify_1.11.1/api/controllers/console/app/model_config.py

@@ -0,0 +1,174 @@
+import json
+from typing import cast
+
+from flask import request
+from flask_restx import Resource, fields
+
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
+from core.agent.entities import AgentToolEntity
+from core.tools.tool_manager import ToolManager
+from core.tools.utils.configuration import ToolParameterConfigurationManager
+from events.app_event import app_model_config_was_updated
+from extensions.ext_database import db
+from libs.datetime_utils import naive_utc_now
+from libs.login import current_account_with_tenant, login_required
+from models.model import AppMode, AppModelConfig
+from services.app_model_config_service import AppModelConfigService
+
+
+@console_ns.route("/apps/<uuid:app_id>/model-config")
+class ModelConfigResource(Resource):
+    @console_ns.doc("update_app_model_config")
+    @console_ns.doc(description="Update application model configuration")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(
+        console_ns.model(
+            "ModelConfigRequest",
+            {
+                "provider": fields.String(description="Model provider"),
+                "model": fields.String(description="Model name"),
+                "configs": fields.Raw(description="Model configuration parameters"),
+                "opening_statement": fields.String(description="Opening statement"),
+                "suggested_questions": fields.List(fields.String(), description="Suggested questions"),
+                "more_like_this": fields.Raw(description="More like this configuration"),
+                "speech_to_text": fields.Raw(description="Speech to text configuration"),
+                "text_to_speech": fields.Raw(description="Text to speech configuration"),
+                "retrieval_model": fields.Raw(description="Retrieval model configuration"),
+                "tools": fields.List(fields.Raw(), description="Available tools"),
+                "dataset_configs": fields.Raw(description="Dataset configurations"),
+                "agent_mode": fields.Raw(description="Agent mode configuration"),
+            },
+        )
+    )
+    @console_ns.response(200, "Model configuration updated successfully")
+    @console_ns.response(400, "Invalid configuration")
+    @console_ns.response(404, "App not found")
+    @setup_required
+    @login_required
+    @edit_permission_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.AGENT_CHAT, AppMode.CHAT, AppMode.COMPLETION])
+    def post(self, app_model):
+        """Modify app model config"""
+        current_user, current_tenant_id = current_account_with_tenant()
+        # validate config
+        model_configuration = AppModelConfigService.validate_configuration(
+            tenant_id=current_tenant_id,
+            config=cast(dict, request.json),
+            app_mode=AppMode.value_of(app_model.mode),
+        )
+
+        new_app_model_config = AppModelConfig(
+            app_id=app_model.id,
+            created_by=current_user.id,
+            updated_by=current_user.id,
+        )
+        new_app_model_config = new_app_model_config.from_model_config_dict(model_configuration)
+
+        if app_model.mode == AppMode.AGENT_CHAT or app_model.is_agent:
+            # get original app model config
+            original_app_model_config = (
+                db.session.query(AppModelConfig).where(AppModelConfig.id == app_model.app_model_config_id).first()
+            )
+            if original_app_model_config is None:
+                raise ValueError("Original app model config not found")
+            agent_mode = original_app_model_config.agent_mode_dict
+            # decrypt agent tool parameters if it's secret-input
+            parameter_map = {}
+            masked_parameter_map = {}
+            tool_map = {}
+            for tool in agent_mode.get("tools") or []:
+                if not isinstance(tool, dict) or len(tool.keys()) <= 3:
+                    continue
+
+                agent_tool_entity = AgentToolEntity.model_validate(tool)
+                # get tool
+                try:
+                    tool_runtime = ToolManager.get_agent_tool_runtime(
+                        tenant_id=current_tenant_id,
+                        app_id=app_model.id,
+                        agent_tool=agent_tool_entity,
+                    )
+                    manager = ToolParameterConfigurationManager(
+                        tenant_id=current_tenant_id,
+                        tool_runtime=tool_runtime,
+                        provider_name=agent_tool_entity.provider_id,
+                        provider_type=agent_tool_entity.provider_type,
+                        identity_id=f"AGENT.{app_model.id}",
+                    )
+                except Exception:
+                    continue
+
+                # get decrypted parameters
+                if agent_tool_entity.tool_parameters:
+                    parameters = manager.decrypt_tool_parameters(agent_tool_entity.tool_parameters or {})
+                    masked_parameter = manager.mask_tool_parameters(parameters or {})
+                else:
+                    parameters = {}
+                    masked_parameter = {}
+
+                key = f"{agent_tool_entity.provider_id}.{agent_tool_entity.provider_type}.{agent_tool_entity.tool_name}"
+                masked_parameter_map[key] = masked_parameter
+                parameter_map[key] = parameters
+                tool_map[key] = tool_runtime
+
+            # encrypt agent tool parameters if it's secret-input
+            agent_mode = new_app_model_config.agent_mode_dict
+            for tool in agent_mode.get("tools") or []:
+                agent_tool_entity = AgentToolEntity.model_validate(tool)
+
+                # get tool
+                key = f"{agent_tool_entity.provider_id}.{agent_tool_entity.provider_type}.{agent_tool_entity.tool_name}"
+                if key in tool_map:
+                    tool_runtime = tool_map[key]
+                else:
+                    try:
+                        tool_runtime = ToolManager.get_agent_tool_runtime(
+                            tenant_id=current_tenant_id,
+                            app_id=app_model.id,
+                            agent_tool=agent_tool_entity,
+                        )
+                    except Exception:
+                        continue
+
+                manager = ToolParameterConfigurationManager(
+                    tenant_id=current_tenant_id,
+                    tool_runtime=tool_runtime,
+                    provider_name=agent_tool_entity.provider_id,
+                    provider_type=agent_tool_entity.provider_type,
+                    identity_id=f"AGENT.{app_model.id}",
+                )
+                manager.delete_tool_parameters_cache()
+
+                # override parameters if it equals to masked parameters
+                if agent_tool_entity.tool_parameters:
+                    if key not in masked_parameter_map:
+                        continue
+
+                    for masked_key, masked_value in masked_parameter_map[key].items():
+                        if (
+                            masked_key in agent_tool_entity.tool_parameters
+                            and agent_tool_entity.tool_parameters[masked_key] == masked_value
+                        ):
+                            agent_tool_entity.tool_parameters[masked_key] = parameter_map[key].get(masked_key)
+
+                # encrypt parameters
+                if agent_tool_entity.tool_parameters:
+                    tool["tool_parameters"] = manager.encrypt_tool_parameters(agent_tool_entity.tool_parameters or {})
+
+            # update app model config
+            new_app_model_config.agent_mode = json.dumps(agent_mode)
+
+        db.session.add(new_app_model_config)
+        db.session.flush()
+
+        app_model.app_model_config_id = new_app_model_config.id
+        app_model.updated_by = current_user.id
+        app_model.updated_at = naive_utc_now()
+        db.session.commit()
+
+        app_model_config_was_updated.send(app_model, app_model_config=new_app_model_config)
+
+        return {"result": "success"}

dify_1.11.1/api/controllers/console/app/ops_trace.py

@@ -0,0 +1,132 @@
+from typing import Any
+
+from flask import request
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field
+from werkzeug.exceptions import BadRequest
+
+from controllers.console import console_ns
+from controllers.console.app.error import TracingConfigCheckError, TracingConfigIsExist, TracingConfigNotExist
+from controllers.console.wraps import account_initialization_required, setup_required
+from libs.login import login_required
+from services.ops_service import OpsService
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class TraceProviderQuery(BaseModel):
+    tracing_provider: str = Field(..., description="Tracing provider name")
+
+
+class TraceConfigPayload(BaseModel):
+    tracing_provider: str = Field(..., description="Tracing provider name")
+    tracing_config: dict[str, Any] = Field(..., description="Tracing configuration data")
+
+
+console_ns.schema_model(
+    TraceProviderQuery.__name__,
+    TraceProviderQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+console_ns.schema_model(
+    TraceConfigPayload.__name__, TraceConfigPayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+
+
+@console_ns.route("/apps/<uuid:app_id>/trace-config")
+class TraceAppConfigApi(Resource):
+    """
+    Manage trace app configurations
+    """
+
+    @console_ns.doc("get_trace_app_config")
+    @console_ns.doc(description="Get tracing configuration for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[TraceProviderQuery.__name__])
+    @console_ns.response(
+        200, "Tracing configuration retrieved successfully", fields.Raw(description="Tracing configuration data")
+    )
+    @console_ns.response(400, "Invalid request parameters")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_id):
+        args = TraceProviderQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        try:
+            trace_config = OpsService.get_tracing_app_config(app_id=app_id, tracing_provider=args.tracing_provider)
+            if not trace_config:
+                return {"has_not_configured": True}
+            return trace_config
+        except Exception as e:
+            raise BadRequest(str(e))
+
+    @console_ns.doc("create_trace_app_config")
+    @console_ns.doc(description="Create a new tracing configuration for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[TraceConfigPayload.__name__])
+    @console_ns.response(
+        201, "Tracing configuration created successfully", fields.Raw(description="Created configuration data")
+    )
+    @console_ns.response(400, "Invalid request parameters or configuration already exists")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, app_id):
+        """Create a new trace app configuration"""
+        args = TraceConfigPayload.model_validate(console_ns.payload)
+
+        try:
+            result = OpsService.create_tracing_app_config(
+                app_id=app_id, tracing_provider=args.tracing_provider, tracing_config=args.tracing_config
+            )
+            if not result:
+                raise TracingConfigIsExist()
+            if result.get("error"):
+                raise TracingConfigCheckError()
+            return result
+        except Exception as e:
+            raise BadRequest(str(e))
+
+    @console_ns.doc("update_trace_app_config")
+    @console_ns.doc(description="Update an existing tracing configuration for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[TraceConfigPayload.__name__])
+    @console_ns.response(200, "Tracing configuration updated successfully", fields.Raw(description="Success response"))
+    @console_ns.response(400, "Invalid request parameters or configuration not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def patch(self, app_id):
+        """Update an existing trace app configuration"""
+        args = TraceConfigPayload.model_validate(console_ns.payload)
+
+        try:
+            result = OpsService.update_tracing_app_config(
+                app_id=app_id, tracing_provider=args.tracing_provider, tracing_config=args.tracing_config
+            )
+            if not result:
+                raise TracingConfigNotExist()
+            return {"result": "success"}
+        except Exception as e:
+            raise BadRequest(str(e))
+
+    @console_ns.doc("delete_trace_app_config")
+    @console_ns.doc(description="Delete an existing tracing configuration for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[TraceProviderQuery.__name__])
+    @console_ns.response(204, "Tracing configuration deleted successfully")
+    @console_ns.response(400, "Invalid request parameters or configuration not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def delete(self, app_id):
+        """Delete an existing trace app configuration"""
+        args = TraceProviderQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        try:
+            result = OpsService.delete_tracing_app_config(app_id=app_id, tracing_provider=args.tracing_provider)
+            if not result:
+                raise TracingConfigNotExist()
+            return {"result": "success"}, 204
+        except Exception as e:
+            raise BadRequest(str(e))

dify_1.11.1/api/controllers/console/app/site.py

@@ -0,0 +1,137 @@
+from typing import Literal
+
+from flask_restx import Resource, marshal_with
+from pydantic import BaseModel, Field, field_validator
+from werkzeug.exceptions import NotFound
+
+from constants.languages import supported_language
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import (
+    account_initialization_required,
+    edit_permission_required,
+    is_admin_or_owner_required,
+    setup_required,
+)
+from extensions.ext_database import db
+from fields.app_fields import app_site_fields
+from libs.datetime_utils import naive_utc_now
+from libs.login import current_account_with_tenant, login_required
+from models import Site
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class AppSiteUpdatePayload(BaseModel):
+    title: str | None = Field(default=None)
+    icon_type: str | None = Field(default=None)
+    icon: str | None = Field(default=None)
+    icon_background: str | None = Field(default=None)
+    description: str | None = Field(default=None)
+    default_language: str | None = Field(default=None)
+    chat_color_theme: str | None = Field(default=None)
+    chat_color_theme_inverted: bool | None = Field(default=None)
+    customize_domain: str | None = Field(default=None)
+    copyright: str | None = Field(default=None)
+    privacy_policy: str | None = Field(default=None)
+    custom_disclaimer: str | None = Field(default=None)
+    customize_token_strategy: Literal["must", "allow", "not_allow"] | None = Field(default=None)
+    prompt_public: bool | None = Field(default=None)
+    show_workflow_steps: bool | None = Field(default=None)
+    use_icon_as_answer_icon: bool | None = Field(default=None)
+
+    @field_validator("default_language")
+    @classmethod
+    def validate_language(cls, value: str | None) -> str | None:
+        if value is None:
+            return value
+        return supported_language(value)
+
+
+console_ns.schema_model(
+    AppSiteUpdatePayload.__name__,
+    AppSiteUpdatePayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+# Register model for flask_restx to avoid dict type issues in Swagger
+app_site_model = console_ns.model("AppSite", app_site_fields)
+
+
+@console_ns.route("/apps/<uuid:app_id>/site")
+class AppSite(Resource):
+    @console_ns.doc("update_app_site")
+    @console_ns.doc(description="Update application site configuration")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[AppSiteUpdatePayload.__name__])
+    @console_ns.response(200, "Site configuration updated successfully", app_site_model)
+    @console_ns.response(403, "Insufficient permissions")
+    @console_ns.response(404, "App not found")
+    @setup_required
+    @login_required
+    @edit_permission_required
+    @account_initialization_required
+    @get_app_model
+    @marshal_with(app_site_model)
+    def post(self, app_model):
+        args = AppSiteUpdatePayload.model_validate(console_ns.payload or {})
+        current_user, _ = current_account_with_tenant()
+        site = db.session.query(Site).where(Site.app_id == app_model.id).first()
+        if not site:
+            raise NotFound
+
+        for attr_name in [
+            "title",
+            "icon_type",
+            "icon",
+            "icon_background",
+            "description",
+            "default_language",
+            "chat_color_theme",
+            "chat_color_theme_inverted",
+            "customize_domain",
+            "copyright",
+            "privacy_policy",
+            "custom_disclaimer",
+            "customize_token_strategy",
+            "prompt_public",
+            "show_workflow_steps",
+            "use_icon_as_answer_icon",
+        ]:
+            value = getattr(args, attr_name)
+            if value is not None:
+                setattr(site, attr_name, value)
+
+        site.updated_by = current_user.id
+        site.updated_at = naive_utc_now()
+        db.session.commit()
+
+        return site
+
+
+@console_ns.route("/apps/<uuid:app_id>/site/access-token-reset")
+class AppSiteAccessTokenReset(Resource):
+    @console_ns.doc("reset_app_site_access_token")
+    @console_ns.doc(description="Reset access token for application site")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(200, "Access token reset successfully", app_site_model)
+    @console_ns.response(403, "Insufficient permissions (admin/owner required)")
+    @console_ns.response(404, "App or site not found")
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    @get_app_model
+    @marshal_with(app_site_model)
+    def post(self, app_model):
+        current_user, _ = current_account_with_tenant()
+        site = db.session.query(Site).where(Site.app_id == app_model.id).first()
+
+        if not site:
+            raise NotFound
+
+        site.code = Site.generate_code(16)
+        site.updated_by = current_user.id
+        site.updated_at = naive_utc_now()
+        db.session.commit()
+
+        return site

dify_1.11.1/api/controllers/console/app/statistic.py

@@ -0,0 +1,524 @@
+from decimal import Decimal
+
+import sqlalchemy as sa
+from flask import abort, jsonify, request
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field, field_validator
+
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, setup_required
+from core.app.entities.app_invoke_entities import InvokeFrom
+from extensions.ext_database import db
+from libs.datetime_utils import parse_time_range
+from libs.helper import convert_datetime_to_date
+from libs.login import current_account_with_tenant, login_required
+from models import AppMode
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class StatisticTimeRangeQuery(BaseModel):
+    start: str | None = Field(default=None, description="Start date (YYYY-MM-DD HH:MM)")
+    end: str | None = Field(default=None, description="End date (YYYY-MM-DD HH:MM)")
+
+    @field_validator("start", "end", mode="before")
+    @classmethod
+    def empty_string_to_none(cls, value: str | None) -> str | None:
+        if value == "":
+            return None
+        return value
+
+
+console_ns.schema_model(
+    StatisticTimeRangeQuery.__name__,
+    StatisticTimeRangeQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+
+@console_ns.route("/apps/<uuid:app_id>/statistics/daily-messages")
+class DailyMessageStatistic(Resource):
+    @console_ns.doc("get_daily_message_statistics")
+    @console_ns.doc(description="Get daily message statistics for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[StatisticTimeRangeQuery.__name__])
+    @console_ns.response(
+        200,
+        "Daily message statistics retrieved successfully",
+        fields.List(fields.Raw(description="Daily message count data")),
+    )
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = StatisticTimeRangeQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        converted_created_at = convert_datetime_to_date("created_at")
+        sql_query = f"""SELECT
+    {converted_created_at} AS date,
+    COUNT(*) AS message_count
+FROM
+    messages
+WHERE
+    app_id = :app_id
+    AND invoke_from != :invoke_from"""
+        arg_dict = {"tz": account.timezone, "app_id": app_model.id, "invoke_from": InvokeFrom.DEBUGGER}
+        assert account.timezone is not None
+
+        try:
+            start_datetime_utc, end_datetime_utc = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        if start_datetime_utc:
+            sql_query += " AND created_at >= :start"
+            arg_dict["start"] = start_datetime_utc
+
+        if end_datetime_utc:
+            sql_query += " AND created_at < :end"
+            arg_dict["end"] = end_datetime_utc
+
+        sql_query += " GROUP BY date ORDER BY date"
+
+        response_data = []
+
+        with db.engine.begin() as conn:
+            rs = conn.execute(sa.text(sql_query), arg_dict)
+            for i in rs:
+                response_data.append({"date": str(i.date), "message_count": i.message_count})
+
+        return jsonify({"data": response_data})
+
+
+@console_ns.route("/apps/<uuid:app_id>/statistics/daily-conversations")
+class DailyConversationStatistic(Resource):
+    @console_ns.doc("get_daily_conversation_statistics")
+    @console_ns.doc(description="Get daily conversation statistics for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[StatisticTimeRangeQuery.__name__])
+    @console_ns.response(
+        200,
+        "Daily conversation statistics retrieved successfully",
+        fields.List(fields.Raw(description="Daily conversation count data")),
+    )
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = StatisticTimeRangeQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        converted_created_at = convert_datetime_to_date("created_at")
+        sql_query = f"""SELECT
+    {converted_created_at} AS date,
+    COUNT(DISTINCT conversation_id) AS conversation_count
+FROM
+    messages
+WHERE
+    app_id = :app_id
+    AND invoke_from != :invoke_from"""
+        arg_dict = {"tz": account.timezone, "app_id": app_model.id, "invoke_from": InvokeFrom.DEBUGGER}
+        assert account.timezone is not None
+
+        try:
+            start_datetime_utc, end_datetime_utc = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        if start_datetime_utc:
+            sql_query += " AND created_at >= :start"
+            arg_dict["start"] = start_datetime_utc
+
+        if end_datetime_utc:
+            sql_query += " AND created_at < :end"
+            arg_dict["end"] = end_datetime_utc
+
+        sql_query += " GROUP BY date ORDER BY date"
+
+        response_data = []
+        with db.engine.begin() as conn:
+            rs = conn.execute(sa.text(sql_query), arg_dict)
+            for i in rs:
+                response_data.append({"date": str(i.date), "conversation_count": i.conversation_count})
+
+        return jsonify({"data": response_data})
+
+
+@console_ns.route("/apps/<uuid:app_id>/statistics/daily-end-users")
+class DailyTerminalsStatistic(Resource):
+    @console_ns.doc("get_daily_terminals_statistics")
+    @console_ns.doc(description="Get daily terminal/end-user statistics for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[StatisticTimeRangeQuery.__name__])
+    @console_ns.response(
+        200,
+        "Daily terminal statistics retrieved successfully",
+        fields.List(fields.Raw(description="Daily terminal count data")),
+    )
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = StatisticTimeRangeQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        converted_created_at = convert_datetime_to_date("created_at")
+        sql_query = f"""SELECT
+    {converted_created_at} AS date,
+    COUNT(DISTINCT messages.from_end_user_id) AS terminal_count
+FROM
+    messages
+WHERE
+    app_id = :app_id
+    AND invoke_from != :invoke_from"""
+        arg_dict = {"tz": account.timezone, "app_id": app_model.id, "invoke_from": InvokeFrom.DEBUGGER}
+        assert account.timezone is not None
+
+        try:
+            start_datetime_utc, end_datetime_utc = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        if start_datetime_utc:
+            sql_query += " AND created_at >= :start"
+            arg_dict["start"] = start_datetime_utc
+
+        if end_datetime_utc:
+            sql_query += " AND created_at < :end"
+            arg_dict["end"] = end_datetime_utc
+
+        sql_query += " GROUP BY date ORDER BY date"
+
+        response_data = []
+
+        with db.engine.begin() as conn:
+            rs = conn.execute(sa.text(sql_query), arg_dict)
+            for i in rs:
+                response_data.append({"date": str(i.date), "terminal_count": i.terminal_count})
+
+        return jsonify({"data": response_data})
+
+
+@console_ns.route("/apps/<uuid:app_id>/statistics/token-costs")
+class DailyTokenCostStatistic(Resource):
+    @console_ns.doc("get_daily_token_cost_statistics")
+    @console_ns.doc(description="Get daily token cost statistics for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[StatisticTimeRangeQuery.__name__])
+    @console_ns.response(
+        200,
+        "Daily token cost statistics retrieved successfully",
+        fields.List(fields.Raw(description="Daily token cost data")),
+    )
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = StatisticTimeRangeQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        converted_created_at = convert_datetime_to_date("created_at")
+        sql_query = f"""SELECT
+    {converted_created_at} AS date,
+    (SUM(messages.message_tokens) + SUM(messages.answer_tokens)) AS token_count,
+    SUM(total_price) AS total_price
+FROM
+    messages
+WHERE
+    app_id = :app_id
+    AND invoke_from != :invoke_from"""
+        arg_dict = {"tz": account.timezone, "app_id": app_model.id, "invoke_from": InvokeFrom.DEBUGGER}
+        assert account.timezone is not None
+
+        try:
+            start_datetime_utc, end_datetime_utc = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        if start_datetime_utc:
+            sql_query += " AND created_at >= :start"
+            arg_dict["start"] = start_datetime_utc
+
+        if end_datetime_utc:
+            sql_query += " AND created_at < :end"
+            arg_dict["end"] = end_datetime_utc
+
+        sql_query += " GROUP BY date ORDER BY date"
+
+        response_data = []
+
+        with db.engine.begin() as conn:
+            rs = conn.execute(sa.text(sql_query), arg_dict)
+            for i in rs:
+                response_data.append(
+                    {"date": str(i.date), "token_count": i.token_count, "total_price": i.total_price, "currency": "USD"}
+                )
+
+        return jsonify({"data": response_data})
+
+
+@console_ns.route("/apps/<uuid:app_id>/statistics/average-session-interactions")
+class AverageSessionInteractionStatistic(Resource):
+    @console_ns.doc("get_average_session_interaction_statistics")
+    @console_ns.doc(description="Get average session interaction statistics for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[StatisticTimeRangeQuery.__name__])
+    @console_ns.response(
+        200,
+        "Average session interaction statistics retrieved successfully",
+        fields.List(fields.Raw(description="Average session interaction data")),
+    )
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT])
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = StatisticTimeRangeQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        converted_created_at = convert_datetime_to_date("c.created_at")
+        sql_query = f"""SELECT
+    {converted_created_at} AS date,
+    AVG(subquery.message_count) AS interactions
+FROM
+    (
+        SELECT
+            m.conversation_id,
+            COUNT(m.id) AS message_count
+        FROM
+            conversations c
+        JOIN
+            messages m
+            ON c.id = m.conversation_id
+        WHERE
+            c.app_id = :app_id
+            AND m.invoke_from != :invoke_from"""
+        arg_dict = {"tz": account.timezone, "app_id": app_model.id, "invoke_from": InvokeFrom.DEBUGGER}
+        assert account.timezone is not None
+
+        try:
+            start_datetime_utc, end_datetime_utc = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        if start_datetime_utc:
+            sql_query += " AND c.created_at >= :start"
+            arg_dict["start"] = start_datetime_utc
+
+        if end_datetime_utc:
+            sql_query += " AND c.created_at < :end"
+            arg_dict["end"] = end_datetime_utc
+
+        sql_query += """
+        GROUP BY m.conversation_id
+    ) subquery
+LEFT JOIN
+    conversations c
+    ON c.id = subquery.conversation_id
+GROUP BY
+    date
+ORDER BY
+    date"""
+
+        response_data = []
+
+        with db.engine.begin() as conn:
+            rs = conn.execute(sa.text(sql_query), arg_dict)
+            for i in rs:
+                response_data.append(
+                    {"date": str(i.date), "interactions": float(i.interactions.quantize(Decimal("0.01")))}
+                )
+
+        return jsonify({"data": response_data})
+
+
+@console_ns.route("/apps/<uuid:app_id>/statistics/user-satisfaction-rate")
+class UserSatisfactionRateStatistic(Resource):
+    @console_ns.doc("get_user_satisfaction_rate_statistics")
+    @console_ns.doc(description="Get user satisfaction rate statistics for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[StatisticTimeRangeQuery.__name__])
+    @console_ns.response(
+        200,
+        "User satisfaction rate statistics retrieved successfully",
+        fields.List(fields.Raw(description="User satisfaction rate data")),
+    )
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = StatisticTimeRangeQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        converted_created_at = convert_datetime_to_date("m.created_at")
+        sql_query = f"""SELECT
+    {converted_created_at} AS date,
+    COUNT(m.id) AS message_count,
+    COUNT(mf.id) AS feedback_count
+FROM
+    messages m
+LEFT JOIN
+    message_feedbacks mf
+    ON mf.message_id=m.id AND mf.rating='like'
+WHERE
+    m.app_id = :app_id
+    AND m.invoke_from != :invoke_from"""
+        arg_dict = {"tz": account.timezone, "app_id": app_model.id, "invoke_from": InvokeFrom.DEBUGGER}
+        assert account.timezone is not None
+
+        try:
+            start_datetime_utc, end_datetime_utc = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        if start_datetime_utc:
+            sql_query += " AND m.created_at >= :start"
+            arg_dict["start"] = start_datetime_utc
+
+        if end_datetime_utc:
+            sql_query += " AND m.created_at < :end"
+            arg_dict["end"] = end_datetime_utc
+
+        sql_query += " GROUP BY date ORDER BY date"
+
+        response_data = []
+
+        with db.engine.begin() as conn:
+            rs = conn.execute(sa.text(sql_query), arg_dict)
+            for i in rs:
+                response_data.append(
+                    {
+                        "date": str(i.date),
+                        "rate": round((i.feedback_count * 1000 / i.message_count) if i.message_count > 0 else 0, 2),
+                    }
+                )
+
+        return jsonify({"data": response_data})
+
+
+@console_ns.route("/apps/<uuid:app_id>/statistics/average-response-time")
+class AverageResponseTimeStatistic(Resource):
+    @console_ns.doc("get_average_response_time_statistics")
+    @console_ns.doc(description="Get average response time statistics for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[StatisticTimeRangeQuery.__name__])
+    @console_ns.response(
+        200,
+        "Average response time statistics retrieved successfully",
+        fields.List(fields.Raw(description="Average response time data")),
+    )
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=AppMode.COMPLETION)
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = StatisticTimeRangeQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        converted_created_at = convert_datetime_to_date("created_at")
+        sql_query = f"""SELECT
+    {converted_created_at} AS date,
+    AVG(provider_response_latency) AS latency
+FROM
+    messages
+WHERE
+    app_id = :app_id
+    AND invoke_from != :invoke_from"""
+        arg_dict = {"tz": account.timezone, "app_id": app_model.id, "invoke_from": InvokeFrom.DEBUGGER}
+        assert account.timezone is not None
+
+        try:
+            start_datetime_utc, end_datetime_utc = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        if start_datetime_utc:
+            sql_query += " AND created_at >= :start"
+            arg_dict["start"] = start_datetime_utc
+
+        if end_datetime_utc:
+            sql_query += " AND created_at < :end"
+            arg_dict["end"] = end_datetime_utc
+
+        sql_query += " GROUP BY date ORDER BY date"
+
+        response_data = []
+
+        with db.engine.begin() as conn:
+            rs = conn.execute(sa.text(sql_query), arg_dict)
+            for i in rs:
+                response_data.append({"date": str(i.date), "latency": round(i.latency * 1000, 4)})
+
+        return jsonify({"data": response_data})
+
+
+@console_ns.route("/apps/<uuid:app_id>/statistics/tokens-per-second")
+class TokensPerSecondStatistic(Resource):
+    @console_ns.doc("get_tokens_per_second_statistics")
+    @console_ns.doc(description="Get tokens per second statistics for an application")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[StatisticTimeRangeQuery.__name__])
+    @console_ns.response(
+        200,
+        "Tokens per second statistics retrieved successfully",
+        fields.List(fields.Raw(description="Tokens per second data")),
+    )
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+        args = StatisticTimeRangeQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        converted_created_at = convert_datetime_to_date("created_at")
+        sql_query = f"""SELECT
+    {converted_created_at} AS date,
+    CASE
+        WHEN SUM(provider_response_latency) = 0 THEN 0
+        ELSE (SUM(answer_tokens) / SUM(provider_response_latency))
+    END as tokens_per_second
+FROM
+    messages
+WHERE
+    app_id = :app_id
+    AND invoke_from != :invoke_from"""
+        arg_dict = {"tz": account.timezone, "app_id": app_model.id, "invoke_from": InvokeFrom.DEBUGGER}
+        assert account.timezone is not None
+
+        try:
+            start_datetime_utc, end_datetime_utc = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        if start_datetime_utc:
+            sql_query += " AND created_at >= :start"
+            arg_dict["start"] = start_datetime_utc
+
+        if end_datetime_utc:
+            sql_query += " AND created_at < :end"
+            arg_dict["end"] = end_datetime_utc
+
+        sql_query += " GROUP BY date ORDER BY date"
+
+        response_data = []
+
+        with db.engine.begin() as conn:
+            rs = conn.execute(sa.text(sql_query), arg_dict)
+            for i in rs:
+                response_data.append({"date": str(i.date), "tps": round(i.tokens_per_second, 4)})
+
+        return jsonify({"data": response_data})

dify_1.11.1/api/controllers/console/app/workflow_app_log.py

@@ -0,0 +1,101 @@
+from datetime import datetime
+
+from dateutil.parser import isoparse
+from flask import request
+from flask_restx import Resource, marshal_with
+from pydantic import BaseModel, Field, field_validator
+from sqlalchemy.orm import Session
+
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, setup_required
+from core.workflow.enums import WorkflowExecutionStatus
+from extensions.ext_database import db
+from fields.workflow_app_log_fields import build_workflow_app_log_pagination_model
+from libs.login import login_required
+from models import App
+from models.model import AppMode
+from services.workflow_app_service import WorkflowAppService
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class WorkflowAppLogQuery(BaseModel):
+    keyword: str | None = Field(default=None, description="Search keyword for filtering logs")
+    status: WorkflowExecutionStatus | None = Field(
+        default=None, description="Execution status filter (succeeded, failed, stopped, partial-succeeded)"
+    )
+    created_at__before: datetime | None = Field(default=None, description="Filter logs created before this timestamp")
+    created_at__after: datetime | None = Field(default=None, description="Filter logs created after this timestamp")
+    created_by_end_user_session_id: str | None = Field(default=None, description="Filter by end user session ID")
+    created_by_account: str | None = Field(default=None, description="Filter by account")
+    detail: bool = Field(default=False, description="Whether to return detailed logs")
+    page: int = Field(default=1, ge=1, le=99999, description="Page number (1-99999)")
+    limit: int = Field(default=20, ge=1, le=100, description="Number of items per page (1-100)")
+
+    @field_validator("created_at__before", "created_at__after", mode="before")
+    @classmethod
+    def parse_datetime(cls, value: str | None) -> datetime | None:
+        if value in (None, ""):
+            return None
+        return isoparse(value)  # type: ignore
+
+    @field_validator("detail", mode="before")
+    @classmethod
+    def parse_bool(cls, value: bool | str | None) -> bool:
+        if isinstance(value, bool):
+            return value
+        if value is None:
+            return False
+        lowered = value.lower()
+        if lowered in {"1", "true", "yes", "on"}:
+            return True
+        if lowered in {"0", "false", "no", "off"}:
+            return False
+        raise ValueError("Invalid boolean value for detail")
+
+
+console_ns.schema_model(
+    WorkflowAppLogQuery.__name__, WorkflowAppLogQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+
+# Register model for flask_restx to avoid dict type issues in Swagger
+workflow_app_log_pagination_model = build_workflow_app_log_pagination_model(console_ns)
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflow-app-logs")
+class WorkflowAppLogApi(Resource):
+    @console_ns.doc("get_workflow_app_logs")
+    @console_ns.doc(description="Get workflow application execution logs")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[WorkflowAppLogQuery.__name__])
+    @console_ns.response(200, "Workflow app logs retrieved successfully", workflow_app_log_pagination_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.WORKFLOW])
+    @marshal_with(workflow_app_log_pagination_model)
+    def get(self, app_model: App):
+        """
+        Get workflow app logs
+        """
+        args = WorkflowAppLogQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        # get paginate workflow app logs
+        workflow_app_service = WorkflowAppService()
+        with Session(db.engine) as session:
+            workflow_app_log_pagination = workflow_app_service.get_paginate_workflow_app_logs(
+                session=session,
+                app_model=app_model,
+                keyword=args.keyword,
+                status=args.status,
+                created_at_before=args.created_at__before,
+                created_at_after=args.created_at__after,
+                page=args.page,
+                limit=args.limit,
+                detail=args.detail,
+                created_by_end_user_session_id=args.created_by_end_user_session_id,
+                created_by_account=args.created_by_account,
+            )
+
+            return workflow_app_log_pagination

dify_1.11.1/api/controllers/console/app/workflow_draft_variable.py

@@ -0,0 +1,529 @@
+import logging
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, NoReturn, ParamSpec, TypeVar
+
+from flask import Response, request
+from flask_restx import Resource, fields, marshal, marshal_with
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+from controllers.console import console_ns
+from controllers.console.app.error import (
+    DraftWorkflowNotExist,
+)
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
+from controllers.web.error import InvalidArgumentError, NotFoundError
+from core.file import helpers as file_helpers
+from core.variables.segment_group import SegmentGroup
+from core.variables.segments import ArrayFileSegment, FileSegment, Segment
+from core.variables.types import SegmentType
+from core.workflow.constants import CONVERSATION_VARIABLE_NODE_ID, SYSTEM_VARIABLE_NODE_ID
+from extensions.ext_database import db
+from factories.file_factory import build_from_mapping, build_from_mappings
+from factories.variable_factory import build_segment_with_type
+from libs.login import login_required
+from models import App, AppMode
+from models.workflow import WorkflowDraftVariable
+from services.workflow_draft_variable_service import WorkflowDraftVariableList, WorkflowDraftVariableService
+from services.workflow_service import WorkflowService
+
+logger = logging.getLogger(__name__)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class WorkflowDraftVariableListQuery(BaseModel):
+    page: int = Field(default=1, ge=1, le=100_000, description="Page number")
+    limit: int = Field(default=20, ge=1, le=100, description="Items per page")
+
+
+class WorkflowDraftVariableUpdatePayload(BaseModel):
+    name: str | None = Field(default=None, description="Variable name")
+    value: Any | None = Field(default=None, description="Variable value")
+
+
+console_ns.schema_model(
+    WorkflowDraftVariableListQuery.__name__,
+    WorkflowDraftVariableListQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+console_ns.schema_model(
+    WorkflowDraftVariableUpdatePayload.__name__,
+    WorkflowDraftVariableUpdatePayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+
+def _convert_values_to_json_serializable_object(value: Segment):
+    if isinstance(value, FileSegment):
+        return value.value.model_dump()
+    elif isinstance(value, ArrayFileSegment):
+        return [i.model_dump() for i in value.value]
+    elif isinstance(value, SegmentGroup):
+        return [_convert_values_to_json_serializable_object(i) for i in value.value]
+    else:
+        return value.value
+
+
+def _serialize_var_value(variable: WorkflowDraftVariable):
+    value = variable.get_value()
+    # create a copy of the value to avoid affecting the model cache.
+    value = value.model_copy(deep=True)
+    # Refresh the url signature before returning it to client.
+    if isinstance(value, FileSegment):
+        file = value.value
+        file.remote_url = file.generate_url()
+    elif isinstance(value, ArrayFileSegment):
+        files = value.value
+        for file in files:
+            file.remote_url = file.generate_url()
+    return _convert_values_to_json_serializable_object(value)
+
+
+def _serialize_variable_type(workflow_draft_var: WorkflowDraftVariable) -> str:
+    value_type = workflow_draft_var.value_type
+    return value_type.exposed_type().value
+
+
+def _serialize_full_content(variable: WorkflowDraftVariable) -> dict | None:
+    """Serialize full_content information for large variables."""
+    if not variable.is_truncated():
+        return None
+
+    variable_file = variable.variable_file
+    assert variable_file is not None
+
+    return {
+        "size_bytes": variable_file.size,
+        "value_type": variable_file.value_type.exposed_type().value,
+        "length": variable_file.length,
+        "download_url": file_helpers.get_signed_file_url(variable_file.upload_file_id, as_attachment=True),
+    }
+
+
+_WORKFLOW_DRAFT_VARIABLE_WITHOUT_VALUE_FIELDS = {
+    "id": fields.String,
+    "type": fields.String(attribute=lambda model: model.get_variable_type()),
+    "name": fields.String,
+    "description": fields.String,
+    "selector": fields.List(fields.String, attribute=lambda model: model.get_selector()),
+    "value_type": fields.String(attribute=_serialize_variable_type),
+    "edited": fields.Boolean(attribute=lambda model: model.edited),
+    "visible": fields.Boolean,
+    "is_truncated": fields.Boolean(attribute=lambda model: model.file_id is not None),
+}
+
+_WORKFLOW_DRAFT_VARIABLE_FIELDS = dict(
+    _WORKFLOW_DRAFT_VARIABLE_WITHOUT_VALUE_FIELDS,
+    value=fields.Raw(attribute=_serialize_var_value),
+    full_content=fields.Raw(attribute=_serialize_full_content),
+)
+
+_WORKFLOW_DRAFT_ENV_VARIABLE_FIELDS = {
+    "id": fields.String,
+    "type": fields.String(attribute=lambda _: "env"),
+    "name": fields.String,
+    "description": fields.String,
+    "selector": fields.List(fields.String, attribute=lambda model: model.get_selector()),
+    "value_type": fields.String(attribute=_serialize_variable_type),
+    "edited": fields.Boolean(attribute=lambda model: model.edited),
+    "visible": fields.Boolean,
+}
+
+_WORKFLOW_DRAFT_ENV_VARIABLE_LIST_FIELDS = {
+    "items": fields.List(fields.Nested(_WORKFLOW_DRAFT_ENV_VARIABLE_FIELDS)),
+}
+
+
+def _get_items(var_list: WorkflowDraftVariableList) -> list[WorkflowDraftVariable]:
+    return var_list.variables
+
+
+_WORKFLOW_DRAFT_VARIABLE_LIST_WITHOUT_VALUE_FIELDS = {
+    "items": fields.List(fields.Nested(_WORKFLOW_DRAFT_VARIABLE_WITHOUT_VALUE_FIELDS), attribute=_get_items),
+    "total": fields.Raw(),
+}
+
+_WORKFLOW_DRAFT_VARIABLE_LIST_FIELDS = {
+    "items": fields.List(fields.Nested(_WORKFLOW_DRAFT_VARIABLE_FIELDS), attribute=_get_items),
+}
+
+# Register models for flask_restx to avoid dict type issues in Swagger
+workflow_draft_variable_without_value_model = console_ns.model(
+    "WorkflowDraftVariableWithoutValue", _WORKFLOW_DRAFT_VARIABLE_WITHOUT_VALUE_FIELDS
+)
+
+workflow_draft_variable_model = console_ns.model("WorkflowDraftVariable", _WORKFLOW_DRAFT_VARIABLE_FIELDS)
+
+workflow_draft_env_variable_model = console_ns.model("WorkflowDraftEnvVariable", _WORKFLOW_DRAFT_ENV_VARIABLE_FIELDS)
+
+workflow_draft_env_variable_list_fields_copy = _WORKFLOW_DRAFT_ENV_VARIABLE_LIST_FIELDS.copy()
+workflow_draft_env_variable_list_fields_copy["items"] = fields.List(fields.Nested(workflow_draft_env_variable_model))
+workflow_draft_env_variable_list_model = console_ns.model(
+    "WorkflowDraftEnvVariableList", workflow_draft_env_variable_list_fields_copy
+)
+
+workflow_draft_variable_list_without_value_fields_copy = _WORKFLOW_DRAFT_VARIABLE_LIST_WITHOUT_VALUE_FIELDS.copy()
+workflow_draft_variable_list_without_value_fields_copy["items"] = fields.List(
+    fields.Nested(workflow_draft_variable_without_value_model), attribute=_get_items
+)
+workflow_draft_variable_list_without_value_model = console_ns.model(
+    "WorkflowDraftVariableListWithoutValue", workflow_draft_variable_list_without_value_fields_copy
+)
+
+workflow_draft_variable_list_fields_copy = _WORKFLOW_DRAFT_VARIABLE_LIST_FIELDS.copy()
+workflow_draft_variable_list_fields_copy["items"] = fields.List(
+    fields.Nested(workflow_draft_variable_model), attribute=_get_items
+)
+workflow_draft_variable_list_model = console_ns.model(
+    "WorkflowDraftVariableList", workflow_draft_variable_list_fields_copy
+)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def _api_prerequisite(f: Callable[P, R]):
+    """Common prerequisites for all draft workflow variable APIs.
+
+    It ensures the following conditions are satisfied:
+
+    - Dify has been property setup.
+    - The request user has logged in and initialized.
+    - The requested app is a workflow or a chat flow.
+    - The request user has the edit permission for the app.
+    """
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
+    @wraps(f)
+    def wrapper(*args: P.args, **kwargs: P.kwargs):
+        return f(*args, **kwargs)
+
+    return wrapper
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/draft/variables")
+class WorkflowVariableCollectionApi(Resource):
+    @console_ns.expect(console_ns.models[WorkflowDraftVariableListQuery.__name__])
+    @console_ns.doc("get_workflow_variables")
+    @console_ns.doc(description="Get draft workflow variables")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.doc(params={"page": "Page number (1-100000)", "limit": "Number of items per page (1-100)"})
+    @console_ns.response(
+        200, "Workflow variables retrieved successfully", workflow_draft_variable_list_without_value_model
+    )
+    @_api_prerequisite
+    @marshal_with(workflow_draft_variable_list_without_value_model)
+    def get(self, app_model: App):
+        """
+        Get draft workflow
+        """
+        args = WorkflowDraftVariableListQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        # fetch draft workflow by app_model
+        workflow_service = WorkflowService()
+        workflow_exist = workflow_service.is_workflow_exist(app_model=app_model)
+        if not workflow_exist:
+            raise DraftWorkflowNotExist()
+
+        # fetch draft workflow by app_model
+        with Session(bind=db.engine, expire_on_commit=False) as session:
+            draft_var_srv = WorkflowDraftVariableService(
+                session=session,
+            )
+            workflow_vars = draft_var_srv.list_variables_without_values(
+                app_id=app_model.id,
+                page=args.page,
+                limit=args.limit,
+            )
+
+        return workflow_vars
+
+    @console_ns.doc("delete_workflow_variables")
+    @console_ns.doc(description="Delete all draft workflow variables")
+    @console_ns.response(204, "Workflow variables deleted successfully")
+    @_api_prerequisite
+    def delete(self, app_model: App):
+        draft_var_srv = WorkflowDraftVariableService(
+            session=db.session(),
+        )
+        draft_var_srv.delete_workflow_variables(app_model.id)
+        db.session.commit()
+        return Response("", 204)
+
+
+def validate_node_id(node_id: str) -> NoReturn | None:
+    if node_id in [
+        CONVERSATION_VARIABLE_NODE_ID,
+        SYSTEM_VARIABLE_NODE_ID,
+    ]:
+        # NOTE(QuantumGhost): While we store the system and conversation variables as node variables
+        # with specific `node_id` in database, we still want to make the API separated. By disallowing
+        # accessing system and conversation variables in `WorkflowDraftNodeVariableListApi`,
+        # we mitigate the risk that user of the API depending on the implementation detail of the API.
+        #
+        # ref: [Hyrum's Law](https://www.hyrumslaw.com/)
+
+        raise InvalidArgumentError(
+            f"invalid node_id, please use correspond api for conversation and system variables, node_id={node_id}",
+        )
+    return None
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/variables")
+class NodeVariableCollectionApi(Resource):
+    @console_ns.doc("get_node_variables")
+    @console_ns.doc(description="Get variables for a specific node")
+    @console_ns.doc(params={"app_id": "Application ID", "node_id": "Node ID"})
+    @console_ns.response(200, "Node variables retrieved successfully", workflow_draft_variable_list_model)
+    @_api_prerequisite
+    @marshal_with(workflow_draft_variable_list_model)
+    def get(self, app_model: App, node_id: str):
+        validate_node_id(node_id)
+        with Session(bind=db.engine, expire_on_commit=False) as session:
+            draft_var_srv = WorkflowDraftVariableService(
+                session=session,
+            )
+            node_vars = draft_var_srv.list_node_variables(app_model.id, node_id)
+
+        return node_vars
+
+    @console_ns.doc("delete_node_variables")
+    @console_ns.doc(description="Delete all variables for a specific node")
+    @console_ns.response(204, "Node variables deleted successfully")
+    @_api_prerequisite
+    def delete(self, app_model: App, node_id: str):
+        validate_node_id(node_id)
+        srv = WorkflowDraftVariableService(db.session())
+        srv.delete_node_variables(app_model.id, node_id)
+        db.session.commit()
+        return Response("", 204)
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/draft/variables/<uuid:variable_id>")
+class VariableApi(Resource):
+    _PATCH_NAME_FIELD = "name"
+    _PATCH_VALUE_FIELD = "value"
+
+    @console_ns.doc("get_variable")
+    @console_ns.doc(description="Get a specific workflow variable")
+    @console_ns.doc(params={"app_id": "Application ID", "variable_id": "Variable ID"})
+    @console_ns.response(200, "Variable retrieved successfully", workflow_draft_variable_model)
+    @console_ns.response(404, "Variable not found")
+    @_api_prerequisite
+    @marshal_with(workflow_draft_variable_model)
+    def get(self, app_model: App, variable_id: str):
+        draft_var_srv = WorkflowDraftVariableService(
+            session=db.session(),
+        )
+        variable = draft_var_srv.get_variable(variable_id=variable_id)
+        if variable is None:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        if variable.app_id != app_model.id:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        return variable
+
+    @console_ns.doc("update_variable")
+    @console_ns.doc(description="Update a workflow variable")
+    @console_ns.expect(console_ns.models[WorkflowDraftVariableUpdatePayload.__name__])
+    @console_ns.response(200, "Variable updated successfully", workflow_draft_variable_model)
+    @console_ns.response(404, "Variable not found")
+    @_api_prerequisite
+    @marshal_with(workflow_draft_variable_model)
+    def patch(self, app_model: App, variable_id: str):
+        # Request payload for file types:
+        #
+        # Local File:
+        #
+        #     {
+        #         "type": "image",
+        #         "transfer_method": "local_file",
+        #         "url": "",
+        #         "upload_file_id": "daded54f-72c7-4f8e-9d18-9b0abdd9f190"
+        #     }
+        #
+        # Remote File:
+        #
+        #
+        #     {
+        #         "type": "image",
+        #         "transfer_method": "remote_url",
+        #         "url": "http://127.0.0.1:5001/files/1602650a-4fe4-423c-85a2-af76c083e3c4/file-preview?timestamp=1750041099&nonce=...&sign=...=",
+        #         "upload_file_id": "1602650a-4fe4-423c-85a2-af76c083e3c4"
+        #     }
+
+        draft_var_srv = WorkflowDraftVariableService(
+            session=db.session(),
+        )
+        args_model = WorkflowDraftVariableUpdatePayload.model_validate(console_ns.payload or {})
+
+        variable = draft_var_srv.get_variable(variable_id=variable_id)
+        if variable is None:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        if variable.app_id != app_model.id:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+
+        new_name = args_model.name
+        raw_value = args_model.value
+        if new_name is None and raw_value is None:
+            return variable
+
+        new_value = None
+        if raw_value is not None:
+            if variable.value_type == SegmentType.FILE:
+                if not isinstance(raw_value, dict):
+                    raise InvalidArgumentError(description=f"expected dict for file, got {type(raw_value)}")
+                raw_value = build_from_mapping(mapping=raw_value, tenant_id=app_model.tenant_id)
+            elif variable.value_type == SegmentType.ARRAY_FILE:
+                if not isinstance(raw_value, list):
+                    raise InvalidArgumentError(description=f"expected list for files, got {type(raw_value)}")
+                if len(raw_value) > 0 and not isinstance(raw_value[0], dict):
+                    raise InvalidArgumentError(description=f"expected dict for files[0], got {type(raw_value)}")
+                raw_value = build_from_mappings(mappings=raw_value, tenant_id=app_model.tenant_id)
+            new_value = build_segment_with_type(variable.value_type, raw_value)
+        draft_var_srv.update_variable(variable, name=new_name, value=new_value)
+        db.session.commit()
+        return variable
+
+    @console_ns.doc("delete_variable")
+    @console_ns.doc(description="Delete a workflow variable")
+    @console_ns.response(204, "Variable deleted successfully")
+    @console_ns.response(404, "Variable not found")
+    @_api_prerequisite
+    def delete(self, app_model: App, variable_id: str):
+        draft_var_srv = WorkflowDraftVariableService(
+            session=db.session(),
+        )
+        variable = draft_var_srv.get_variable(variable_id=variable_id)
+        if variable is None:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        if variable.app_id != app_model.id:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        draft_var_srv.delete_variable(variable)
+        db.session.commit()
+        return Response("", 204)
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/draft/variables/<uuid:variable_id>/reset")
+class VariableResetApi(Resource):
+    @console_ns.doc("reset_variable")
+    @console_ns.doc(description="Reset a workflow variable to its default value")
+    @console_ns.doc(params={"app_id": "Application ID", "variable_id": "Variable ID"})
+    @console_ns.response(200, "Variable reset successfully", workflow_draft_variable_model)
+    @console_ns.response(204, "Variable reset (no content)")
+    @console_ns.response(404, "Variable not found")
+    @_api_prerequisite
+    def put(self, app_model: App, variable_id: str):
+        draft_var_srv = WorkflowDraftVariableService(
+            session=db.session(),
+        )
+
+        workflow_srv = WorkflowService()
+        draft_workflow = workflow_srv.get_draft_workflow(app_model)
+        if draft_workflow is None:
+            raise NotFoundError(
+                f"Draft workflow not found, app_id={app_model.id}",
+            )
+        variable = draft_var_srv.get_variable(variable_id=variable_id)
+        if variable is None:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        if variable.app_id != app_model.id:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+
+        resetted = draft_var_srv.reset_variable(draft_workflow, variable)
+        db.session.commit()
+        if resetted is None:
+            return Response("", 204)
+        else:
+            return marshal(resetted, workflow_draft_variable_model)
+
+
+def _get_variable_list(app_model: App, node_id) -> WorkflowDraftVariableList:
+    with Session(bind=db.engine, expire_on_commit=False) as session:
+        draft_var_srv = WorkflowDraftVariableService(
+            session=session,
+        )
+        if node_id == CONVERSATION_VARIABLE_NODE_ID:
+            draft_vars = draft_var_srv.list_conversation_variables(app_model.id)
+        elif node_id == SYSTEM_VARIABLE_NODE_ID:
+            draft_vars = draft_var_srv.list_system_variables(app_model.id)
+        else:
+            draft_vars = draft_var_srv.list_node_variables(app_id=app_model.id, node_id=node_id)
+    return draft_vars
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/draft/conversation-variables")
+class ConversationVariableCollectionApi(Resource):
+    @console_ns.doc("get_conversation_variables")
+    @console_ns.doc(description="Get conversation variables for workflow")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(200, "Conversation variables retrieved successfully", workflow_draft_variable_list_model)
+    @console_ns.response(404, "Draft workflow not found")
+    @_api_prerequisite
+    @marshal_with(workflow_draft_variable_list_model)
+    def get(self, app_model: App):
+        # NOTE(QuantumGhost): Prefill conversation variables into the draft variables table
+        # so their IDs can be returned to the caller.
+        workflow_srv = WorkflowService()
+        draft_workflow = workflow_srv.get_draft_workflow(app_model)
+        if draft_workflow is None:
+            raise NotFoundError(description=f"draft workflow not found, id={app_model.id}")
+        draft_var_srv = WorkflowDraftVariableService(db.session())
+        draft_var_srv.prefill_conversation_variable_default_values(draft_workflow)
+        db.session.commit()
+        return _get_variable_list(app_model, CONVERSATION_VARIABLE_NODE_ID)
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/draft/system-variables")
+class SystemVariableCollectionApi(Resource):
+    @console_ns.doc("get_system_variables")
+    @console_ns.doc(description="Get system variables for workflow")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(200, "System variables retrieved successfully", workflow_draft_variable_list_model)
+    @_api_prerequisite
+    @marshal_with(workflow_draft_variable_list_model)
+    def get(self, app_model: App):
+        return _get_variable_list(app_model, SYSTEM_VARIABLE_NODE_ID)
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/draft/environment-variables")
+class EnvironmentVariableCollectionApi(Resource):
+    @console_ns.doc("get_environment_variables")
+    @console_ns.doc(description="Get environment variables for workflow")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.response(200, "Environment variables retrieved successfully")
+    @console_ns.response(404, "Draft workflow not found")
+    @_api_prerequisite
+    def get(self, app_model: App):
+        """
+        Get draft workflow
+        """
+        # fetch draft workflow by app_model
+        workflow_service = WorkflowService()
+        workflow = workflow_service.get_draft_workflow(app_model=app_model)
+        if workflow is None:
+            raise DraftWorkflowNotExist()
+
+        env_vars = workflow.environment_variables
+        env_vars_list = []
+        for v in env_vars:
+            env_vars_list.append(
+                {
+                    "id": v.id,
+                    "type": "env",
+                    "name": v.name,
+                    "description": v.description,
+                    "selector": v.selector,
+                    "value_type": v.value_type.exposed_type().value,
+                    "value": v.value,
+                    # Do not track edited for env vars.
+                    "edited": False,
+                    "visible": True,
+                    "editable": True,
+                }
+            )
+
+        return {"items": env_vars_list}

dify_1.11.1/api/controllers/console/app/workflow_run.py

@@ -0,0 +1,377 @@
+from typing import Literal, cast
+
+from flask import request
+from flask_restx import Resource, fields, marshal_with
+from pydantic import BaseModel, Field, field_validator
+
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, setup_required
+from fields.end_user_fields import simple_end_user_fields
+from fields.member_fields import simple_account_fields
+from fields.workflow_run_fields import (
+    advanced_chat_workflow_run_for_list_fields,
+    advanced_chat_workflow_run_pagination_fields,
+    workflow_run_count_fields,
+    workflow_run_detail_fields,
+    workflow_run_for_list_fields,
+    workflow_run_node_execution_fields,
+    workflow_run_node_execution_list_fields,
+    workflow_run_pagination_fields,
+)
+from libs.custom_inputs import time_duration
+from libs.helper import uuid_value
+from libs.login import current_user, login_required
+from models import Account, App, AppMode, EndUser, WorkflowRunTriggeredFrom
+from services.workflow_run_service import WorkflowRunService
+
+# Workflow run status choices for filtering
+WORKFLOW_RUN_STATUS_CHOICES = ["running", "succeeded", "failed", "stopped", "partial-succeeded"]
+
+# Register models for flask_restx to avoid dict type issues in Swagger
+# Register in dependency order: base models first, then dependent models
+
+# Base models
+simple_account_model = console_ns.model("SimpleAccount", simple_account_fields)
+
+simple_end_user_model = console_ns.model("SimpleEndUser", simple_end_user_fields)
+
+# Models that depend on simple_account_fields
+workflow_run_for_list_fields_copy = workflow_run_for_list_fields.copy()
+workflow_run_for_list_fields_copy["created_by_account"] = fields.Nested(
+    simple_account_model, attribute="created_by_account", allow_null=True
+)
+workflow_run_for_list_model = console_ns.model("WorkflowRunForList", workflow_run_for_list_fields_copy)
+
+advanced_chat_workflow_run_for_list_fields_copy = advanced_chat_workflow_run_for_list_fields.copy()
+advanced_chat_workflow_run_for_list_fields_copy["created_by_account"] = fields.Nested(
+    simple_account_model, attribute="created_by_account", allow_null=True
+)
+advanced_chat_workflow_run_for_list_model = console_ns.model(
+    "AdvancedChatWorkflowRunForList", advanced_chat_workflow_run_for_list_fields_copy
+)
+
+workflow_run_detail_fields_copy = workflow_run_detail_fields.copy()
+workflow_run_detail_fields_copy["created_by_account"] = fields.Nested(
+    simple_account_model, attribute="created_by_account", allow_null=True
+)
+workflow_run_detail_fields_copy["created_by_end_user"] = fields.Nested(
+    simple_end_user_model, attribute="created_by_end_user", allow_null=True
+)
+workflow_run_detail_model = console_ns.model("WorkflowRunDetail", workflow_run_detail_fields_copy)
+
+workflow_run_node_execution_fields_copy = workflow_run_node_execution_fields.copy()
+workflow_run_node_execution_fields_copy["created_by_account"] = fields.Nested(
+    simple_account_model, attribute="created_by_account", allow_null=True
+)
+workflow_run_node_execution_fields_copy["created_by_end_user"] = fields.Nested(
+    simple_end_user_model, attribute="created_by_end_user", allow_null=True
+)
+workflow_run_node_execution_model = console_ns.model(
+    "WorkflowRunNodeExecution", workflow_run_node_execution_fields_copy
+)
+
+# Simple models without nested dependencies
+workflow_run_count_model = console_ns.model("WorkflowRunCount", workflow_run_count_fields)
+
+# Pagination models that depend on list models
+advanced_chat_workflow_run_pagination_fields_copy = advanced_chat_workflow_run_pagination_fields.copy()
+advanced_chat_workflow_run_pagination_fields_copy["data"] = fields.List(
+    fields.Nested(advanced_chat_workflow_run_for_list_model), attribute="data"
+)
+advanced_chat_workflow_run_pagination_model = console_ns.model(
+    "AdvancedChatWorkflowRunPagination", advanced_chat_workflow_run_pagination_fields_copy
+)
+
+workflow_run_pagination_fields_copy = workflow_run_pagination_fields.copy()
+workflow_run_pagination_fields_copy["data"] = fields.List(fields.Nested(workflow_run_for_list_model), attribute="data")
+workflow_run_pagination_model = console_ns.model("WorkflowRunPagination", workflow_run_pagination_fields_copy)
+
+workflow_run_node_execution_list_fields_copy = workflow_run_node_execution_list_fields.copy()
+workflow_run_node_execution_list_fields_copy["data"] = fields.List(fields.Nested(workflow_run_node_execution_model))
+workflow_run_node_execution_list_model = console_ns.model(
+    "WorkflowRunNodeExecutionList", workflow_run_node_execution_list_fields_copy
+)
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class WorkflowRunListQuery(BaseModel):
+    last_id: str | None = Field(default=None, description="Last run ID for pagination")
+    limit: int = Field(default=20, ge=1, le=100, description="Number of items per page (1-100)")
+    status: Literal["running", "succeeded", "failed", "stopped", "partial-succeeded"] | None = Field(
+        default=None, description="Workflow run status filter"
+    )
+    triggered_from: Literal["debugging", "app-run"] | None = Field(
+        default=None, description="Filter by trigger source: debugging or app-run"
+    )
+
+    @field_validator("last_id")
+    @classmethod
+    def validate_last_id(cls, value: str | None) -> str | None:
+        if value is None:
+            return value
+        return uuid_value(value)
+
+
+class WorkflowRunCountQuery(BaseModel):
+    status: Literal["running", "succeeded", "failed", "stopped", "partial-succeeded"] | None = Field(
+        default=None, description="Workflow run status filter"
+    )
+    time_range: str | None = Field(default=None, description="Time range filter (e.g., 7d, 4h, 30m, 30s)")
+    triggered_from: Literal["debugging", "app-run"] | None = Field(
+        default=None, description="Filter by trigger source: debugging or app-run"
+    )
+
+    @field_validator("time_range")
+    @classmethod
+    def validate_time_range(cls, value: str | None) -> str | None:
+        if value is None:
+            return value
+        return time_duration(value)
+
+
+console_ns.schema_model(
+    WorkflowRunListQuery.__name__, WorkflowRunListQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+console_ns.schema_model(
+    WorkflowRunCountQuery.__name__,
+    WorkflowRunCountQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+
+@console_ns.route("/apps/<uuid:app_id>/advanced-chat/workflow-runs")
+class AdvancedChatAppWorkflowRunListApi(Resource):
+    @console_ns.doc("get_advanced_chat_workflow_runs")
+    @console_ns.doc(description="Get advanced chat workflow run list")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.doc(params={"last_id": "Last run ID for pagination", "limit": "Number of items per page (1-100)"})
+    @console_ns.doc(
+        params={"status": "Filter by status (optional): running, succeeded, failed, stopped, partial-succeeded"}
+    )
+    @console_ns.doc(
+        params={"triggered_from": "Filter by trigger source (optional): debugging or app-run. Default: debugging"}
+    )
+    @console_ns.expect(console_ns.models[WorkflowRunListQuery.__name__])
+    @console_ns.response(200, "Workflow runs retrieved successfully", advanced_chat_workflow_run_pagination_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT])
+    @marshal_with(advanced_chat_workflow_run_pagination_model)
+    def get(self, app_model: App):
+        """
+        Get advanced chat app workflow run list
+        """
+        args_model = WorkflowRunListQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        args = args_model.model_dump(exclude_none=True)
+
+        # Default to DEBUGGING if not specified
+        triggered_from = (
+            WorkflowRunTriggeredFrom(args_model.triggered_from)
+            if args_model.triggered_from
+            else WorkflowRunTriggeredFrom.DEBUGGING
+        )
+
+        workflow_run_service = WorkflowRunService()
+        result = workflow_run_service.get_paginate_advanced_chat_workflow_runs(
+            app_model=app_model, args=args, triggered_from=triggered_from
+        )
+
+        return result
+
+
+@console_ns.route("/apps/<uuid:app_id>/advanced-chat/workflow-runs/count")
+class AdvancedChatAppWorkflowRunCountApi(Resource):
+    @console_ns.doc("get_advanced_chat_workflow_runs_count")
+    @console_ns.doc(description="Get advanced chat workflow runs count statistics")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.doc(
+        params={"status": "Filter by status (optional): running, succeeded, failed, stopped, partial-succeeded"}
+    )
+    @console_ns.doc(
+        params={
+            "time_range": (
+                "Filter by time range (optional): e.g., 7d (7 days), 4h (4 hours), "
+                "30m (30 minutes), 30s (30 seconds). Filters by created_at field."
+            )
+        }
+    )
+    @console_ns.doc(
+        params={"triggered_from": "Filter by trigger source (optional): debugging or app-run. Default: debugging"}
+    )
+    @console_ns.response(200, "Workflow runs count retrieved successfully", workflow_run_count_model)
+    @console_ns.expect(console_ns.models[WorkflowRunCountQuery.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT])
+    @marshal_with(workflow_run_count_model)
+    def get(self, app_model: App):
+        """
+        Get advanced chat workflow runs count statistics
+        """
+        args_model = WorkflowRunCountQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        args = args_model.model_dump(exclude_none=True)
+
+        # Default to DEBUGGING if not specified
+        triggered_from = (
+            WorkflowRunTriggeredFrom(args_model.triggered_from)
+            if args_model.triggered_from
+            else WorkflowRunTriggeredFrom.DEBUGGING
+        )
+
+        workflow_run_service = WorkflowRunService()
+        result = workflow_run_service.get_workflow_runs_count(
+            app_model=app_model,
+            status=args.get("status"),
+            time_range=args.get("time_range"),
+            triggered_from=triggered_from,
+        )
+
+        return result
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflow-runs")
+class WorkflowRunListApi(Resource):
+    @console_ns.doc("get_workflow_runs")
+    @console_ns.doc(description="Get workflow run list")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.doc(params={"last_id": "Last run ID for pagination", "limit": "Number of items per page (1-100)"})
+    @console_ns.doc(
+        params={"status": "Filter by status (optional): running, succeeded, failed, stopped, partial-succeeded"}
+    )
+    @console_ns.doc(
+        params={"triggered_from": "Filter by trigger source (optional): debugging or app-run. Default: debugging"}
+    )
+    @console_ns.response(200, "Workflow runs retrieved successfully", workflow_run_pagination_model)
+    @console_ns.expect(console_ns.models[WorkflowRunListQuery.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
+    @marshal_with(workflow_run_pagination_model)
+    def get(self, app_model: App):
+        """
+        Get workflow run list
+        """
+        args_model = WorkflowRunListQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        args = args_model.model_dump(exclude_none=True)
+
+        # Default to DEBUGGING for workflow if not specified (backward compatibility)
+        triggered_from = (
+            WorkflowRunTriggeredFrom(args_model.triggered_from)
+            if args_model.triggered_from
+            else WorkflowRunTriggeredFrom.DEBUGGING
+        )
+
+        workflow_run_service = WorkflowRunService()
+        result = workflow_run_service.get_paginate_workflow_runs(
+            app_model=app_model, args=args, triggered_from=triggered_from
+        )
+
+        return result
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflow-runs/count")
+class WorkflowRunCountApi(Resource):
+    @console_ns.doc("get_workflow_runs_count")
+    @console_ns.doc(description="Get workflow runs count statistics")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.doc(
+        params={"status": "Filter by status (optional): running, succeeded, failed, stopped, partial-succeeded"}
+    )
+    @console_ns.doc(
+        params={
+            "time_range": (
+                "Filter by time range (optional): e.g., 7d (7 days), 4h (4 hours), "
+                "30m (30 minutes), 30s (30 seconds). Filters by created_at field."
+            )
+        }
+    )
+    @console_ns.doc(
+        params={"triggered_from": "Filter by trigger source (optional): debugging or app-run. Default: debugging"}
+    )
+    @console_ns.response(200, "Workflow runs count retrieved successfully", workflow_run_count_model)
+    @console_ns.expect(console_ns.models[WorkflowRunCountQuery.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
+    @marshal_with(workflow_run_count_model)
+    def get(self, app_model: App):
+        """
+        Get workflow runs count statistics
+        """
+        args_model = WorkflowRunCountQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        args = args_model.model_dump(exclude_none=True)
+
+        # Default to DEBUGGING for workflow if not specified (backward compatibility)
+        triggered_from = (
+            WorkflowRunTriggeredFrom(args_model.triggered_from)
+            if args_model.triggered_from
+            else WorkflowRunTriggeredFrom.DEBUGGING
+        )
+
+        workflow_run_service = WorkflowRunService()
+        result = workflow_run_service.get_workflow_runs_count(
+            app_model=app_model,
+            status=args.get("status"),
+            time_range=args.get("time_range"),
+            triggered_from=triggered_from,
+        )
+
+        return result
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflow-runs/<uuid:run_id>")
+class WorkflowRunDetailApi(Resource):
+    @console_ns.doc("get_workflow_run_detail")
+    @console_ns.doc(description="Get workflow run detail")
+    @console_ns.doc(params={"app_id": "Application ID", "run_id": "Workflow run ID"})
+    @console_ns.response(200, "Workflow run detail retrieved successfully", workflow_run_detail_model)
+    @console_ns.response(404, "Workflow run not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
+    @marshal_with(workflow_run_detail_model)
+    def get(self, app_model: App, run_id):
+        """
+        Get workflow run detail
+        """
+        run_id = str(run_id)
+
+        workflow_run_service = WorkflowRunService()
+        workflow_run = workflow_run_service.get_workflow_run(app_model=app_model, run_id=run_id)
+
+        return workflow_run
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflow-runs/<uuid:run_id>/node-executions")
+class WorkflowRunNodeExecutionListApi(Resource):
+    @console_ns.doc("get_workflow_run_node_executions")
+    @console_ns.doc(description="Get workflow run node execution list")
+    @console_ns.doc(params={"app_id": "Application ID", "run_id": "Workflow run ID"})
+    @console_ns.response(200, "Node executions retrieved successfully", workflow_run_node_execution_list_model)
+    @console_ns.response(404, "Workflow run not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
+    @marshal_with(workflow_run_node_execution_list_model)
+    def get(self, app_model: App, run_id):
+        """
+        Get workflow run node execution list
+        """
+        run_id = str(run_id)
+
+        workflow_run_service = WorkflowRunService()
+        user = cast("Account | EndUser", current_user)
+        node_executions = workflow_run_service.get_workflow_run_node_executions(
+            app_model=app_model,
+            run_id=run_id,
+            user=user,
+        )
+
+        return {"data": node_executions}

dify_1.11.1/api/controllers/console/app/workflow_statistic.py

@@ -0,0 +1,194 @@
+from flask import abort, jsonify, request
+from flask_restx import Resource
+from pydantic import BaseModel, Field, field_validator
+from sqlalchemy.orm import sessionmaker
+
+from controllers.console import console_ns
+from controllers.console.app.wraps import get_app_model
+from controllers.console.wraps import account_initialization_required, setup_required
+from extensions.ext_database import db
+from libs.datetime_utils import parse_time_range
+from libs.login import current_account_with_tenant, login_required
+from models.enums import WorkflowRunTriggeredFrom
+from models.model import AppMode
+from repositories.factory import DifyAPIRepositoryFactory
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class WorkflowStatisticQuery(BaseModel):
+    start: str | None = Field(default=None, description="Start date and time (YYYY-MM-DD HH:MM)")
+    end: str | None = Field(default=None, description="End date and time (YYYY-MM-DD HH:MM)")
+
+    @field_validator("start", "end", mode="before")
+    @classmethod
+    def blank_to_none(cls, value: str | None) -> str | None:
+        if value == "":
+            return None
+        return value
+
+
+console_ns.schema_model(
+    WorkflowStatisticQuery.__name__,
+    WorkflowStatisticQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflow/statistics/daily-conversations")
+class WorkflowDailyRunsStatistic(Resource):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)
+        self._workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)
+
+    @console_ns.doc("get_workflow_daily_runs_statistic")
+    @console_ns.doc(description="Get workflow daily runs statistics")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[WorkflowStatisticQuery.__name__])
+    @console_ns.response(200, "Daily runs statistics retrieved successfully")
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = WorkflowStatisticQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        assert account.timezone is not None
+
+        try:
+            start_date, end_date = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        response_data = self._workflow_run_repo.get_daily_runs_statistics(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            triggered_from=WorkflowRunTriggeredFrom.APP_RUN,
+            start_date=start_date,
+            end_date=end_date,
+            timezone=account.timezone,
+        )
+
+        return jsonify({"data": response_data})
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflow/statistics/daily-terminals")
+class WorkflowDailyTerminalsStatistic(Resource):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)
+        self._workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)
+
+    @console_ns.doc("get_workflow_daily_terminals_statistic")
+    @console_ns.doc(description="Get workflow daily terminals statistics")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[WorkflowStatisticQuery.__name__])
+    @console_ns.response(200, "Daily terminals statistics retrieved successfully")
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = WorkflowStatisticQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        assert account.timezone is not None
+
+        try:
+            start_date, end_date = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        response_data = self._workflow_run_repo.get_daily_terminals_statistics(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            triggered_from=WorkflowRunTriggeredFrom.APP_RUN,
+            start_date=start_date,
+            end_date=end_date,
+            timezone=account.timezone,
+        )
+
+        return jsonify({"data": response_data})
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflow/statistics/token-costs")
+class WorkflowDailyTokenCostStatistic(Resource):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)
+        self._workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)
+
+    @console_ns.doc("get_workflow_daily_token_cost_statistic")
+    @console_ns.doc(description="Get workflow daily token cost statistics")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[WorkflowStatisticQuery.__name__])
+    @console_ns.response(200, "Daily token cost statistics retrieved successfully")
+    @get_app_model
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = WorkflowStatisticQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        assert account.timezone is not None
+
+        try:
+            start_date, end_date = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        response_data = self._workflow_run_repo.get_daily_token_cost_statistics(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            triggered_from=WorkflowRunTriggeredFrom.APP_RUN,
+            start_date=start_date,
+            end_date=end_date,
+            timezone=account.timezone,
+        )
+
+        return jsonify({"data": response_data})
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflow/statistics/average-app-interactions")
+class WorkflowAverageAppInteractionStatistic(Resource):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)
+        self._workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)
+
+    @console_ns.doc("get_workflow_average_app_interaction_statistic")
+    @console_ns.doc(description="Get workflow average app interaction statistics")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[WorkflowStatisticQuery.__name__])
+    @console_ns.response(200, "Average app interaction statistics retrieved successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.WORKFLOW])
+    def get(self, app_model):
+        account, _ = current_account_with_tenant()
+
+        args = WorkflowStatisticQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        assert account.timezone is not None
+
+        try:
+            start_date, end_date = parse_time_range(args.start, args.end, account.timezone)
+        except ValueError as e:
+            abort(400, description=str(e))
+
+        response_data = self._workflow_run_repo.get_average_app_interaction_statistics(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            triggered_from=WorkflowRunTriggeredFrom.APP_RUN,
+            start_date=start_date,
+            end_date=end_date,
+            timezone=account.timezone,
+        )
+
+        return jsonify({"data": response_data})

dify_1.11.1/api/controllers/console/app/workflow_trigger.py

@@ -0,0 +1,157 @@
+import logging
+
+from flask import request
+from flask_restx import Resource, marshal_with
+from pydantic import BaseModel
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import NotFound
+
+from configs import dify_config
+from extensions.ext_database import db
+from fields.workflow_trigger_fields import trigger_fields, triggers_list_fields, webhook_trigger_fields
+from libs.login import current_user, login_required
+from models.enums import AppTriggerStatus
+from models.model import Account, App, AppMode
+from models.trigger import AppTrigger, WorkflowWebhookTrigger
+
+from .. import console_ns
+from ..app.wraps import get_app_model
+from ..wraps import account_initialization_required, edit_permission_required, setup_required
+
+logger = logging.getLogger(__name__)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class Parser(BaseModel):
+    node_id: str
+
+
+class ParserEnable(BaseModel):
+    trigger_id: str
+    enable_trigger: bool
+
+
+console_ns.schema_model(Parser.__name__, Parser.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+console_ns.schema_model(
+    ParserEnable.__name__, ParserEnable.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/triggers/webhook")
+class WebhookTriggerApi(Resource):
+    """Webhook Trigger API"""
+
+    @console_ns.expect(console_ns.models[Parser.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=AppMode.WORKFLOW)
+    @marshal_with(webhook_trigger_fields)
+    def get(self, app_model: App):
+        """Get webhook trigger for a node"""
+        args = Parser.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        node_id = args.node_id
+
+        with Session(db.engine) as session:
+            # Get webhook trigger for this app and node
+            webhook_trigger = (
+                session.query(WorkflowWebhookTrigger)
+                .where(
+                    WorkflowWebhookTrigger.app_id == app_model.id,
+                    WorkflowWebhookTrigger.node_id == node_id,
+                )
+                .first()
+            )
+
+            if not webhook_trigger:
+                raise NotFound("Webhook trigger not found for this node")
+
+            return webhook_trigger
+
+
+@console_ns.route("/apps/<uuid:app_id>/triggers")
+class AppTriggersApi(Resource):
+    """App Triggers list API"""
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=AppMode.WORKFLOW)
+    @marshal_with(triggers_list_fields)
+    def get(self, app_model: App):
+        """Get app triggers list"""
+        assert isinstance(current_user, Account)
+        assert current_user.current_tenant_id is not None
+
+        with Session(db.engine) as session:
+            # Get all triggers for this app using select API
+            triggers = (
+                session.execute(
+                    select(AppTrigger)
+                    .where(
+                        AppTrigger.tenant_id == current_user.current_tenant_id,
+                        AppTrigger.app_id == app_model.id,
+                    )
+                    .order_by(AppTrigger.created_at.desc(), AppTrigger.id.desc())
+                )
+                .scalars()
+                .all()
+            )
+
+        # Add computed icon field for each trigger
+        url_prefix = dify_config.CONSOLE_API_URL + "/console/api/workspaces/current/tool-provider/builtin/"
+        for trigger in triggers:
+            if trigger.trigger_type == "trigger-plugin":
+                trigger.icon = url_prefix + trigger.provider_name + "/icon"  # type: ignore
+            else:
+                trigger.icon = ""  # type: ignore
+
+        return {"data": triggers}
+
+
+@console_ns.route("/apps/<uuid:app_id>/trigger-enable")
+class AppTriggerEnableApi(Resource):
+    @console_ns.expect(console_ns.models[ParserEnable.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_app_model(mode=AppMode.WORKFLOW)
+    @marshal_with(trigger_fields)
+    def post(self, app_model: App):
+        """Update app trigger (enable/disable)"""
+        args = ParserEnable.model_validate(console_ns.payload)
+
+        assert current_user.current_tenant_id is not None
+
+        trigger_id = args.trigger_id
+        with Session(db.engine) as session:
+            # Find the trigger using select
+            trigger = session.execute(
+                select(AppTrigger).where(
+                    AppTrigger.id == trigger_id,
+                    AppTrigger.tenant_id == current_user.current_tenant_id,
+                    AppTrigger.app_id == app_model.id,
+                )
+            ).scalar_one_or_none()
+
+            if not trigger:
+                raise NotFound("Trigger not found")
+
+            # Update status based on enable_trigger boolean
+            trigger.status = AppTriggerStatus.ENABLED if args.enable_trigger else AppTriggerStatus.DISABLED
+
+            session.commit()
+            session.refresh(trigger)
+
+        # Add computed icon field
+        url_prefix = dify_config.CONSOLE_API_URL + "/console/api/workspaces/current/tool-provider/builtin/"
+        if trigger.trigger_type == "trigger-plugin":
+            trigger.icon = url_prefix + trigger.provider_name + "/icon"  # type: ignore
+        else:
+            trigger.icon = ""  # type: ignore
+
+        return trigger

dify_1.11.1/api/controllers/console/app/wraps.py

@@ -0,0 +1,64 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import ParamSpec, TypeVar, Union
+
+from controllers.console.app.error import AppNotFoundError
+from extensions.ext_database import db
+from libs.login import current_account_with_tenant
+from models import App, AppMode
+
+P = ParamSpec("P")
+R = TypeVar("R")
+P1 = ParamSpec("P1")
+R1 = TypeVar("R1")
+
+
+def _load_app_model(app_id: str) -> App | None:
+    _, current_tenant_id = current_account_with_tenant()
+    app_model = (
+        db.session.query(App)
+        .where(App.id == app_id, App.tenant_id == current_tenant_id, App.status == "normal")
+        .first()
+    )
+    return app_model
+
+
+def get_app_model(view: Callable[P, R] | None = None, *, mode: Union[AppMode, list[AppMode], None] = None):
+    def decorator(view_func: Callable[P1, R1]):
+        @wraps(view_func)
+        def decorated_view(*args: P1.args, **kwargs: P1.kwargs):
+            if not kwargs.get("app_id"):
+                raise ValueError("missing app_id in path parameters")
+
+            app_id = kwargs.get("app_id")
+            app_id = str(app_id)
+
+            del kwargs["app_id"]
+
+            app_model = _load_app_model(app_id)
+
+            if not app_model:
+                raise AppNotFoundError()
+
+            app_mode = AppMode.value_of(app_model.mode)
+
+            if mode is not None:
+                if isinstance(mode, list):
+                    modes = mode
+                else:
+                    modes = [mode]
+
+                if app_mode not in modes:
+                    mode_values = {m.value for m in modes}
+                    raise AppNotFoundError(f"App mode is not in the supported list: {mode_values}")
+
+            kwargs["app_model"] = app_model
+
+            return view_func(*args, **kwargs)
+
+        return decorated_view
+
+    if view is None:
+        return decorator
+    else:
+        return decorator(view)

dify_1.11.1/api/controllers/console/auth/activate.py

@@ -0,0 +1,122 @@
+from flask import request
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field, field_validator
+
+from constants.languages import supported_language
+from controllers.console import console_ns
+from controllers.console.error import AlreadyActivateError
+from extensions.ext_database import db
+from libs.datetime_utils import naive_utc_now
+from libs.helper import EmailStr, extract_remote_ip, timezone
+from models import AccountStatus
+from services.account_service import AccountService, RegisterService
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class ActivateCheckQuery(BaseModel):
+    workspace_id: str | None = Field(default=None)
+    email: EmailStr | None = Field(default=None)
+    token: str
+
+
+class ActivatePayload(BaseModel):
+    workspace_id: str | None = Field(default=None)
+    email: EmailStr | None = Field(default=None)
+    token: str
+    name: str = Field(..., max_length=30)
+    interface_language: str = Field(...)
+    timezone: str = Field(...)
+
+    @field_validator("interface_language")
+    @classmethod
+    def validate_lang(cls, value: str) -> str:
+        return supported_language(value)
+
+    @field_validator("timezone")
+    @classmethod
+    def validate_tz(cls, value: str) -> str:
+        return timezone(value)
+
+
+for model in (ActivateCheckQuery, ActivatePayload):
+    console_ns.schema_model(model.__name__, model.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+@console_ns.route("/activate/check")
+class ActivateCheckApi(Resource):
+    @console_ns.doc("check_activation_token")
+    @console_ns.doc(description="Check if activation token is valid")
+    @console_ns.expect(console_ns.models[ActivateCheckQuery.__name__])
+    @console_ns.response(
+        200,
+        "Success",
+        console_ns.model(
+            "ActivationCheckResponse",
+            {
+                "is_valid": fields.Boolean(description="Whether token is valid"),
+                "data": fields.Raw(description="Activation data if valid"),
+            },
+        ),
+    )
+    def get(self):
+        args = ActivateCheckQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        workspaceId = args.workspace_id
+        reg_email = args.email
+        token = args.token
+
+        invitation = RegisterService.get_invitation_if_token_valid(workspaceId, reg_email, token)
+        if invitation:
+            data = invitation.get("data", {})
+            tenant = invitation.get("tenant", None)
+            workspace_name = tenant.name if tenant else None
+            workspace_id = tenant.id if tenant else None
+            invitee_email = data.get("email") if data else None
+            return {
+                "is_valid": invitation is not None,
+                "data": {"workspace_name": workspace_name, "workspace_id": workspace_id, "email": invitee_email},
+            }
+        else:
+            return {"is_valid": False}
+
+
+@console_ns.route("/activate")
+class ActivateApi(Resource):
+    @console_ns.doc("activate_account")
+    @console_ns.doc(description="Activate account with invitation token")
+    @console_ns.expect(console_ns.models[ActivatePayload.__name__])
+    @console_ns.response(
+        200,
+        "Account activated successfully",
+        console_ns.model(
+            "ActivationResponse",
+            {
+                "result": fields.String(description="Operation result"),
+                "data": fields.Raw(description="Login token data"),
+            },
+        ),
+    )
+    @console_ns.response(400, "Already activated or invalid token")
+    def post(self):
+        args = ActivatePayload.model_validate(console_ns.payload)
+
+        invitation = RegisterService.get_invitation_if_token_valid(args.workspace_id, args.email, args.token)
+        if invitation is None:
+            raise AlreadyActivateError()
+
+        RegisterService.revoke_token(args.workspace_id, args.email, args.token)
+
+        account = invitation["account"]
+        account.name = args.name
+
+        account.interface_language = args.interface_language
+        account.timezone = args.timezone
+        account.interface_theme = "light"
+        account.status = AccountStatus.ACTIVE
+        account.initialized_at = naive_utc_now()
+        db.session.commit()
+
+        token_pair = AccountService.login(account, ip_address=extract_remote_ip(request))
+
+        return {"result": "success", "data": token_pair.model_dump()}

dify_1.11.1/api/controllers/console/auth/data_source_bearer_auth.py

@@ -0,0 +1,83 @@
+from flask_restx import Resource
+from pydantic import BaseModel, Field
+
+from libs.login import current_account_with_tenant, login_required
+from services.auth.api_key_auth_service import ApiKeyAuthService
+
+from .. import console_ns
+from ..auth.error import ApiKeyAuthFailedError
+from ..wraps import account_initialization_required, is_admin_or_owner_required, setup_required
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class ApiKeyAuthBindingPayload(BaseModel):
+    category: str = Field(...)
+    provider: str = Field(...)
+    credentials: dict = Field(...)
+
+
+console_ns.schema_model(
+    ApiKeyAuthBindingPayload.__name__,
+    ApiKeyAuthBindingPayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+
+@console_ns.route("/api-key-auth/data-source")
+class ApiKeyAuthDataSource(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, current_tenant_id = current_account_with_tenant()
+        data_source_api_key_bindings = ApiKeyAuthService.get_provider_auth_list(current_tenant_id)
+        if data_source_api_key_bindings:
+            return {
+                "sources": [
+                    {
+                        "id": data_source_api_key_binding.id,
+                        "category": data_source_api_key_binding.category,
+                        "provider": data_source_api_key_binding.provider,
+                        "disabled": data_source_api_key_binding.disabled,
+                        "created_at": int(data_source_api_key_binding.created_at.timestamp()),
+                        "updated_at": int(data_source_api_key_binding.updated_at.timestamp()),
+                    }
+                    for data_source_api_key_binding in data_source_api_key_bindings
+                ]
+            }
+        return {"sources": []}
+
+
+@console_ns.route("/api-key-auth/data-source/binding")
+class ApiKeyAuthDataSourceBinding(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @is_admin_or_owner_required
+    @console_ns.expect(console_ns.models[ApiKeyAuthBindingPayload.__name__])
+    def post(self):
+        # The role of the current user in the table must be admin or owner
+        _, current_tenant_id = current_account_with_tenant()
+        payload = ApiKeyAuthBindingPayload.model_validate(console_ns.payload)
+        data = payload.model_dump()
+        ApiKeyAuthService.validate_api_key_auth_args(data)
+        try:
+            ApiKeyAuthService.create_provider_auth(current_tenant_id, data)
+        except Exception as e:
+            raise ApiKeyAuthFailedError(str(e))
+        return {"result": "success"}, 200
+
+
+@console_ns.route("/api-key-auth/data-source/<uuid:binding_id>")
+class ApiKeyAuthDataSourceBindingDelete(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @is_admin_or_owner_required
+    def delete(self, binding_id):
+        # The role of the current user in the table must be admin or owner
+        _, current_tenant_id = current_account_with_tenant()
+
+        ApiKeyAuthService.delete_provider_auth(current_tenant_id, binding_id)
+
+        return {"result": "success"}, 204

dify_1.11.1/api/controllers/console/auth/data_source_oauth.py

@@ -0,0 +1,158 @@
+import logging
+
+import httpx
+from flask import current_app, redirect, request
+from flask_restx import Resource, fields
+
+from configs import dify_config
+from libs.login import login_required
+from libs.oauth_data_source import NotionOAuth
+
+from .. import console_ns
+from ..wraps import account_initialization_required, is_admin_or_owner_required, setup_required
+
+logger = logging.getLogger(__name__)
+
+
+def get_oauth_providers():
+    with current_app.app_context():
+        notion_oauth = NotionOAuth(
+            client_id=dify_config.NOTION_CLIENT_ID or "",
+            client_secret=dify_config.NOTION_CLIENT_SECRET or "",
+            redirect_uri=dify_config.CONSOLE_API_URL + "/console/api/oauth/data-source/callback/notion",
+        )
+
+        OAUTH_PROVIDERS = {"notion": notion_oauth}
+        return OAUTH_PROVIDERS
+
+
+@console_ns.route("/oauth/data-source/<string:provider>")
+class OAuthDataSource(Resource):
+    @console_ns.doc("oauth_data_source")
+    @console_ns.doc(description="Get OAuth authorization URL for data source provider")
+    @console_ns.doc(params={"provider": "Data source provider name (notion)"})
+    @console_ns.response(
+        200,
+        "Authorization URL or internal setup success",
+        console_ns.model(
+            "OAuthDataSourceResponse",
+            {"data": fields.Raw(description="Authorization URL or 'internal' for internal setup")},
+        ),
+    )
+    @console_ns.response(400, "Invalid provider")
+    @console_ns.response(403, "Admin privileges required")
+    @is_admin_or_owner_required
+    def get(self, provider: str):
+        # The role of the current user in the table must be admin or owner
+        OAUTH_DATASOURCE_PROVIDERS = get_oauth_providers()
+        with current_app.app_context():
+            oauth_provider = OAUTH_DATASOURCE_PROVIDERS.get(provider)
+        if not oauth_provider:
+            return {"error": "Invalid provider"}, 400
+        if dify_config.NOTION_INTEGRATION_TYPE == "internal":
+            internal_secret = dify_config.NOTION_INTERNAL_SECRET
+            if not internal_secret:
+                return ({"error": "Internal secret is not set"},)
+            oauth_provider.save_internal_access_token(internal_secret)
+            return {"data": "internal"}
+        else:
+            auth_url = oauth_provider.get_authorization_url()
+            return {"data": auth_url}, 200
+
+
+@console_ns.route("/oauth/data-source/callback/<string:provider>")
+class OAuthDataSourceCallback(Resource):
+    @console_ns.doc("oauth_data_source_callback")
+    @console_ns.doc(description="Handle OAuth callback from data source provider")
+    @console_ns.doc(
+        params={
+            "provider": "Data source provider name (notion)",
+            "code": "Authorization code from OAuth provider",
+            "error": "Error message from OAuth provider",
+        }
+    )
+    @console_ns.response(302, "Redirect to console with result")
+    @console_ns.response(400, "Invalid provider")
+    def get(self, provider: str):
+        OAUTH_DATASOURCE_PROVIDERS = get_oauth_providers()
+        with current_app.app_context():
+            oauth_provider = OAUTH_DATASOURCE_PROVIDERS.get(provider)
+        if not oauth_provider:
+            return {"error": "Invalid provider"}, 400
+        if "code" in request.args:
+            code = request.args.get("code")
+
+            return redirect(f"{dify_config.CONSOLE_WEB_URL}?type=notion&code={code}")
+        elif "error" in request.args:
+            error = request.args.get("error")
+
+            return redirect(f"{dify_config.CONSOLE_WEB_URL}?type=notion&error={error}")
+        else:
+            return redirect(f"{dify_config.CONSOLE_WEB_URL}?type=notion&error=Access denied")
+
+
+@console_ns.route("/oauth/data-source/binding/<string:provider>")
+class OAuthDataSourceBinding(Resource):
+    @console_ns.doc("oauth_data_source_binding")
+    @console_ns.doc(description="Bind OAuth data source with authorization code")
+    @console_ns.doc(
+        params={"provider": "Data source provider name (notion)", "code": "Authorization code from OAuth provider"}
+    )
+    @console_ns.response(
+        200,
+        "Data source binding success",
+        console_ns.model("OAuthDataSourceBindingResponse", {"result": fields.String(description="Operation result")}),
+    )
+    @console_ns.response(400, "Invalid provider or code")
+    def get(self, provider: str):
+        OAUTH_DATASOURCE_PROVIDERS = get_oauth_providers()
+        with current_app.app_context():
+            oauth_provider = OAUTH_DATASOURCE_PROVIDERS.get(provider)
+        if not oauth_provider:
+            return {"error": "Invalid provider"}, 400
+        if "code" in request.args:
+            code = request.args.get("code", "")
+            if not code:
+                return {"error": "Invalid code"}, 400
+            try:
+                oauth_provider.get_access_token(code)
+            except httpx.HTTPStatusError as e:
+                logger.exception(
+                    "An error occurred during the OAuthCallback process with %s: %s", provider, e.response.text
+                )
+                return {"error": "OAuth data source process failed"}, 400
+
+            return {"result": "success"}, 200
+
+
+@console_ns.route("/oauth/data-source/<string:provider>/<uuid:binding_id>/sync")
+class OAuthDataSourceSync(Resource):
+    @console_ns.doc("oauth_data_source_sync")
+    @console_ns.doc(description="Sync data from OAuth data source")
+    @console_ns.doc(params={"provider": "Data source provider name (notion)", "binding_id": "Data source binding ID"})
+    @console_ns.response(
+        200,
+        "Data source sync success",
+        console_ns.model("OAuthDataSourceSyncResponse", {"result": fields.String(description="Operation result")}),
+    )
+    @console_ns.response(400, "Invalid provider or sync failed")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider, binding_id):
+        provider = str(provider)
+        binding_id = str(binding_id)
+        OAUTH_DATASOURCE_PROVIDERS = get_oauth_providers()
+        with current_app.app_context():
+            oauth_provider = OAUTH_DATASOURCE_PROVIDERS.get(provider)
+        if not oauth_provider:
+            return {"error": "Invalid provider"}, 400
+        try:
+            oauth_provider.sync_data_source(binding_id)
+        except httpx.HTTPStatusError as e:
+            logger.exception(
+                "An error occurred during the OAuthCallback process with %s: %s", provider, e.response.text
+            )
+            return {"error": "OAuth data source process failed"}, 400
+
+        return {"result": "success"}, 200

dify_1.11.1/api/controllers/console/auth/email_register.py

@@ -0,0 +1,172 @@
+from flask import request
+from flask_restx import Resource
+from pydantic import BaseModel, Field, field_validator
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from configs import dify_config
+from constants.languages import languages
+from controllers.console import console_ns
+from controllers.console.auth.error import (
+    EmailAlreadyInUseError,
+    EmailCodeError,
+    EmailRegisterLimitError,
+    InvalidEmailError,
+    InvalidTokenError,
+    PasswordMismatchError,
+)
+from extensions.ext_database import db
+from libs.helper import EmailStr, extract_remote_ip
+from libs.password import valid_password
+from models import Account
+from services.account_service import AccountService
+from services.billing_service import BillingService
+from services.errors.account import AccountNotFoundError, AccountRegisterError
+
+from ..error import AccountInFreezeError, EmailSendIpLimitError
+from ..wraps import email_password_login_enabled, email_register_enabled, setup_required
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class EmailRegisterSendPayload(BaseModel):
+    email: EmailStr = Field(..., description="Email address")
+    language: str | None = Field(default=None, description="Language code")
+
+
+class EmailRegisterValidityPayload(BaseModel):
+    email: EmailStr = Field(...)
+    code: str = Field(...)
+    token: str = Field(...)
+
+
+class EmailRegisterResetPayload(BaseModel):
+    token: str = Field(...)
+    new_password: str = Field(...)
+    password_confirm: str = Field(...)
+
+    @field_validator("new_password", "password_confirm")
+    @classmethod
+    def validate_password(cls, value: str) -> str:
+        return valid_password(value)
+
+
+for model in (EmailRegisterSendPayload, EmailRegisterValidityPayload, EmailRegisterResetPayload):
+    console_ns.schema_model(model.__name__, model.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+@console_ns.route("/email-register/send-email")
+class EmailRegisterSendEmailApi(Resource):
+    @setup_required
+    @email_password_login_enabled
+    @email_register_enabled
+    def post(self):
+        args = EmailRegisterSendPayload.model_validate(console_ns.payload)
+
+        ip_address = extract_remote_ip(request)
+        if AccountService.is_email_send_ip_limit(ip_address):
+            raise EmailSendIpLimitError()
+        language = "en-US"
+        if args.language in languages:
+            language = args.language
+
+        if dify_config.BILLING_ENABLED and BillingService.is_email_in_freeze(args.email):
+            raise AccountInFreezeError()
+
+        with Session(db.engine) as session:
+            account = session.execute(select(Account).filter_by(email=args.email)).scalar_one_or_none()
+        token = None
+        token = AccountService.send_email_register_email(email=args.email, account=account, language=language)
+        return {"result": "success", "data": token}
+
+
+@console_ns.route("/email-register/validity")
+class EmailRegisterCheckApi(Resource):
+    @setup_required
+    @email_password_login_enabled
+    @email_register_enabled
+    def post(self):
+        args = EmailRegisterValidityPayload.model_validate(console_ns.payload)
+
+        user_email = args.email
+
+        is_email_register_error_rate_limit = AccountService.is_email_register_error_rate_limit(args.email)
+        if is_email_register_error_rate_limit:
+            raise EmailRegisterLimitError()
+
+        token_data = AccountService.get_email_register_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_email_register_error_rate_limit(args.email)
+            raise EmailCodeError()
+
+        # Verified, revoke the first token
+        AccountService.revoke_email_register_token(args.token)
+
+        # Refresh token data by generating a new token
+        _, new_token = AccountService.generate_email_register_token(
+            user_email, code=args.code, additional_data={"phase": "register"}
+        )
+
+        AccountService.reset_email_register_error_rate_limit(args.email)
+        return {"is_valid": True, "email": token_data.get("email"), "token": new_token}
+
+
+@console_ns.route("/email-register")
+class EmailRegisterResetApi(Resource):
+    @setup_required
+    @email_password_login_enabled
+    @email_register_enabled
+    def post(self):
+        args = EmailRegisterResetPayload.model_validate(console_ns.payload)
+
+        # Validate passwords match
+        if args.new_password != args.password_confirm:
+            raise PasswordMismatchError()
+
+        # Validate token and get register data
+        register_data = AccountService.get_email_register_data(args.token)
+        if not register_data:
+            raise InvalidTokenError()
+        # Must use token in reset phase
+        if register_data.get("phase", "") != "register":
+            raise InvalidTokenError()
+
+        # Revoke token to prevent reuse
+        AccountService.revoke_email_register_token(args.token)
+
+        email = register_data.get("email", "")
+
+        with Session(db.engine) as session:
+            account = session.execute(select(Account).filter_by(email=email)).scalar_one_or_none()
+
+            if account:
+                raise EmailAlreadyInUseError()
+            else:
+                account = self._create_new_account(email, args.password_confirm)
+                if not account:
+                    raise AccountNotFoundError()
+                token_pair = AccountService.login(account=account, ip_address=extract_remote_ip(request))
+                AccountService.reset_login_error_rate_limit(email)
+
+        return {"result": "success", "data": token_pair.model_dump()}
+
+    def _create_new_account(self, email, password) -> Account | None:
+        # Create new account if allowed
+        account = None
+        try:
+            account = AccountService.create_account_and_tenant(
+                email=email,
+                name=email,
+                password=password,
+                interface_language=languages[0],
+            )
+        except AccountRegisterError:
+            raise AccountInFreezeError()
+
+        return account

dify_1.11.1/api/controllers/console/auth/error.py

@@ -0,0 +1,157 @@
+from libs.exception import BaseHTTPException
+
+
+class ApiKeyAuthFailedError(BaseHTTPException):
+    error_code = "auth_failed"
+    description = "{message}"
+    code = 500
+
+
+class InvalidEmailError(BaseHTTPException):
+    error_code = "invalid_email"
+    description = "The email address is not valid."
+    code = 400
+
+
+class PasswordMismatchError(BaseHTTPException):
+    error_code = "password_mismatch"
+    description = "The passwords do not match."
+    code = 400
+
+
+class InvalidTokenError(BaseHTTPException):
+    error_code = "invalid_or_expired_token"
+    description = "The token is invalid or has expired."
+    code = 400
+
+
+class PasswordResetRateLimitExceededError(BaseHTTPException):
+    error_code = "password_reset_rate_limit_exceeded"
+    description = "Too many password reset emails have been sent. Please try again in {minutes} minutes."
+    code = 429
+
+    def __init__(self, minutes: int = 1):
+        description = self.description.format(minutes=int(minutes)) if self.description else None
+        super().__init__(description=description)
+
+
+class EmailRegisterRateLimitExceededError(BaseHTTPException):
+    error_code = "email_register_rate_limit_exceeded"
+    description = "Too many email register emails have been sent. Please try again in {minutes} minutes."
+    code = 429
+
+    def __init__(self, minutes: int = 1):
+        description = self.description.format(minutes=int(minutes)) if self.description else None
+        super().__init__(description=description)
+
+
+class EmailChangeRateLimitExceededError(BaseHTTPException):
+    error_code = "email_change_rate_limit_exceeded"
+    description = "Too many email change emails have been sent. Please try again in {minutes} minutes."
+    code = 429
+
+    def __init__(self, minutes: int = 1):
+        description = self.description.format(minutes=int(minutes)) if self.description else None
+        super().__init__(description=description)
+
+
+class OwnerTransferRateLimitExceededError(BaseHTTPException):
+    error_code = "owner_transfer_rate_limit_exceeded"
+    description = "Too many owner transfer emails have been sent. Please try again in {minutes} minutes."
+    code = 429
+
+    def __init__(self, minutes: int = 1):
+        description = self.description.format(minutes=int(minutes)) if self.description else None
+        super().__init__(description=description)
+
+
+class EmailCodeError(BaseHTTPException):
+    error_code = "email_code_error"
+    description = "Email code is invalid or expired."
+    code = 400
+
+
+class EmailOrPasswordMismatchError(BaseHTTPException):
+    error_code = "email_or_password_mismatch"
+    description = "The email or password is mismatched."
+    code = 400
+
+
+class AuthenticationFailedError(BaseHTTPException):
+    error_code = "authentication_failed"
+    description = "Invalid email or password."
+    code = 401
+
+
+class EmailPasswordLoginLimitError(BaseHTTPException):
+    error_code = "email_code_login_limit"
+    description = "Too many incorrect password attempts. Please try again later."
+    code = 429
+
+
+class EmailCodeLoginRateLimitExceededError(BaseHTTPException):
+    error_code = "email_code_login_rate_limit_exceeded"
+    description = "Too many login emails have been sent. Please try again in {minutes} minutes."
+    code = 429
+
+    def __init__(self, minutes: int = 5):
+        description = self.description.format(minutes=int(minutes)) if self.description else None
+        super().__init__(description=description)
+
+
+class EmailCodeAccountDeletionRateLimitExceededError(BaseHTTPException):
+    error_code = "email_code_account_deletion_rate_limit_exceeded"
+    description = "Too many account deletion emails have been sent. Please try again in {minutes} minutes."
+    code = 429
+
+    def __init__(self, minutes: int = 5):
+        description = self.description.format(minutes=int(minutes)) if self.description else None
+        super().__init__(description=description)
+
+
+class EmailPasswordResetLimitError(BaseHTTPException):
+    error_code = "email_password_reset_limit"
+    description = "Too many failed password reset attempts. Please try again in 24 hours."
+    code = 429
+
+
+class EmailRegisterLimitError(BaseHTTPException):
+    error_code = "email_register_limit"
+    description = "Too many failed email register attempts. Please try again in 24 hours."
+    code = 429
+
+
+class EmailChangeLimitError(BaseHTTPException):
+    error_code = "email_change_limit"
+    description = "Too many failed email change attempts. Please try again in 24 hours."
+    code = 429
+
+
+class EmailAlreadyInUseError(BaseHTTPException):
+    error_code = "email_already_in_use"
+    description = "A user with this email already exists."
+    code = 400
+
+
+class OwnerTransferLimitError(BaseHTTPException):
+    error_code = "owner_transfer_limit"
+    description = "Too many failed owner transfer attempts. Please try again in 24 hours."
+    code = 429
+
+
+class NotOwnerError(BaseHTTPException):
+    error_code = "not_owner"
+    description = "You are not the owner of the workspace."
+    code = 400
+
+
+class CannotTransferOwnerToSelfError(BaseHTTPException):
+    error_code = "cannot_transfer_owner_to_self"
+    description = "You cannot transfer ownership to yourself."
+    code = 400
+
+
+class MemberNotInTenantError(BaseHTTPException):
+    error_code = "member_not_in_tenant"
+    description = "The member is not in the workspace."
+    code = 400

dify_1.11.1/api/controllers/console/auth/forgot_password.py

@@ -0,0 +1,215 @@
+import base64
+import secrets
+
+from flask import request
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field, field_validator
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from controllers.console import console_ns
+from controllers.console.auth.error import (
+    EmailCodeError,
+    EmailPasswordResetLimitError,
+    InvalidEmailError,
+    InvalidTokenError,
+    PasswordMismatchError,
+)
+from controllers.console.error import AccountNotFound, EmailSendIpLimitError
+from controllers.console.wraps import email_password_login_enabled, setup_required
+from events.tenant_event import tenant_was_created
+from extensions.ext_database import db
+from libs.helper import EmailStr, extract_remote_ip
+from libs.password import hash_password, valid_password
+from models import Account
+from services.account_service import AccountService, TenantService
+from services.feature_service import FeatureService
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class ForgotPasswordSendPayload(BaseModel):
+    email: EmailStr = Field(...)
+    language: str | None = Field(default=None)
+
+
+class ForgotPasswordCheckPayload(BaseModel):
+    email: EmailStr = Field(...)
+    code: str = Field(...)
+    token: str = Field(...)
+
+
+class ForgotPasswordResetPayload(BaseModel):
+    token: str = Field(...)
+    new_password: str = Field(...)
+    password_confirm: str = Field(...)
+
+    @field_validator("new_password", "password_confirm")
+    @classmethod
+    def validate_password(cls, value: str) -> str:
+        return valid_password(value)
+
+
+for model in (ForgotPasswordSendPayload, ForgotPasswordCheckPayload, ForgotPasswordResetPayload):
+    console_ns.schema_model(model.__name__, model.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+@console_ns.route("/forgot-password")
+class ForgotPasswordSendEmailApi(Resource):
+    @console_ns.doc("send_forgot_password_email")
+    @console_ns.doc(description="Send password reset email")
+    @console_ns.expect(console_ns.models[ForgotPasswordSendPayload.__name__])
+    @console_ns.response(
+        200,
+        "Email sent successfully",
+        console_ns.model(
+            "ForgotPasswordEmailResponse",
+            {
+                "result": fields.String(description="Operation result"),
+                "data": fields.String(description="Reset token"),
+                "code": fields.String(description="Error code if account not found"),
+            },
+        ),
+    )
+    @console_ns.response(400, "Invalid email or rate limit exceeded")
+    @setup_required
+    @email_password_login_enabled
+    def post(self):
+        args = ForgotPasswordSendPayload.model_validate(console_ns.payload)
+
+        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"
+
+        with Session(db.engine) as session:
+            account = session.execute(select(Account).filter_by(email=args.email)).scalar_one_or_none()
+
+        token = AccountService.send_reset_password_email(
+            account=account,
+            email=args.email,
+            language=language,
+            is_allow_register=FeatureService.get_system_features().is_allow_register,
+        )
+
+        return {"result": "success", "data": token}
+
+
+@console_ns.route("/forgot-password/validity")
+class ForgotPasswordCheckApi(Resource):
+    @console_ns.doc("check_forgot_password_code")
+    @console_ns.doc(description="Verify password reset code")
+    @console_ns.expect(console_ns.models[ForgotPasswordCheckPayload.__name__])
+    @console_ns.response(
+        200,
+        "Code verified successfully",
+        console_ns.model(
+            "ForgotPasswordCheckResponse",
+            {
+                "is_valid": fields.Boolean(description="Whether code is valid"),
+                "email": fields.String(description="Email address"),
+                "token": fields.String(description="New reset token"),
+            },
+        ),
+    )
+    @console_ns.response(400, "Invalid code or token")
+    @setup_required
+    @email_password_login_enabled
+    def post(self):
+        args = ForgotPasswordCheckPayload.model_validate(console_ns.payload)
+
+        user_email = args.email
+
+        is_forgot_password_error_rate_limit = AccountService.is_forgot_password_error_rate_limit(args.email)
+        if is_forgot_password_error_rate_limit:
+            raise EmailPasswordResetLimitError()
+
+        token_data = AccountService.get_reset_password_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_forgot_password_error_rate_limit(args.email)
+            raise EmailCodeError()
+
+        # Verified, revoke the first token
+        AccountService.revoke_reset_password_token(args.token)
+
+        # Refresh token data by generating a new token
+        _, new_token = AccountService.generate_reset_password_token(
+            user_email, code=args.code, additional_data={"phase": "reset"}
+        )
+
+        AccountService.reset_forgot_password_error_rate_limit(args.email)
+        return {"is_valid": True, "email": token_data.get("email"), "token": new_token}
+
+
+@console_ns.route("/forgot-password/resets")
+class ForgotPasswordResetApi(Resource):
+    @console_ns.doc("reset_password")
+    @console_ns.doc(description="Reset password with verification token")
+    @console_ns.expect(console_ns.models[ForgotPasswordResetPayload.__name__])
+    @console_ns.response(
+        200,
+        "Password reset successfully",
+        console_ns.model("ForgotPasswordResetResponse", {"result": fields.String(description="Operation result")}),
+    )
+    @console_ns.response(400, "Invalid token or password mismatch")
+    @setup_required
+    @email_password_login_enabled
+    def post(self):
+        args = ForgotPasswordResetPayload.model_validate(console_ns.payload)
+
+        # Validate passwords match
+        if args.new_password != args.password_confirm:
+            raise PasswordMismatchError()
+
+        # Validate token and get reset data
+        reset_data = AccountService.get_reset_password_data(args.token)
+        if not reset_data:
+            raise InvalidTokenError()
+        # Must use token in reset phase
+        if reset_data.get("phase", "") != "reset":
+            raise InvalidTokenError()
+
+        # Revoke token to prevent reuse
+        AccountService.revoke_reset_password_token(args.token)
+
+        # Generate secure salt and hash password
+        salt = secrets.token_bytes(16)
+        password_hashed = hash_password(args.new_password, salt)
+
+        email = reset_data.get("email", "")
+
+        with Session(db.engine) as session:
+            account = session.execute(select(Account).filter_by(email=email)).scalar_one_or_none()
+
+            if account:
+                self._update_existing_account(account, password_hashed, salt, session)
+            else:
+                raise AccountNotFound()
+
+        return {"result": "success"}
+
+    def _update_existing_account(self, account, password_hashed, salt, session):
+        # Update existing account credentials
+        account.password = base64.b64encode(password_hashed).decode()
+        account.password_salt = base64.b64encode(salt).decode()
+        session.commit()
+
+        # Create workspace if needed
+        if (
+            not TenantService.get_join_tenants(account)
+            and FeatureService.get_system_features().is_allow_create_workspace
+        ):
+            tenant = TenantService.create_tenant(f"{account.name}'s Workspace")
+            TenantService.create_tenant_member(tenant, account, role="owner")
+            account.current_tenant = tenant
+            tenant_was_created.send(tenant)

dify_1.11.1/api/controllers/console/auth/login.py

@@ -0,0 +1,303 @@
+import flask_login
+from flask import make_response, request
+from flask_restx import Resource
+from pydantic import BaseModel, Field
+
+import services
+from configs import dify_config
+from constants.languages import get_valid_language
+from controllers.console import console_ns
+from controllers.console.auth.error import (
+    AuthenticationFailedError,
+    EmailCodeError,
+    EmailPasswordLoginLimitError,
+    InvalidEmailError,
+    InvalidTokenError,
+)
+from controllers.console.error import (
+    AccountBannedError,
+    AccountInFreezeError,
+    AccountNotFound,
+    EmailSendIpLimitError,
+    NotAllowedCreateWorkspace,
+    WorkspacesLimitExceeded,
+)
+from controllers.console.wraps import email_password_login_enabled, setup_required
+from events.tenant_event import tenant_was_created
+from libs.helper import EmailStr, extract_remote_ip
+from libs.login import current_account_with_tenant
+from libs.token import (
+    clear_access_token_from_cookie,
+    clear_csrf_token_from_cookie,
+    clear_refresh_token_from_cookie,
+    extract_refresh_token,
+    set_access_token_to_cookie,
+    set_csrf_token_to_cookie,
+    set_refresh_token_to_cookie,
+)
+from services.account_service import AccountService, RegisterService, TenantService
+from services.billing_service import BillingService
+from services.errors.account import AccountRegisterError
+from services.errors.workspace import WorkSpaceNotAllowedCreateError, WorkspacesLimitExceededError
+from services.feature_service import FeatureService
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class LoginPayload(BaseModel):
+    email: EmailStr = Field(..., description="Email address")
+    password: str = Field(..., description="Password")
+    remember_me: bool = Field(default=False, description="Remember me flag")
+    invite_token: str | None = Field(default=None, description="Invitation token")
+
+
+class EmailPayload(BaseModel):
+    email: EmailStr = Field(...)
+    language: str | None = Field(default=None)
+
+
+class EmailCodeLoginPayload(BaseModel):
+    email: EmailStr = Field(...)
+    code: str = Field(...)
+    token: str = Field(...)
+    language: str | None = Field(default=None)
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(LoginPayload)
+reg(EmailPayload)
+reg(EmailCodeLoginPayload)
+
+
+@console_ns.route("/login")
+class LoginApi(Resource):
+    """Resource for user login."""
+
+    @setup_required
+    @email_password_login_enabled
+    @console_ns.expect(console_ns.models[LoginPayload.__name__])
+    def post(self):
+        """Authenticate user and login."""
+        args = LoginPayload.model_validate(console_ns.payload)
+
+        if dify_config.BILLING_ENABLED and BillingService.is_email_in_freeze(args.email):
+            raise AccountInFreezeError()
+
+        is_login_error_rate_limit = AccountService.is_login_error_rate_limit(args.email)
+        if is_login_error_rate_limit:
+            raise EmailPasswordLoginLimitError()
+
+        # TODO: why invitation is re-assigned with different type?
+        invitation = args.invite_token  # type: ignore
+        if invitation:
+            invitation = RegisterService.get_invitation_if_token_valid(None, args.email, invitation)  # type: ignore
+
+        try:
+            if invitation:
+                data = invitation.get("data", {})  # type: ignore
+                invitee_email = data.get("email") if data else None
+                if invitee_email != args.email:
+                    raise InvalidEmailError()
+                account = AccountService.authenticate(args.email, args.password, args.invite_token)
+            else:
+                account = AccountService.authenticate(args.email, args.password)
+        except services.errors.account.AccountLoginError:
+            raise AccountBannedError()
+        except services.errors.account.AccountPasswordError:
+            AccountService.add_login_error_rate_limit(args.email)
+            raise AuthenticationFailedError()
+        # SELF_HOSTED only have one workspace
+        tenants = TenantService.get_join_tenants(account)
+        if len(tenants) == 0:
+            system_features = FeatureService.get_system_features()
+
+            if system_features.is_allow_create_workspace and not system_features.license.workspaces.is_available():
+                raise WorkspacesLimitExceeded()
+            else:
+                return {
+                    "result": "fail",
+                    "data": "workspace not found, please contact system admin to invite you to join in a workspace",
+                }
+
+        token_pair = AccountService.login(account=account, ip_address=extract_remote_ip(request))
+        AccountService.reset_login_error_rate_limit(args.email)
+
+        # Create response with cookies instead of returning tokens in body
+        response = make_response({"result": "success"})
+
+        set_access_token_to_cookie(request, response, token_pair.access_token)
+        set_refresh_token_to_cookie(request, response, token_pair.refresh_token)
+        set_csrf_token_to_cookie(request, response, token_pair.csrf_token)
+
+        return response
+
+
+@console_ns.route("/logout")
+class LogoutApi(Resource):
+    @setup_required
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        account = current_user
+        if isinstance(account, flask_login.AnonymousUserMixin):
+            response = make_response({"result": "success"})
+        else:
+            AccountService.logout(account=account)
+            flask_login.logout_user()
+            response = make_response({"result": "success"})
+
+        # Clear cookies on logout
+        clear_access_token_from_cookie(response)
+        clear_refresh_token_from_cookie(response)
+        clear_csrf_token_from_cookie(response)
+
+        return response
+
+
+@console_ns.route("/reset-password")
+class ResetPasswordSendEmailApi(Resource):
+    @setup_required
+    @email_password_login_enabled
+    @console_ns.expect(console_ns.models[EmailPayload.__name__])
+    def post(self):
+        args = EmailPayload.model_validate(console_ns.payload)
+
+        if args.language is not None and args.language == "zh-Hans":
+            language = "zh-Hans"
+        else:
+            language = "en-US"
+        try:
+            account = AccountService.get_user_through_email(args.email)
+        except AccountRegisterError:
+            raise AccountInFreezeError()
+
+        token = AccountService.send_reset_password_email(
+            email=args.email,
+            account=account,
+            language=language,
+            is_allow_register=FeatureService.get_system_features().is_allow_register,
+        )
+
+        return {"result": "success", "data": token}
+
+
+@console_ns.route("/email-code-login")
+class EmailCodeLoginSendEmailApi(Resource):
+    @setup_required
+    @console_ns.expect(console_ns.models[EmailPayload.__name__])
+    def post(self):
+        args = EmailPayload.model_validate(console_ns.payload)
+
+        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"
+        try:
+            account = AccountService.get_user_through_email(args.email)
+        except AccountRegisterError:
+            raise AccountInFreezeError()
+
+        if account is None:
+            if FeatureService.get_system_features().is_allow_register:
+                token = AccountService.send_email_code_login_email(email=args.email, language=language)
+            else:
+                raise AccountNotFound()
+        else:
+            token = AccountService.send_email_code_login_email(account=account, language=language)
+
+        return {"result": "success", "data": token}
+
+
+@console_ns.route("/email-code-login/validity")
+class EmailCodeLoginApi(Resource):
+    @setup_required
+    @console_ns.expect(console_ns.models[EmailCodeLoginPayload.__name__])
+    def post(self):
+        args = EmailCodeLoginPayload.model_validate(console_ns.payload)
+
+        user_email = args.email
+        language = args.language
+
+        token_data = AccountService.get_email_code_login_data(args.token)
+        if token_data is None:
+            raise InvalidTokenError()
+
+        if token_data["email"] != args.email:
+            raise InvalidEmailError()
+
+        if token_data["code"] != args.code:
+            raise EmailCodeError()
+
+        AccountService.revoke_email_code_login_token(args.token)
+        try:
+            account = AccountService.get_user_through_email(user_email)
+        except AccountRegisterError:
+            raise AccountInFreezeError()
+        if account:
+            tenants = TenantService.get_join_tenants(account)
+            if not tenants:
+                workspaces = FeatureService.get_system_features().license.workspaces
+                if not workspaces.is_available():
+                    raise WorkspacesLimitExceeded()
+                if not FeatureService.get_system_features().is_allow_create_workspace:
+                    raise NotAllowedCreateWorkspace()
+                else:
+                    new_tenant = TenantService.create_tenant(f"{account.name}'s Workspace")
+                    TenantService.create_tenant_member(new_tenant, account, role="owner")
+                    account.current_tenant = new_tenant
+                    tenant_was_created.send(new_tenant)
+
+        if account is None:
+            try:
+                account = AccountService.create_account_and_tenant(
+                    email=user_email,
+                    name=user_email,
+                    interface_language=get_valid_language(language),
+                )
+            except WorkSpaceNotAllowedCreateError:
+                raise NotAllowedCreateWorkspace()
+            except AccountRegisterError:
+                raise AccountInFreezeError()
+            except WorkspacesLimitExceededError:
+                raise WorkspacesLimitExceeded()
+        token_pair = AccountService.login(account, ip_address=extract_remote_ip(request))
+        AccountService.reset_login_error_rate_limit(args.email)
+
+        # Create response with cookies instead of returning tokens in body
+        response = make_response({"result": "success"})
+
+        set_csrf_token_to_cookie(request, response, token_pair.csrf_token)
+        # Set HTTP-only secure cookies for tokens
+        set_access_token_to_cookie(request, response, token_pair.access_token)
+        set_refresh_token_to_cookie(request, response, token_pair.refresh_token)
+        return response
+
+
+@console_ns.route("/refresh-token")
+class RefreshTokenApi(Resource):
+    def post(self):
+        # Get refresh token from cookie instead of request body
+        refresh_token = extract_refresh_token(request)
+
+        if not refresh_token:
+            return {"result": "fail", "message": "No refresh token provided"}, 401
+
+        try:
+            new_token_pair = AccountService.refresh_token(refresh_token)
+
+            # Create response with new cookies
+            response = make_response({"result": "success"})
+
+            # Update cookies with new tokens
+            set_csrf_token_to_cookie(request, response, new_token_pair.csrf_token)
+            set_access_token_to_cookie(request, response, new_token_pair.access_token)
+            set_refresh_token_to_cookie(request, response, new_token_pair.refresh_token)
+            return response
+        except Exception as e:
+            return {"result": "fail", "message": str(e)}, 401

dify_1.11.1/api/controllers/console/auth/oauth.py

@@ -0,0 +1,223 @@
+import logging
+
+import httpx
+from flask import current_app, redirect, request
+from flask_restx import Resource
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import Unauthorized
+
+from configs import dify_config
+from constants.languages import languages
+from events.tenant_event import tenant_was_created
+from extensions.ext_database import db
+from libs.datetime_utils import naive_utc_now
+from libs.helper import extract_remote_ip
+from libs.oauth import GitHubOAuth, GoogleOAuth, OAuthUserInfo
+from libs.token import (
+    set_access_token_to_cookie,
+    set_csrf_token_to_cookie,
+    set_refresh_token_to_cookie,
+)
+from models import Account, AccountStatus
+from services.account_service import AccountService, RegisterService, TenantService
+from services.billing_service import BillingService
+from services.errors.account import AccountNotFoundError, AccountRegisterError
+from services.errors.workspace import WorkSpaceNotAllowedCreateError, WorkSpaceNotFoundError
+from services.feature_service import FeatureService
+
+from .. import console_ns
+
+logger = logging.getLogger(__name__)
+
+
+def get_oauth_providers():
+    with current_app.app_context():
+        if not dify_config.GITHUB_CLIENT_ID or not dify_config.GITHUB_CLIENT_SECRET:
+            github_oauth = None
+        else:
+            github_oauth = GitHubOAuth(
+                client_id=dify_config.GITHUB_CLIENT_ID,
+                client_secret=dify_config.GITHUB_CLIENT_SECRET,
+                redirect_uri=dify_config.CONSOLE_API_URL + "/console/api/oauth/authorize/github",
+            )
+        if not dify_config.GOOGLE_CLIENT_ID or not dify_config.GOOGLE_CLIENT_SECRET:
+            google_oauth = None
+        else:
+            google_oauth = GoogleOAuth(
+                client_id=dify_config.GOOGLE_CLIENT_ID,
+                client_secret=dify_config.GOOGLE_CLIENT_SECRET,
+                redirect_uri=dify_config.CONSOLE_API_URL + "/console/api/oauth/authorize/google",
+            )
+
+        OAUTH_PROVIDERS = {"github": github_oauth, "google": google_oauth}
+        return OAUTH_PROVIDERS
+
+
+@console_ns.route("/oauth/login/<provider>")
+class OAuthLogin(Resource):
+    @console_ns.doc("oauth_login")
+    @console_ns.doc(description="Initiate OAuth login process")
+    @console_ns.doc(
+        params={"provider": "OAuth provider name (github/google)", "invite_token": "Optional invitation token"}
+    )
+    @console_ns.response(302, "Redirect to OAuth authorization URL")
+    @console_ns.response(400, "Invalid provider")
+    def get(self, provider: str):
+        invite_token = request.args.get("invite_token") or None
+        OAUTH_PROVIDERS = get_oauth_providers()
+        with current_app.app_context():
+            oauth_provider = OAUTH_PROVIDERS.get(provider)
+        if not oauth_provider:
+            return {"error": "Invalid provider"}, 400
+
+        auth_url = oauth_provider.get_authorization_url(invite_token=invite_token)
+        return redirect(auth_url)
+
+
+@console_ns.route("/oauth/authorize/<provider>")
+class OAuthCallback(Resource):
+    @console_ns.doc("oauth_callback")
+    @console_ns.doc(description="Handle OAuth callback and complete login process")
+    @console_ns.doc(
+        params={
+            "provider": "OAuth provider name (github/google)",
+            "code": "Authorization code from OAuth provider",
+            "state": "Optional state parameter (used for invite token)",
+        }
+    )
+    @console_ns.response(302, "Redirect to console with access token")
+    @console_ns.response(400, "OAuth process failed")
+    def get(self, provider: str):
+        OAUTH_PROVIDERS = get_oauth_providers()
+        with current_app.app_context():
+            oauth_provider = OAUTH_PROVIDERS.get(provider)
+        if not oauth_provider:
+            return {"error": "Invalid provider"}, 400
+
+        code = request.args.get("code")
+        state = request.args.get("state")
+        invite_token = None
+        if state:
+            invite_token = state
+
+        if not code:
+            return {"error": "Authorization code is required"}, 400
+
+        try:
+            token = oauth_provider.get_access_token(code)
+            user_info = oauth_provider.get_user_info(token)
+        except httpx.RequestError as e:
+            error_text = str(e)
+            if isinstance(e, httpx.HTTPStatusError):
+                error_text = e.response.text
+            logger.exception("An error occurred during the OAuth process with %s: %s", provider, error_text)
+            return {"error": "OAuth process failed"}, 400
+
+        if invite_token and RegisterService.is_valid_invite_token(invite_token):
+            invitation = RegisterService.get_invitation_by_token(token=invite_token)
+            if invitation:
+                invitation_email = invitation.get("email", None)
+                if invitation_email != user_info.email:
+                    return redirect(f"{dify_config.CONSOLE_WEB_URL}/signin?message=Invalid invitation token.")
+
+            return redirect(f"{dify_config.CONSOLE_WEB_URL}/signin/invite-settings?invite_token={invite_token}")
+
+        try:
+            account = _generate_account(provider, user_info)
+        except AccountNotFoundError:
+            return redirect(f"{dify_config.CONSOLE_WEB_URL}/signin?message=Account not found.")
+        except (WorkSpaceNotFoundError, WorkSpaceNotAllowedCreateError):
+            return redirect(
+                f"{dify_config.CONSOLE_WEB_URL}/signin"
+                "?message=Workspace not found, please contact system admin to invite you to join in a workspace."
+            )
+        except AccountRegisterError as e:
+            return redirect(f"{dify_config.CONSOLE_WEB_URL}/signin?message={e.description}")
+
+        # Check account status
+        if account.status == AccountStatus.BANNED:
+            return redirect(f"{dify_config.CONSOLE_WEB_URL}/signin?message=Account is banned.")
+
+        if account.status == AccountStatus.PENDING:
+            account.status = AccountStatus.ACTIVE
+            account.initialized_at = naive_utc_now()
+            db.session.commit()
+
+        try:
+            TenantService.create_owner_tenant_if_not_exist(account)
+        except Unauthorized:
+            return redirect(f"{dify_config.CONSOLE_WEB_URL}/signin?message=Workspace not found.")
+        except WorkSpaceNotAllowedCreateError:
+            return redirect(
+                f"{dify_config.CONSOLE_WEB_URL}/signin"
+                "?message=Workspace not found, please contact system admin to invite you to join in a workspace."
+            )
+
+        token_pair = AccountService.login(
+            account=account,
+            ip_address=extract_remote_ip(request),
+        )
+
+        response = redirect(f"{dify_config.CONSOLE_WEB_URL}")
+
+        set_access_token_to_cookie(request, response, token_pair.access_token)
+        set_refresh_token_to_cookie(request, response, token_pair.refresh_token)
+        set_csrf_token_to_cookie(request, response, token_pair.csrf_token)
+        return response
+
+
+def _get_account_by_openid_or_email(provider: str, user_info: OAuthUserInfo) -> Account | None:
+    account: Account | None = Account.get_by_openid(provider, user_info.id)
+
+    if not account:
+        with Session(db.engine) as session:
+            account = session.execute(select(Account).filter_by(email=user_info.email)).scalar_one_or_none()
+
+    return account
+
+
+def _generate_account(provider: str, user_info: OAuthUserInfo):
+    # Get account by openid or email.
+    account = _get_account_by_openid_or_email(provider, user_info)
+
+    if account:
+        tenants = TenantService.get_join_tenants(account)
+        if not tenants:
+            if not FeatureService.get_system_features().is_allow_create_workspace:
+                raise WorkSpaceNotAllowedCreateError()
+            else:
+                new_tenant = TenantService.create_tenant(f"{account.name}'s Workspace")
+                TenantService.create_tenant_member(new_tenant, account, role="owner")
+                account.current_tenant = new_tenant
+                tenant_was_created.send(new_tenant)
+
+    if not account:
+        if not FeatureService.get_system_features().is_allow_register:
+            if dify_config.BILLING_ENABLED and BillingService.is_email_in_freeze(user_info.email):
+                raise AccountRegisterError(
+                    description=(
+                        "This email account has been deleted within the past "
+                        "30 days and is temporarily unavailable for new account registration"
+                    )
+                )
+            else:
+                raise AccountRegisterError(description=("Invalid email or password"))
+        account_name = user_info.name or "Dify"
+        account = RegisterService.register(
+            email=user_info.email, name=account_name, password=None, open_id=user_info.id, provider=provider
+        )
+
+        # Set interface language
+        preferred_lang = request.accept_languages.best_match(languages)
+        if preferred_lang and preferred_lang in languages:
+            interface_language = preferred_lang
+        else:
+            interface_language = languages[0]
+        account.interface_language = interface_language
+        db.session.commit()
+
+    # Link account
+    AccountService.link_account_integrate(provider, user_info.id, account)
+
+    return account

dify_1.11.1/api/controllers/console/auth/oauth_server.py

@@ -0,0 +1,211 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import Concatenate, ParamSpec, TypeVar
+
+from flask import jsonify, request
+from flask_restx import Resource
+from pydantic import BaseModel
+from werkzeug.exceptions import BadRequest, NotFound
+
+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 models import Account
+from models.model import OAuthProviderApp
+from services.oauth_server import OAUTH_ACCESS_TOKEN_EXPIRES_IN, OAuthGrantType, OAuthServerService
+
+from .. import console_ns
+
+P = ParamSpec("P")
+R = TypeVar("R")
+T = TypeVar("T")
+
+
+class OAuthClientPayload(BaseModel):
+    client_id: str
+
+
+class OAuthProviderRequest(BaseModel):
+    client_id: str
+    redirect_uri: str
+
+
+class OAuthTokenRequest(BaseModel):
+    client_id: str
+    grant_type: str
+    code: str | None = None
+    client_secret: str | None = None
+    redirect_uri: str | None = None
+    refresh_token: str | None = None
+
+
+def oauth_server_client_id_required(view: Callable[Concatenate[T, OAuthProviderApp, P], R]):
+    @wraps(view)
+    def decorated(self: T, *args: P.args, **kwargs: P.kwargs):
+        json_data = request.get_json()
+        if json_data is None:
+            raise BadRequest("client_id is required")
+
+        payload = OAuthClientPayload.model_validate(json_data)
+        client_id = payload.client_id
+
+        oauth_provider_app = OAuthServerService.get_oauth_provider_app(client_id)
+        if not oauth_provider_app:
+            raise NotFound("client_id is invalid")
+
+        return view(self, oauth_provider_app, *args, **kwargs)
+
+    return decorated
+
+
+def oauth_server_access_token_required(view: Callable[Concatenate[T, OAuthProviderApp, Account, P], R]):
+    @wraps(view)
+    def decorated(self: T, oauth_provider_app: OAuthProviderApp, *args: P.args, **kwargs: P.kwargs):
+        if not isinstance(oauth_provider_app, OAuthProviderApp):
+            raise BadRequest("Invalid oauth_provider_app")
+
+        authorization_header = request.headers.get("Authorization")
+        if not authorization_header:
+            response = jsonify({"error": "Authorization header is required"})
+            response.status_code = 401
+            response.headers["WWW-Authenticate"] = "Bearer"
+            return response
+
+        parts = authorization_header.strip().split(None, 1)
+        if len(parts) != 2:
+            response = jsonify({"error": "Invalid Authorization header format"})
+            response.status_code = 401
+            response.headers["WWW-Authenticate"] = "Bearer"
+            return response
+
+        token_type = parts[0].strip()
+        if token_type.lower() != "bearer":
+            response = jsonify({"error": "token_type is invalid"})
+            response.status_code = 401
+            response.headers["WWW-Authenticate"] = "Bearer"
+            return response
+
+        access_token = parts[1].strip()
+        if not access_token:
+            response = jsonify({"error": "access_token is required"})
+            response.status_code = 401
+            response.headers["WWW-Authenticate"] = "Bearer"
+            return response
+
+        account = OAuthServerService.validate_oauth_access_token(oauth_provider_app.client_id, access_token)
+        if not account:
+            response = jsonify({"error": "access_token or client_id is invalid"})
+            response.status_code = 401
+            response.headers["WWW-Authenticate"] = "Bearer"
+            return response
+
+        return view(self, oauth_provider_app, account, *args, **kwargs)
+
+    return decorated
+
+
+@console_ns.route("/oauth/provider")
+class OAuthServerAppApi(Resource):
+    @setup_required
+    @oauth_server_client_id_required
+    def post(self, oauth_provider_app: OAuthProviderApp):
+        payload = OAuthProviderRequest.model_validate(request.get_json())
+        redirect_uri = payload.redirect_uri
+
+        # check if redirect_uri is valid
+        if redirect_uri not in oauth_provider_app.redirect_uris:
+            raise BadRequest("redirect_uri is invalid")
+
+        return jsonable_encoder(
+            {
+                "app_icon": oauth_provider_app.app_icon,
+                "app_label": oauth_provider_app.app_label,
+                "scope": oauth_provider_app.scope,
+            }
+        )
+
+
+@console_ns.route("/oauth/provider/authorize")
+class OAuthServerUserAuthorizeApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @oauth_server_client_id_required
+    def post(self, oauth_provider_app: OAuthProviderApp):
+        current_user, _ = current_account_with_tenant()
+        account = current_user
+        user_account_id = account.id
+
+        code = OAuthServerService.sign_oauth_authorization_code(oauth_provider_app.client_id, user_account_id)
+        return jsonable_encoder(
+            {
+                "code": code,
+            }
+        )
+
+
+@console_ns.route("/oauth/provider/token")
+class OAuthServerUserTokenApi(Resource):
+    @setup_required
+    @oauth_server_client_id_required
+    def post(self, oauth_provider_app: OAuthProviderApp):
+        payload = OAuthTokenRequest.model_validate(request.get_json())
+
+        try:
+            grant_type = OAuthGrantType(payload.grant_type)
+        except ValueError:
+            raise BadRequest("invalid grant_type")
+
+        if grant_type == OAuthGrantType.AUTHORIZATION_CODE:
+            if not payload.code:
+                raise BadRequest("code is required")
+
+            if payload.client_secret != oauth_provider_app.client_secret:
+                raise BadRequest("client_secret is invalid")
+
+            if payload.redirect_uri not in oauth_provider_app.redirect_uris:
+                raise BadRequest("redirect_uri is invalid")
+
+            access_token, refresh_token = OAuthServerService.sign_oauth_access_token(
+                grant_type, code=payload.code, client_id=oauth_provider_app.client_id
+            )
+            return jsonable_encoder(
+                {
+                    "access_token": access_token,
+                    "token_type": "Bearer",
+                    "expires_in": OAUTH_ACCESS_TOKEN_EXPIRES_IN,
+                    "refresh_token": refresh_token,
+                }
+            )
+        elif grant_type == OAuthGrantType.REFRESH_TOKEN:
+            if not payload.refresh_token:
+                raise BadRequest("refresh_token is required")
+
+            access_token, refresh_token = OAuthServerService.sign_oauth_access_token(
+                grant_type, refresh_token=payload.refresh_token, client_id=oauth_provider_app.client_id
+            )
+            return jsonable_encoder(
+                {
+                    "access_token": access_token,
+                    "token_type": "Bearer",
+                    "expires_in": OAUTH_ACCESS_TOKEN_EXPIRES_IN,
+                    "refresh_token": refresh_token,
+                }
+            )
+
+
+@console_ns.route("/oauth/provider/account")
+class OAuthServerUserAccountApi(Resource):
+    @setup_required
+    @oauth_server_client_id_required
+    @oauth_server_access_token_required
+    def post(self, oauth_provider_app: OAuthProviderApp, account: Account):
+        return jsonable_encoder(
+            {
+                "name": account.name,
+                "email": account.email,
+                "avatar": account.avatar,
+                "interface_language": account.interface_language,
+                "timezone": account.timezone,
+            }
+        )

dify_1.11.1/api/controllers/console/billing/billing.py

@@ -0,0 +1,99 @@
+import base64
+
+from flask import request
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field, field_validator
+from werkzeug.exceptions import BadRequest
+
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, only_edition_cloud, setup_required
+from enums.cloud_plan import CloudPlan
+from libs.login import current_account_with_tenant, login_required
+from services.billing_service import BillingService
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class SubscriptionQuery(BaseModel):
+    plan: str = Field(..., description="Subscription plan")
+    interval: str = Field(..., description="Billing interval")
+
+    @field_validator("plan")
+    @classmethod
+    def validate_plan(cls, value: str) -> str:
+        if value not in [CloudPlan.PROFESSIONAL, CloudPlan.TEAM]:
+            raise ValueError("Invalid plan")
+        return value
+
+    @field_validator("interval")
+    @classmethod
+    def validate_interval(cls, value: str) -> str:
+        if value not in {"month", "year"}:
+            raise ValueError("Invalid interval")
+        return value
+
+
+class PartnerTenantsPayload(BaseModel):
+    click_id: str = Field(..., description="Click Id from partner referral link")
+
+
+for model in (SubscriptionQuery, PartnerTenantsPayload):
+    console_ns.schema_model(model.__name__, model.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+@console_ns.route("/billing/subscription")
+class Subscription(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @only_edition_cloud
+    def get(self):
+        current_user, current_tenant_id = current_account_with_tenant()
+        args = SubscriptionQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        BillingService.is_tenant_owner_or_admin(current_user)
+        return BillingService.get_subscription(args.plan, args.interval, current_user.email, current_tenant_id)
+
+
+@console_ns.route("/billing/invoices")
+class Invoices(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @only_edition_cloud
+    def get(self):
+        current_user, current_tenant_id = current_account_with_tenant()
+        BillingService.is_tenant_owner_or_admin(current_user)
+        return BillingService.get_invoices(current_user.email, current_tenant_id)
+
+
+@console_ns.route("/billing/partners/<string:partner_key>/tenants")
+class PartnerTenants(Resource):
+    @console_ns.doc("sync_partner_tenants_bindings")
+    @console_ns.doc(description="Sync partner tenants bindings")
+    @console_ns.doc(params={"partner_key": "Partner key"})
+    @console_ns.expect(
+        console_ns.model(
+            "SyncPartnerTenantsBindingsRequest",
+            {"click_id": fields.String(required=True, description="Click Id from partner referral link")},
+        )
+    )
+    @console_ns.response(200, "Tenants synced to partner successfully")
+    @console_ns.response(400, "Invalid partner information")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @only_edition_cloud
+    def put(self, partner_key: str):
+        current_user, _ = current_account_with_tenant()
+
+        try:
+            args = PartnerTenantsPayload.model_validate(console_ns.payload or {})
+            click_id = args.click_id
+            decoded_partner_key = base64.b64decode(partner_key).decode("utf-8")
+        except Exception:
+            raise BadRequest("Invalid partner_key")
+
+        if not click_id or not decoded_partner_key or not current_user.id:
+            raise BadRequest("Invalid partner information")
+
+        return BillingService.sync_partner_tenants_bindings(current_user.id, decoded_partner_key, click_id)

dify_1.11.1/api/controllers/console/billing/compliance.py

@@ -0,0 +1,44 @@
+from flask import request
+from flask_restx import Resource
+from pydantic import BaseModel, Field
+
+from libs.helper import extract_remote_ip
+from libs.login import current_account_with_tenant, login_required
+from services.billing_service import BillingService
+
+from .. import console_ns
+from ..wraps import account_initialization_required, only_edition_cloud, setup_required
+
+
+class ComplianceDownloadQuery(BaseModel):
+    doc_name: str = Field(..., description="Compliance document name")
+
+
+console_ns.schema_model(
+    ComplianceDownloadQuery.__name__,
+    ComplianceDownloadQuery.model_json_schema(ref_template="#/definitions/{model}"),
+)
+
+
+@console_ns.route("/compliance/download")
+class ComplianceApi(Resource):
+    @console_ns.expect(console_ns.models[ComplianceDownloadQuery.__name__])
+    @console_ns.doc("download_compliance_document")
+    @console_ns.doc(description="Get compliance document download link")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @only_edition_cloud
+    def get(self):
+        current_user, current_tenant_id = current_account_with_tenant()
+        args = ComplianceDownloadQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        ip_address = extract_remote_ip(request)
+        device_info = request.headers.get("User-Agent", "Unknown device")
+        return BillingService.get_compliance_download_link(
+            doc_name=args.doc_name,
+            account_id=current_user.id,
+            tenant_id=current_tenant_id,
+            ip=ip_address,
+            device_info=device_info,
+        )

dify_1.11.1/api/controllers/console/datasets/data_source.py

@@ -0,0 +1,331 @@
+import json
+from collections.abc import Generator
+from typing import Any, cast
+
+from flask import request
+from flask_restx import Resource, marshal_with
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import NotFound
+
+from controllers.common.schema import register_schema_model
+from core.datasource.entities.datasource_entities import DatasourceProviderType, OnlineDocumentPagesMessage
+from core.datasource.online_document.online_document_plugin import OnlineDocumentDatasourcePlugin
+from core.indexing_runner import IndexingRunner
+from core.rag.extractor.entity.datasource_type import DatasourceType
+from core.rag.extractor.entity.extract_setting import ExtractSetting, NotionInfo
+from core.rag.extractor.notion_extractor import NotionExtractor
+from extensions.ext_database import db
+from fields.data_source_fields import integrate_list_fields, integrate_notion_info_list_fields
+from libs.datetime_utils import naive_utc_now
+from libs.login import current_account_with_tenant, login_required
+from models import DataSourceOauthBinding, Document
+from services.dataset_service import DatasetService, DocumentService
+from services.datasource_provider_service import DatasourceProviderService
+from tasks.document_indexing_sync_task import document_indexing_sync_task
+
+from .. import console_ns
+from ..wraps import account_initialization_required, setup_required
+
+
+class NotionEstimatePayload(BaseModel):
+    notion_info_list: list[dict[str, Any]]
+    process_rule: dict[str, Any]
+    doc_form: str = Field(default="text_model")
+    doc_language: str = Field(default="English")
+
+
+register_schema_model(console_ns, NotionEstimatePayload)
+
+
+@console_ns.route(
+    "/data-source/integrates",
+    "/data-source/integrates/<uuid:binding_id>/<string:action>",
+)
+class DataSourceApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(integrate_list_fields)
+    def get(self):
+        _, current_tenant_id = current_account_with_tenant()
+
+        # get workspace data source integrates
+        data_source_integrates = db.session.scalars(
+            select(DataSourceOauthBinding).where(
+                DataSourceOauthBinding.tenant_id == current_tenant_id,
+                DataSourceOauthBinding.disabled == False,
+            )
+        ).all()
+
+        base_url = request.url_root.rstrip("/")
+        data_source_oauth_base_path = "/console/api/oauth/data-source"
+        providers = ["notion"]
+
+        integrate_data = []
+        for provider in providers:
+            # existing_integrate = next((ai for ai in data_source_integrates if ai.provider == provider), None)
+            existing_integrates = filter(lambda item: item.provider == provider, data_source_integrates)
+            if existing_integrates:
+                for existing_integrate in list(existing_integrates):
+                    integrate_data.append(
+                        {
+                            "id": existing_integrate.id,
+                            "provider": provider,
+                            "created_at": existing_integrate.created_at,
+                            "is_bound": True,
+                            "disabled": existing_integrate.disabled,
+                            "source_info": existing_integrate.source_info,
+                            "link": f"{base_url}{data_source_oauth_base_path}/{provider}",
+                        }
+                    )
+            else:
+                integrate_data.append(
+                    {
+                        "id": None,
+                        "provider": provider,
+                        "created_at": None,
+                        "source_info": None,
+                        "is_bound": False,
+                        "disabled": None,
+                        "link": f"{base_url}{data_source_oauth_base_path}/{provider}",
+                    }
+                )
+        return {"data": integrate_data}, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def patch(self, binding_id, action):
+        binding_id = str(binding_id)
+        action = str(action)
+        with Session(db.engine) as session:
+            data_source_binding = session.execute(
+                select(DataSourceOauthBinding).filter_by(id=binding_id)
+            ).scalar_one_or_none()
+        if data_source_binding is None:
+            raise NotFound("Data source binding not found.")
+        # enable binding
+        if action == "enable":
+            if data_source_binding.disabled:
+                data_source_binding.disabled = False
+                data_source_binding.updated_at = naive_utc_now()
+                db.session.add(data_source_binding)
+                db.session.commit()
+            else:
+                raise ValueError("Data source is not disabled.")
+        # disable binding
+        if action == "disable":
+            if not data_source_binding.disabled:
+                data_source_binding.disabled = True
+                data_source_binding.updated_at = naive_utc_now()
+                db.session.add(data_source_binding)
+                db.session.commit()
+            else:
+                raise ValueError("Data source is disabled.")
+        return {"result": "success"}, 200
+
+
+@console_ns.route("/notion/pre-import/pages")
+class DataSourceNotionListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(integrate_notion_info_list_fields)
+    def get(self):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        dataset_id = request.args.get("dataset_id", default=None, type=str)
+        credential_id = request.args.get("credential_id", default=None, type=str)
+        if not credential_id:
+            raise ValueError("Credential id is required.")
+        datasource_provider_service = DatasourceProviderService()
+        credential = datasource_provider_service.get_datasource_credentials(
+            tenant_id=current_tenant_id,
+            credential_id=credential_id,
+            provider="notion_datasource",
+            plugin_id="langgenius/notion_datasource",
+        )
+        if not credential:
+            raise NotFound("Credential not found.")
+        exist_page_ids = []
+        with Session(db.engine) as session:
+            # import notion in the exist dataset
+            if dataset_id:
+                dataset = DatasetService.get_dataset(dataset_id)
+                if not dataset:
+                    raise NotFound("Dataset not found.")
+                if dataset.data_source_type != "notion_import":
+                    raise ValueError("Dataset is not notion type.")
+
+                documents = session.scalars(
+                    select(Document).filter_by(
+                        dataset_id=dataset_id,
+                        tenant_id=current_tenant_id,
+                        data_source_type="notion_import",
+                        enabled=True,
+                    )
+                ).all()
+                if documents:
+                    for document in documents:
+                        data_source_info = json.loads(document.data_source_info)
+                        exist_page_ids.append(data_source_info["notion_page_id"])
+            # get all authorized pages
+            from core.datasource.datasource_manager import DatasourceManager
+
+            datasource_runtime = DatasourceManager.get_datasource_runtime(
+                provider_id="langgenius/notion_datasource/notion_datasource",
+                datasource_name="notion_datasource",
+                tenant_id=current_tenant_id,
+                datasource_type=DatasourceProviderType.ONLINE_DOCUMENT,
+            )
+            datasource_provider_service = DatasourceProviderService()
+            if credential:
+                datasource_runtime.runtime.credentials = credential
+            datasource_runtime = cast(OnlineDocumentDatasourcePlugin, datasource_runtime)
+            online_document_result: Generator[OnlineDocumentPagesMessage, None, None] = (
+                datasource_runtime.get_online_document_pages(
+                    user_id=current_user.id,
+                    datasource_parameters={},
+                    provider_type=datasource_runtime.datasource_provider_type(),
+                )
+            )
+            try:
+                pages = []
+                workspace_info = {}
+                for message in online_document_result:
+                    result = message.result
+                    for info in result:
+                        workspace_info = {
+                            "workspace_id": info.workspace_id,
+                            "workspace_name": info.workspace_name,
+                            "workspace_icon": info.workspace_icon,
+                        }
+                        for page in info.pages:
+                            page_info = {
+                                "page_id": page.page_id,
+                                "page_name": page.page_name,
+                                "type": page.type,
+                                "parent_id": page.parent_id,
+                                "is_bound": page.page_id in exist_page_ids,
+                                "page_icon": page.page_icon,
+                            }
+                            pages.append(page_info)
+            except Exception as e:
+                raise e
+            return {"notion_info": {**workspace_info, "pages": pages}}, 200
+
+
+@console_ns.route(
+    "/notion/workspaces/<uuid:workspace_id>/pages/<uuid:page_id>/<string:page_type>/preview",
+    "/datasets/notion-indexing-estimate",
+)
+class DataSourceNotionApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, workspace_id, page_id, page_type):
+        _, current_tenant_id = current_account_with_tenant()
+
+        credential_id = request.args.get("credential_id", default=None, type=str)
+        if not credential_id:
+            raise ValueError("Credential id is required.")
+        datasource_provider_service = DatasourceProviderService()
+        credential = datasource_provider_service.get_datasource_credentials(
+            tenant_id=current_tenant_id,
+            credential_id=credential_id,
+            provider="notion_datasource",
+            plugin_id="langgenius/notion_datasource",
+        )
+
+        workspace_id = str(workspace_id)
+        page_id = str(page_id)
+
+        extractor = NotionExtractor(
+            notion_workspace_id=workspace_id,
+            notion_obj_id=page_id,
+            notion_page_type=page_type,
+            notion_access_token=credential.get("integration_secret"),
+            tenant_id=current_tenant_id,
+        )
+
+        text_docs = extractor.extract()
+        return {"content": "\n".join([doc.page_content for doc in text_docs])}, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @console_ns.expect(console_ns.models[NotionEstimatePayload.__name__])
+    def post(self):
+        _, current_tenant_id = current_account_with_tenant()
+
+        payload = NotionEstimatePayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump()
+        # validate args
+        DocumentService.estimate_args_validate(args)
+        notion_info_list = payload.notion_info_list
+        extract_settings = []
+        for notion_info in notion_info_list:
+            workspace_id = notion_info["workspace_id"]
+            credential_id = notion_info.get("credential_id")
+            for page in notion_info["pages"]:
+                extract_setting = ExtractSetting(
+                    datasource_type=DatasourceType.NOTION,
+                    notion_info=NotionInfo.model_validate(
+                        {
+                            "credential_id": credential_id,
+                            "notion_workspace_id": workspace_id,
+                            "notion_obj_id": page["page_id"],
+                            "notion_page_type": page["type"],
+                            "tenant_id": current_tenant_id,
+                        }
+                    ),
+                    document_model=args["doc_form"],
+                )
+                extract_settings.append(extract_setting)
+        indexing_runner = IndexingRunner()
+        response = indexing_runner.indexing_estimate(
+            current_tenant_id,
+            extract_settings,
+            args["process_rule"],
+            args["doc_form"],
+            args["doc_language"],
+        )
+        return response.model_dump(), 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/notion/sync")
+class DataSourceNotionDatasetSyncApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id):
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+
+        documents = DocumentService.get_document_by_dataset_id(dataset_id_str)
+        for document in documents:
+            document_indexing_sync_task.delay(dataset_id_str, document.id)
+        return {"result": "success"}, 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/notion/sync")
+class DataSourceNotionDocumentSyncApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id, document_id):
+        dataset_id_str = str(dataset_id)
+        document_id_str = str(document_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+
+        document = DocumentService.get_document(dataset_id_str, document_id_str)
+        if document is None:
+            raise NotFound("Document not found.")
+        document_indexing_sync_task.delay(dataset_id_str, document_id_str)
+        return {"result": "success"}, 200

dify_1.11.1/api/controllers/console/datasets/datasets.py

@@ -0,0 +1,914 @@
+from typing import Any, cast
+
+from flask import request
+from flask_restx import Resource, fields, marshal, marshal_with
+from pydantic import BaseModel, Field, field_validator
+from sqlalchemy import select
+from werkzeug.exceptions import Forbidden, NotFound
+
+import services
+from configs import dify_config
+from controllers.common.schema import register_schema_models
+from controllers.console import console_ns
+from controllers.console.apikey import (
+    api_key_item_model,
+    api_key_list_model,
+)
+from controllers.console.app.error import ProviderNotInitializeError
+from controllers.console.datasets.error import DatasetInUseError, DatasetNameDuplicateError, IndexingEstimateError
+from controllers.console.wraps import (
+    account_initialization_required,
+    cloud_edition_billing_rate_limit_check,
+    enterprise_license_required,
+    is_admin_or_owner_required,
+    setup_required,
+)
+from core.errors.error import LLMBadRequestError, ProviderTokenNotInitError
+from core.indexing_runner import IndexingRunner
+from core.model_runtime.entities.model_entities import ModelType
+from core.provider_manager import ProviderManager
+from core.rag.datasource.vdb.vector_type import VectorType
+from core.rag.extractor.entity.datasource_type import DatasourceType
+from core.rag.extractor.entity.extract_setting import ExtractSetting, NotionInfo, WebsiteInfo
+from core.rag.retrieval.retrieval_methods import RetrievalMethod
+from extensions.ext_database import db
+from fields.app_fields import app_detail_kernel_fields, related_app_list
+from fields.dataset_fields import (
+    dataset_detail_fields,
+    dataset_fields,
+    dataset_query_detail_fields,
+    dataset_retrieval_model_fields,
+    doc_metadata_fields,
+    external_knowledge_info_fields,
+    external_retrieval_model_fields,
+    icon_info_fields,
+    keyword_setting_fields,
+    reranking_model_fields,
+    tag_fields,
+    vector_setting_fields,
+    weighted_score_fields,
+)
+from fields.document_fields import document_status_fields
+from libs.login import current_account_with_tenant, login_required
+from models import ApiToken, Dataset, Document, DocumentSegment, UploadFile
+from models.dataset import DatasetPermissionEnum
+from models.provider_ids import ModelProviderID
+from services.dataset_service import DatasetPermissionService, DatasetService, DocumentService
+
+
+def _get_or_create_model(model_name: str, field_def):
+    existing = console_ns.models.get(model_name)
+    if existing is None:
+        existing = console_ns.model(model_name, field_def)
+    return existing
+
+
+# Register models for flask_restx to avoid dict type issues in Swagger
+dataset_base_model = _get_or_create_model("DatasetBase", dataset_fields)
+
+tag_model = _get_or_create_model("Tag", tag_fields)
+
+keyword_setting_model = _get_or_create_model("DatasetKeywordSetting", keyword_setting_fields)
+vector_setting_model = _get_or_create_model("DatasetVectorSetting", vector_setting_fields)
+
+weighted_score_fields_copy = weighted_score_fields.copy()
+weighted_score_fields_copy["keyword_setting"] = fields.Nested(keyword_setting_model)
+weighted_score_fields_copy["vector_setting"] = fields.Nested(vector_setting_model)
+weighted_score_model = _get_or_create_model("DatasetWeightedScore", weighted_score_fields_copy)
+
+reranking_model = _get_or_create_model("DatasetRerankingModel", reranking_model_fields)
+
+dataset_retrieval_model_fields_copy = dataset_retrieval_model_fields.copy()
+dataset_retrieval_model_fields_copy["reranking_model"] = fields.Nested(reranking_model)
+dataset_retrieval_model_fields_copy["weights"] = fields.Nested(weighted_score_model, allow_null=True)
+dataset_retrieval_model = _get_or_create_model("DatasetRetrievalModel", dataset_retrieval_model_fields_copy)
+
+external_knowledge_info_model = _get_or_create_model("ExternalKnowledgeInfo", external_knowledge_info_fields)
+
+external_retrieval_model = _get_or_create_model("ExternalRetrievalModel", external_retrieval_model_fields)
+
+doc_metadata_model = _get_or_create_model("DatasetDocMetadata", doc_metadata_fields)
+
+icon_info_model = _get_or_create_model("DatasetIconInfo", icon_info_fields)
+
+dataset_detail_fields_copy = dataset_detail_fields.copy()
+dataset_detail_fields_copy["retrieval_model_dict"] = fields.Nested(dataset_retrieval_model)
+dataset_detail_fields_copy["tags"] = fields.List(fields.Nested(tag_model))
+dataset_detail_fields_copy["external_knowledge_info"] = fields.Nested(external_knowledge_info_model)
+dataset_detail_fields_copy["external_retrieval_model"] = fields.Nested(external_retrieval_model, allow_null=True)
+dataset_detail_fields_copy["doc_metadata"] = fields.List(fields.Nested(doc_metadata_model))
+dataset_detail_fields_copy["icon_info"] = fields.Nested(icon_info_model)
+dataset_detail_model = _get_or_create_model("DatasetDetail", dataset_detail_fields_copy)
+
+dataset_query_detail_model = _get_or_create_model("DatasetQueryDetail", dataset_query_detail_fields)
+
+app_detail_kernel_model = _get_or_create_model("AppDetailKernel", app_detail_kernel_fields)
+related_app_list_copy = related_app_list.copy()
+related_app_list_copy["data"] = fields.List(fields.Nested(app_detail_kernel_model))
+related_app_list_model = _get_or_create_model("RelatedAppList", related_app_list_copy)
+
+
+def _validate_indexing_technique(value: str | None) -> str | None:
+    if value is None:
+        return value
+    if value not in Dataset.INDEXING_TECHNIQUE_LIST:
+        raise ValueError("Invalid indexing technique.")
+    return value
+
+
+class DatasetCreatePayload(BaseModel):
+    name: str = Field(..., min_length=1, max_length=40)
+    description: str = Field("", max_length=400)
+    indexing_technique: str | None = None
+    permission: DatasetPermissionEnum | None = DatasetPermissionEnum.ONLY_ME
+    provider: str = "vendor"
+    external_knowledge_api_id: str | None = None
+    external_knowledge_id: str | None = None
+
+    @field_validator("indexing_technique")
+    @classmethod
+    def validate_indexing(cls, value: str | None) -> str | None:
+        return _validate_indexing_technique(value)
+
+    @field_validator("provider")
+    @classmethod
+    def validate_provider(cls, value: str) -> str:
+        if value not in Dataset.PROVIDER_LIST:
+            raise ValueError("Invalid provider.")
+        return value
+
+
+class DatasetUpdatePayload(BaseModel):
+    name: str | None = Field(None, min_length=1, max_length=40)
+    description: str | None = Field(None, max_length=400)
+    permission: DatasetPermissionEnum | None = None
+    indexing_technique: str | None = None
+    embedding_model: str | None = None
+    embedding_model_provider: str | None = None
+    retrieval_model: dict[str, Any] | None = None
+    partial_member_list: list[str] | None = None
+    external_retrieval_model: dict[str, Any] | None = None
+    external_knowledge_id: str | None = None
+    external_knowledge_api_id: str | None = None
+    icon_info: dict[str, Any] | None = None
+    is_multimodal: bool | None = False
+
+    @field_validator("indexing_technique")
+    @classmethod
+    def validate_indexing(cls, value: str | None) -> str | None:
+        return _validate_indexing_technique(value)
+
+
+class IndexingEstimatePayload(BaseModel):
+    info_list: dict[str, Any]
+    process_rule: dict[str, Any]
+    indexing_technique: str
+    doc_form: str = "text_model"
+    dataset_id: str | None = None
+    doc_language: str = "English"
+
+    @field_validator("indexing_technique")
+    @classmethod
+    def validate_indexing(cls, value: str) -> str:
+        result = _validate_indexing_technique(value)
+        if result is None:
+            raise ValueError("indexing_technique is required.")
+        return result
+
+
+register_schema_models(console_ns, DatasetCreatePayload, DatasetUpdatePayload, IndexingEstimatePayload)
+
+
+def _get_retrieval_methods_by_vector_type(vector_type: str | None, is_mock: bool = False) -> dict[str, list[str]]:
+    """
+    Get supported retrieval methods based on vector database type.
+
+    Args:
+        vector_type: Vector database type, can be None
+        is_mock: Whether this is a Mock API, affects MILVUS handling
+
+    Returns:
+        Dictionary containing supported retrieval methods
+
+    Raises:
+        ValueError: If vector_type is None or unsupported
+    """
+    if vector_type is None:
+        raise ValueError("Vector store type is not configured.")
+
+    # Define vector database types that only support semantic search
+    semantic_only_types = {
+        VectorType.RELYT,
+        VectorType.TIDB_VECTOR,
+        VectorType.CHROMA,
+        VectorType.PGVECTO_RS,
+        VectorType.VIKINGDB,
+        VectorType.UPSTASH,
+    }
+
+    # Define vector database types that support all retrieval methods
+    full_search_types = {
+        VectorType.QDRANT,
+        VectorType.WEAVIATE,
+        VectorType.OPENSEARCH,
+        VectorType.ANALYTICDB,
+        VectorType.MYSCALE,
+        VectorType.ORACLE,
+        VectorType.ELASTICSEARCH,
+        VectorType.ELASTICSEARCH_JA,
+        VectorType.PGVECTOR,
+        VectorType.VASTBASE,
+        VectorType.TIDB_ON_QDRANT,
+        VectorType.LINDORM,
+        VectorType.COUCHBASE,
+        VectorType.OPENGAUSS,
+        VectorType.OCEANBASE,
+        VectorType.TABLESTORE,
+        VectorType.HUAWEI_CLOUD,
+        VectorType.TENCENT,
+        VectorType.MATRIXONE,
+        VectorType.CLICKZETTA,
+        VectorType.BAIDU,
+        VectorType.ALIBABACLOUD_MYSQL,
+    }
+
+    semantic_methods = {"retrieval_method": [RetrievalMethod.SEMANTIC_SEARCH.value]}
+    full_methods = {
+        "retrieval_method": [
+            RetrievalMethod.SEMANTIC_SEARCH.value,
+            RetrievalMethod.FULL_TEXT_SEARCH.value,
+            RetrievalMethod.HYBRID_SEARCH.value,
+        ]
+    }
+
+    if vector_type == VectorType.MILVUS:
+        return semantic_methods if is_mock else full_methods
+
+    if vector_type in semantic_only_types:
+        return semantic_methods
+    elif vector_type in full_search_types:
+        return full_methods
+    else:
+        raise ValueError(f"Unsupported vector db type {vector_type}.")
+
+
+@console_ns.route("/datasets")
+class DatasetListApi(Resource):
+    @console_ns.doc("get_datasets")
+    @console_ns.doc(description="Get list of datasets")
+    @console_ns.doc(
+        params={
+            "page": "Page number (default: 1)",
+            "limit": "Number of items per page (default: 20)",
+            "ids": "Filter by dataset IDs (list)",
+            "keyword": "Search keyword",
+            "tag_ids": "Filter by tag IDs (list)",
+            "include_all": "Include all datasets (default: false)",
+        }
+    )
+    @console_ns.response(200, "Datasets retrieved successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def get(self):
+        current_user, current_tenant_id = current_account_with_tenant()
+        page = request.args.get("page", default=1, type=int)
+        limit = request.args.get("limit", default=20, type=int)
+        ids = request.args.getlist("ids")
+        # provider = request.args.get("provider", default="vendor")
+        search = request.args.get("keyword", default=None, type=str)
+        tag_ids = request.args.getlist("tag_ids")
+        include_all = request.args.get("include_all", default="false").lower() == "true"
+        if ids:
+            datasets, total = DatasetService.get_datasets_by_ids(ids, current_tenant_id)
+        else:
+            datasets, total = DatasetService.get_datasets(
+                page, limit, current_tenant_id, current_user, search, tag_ids, include_all
+            )
+
+        # check embedding setting
+        provider_manager = ProviderManager()
+        configurations = provider_manager.get_configurations(tenant_id=current_tenant_id)
+
+        embedding_models = configurations.get_models(model_type=ModelType.TEXT_EMBEDDING, only_active=True)
+
+        model_names = []
+        for embedding_model in embedding_models:
+            model_names.append(f"{embedding_model.model}:{embedding_model.provider.provider}")
+
+        data = cast(list[dict[str, Any]], marshal(datasets, dataset_detail_fields))
+        for item in data:
+            # convert embedding_model_provider to plugin standard format
+            if item["indexing_technique"] == "high_quality" and item["embedding_model_provider"]:
+                item["embedding_model_provider"] = str(ModelProviderID(item["embedding_model_provider"]))
+                item_model = f"{item['embedding_model']}:{item['embedding_model_provider']}"
+                if item_model in model_names:
+                    item["embedding_available"] = True
+                else:
+                    item["embedding_available"] = False
+            else:
+                item["embedding_available"] = True
+
+            if item.get("permission") == "partial_members":
+                part_users_list = DatasetPermissionService.get_dataset_partial_member_list(item["id"])
+                item.update({"partial_member_list": part_users_list})
+            else:
+                item.update({"partial_member_list": []})
+
+        response = {"data": data, "has_more": len(datasets) == limit, "limit": limit, "total": total, "page": page}
+        return response, 200
+
+    @console_ns.doc("create_dataset")
+    @console_ns.doc(description="Create a new dataset")
+    @console_ns.expect(console_ns.models[DatasetCreatePayload.__name__])
+    @console_ns.response(201, "Dataset created successfully")
+    @console_ns.response(400, "Invalid request parameters")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def post(self):
+        payload = DatasetCreatePayload.model_validate(console_ns.payload or {})
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        # The role of the current user in the ta table must be admin, owner, or editor, or dataset_operator
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+
+        try:
+            dataset = DatasetService.create_empty_dataset(
+                tenant_id=current_tenant_id,
+                name=payload.name,
+                description=payload.description,
+                indexing_technique=payload.indexing_technique,
+                account=current_user,
+                permission=payload.permission or DatasetPermissionEnum.ONLY_ME,
+                provider=payload.provider,
+                external_knowledge_api_id=payload.external_knowledge_api_id,
+                external_knowledge_id=payload.external_knowledge_id,
+            )
+        except services.errors.dataset.DatasetNameDuplicateError:
+            raise DatasetNameDuplicateError()
+
+        return marshal(dataset, dataset_detail_fields), 201
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>")
+class DatasetApi(Resource):
+    @console_ns.doc("get_dataset")
+    @console_ns.doc(description="Get dataset details")
+    @console_ns.doc(params={"dataset_id": "Dataset ID"})
+    @console_ns.response(200, "Dataset retrieved successfully", dataset_detail_model)
+    @console_ns.response(404, "Dataset not found")
+    @console_ns.response(403, "Permission denied")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+        data = cast(dict[str, Any], marshal(dataset, dataset_detail_fields))
+        if dataset.indexing_technique == "high_quality":
+            if dataset.embedding_model_provider:
+                provider_id = ModelProviderID(dataset.embedding_model_provider)
+                data["embedding_model_provider"] = str(provider_id)
+        if data.get("permission") == "partial_members":
+            part_users_list = DatasetPermissionService.get_dataset_partial_member_list(dataset_id_str)
+            data.update({"partial_member_list": part_users_list})
+
+        # check embedding setting
+        provider_manager = ProviderManager()
+        configurations = provider_manager.get_configurations(tenant_id=current_tenant_id)
+
+        embedding_models = configurations.get_models(model_type=ModelType.TEXT_EMBEDDING, only_active=True)
+
+        model_names = []
+        for embedding_model in embedding_models:
+            model_names.append(f"{embedding_model.model}:{embedding_model.provider.provider}")
+
+        if data["indexing_technique"] == "high_quality":
+            item_model = f"{data['embedding_model']}:{data['embedding_model_provider']}"
+            if item_model in model_names:
+                data["embedding_available"] = True
+            else:
+                data["embedding_available"] = False
+        else:
+            data["embedding_available"] = True
+
+        return data, 200
+
+    @console_ns.doc("update_dataset")
+    @console_ns.doc(description="Update dataset details")
+    @console_ns.expect(console_ns.models[DatasetUpdatePayload.__name__])
+    @console_ns.response(200, "Dataset updated successfully", dataset_detail_model)
+    @console_ns.response(404, "Dataset not found")
+    @console_ns.response(403, "Permission denied")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def patch(self, dataset_id):
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+
+        payload = DatasetUpdatePayload.model_validate(console_ns.payload or {})
+        current_user, current_tenant_id = current_account_with_tenant()
+        # check embedding model setting
+        if (
+            payload.indexing_technique == "high_quality"
+            and payload.embedding_model_provider is not None
+            and payload.embedding_model is not None
+        ):
+            is_multimodal = DatasetService.check_is_multimodal_model(
+                dataset.tenant_id, payload.embedding_model_provider, payload.embedding_model
+            )
+            payload.is_multimodal = is_multimodal
+        payload_data = payload.model_dump(exclude_unset=True)
+        # The role of the current user in the ta table must be admin, owner, editor, or dataset_operator
+        DatasetPermissionService.check_permission(
+            current_user, dataset, payload.permission, payload.partial_member_list
+        )
+
+        dataset = DatasetService.update_dataset(dataset_id_str, payload_data, current_user)
+
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+
+        result_data = cast(dict[str, Any], marshal(dataset, dataset_detail_fields))
+        tenant_id = current_tenant_id
+
+        if payload.partial_member_list is not None and payload.permission == DatasetPermissionEnum.PARTIAL_TEAM:
+            DatasetPermissionService.update_partial_member_list(tenant_id, dataset_id_str, payload.partial_member_list)
+        # clear partial member list when permission is only_me or all_team_members
+        elif payload.permission in {DatasetPermissionEnum.ONLY_ME, DatasetPermissionEnum.ALL_TEAM}:
+            DatasetPermissionService.clear_partial_member_list(dataset_id_str)
+
+        partial_member_list = DatasetPermissionService.get_dataset_partial_member_list(dataset_id_str)
+        result_data.update({"partial_member_list": partial_member_list})
+
+        return result_data, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def delete(self, dataset_id):
+        dataset_id_str = str(dataset_id)
+        current_user, _ = current_account_with_tenant()
+
+        if not (current_user.has_edit_permission or current_user.is_dataset_operator):
+            raise Forbidden()
+
+        try:
+            if DatasetService.delete_dataset(dataset_id_str, current_user):
+                DatasetPermissionService.clear_partial_member_list(dataset_id_str)
+                return {"result": "success"}, 204
+            else:
+                raise NotFound("Dataset not found.")
+        except services.errors.dataset.DatasetInUseError:
+            raise DatasetInUseError()
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/use-check")
+class DatasetUseCheckApi(Resource):
+    @console_ns.doc("check_dataset_use")
+    @console_ns.doc(description="Check if dataset is in use")
+    @console_ns.doc(params={"dataset_id": "Dataset ID"})
+    @console_ns.response(200, "Dataset use status retrieved successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id):
+        dataset_id_str = str(dataset_id)
+
+        dataset_is_using = DatasetService.dataset_use_check(dataset_id_str)
+        return {"is_using": dataset_is_using}, 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/queries")
+class DatasetQueryApi(Resource):
+    @console_ns.doc("get_dataset_queries")
+    @console_ns.doc(description="Get dataset query history")
+    @console_ns.doc(params={"dataset_id": "Dataset ID"})
+    @console_ns.response(200, "Query history retrieved successfully", dataset_query_detail_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id):
+        current_user, _ = current_account_with_tenant()
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+
+        page = request.args.get("page", default=1, type=int)
+        limit = request.args.get("limit", default=20, type=int)
+
+        dataset_queries, total = DatasetService.get_dataset_queries(dataset_id=dataset.id, page=page, per_page=limit)
+
+        response = {
+            "data": marshal(dataset_queries, dataset_query_detail_model),
+            "has_more": len(dataset_queries) == limit,
+            "limit": limit,
+            "total": total,
+            "page": page,
+        }
+        return response, 200
+
+
+@console_ns.route("/datasets/indexing-estimate")
+class DatasetIndexingEstimateApi(Resource):
+    @console_ns.doc("estimate_dataset_indexing")
+    @console_ns.doc(description="Estimate dataset indexing cost")
+    @console_ns.response(200, "Indexing estimate calculated successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @console_ns.expect(console_ns.models[IndexingEstimatePayload.__name__])
+    def post(self):
+        payload = IndexingEstimatePayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump()
+        _, current_tenant_id = current_account_with_tenant()
+        # validate args
+        DocumentService.estimate_args_validate(args)
+        extract_settings = []
+        if args["info_list"]["data_source_type"] == "upload_file":
+            file_ids = args["info_list"]["file_info_list"]["file_ids"]
+            file_details = db.session.scalars(
+                select(UploadFile).where(UploadFile.tenant_id == current_tenant_id, UploadFile.id.in_(file_ids))
+            ).all()
+
+            if file_details is None:
+                raise NotFound("File not found.")
+
+            if file_details:
+                for file_detail in file_details:
+                    extract_setting = ExtractSetting(
+                        datasource_type=DatasourceType.FILE,
+                        upload_file=file_detail,
+                        document_model=args["doc_form"],
+                    )
+                    extract_settings.append(extract_setting)
+        elif args["info_list"]["data_source_type"] == "notion_import":
+            notion_info_list = args["info_list"]["notion_info_list"]
+            for notion_info in notion_info_list:
+                workspace_id = notion_info["workspace_id"]
+                credential_id = notion_info.get("credential_id")
+                for page in notion_info["pages"]:
+                    extract_setting = ExtractSetting(
+                        datasource_type=DatasourceType.NOTION,
+                        notion_info=NotionInfo.model_validate(
+                            {
+                                "credential_id": credential_id,
+                                "notion_workspace_id": workspace_id,
+                                "notion_obj_id": page["page_id"],
+                                "notion_page_type": page["type"],
+                                "tenant_id": current_tenant_id,
+                            }
+                        ),
+                        document_model=args["doc_form"],
+                    )
+                    extract_settings.append(extract_setting)
+        elif args["info_list"]["data_source_type"] == "website_crawl":
+            website_info_list = args["info_list"]["website_info_list"]
+            for url in website_info_list["urls"]:
+                extract_setting = ExtractSetting(
+                    datasource_type=DatasourceType.WEBSITE,
+                    website_info=WebsiteInfo.model_validate(
+                        {
+                            "provider": website_info_list["provider"],
+                            "job_id": website_info_list["job_id"],
+                            "url": url,
+                            "tenant_id": current_tenant_id,
+                            "mode": "crawl",
+                            "only_main_content": website_info_list["only_main_content"],
+                        }
+                    ),
+                    document_model=args["doc_form"],
+                )
+                extract_settings.append(extract_setting)
+        else:
+            raise ValueError("Data source type not support")
+        indexing_runner = IndexingRunner()
+        try:
+            response = indexing_runner.indexing_estimate(
+                current_tenant_id,
+                extract_settings,
+                args["process_rule"],
+                args["doc_form"],
+                args["doc_language"],
+                args["dataset_id"],
+                args["indexing_technique"],
+            )
+        except LLMBadRequestError:
+            raise ProviderNotInitializeError(
+                "No Embedding Model available. Please configure a valid provider in the Settings -> Model Provider."
+            )
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except Exception as e:
+            raise IndexingEstimateError(str(e))
+
+        return response.model_dump(), 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/related-apps")
+class DatasetRelatedAppListApi(Resource):
+    @console_ns.doc("get_dataset_related_apps")
+    @console_ns.doc(description="Get applications related to dataset")
+    @console_ns.doc(params={"dataset_id": "Dataset ID"})
+    @console_ns.response(200, "Related apps retrieved successfully", related_app_list_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(related_app_list_model)
+    def get(self, dataset_id):
+        current_user, _ = current_account_with_tenant()
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+
+        app_dataset_joins = DatasetService.get_related_apps(dataset.id)
+
+        related_apps = []
+        for app_dataset_join in app_dataset_joins:
+            app_model = app_dataset_join.app
+            if app_model:
+                related_apps.append(app_model)
+
+        return {"data": related_apps, "total": len(related_apps)}, 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/indexing-status")
+class DatasetIndexingStatusApi(Resource):
+    @console_ns.doc("get_dataset_indexing_status")
+    @console_ns.doc(description="Get dataset indexing status")
+    @console_ns.doc(params={"dataset_id": "Dataset ID"})
+    @console_ns.response(200, "Indexing status retrieved successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id):
+        _, current_tenant_id = current_account_with_tenant()
+        dataset_id = str(dataset_id)
+        documents = db.session.scalars(
+            select(Document).where(Document.dataset_id == dataset_id, Document.tenant_id == current_tenant_id)
+        ).all()
+        documents_status = []
+        for document in documents:
+            completed_segments = (
+                db.session.query(DocumentSegment)
+                .where(
+                    DocumentSegment.completed_at.isnot(None),
+                    DocumentSegment.document_id == str(document.id),
+                    DocumentSegment.status != "re_segment",
+                )
+                .count()
+            )
+            total_segments = (
+                db.session.query(DocumentSegment)
+                .where(DocumentSegment.document_id == str(document.id), DocumentSegment.status != "re_segment")
+                .count()
+            )
+            # Create a dictionary with document attributes and additional fields
+            document_dict = {
+                "id": document.id,
+                "indexing_status": document.indexing_status,
+                "processing_started_at": document.processing_started_at,
+                "parsing_completed_at": document.parsing_completed_at,
+                "cleaning_completed_at": document.cleaning_completed_at,
+                "splitting_completed_at": document.splitting_completed_at,
+                "completed_at": document.completed_at,
+                "paused_at": document.paused_at,
+                "error": document.error,
+                "stopped_at": document.stopped_at,
+                "completed_segments": completed_segments,
+                "total_segments": total_segments,
+            }
+            documents_status.append(marshal(document_dict, document_status_fields))
+        data = {"data": documents_status}
+        return data, 200
+
+
+@console_ns.route("/datasets/api-keys")
+class DatasetApiKeyApi(Resource):
+    max_keys = 10
+    token_prefix = "dataset-"
+    resource_type = "dataset"
+
+    @console_ns.doc("get_dataset_api_keys")
+    @console_ns.doc(description="Get dataset API keys")
+    @console_ns.response(200, "API keys retrieved successfully", api_key_list_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(api_key_list_model)
+    def get(self):
+        _, current_tenant_id = current_account_with_tenant()
+        keys = db.session.scalars(
+            select(ApiToken).where(ApiToken.type == self.resource_type, ApiToken.tenant_id == current_tenant_id)
+        ).all()
+        return {"items": keys}
+
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    @marshal_with(api_key_item_model)
+    def post(self):
+        _, current_tenant_id = current_account_with_tenant()
+
+        current_key_count = (
+            db.session.query(ApiToken)
+            .where(ApiToken.type == self.resource_type, ApiToken.tenant_id == current_tenant_id)
+            .count()
+        )
+
+        if current_key_count >= self.max_keys:
+            console_ns.abort(
+                400,
+                message=f"Cannot create more than {self.max_keys} API keys for this resource type.",
+                code="max_keys_exceeded",
+            )
+
+        key = ApiToken.generate_api_key(self.token_prefix, 24)
+        api_token = ApiToken()
+        api_token.tenant_id = current_tenant_id
+        api_token.token = key
+        api_token.type = self.resource_type
+        db.session.add(api_token)
+        db.session.commit()
+        return api_token, 200
+
+
+@console_ns.route("/datasets/api-keys/<uuid:api_key_id>")
+class DatasetApiDeleteApi(Resource):
+    resource_type = "dataset"
+
+    @console_ns.doc("delete_dataset_api_key")
+    @console_ns.doc(description="Delete dataset API key")
+    @console_ns.doc(params={"api_key_id": "API key ID"})
+    @console_ns.response(204, "API key deleted successfully")
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def delete(self, api_key_id):
+        _, current_tenant_id = current_account_with_tenant()
+        api_key_id = str(api_key_id)
+        key = (
+            db.session.query(ApiToken)
+            .where(
+                ApiToken.tenant_id == current_tenant_id,
+                ApiToken.type == self.resource_type,
+                ApiToken.id == api_key_id,
+            )
+            .first()
+        )
+
+        if key is None:
+            console_ns.abort(404, message="API key not found")
+
+        db.session.query(ApiToken).where(ApiToken.id == api_key_id).delete()
+        db.session.commit()
+
+        return {"result": "success"}, 204
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/api-keys/<string:status>")
+class DatasetEnableApiApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, dataset_id, status):
+        dataset_id_str = str(dataset_id)
+
+        DatasetService.update_dataset_api_status(dataset_id_str, status == "enable")
+
+        return {"result": "success"}, 200
+
+
+@console_ns.route("/datasets/api-base-info")
+class DatasetApiBaseUrlApi(Resource):
+    @console_ns.doc("get_dataset_api_base_info")
+    @console_ns.doc(description="Get dataset API base information")
+    @console_ns.response(200, "API base info retrieved successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        return {"api_base_url": (dify_config.SERVICE_API_URL or request.host_url.rstrip("/")) + "/v1"}
+
+
+@console_ns.route("/datasets/retrieval-setting")
+class DatasetRetrievalSettingApi(Resource):
+    @console_ns.doc("get_dataset_retrieval_setting")
+    @console_ns.doc(description="Get dataset retrieval settings")
+    @console_ns.response(200, "Retrieval settings retrieved successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        vector_type = dify_config.VECTOR_STORE
+        return _get_retrieval_methods_by_vector_type(vector_type, is_mock=False)
+
+
+@console_ns.route("/datasets/retrieval-setting/<string:vector_type>")
+class DatasetRetrievalSettingMockApi(Resource):
+    @console_ns.doc("get_dataset_retrieval_setting_mock")
+    @console_ns.doc(description="Get mock dataset retrieval settings by vector type")
+    @console_ns.doc(params={"vector_type": "Vector store type"})
+    @console_ns.response(200, "Mock retrieval settings retrieved successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, vector_type):
+        return _get_retrieval_methods_by_vector_type(vector_type, is_mock=True)
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/error-docs")
+class DatasetErrorDocs(Resource):
+    @console_ns.doc("get_dataset_error_docs")
+    @console_ns.doc(description="Get dataset error documents")
+    @console_ns.doc(params={"dataset_id": "Dataset ID"})
+    @console_ns.response(200, "Error documents retrieved successfully")
+    @console_ns.response(404, "Dataset not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id):
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+        results = DocumentService.get_error_documents_by_dataset_id(dataset_id_str)
+
+        return {"data": [marshal(item, document_status_fields) for item in results], "total": len(results)}, 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/permission-part-users")
+class DatasetPermissionUserListApi(Resource):
+    @console_ns.doc("get_dataset_permission_users")
+    @console_ns.doc(description="Get dataset permission user list")
+    @console_ns.doc(params={"dataset_id": "Dataset ID"})
+    @console_ns.response(200, "Permission users retrieved successfully")
+    @console_ns.response(404, "Dataset not found")
+    @console_ns.response(403, "Permission denied")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id):
+        current_user, _ = current_account_with_tenant()
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+
+        partial_members_list = DatasetPermissionService.get_dataset_partial_member_list(dataset_id_str)
+
+        return {
+            "data": partial_members_list,
+        }, 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/auto-disable-logs")
+class DatasetAutoDisableLogApi(Resource):
+    @console_ns.doc("get_dataset_auto_disable_logs")
+    @console_ns.doc(description="Get dataset auto disable logs")
+    @console_ns.doc(params={"dataset_id": "Dataset ID"})
+    @console_ns.response(200, "Auto disable logs retrieved successfully")
+    @console_ns.response(404, "Dataset not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id):
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+        return DatasetService.get_dataset_auto_disable_logs(dataset_id_str), 200

dify_1.11.1/api/controllers/console/datasets/datasets_segments.py

@@ -0,0 +1,749 @@
+import uuid
+
+from flask import request
+from flask_restx import Resource, marshal
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+from werkzeug.exceptions import Forbidden, NotFound
+
+import services
+from controllers.common.schema import register_schema_models
+from controllers.console import console_ns
+from controllers.console.app.error import ProviderNotInitializeError
+from controllers.console.datasets.error import (
+    ChildChunkDeleteIndexError,
+    ChildChunkIndexingError,
+    InvalidActionError,
+)
+from controllers.console.wraps import (
+    account_initialization_required,
+    cloud_edition_billing_knowledge_limit_check,
+    cloud_edition_billing_rate_limit_check,
+    cloud_edition_billing_resource_check,
+    setup_required,
+)
+from core.errors.error import LLMBadRequestError, ProviderTokenNotInitError
+from core.model_manager import ModelManager
+from core.model_runtime.entities.model_entities import ModelType
+from extensions.ext_database import db
+from extensions.ext_redis import redis_client
+from fields.segment_fields import child_chunk_fields, segment_fields
+from libs.login import current_account_with_tenant, login_required
+from models.dataset import ChildChunk, DocumentSegment
+from models.model import UploadFile
+from services.dataset_service import DatasetService, DocumentService, SegmentService
+from services.entities.knowledge_entities.knowledge_entities import ChildChunkUpdateArgs, SegmentUpdateArgs
+from services.errors.chunk import ChildChunkDeleteIndexError as ChildChunkDeleteIndexServiceError
+from services.errors.chunk import ChildChunkIndexingError as ChildChunkIndexingServiceError
+from tasks.batch_create_segment_to_index_task import batch_create_segment_to_index_task
+
+
+class SegmentListQuery(BaseModel):
+    limit: int = Field(default=20, ge=1, le=100)
+    status: list[str] = Field(default_factory=list)
+    hit_count_gte: int | None = None
+    enabled: str = Field(default="all")
+    keyword: str | None = None
+    page: int = Field(default=1, ge=1)
+
+
+class SegmentCreatePayload(BaseModel):
+    content: str
+    answer: str | None = None
+    keywords: list[str] | None = None
+    attachment_ids: list[str] | None = None
+
+
+class SegmentUpdatePayload(BaseModel):
+    content: str
+    answer: str | None = None
+    keywords: list[str] | None = None
+    regenerate_child_chunks: bool = False
+    attachment_ids: list[str] | None = None
+
+
+class BatchImportPayload(BaseModel):
+    upload_file_id: str
+
+
+class ChildChunkCreatePayload(BaseModel):
+    content: str
+
+
+class ChildChunkUpdatePayload(BaseModel):
+    content: str
+
+
+class ChildChunkBatchUpdatePayload(BaseModel):
+    chunks: list[ChildChunkUpdateArgs]
+
+
+register_schema_models(
+    console_ns,
+    SegmentListQuery,
+    SegmentCreatePayload,
+    SegmentUpdatePayload,
+    BatchImportPayload,
+    ChildChunkCreatePayload,
+    ChildChunkUpdatePayload,
+    ChildChunkBatchUpdatePayload,
+)
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/segments")
+class DatasetDocumentSegmentListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id, document_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        dataset_id = str(dataset_id)
+        document_id = str(document_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+
+        document = DocumentService.get_document(dataset_id, document_id)
+
+        if not document:
+            raise NotFound("Document not found.")
+
+        args = SegmentListQuery.model_validate(
+            {
+                **request.args.to_dict(),
+                "status": request.args.getlist("status"),
+            }
+        )
+
+        page = args.page
+        limit = min(args.limit, 100)
+        status_list = args.status
+        hit_count_gte = args.hit_count_gte
+        keyword = args.keyword
+
+        query = (
+            select(DocumentSegment)
+            .where(
+                DocumentSegment.document_id == str(document_id),
+                DocumentSegment.tenant_id == current_tenant_id,
+            )
+            .order_by(DocumentSegment.position.asc())
+        )
+
+        if status_list:
+            query = query.where(DocumentSegment.status.in_(status_list))
+
+        if hit_count_gte is not None:
+            query = query.where(DocumentSegment.hit_count >= hit_count_gte)
+
+        if keyword:
+            query = query.where(DocumentSegment.content.ilike(f"%{keyword}%"))
+
+        if args.enabled.lower() != "all":
+            if args.enabled.lower() == "true":
+                query = query.where(DocumentSegment.enabled == True)
+            elif args.enabled.lower() == "false":
+                query = query.where(DocumentSegment.enabled == False)
+
+        segments = db.paginate(select=query, page=page, per_page=limit, max_per_page=100, error_out=False)
+
+        response = {
+            "data": marshal(segments.items, segment_fields),
+            "limit": limit,
+            "total": segments.total,
+            "total_pages": segments.pages,
+            "page": page,
+        }
+        return response, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def delete(self, dataset_id, document_id):
+        current_user, _ = current_account_with_tenant()
+
+        # check dataset
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        # check user's model setting
+        DatasetService.check_dataset_model_setting(dataset)
+        # check document
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+        segment_ids = request.args.getlist("segment_id")
+
+        # The role of the current user in the ta table must be admin, owner, dataset_operator, or editor
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+        SegmentService.delete_segments(segment_ids, document, dataset)
+        return {"result": "success"}, 204
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/segment/<string:action>")
+class DatasetDocumentSegmentApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("vector_space")
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def patch(self, dataset_id, document_id, action):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+        # check user's model setting
+        DatasetService.check_dataset_model_setting(dataset)
+        # The role of the current user in the ta table must be admin, owner, dataset_operator, or editor
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+        if dataset.indexing_technique == "high_quality":
+            # check embedding model setting
+            try:
+                model_manager = ModelManager()
+                model_manager.get_model_instance(
+                    tenant_id=current_tenant_id,
+                    provider=dataset.embedding_model_provider,
+                    model_type=ModelType.TEXT_EMBEDDING,
+                    model=dataset.embedding_model,
+                )
+            except LLMBadRequestError:
+                raise ProviderNotInitializeError(
+                    "No Embedding Model available. Please configure a valid provider in the Settings -> Model Provider."
+                )
+            except ProviderTokenNotInitError as ex:
+                raise ProviderNotInitializeError(ex.description)
+        segment_ids = request.args.getlist("segment_id")
+
+        document_indexing_cache_key = f"document_{document.id}_indexing"
+        cache_result = redis_client.get(document_indexing_cache_key)
+        if cache_result is not None:
+            raise InvalidActionError("Document is being indexed, please try again later")
+        try:
+            SegmentService.update_segments_status(segment_ids, action, dataset, document)
+        except Exception as e:
+            raise InvalidActionError(str(e))
+        return {"result": "success"}, 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/segment")
+class DatasetDocumentSegmentAddApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("vector_space")
+    @cloud_edition_billing_knowledge_limit_check("add_segment")
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    @console_ns.expect(console_ns.models[SegmentCreatePayload.__name__])
+    def post(self, dataset_id, document_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        # check dataset
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        # check document
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+        # check embedding model setting
+        if dataset.indexing_technique == "high_quality":
+            try:
+                model_manager = ModelManager()
+                model_manager.get_model_instance(
+                    tenant_id=current_tenant_id,
+                    provider=dataset.embedding_model_provider,
+                    model_type=ModelType.TEXT_EMBEDDING,
+                    model=dataset.embedding_model,
+                )
+            except LLMBadRequestError:
+                raise ProviderNotInitializeError(
+                    "No Embedding Model available. Please configure a valid provider in the Settings -> Model Provider."
+                )
+            except ProviderTokenNotInitError as ex:
+                raise ProviderNotInitializeError(ex.description)
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+        # validate args
+        payload = SegmentCreatePayload.model_validate(console_ns.payload or {})
+        payload_dict = payload.model_dump(exclude_none=True)
+        SegmentService.segment_create_args_validate(payload_dict, document)
+        segment = SegmentService.create_segment(payload_dict, document, dataset)
+        return {"data": marshal(segment, segment_fields), "doc_form": document.doc_form}, 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/segments/<uuid:segment_id>")
+class DatasetDocumentSegmentUpdateApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("vector_space")
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    @console_ns.expect(console_ns.models[SegmentUpdatePayload.__name__])
+    def patch(self, dataset_id, document_id, segment_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        # check dataset
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        # check user's model setting
+        DatasetService.check_dataset_model_setting(dataset)
+        # check document
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+        if dataset.indexing_technique == "high_quality":
+            # check embedding model setting
+            try:
+                model_manager = ModelManager()
+                model_manager.get_model_instance(
+                    tenant_id=current_tenant_id,
+                    provider=dataset.embedding_model_provider,
+                    model_type=ModelType.TEXT_EMBEDDING,
+                    model=dataset.embedding_model,
+                )
+            except LLMBadRequestError:
+                raise ProviderNotInitializeError(
+                    "No Embedding Model available. Please configure a valid provider in the Settings -> Model Provider."
+                )
+            except ProviderTokenNotInitError as ex:
+                raise ProviderNotInitializeError(ex.description)
+            # check segment
+        segment_id = str(segment_id)
+        segment = (
+            db.session.query(DocumentSegment)
+            .where(DocumentSegment.id == str(segment_id), DocumentSegment.tenant_id == current_tenant_id)
+            .first()
+        )
+        if not segment:
+            raise NotFound("Segment not found.")
+        # The role of the current user in the ta table must be admin, owner, dataset_operator, or editor
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+        # validate args
+        payload = SegmentUpdatePayload.model_validate(console_ns.payload or {})
+        payload_dict = payload.model_dump(exclude_none=True)
+        SegmentService.segment_create_args_validate(payload_dict, document)
+        segment = SegmentService.update_segment(
+            SegmentUpdateArgs.model_validate(payload.model_dump(exclude_none=True)), segment, document, dataset
+        )
+        return {"data": marshal(segment, segment_fields), "doc_form": document.doc_form}, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def delete(self, dataset_id, document_id, segment_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        # check dataset
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        # check user's model setting
+        DatasetService.check_dataset_model_setting(dataset)
+        # check document
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+        # check segment
+        segment_id = str(segment_id)
+        segment = (
+            db.session.query(DocumentSegment)
+            .where(DocumentSegment.id == str(segment_id), DocumentSegment.tenant_id == current_tenant_id)
+            .first()
+        )
+        if not segment:
+            raise NotFound("Segment not found.")
+        # The role of the current user in the ta table must be admin, owner, dataset_operator, or editor
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+        SegmentService.delete_segment(segment, document, dataset)
+        return {"result": "success"}, 204
+
+
+@console_ns.route(
+    "/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/segments/batch_import",
+    "/datasets/batch_import_status/<uuid:job_id>",
+)
+class DatasetDocumentSegmentBatchImportApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("vector_space")
+    @cloud_edition_billing_knowledge_limit_check("add_segment")
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    @console_ns.expect(console_ns.models[BatchImportPayload.__name__])
+    def post(self, dataset_id, document_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        # check dataset
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        # check document
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+
+        payload = BatchImportPayload.model_validate(console_ns.payload or {})
+        upload_file_id = payload.upload_file_id
+
+        upload_file = db.session.query(UploadFile).where(UploadFile.id == upload_file_id).first()
+        if not upload_file:
+            raise NotFound("UploadFile not found.")
+
+        # check file type
+        if not upload_file.name or not upload_file.name.lower().endswith(".csv"):
+            raise ValueError("Invalid file type. Only CSV files are allowed")
+
+        try:
+            # async job
+            job_id = str(uuid.uuid4())
+            indexing_cache_key = f"segment_batch_import_{str(job_id)}"
+            # send batch add segments task
+            redis_client.setnx(indexing_cache_key, "waiting")
+            batch_create_segment_to_index_task.delay(
+                str(job_id),
+                upload_file_id,
+                dataset_id,
+                document_id,
+                current_tenant_id,
+                current_user.id,
+            )
+        except Exception as e:
+            return {"error": str(e)}, 500
+        return {"job_id": job_id, "job_status": "waiting"}, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, job_id=None, dataset_id=None, document_id=None):
+        if job_id is None:
+            raise NotFound("The job does not exist.")
+        job_id = str(job_id)
+        indexing_cache_key = f"segment_batch_import_{job_id}"
+        cache_result = redis_client.get(indexing_cache_key)
+        if cache_result is None:
+            raise ValueError("The job does not exist.")
+
+        return {"job_id": job_id, "job_status": cache_result.decode()}, 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/segments/<uuid:segment_id>/child_chunks")
+class ChildChunkAddApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("vector_space")
+    @cloud_edition_billing_knowledge_limit_check("add_segment")
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    @console_ns.expect(console_ns.models[ChildChunkCreatePayload.__name__])
+    def post(self, dataset_id, document_id, segment_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        # check dataset
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        # check document
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+        # check segment
+        segment_id = str(segment_id)
+        segment = (
+            db.session.query(DocumentSegment)
+            .where(DocumentSegment.id == str(segment_id), DocumentSegment.tenant_id == current_tenant_id)
+            .first()
+        )
+        if not segment:
+            raise NotFound("Segment not found.")
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+        # check embedding model setting
+        if dataset.indexing_technique == "high_quality":
+            try:
+                model_manager = ModelManager()
+                model_manager.get_model_instance(
+                    tenant_id=current_tenant_id,
+                    provider=dataset.embedding_model_provider,
+                    model_type=ModelType.TEXT_EMBEDDING,
+                    model=dataset.embedding_model,
+                )
+            except LLMBadRequestError:
+                raise ProviderNotInitializeError(
+                    "No Embedding Model available. Please configure a valid provider in the Settings -> Model Provider."
+                )
+            except ProviderTokenNotInitError as ex:
+                raise ProviderNotInitializeError(ex.description)
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+        # validate args
+        try:
+            payload = ChildChunkCreatePayload.model_validate(console_ns.payload or {})
+            child_chunk = SegmentService.create_child_chunk(payload.content, segment, document, dataset)
+        except ChildChunkIndexingServiceError as e:
+            raise ChildChunkIndexingError(str(e))
+        return {"data": marshal(child_chunk, child_chunk_fields)}, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, dataset_id, document_id, segment_id):
+        _, current_tenant_id = current_account_with_tenant()
+
+        # check dataset
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        # check user's model setting
+        DatasetService.check_dataset_model_setting(dataset)
+        # check document
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+        # check segment
+        segment_id = str(segment_id)
+        segment = (
+            db.session.query(DocumentSegment)
+            .where(DocumentSegment.id == str(segment_id), DocumentSegment.tenant_id == current_tenant_id)
+            .first()
+        )
+        if not segment:
+            raise NotFound("Segment not found.")
+        args = SegmentListQuery.model_validate(
+            {
+                "limit": request.args.get("limit", default=20, type=int),
+                "keyword": request.args.get("keyword"),
+                "page": request.args.get("page", default=1, type=int),
+            }
+        )
+
+        page = args.page
+        limit = min(args.limit, 100)
+        keyword = args.keyword
+
+        child_chunks = SegmentService.get_child_chunks(segment_id, document_id, dataset_id, page, limit, keyword)
+        return {
+            "data": marshal(child_chunks.items, child_chunk_fields),
+            "total": child_chunks.total,
+            "total_pages": child_chunks.pages,
+            "page": page,
+            "limit": limit,
+        }, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("vector_space")
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def patch(self, dataset_id, document_id, segment_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        # check dataset
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        # check user's model setting
+        DatasetService.check_dataset_model_setting(dataset)
+        # check document
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+            # check segment
+        segment_id = str(segment_id)
+        segment = (
+            db.session.query(DocumentSegment)
+            .where(DocumentSegment.id == str(segment_id), DocumentSegment.tenant_id == current_tenant_id)
+            .first()
+        )
+        if not segment:
+            raise NotFound("Segment not found.")
+        # The role of the current user in the ta table must be admin, owner, dataset_operator, or editor
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+        # validate args
+        payload = ChildChunkBatchUpdatePayload.model_validate(console_ns.payload or {})
+        try:
+            child_chunks = SegmentService.update_child_chunks(payload.chunks, segment, document, dataset)
+        except ChildChunkIndexingServiceError as e:
+            raise ChildChunkIndexingError(str(e))
+        return {"data": marshal(child_chunks, child_chunk_fields)}, 200
+
+
+@console_ns.route(
+    "/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/segments/<uuid:segment_id>/child_chunks/<uuid:child_chunk_id>"
+)
+class ChildChunkUpdateApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def delete(self, dataset_id, document_id, segment_id, child_chunk_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        # check dataset
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        # check user's model setting
+        DatasetService.check_dataset_model_setting(dataset)
+        # check document
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+        # check segment
+        segment_id = str(segment_id)
+        segment = (
+            db.session.query(DocumentSegment)
+            .where(DocumentSegment.id == str(segment_id), DocumentSegment.tenant_id == current_tenant_id)
+            .first()
+        )
+        if not segment:
+            raise NotFound("Segment not found.")
+        # check child chunk
+        child_chunk_id = str(child_chunk_id)
+        child_chunk = (
+            db.session.query(ChildChunk)
+            .where(
+                ChildChunk.id == str(child_chunk_id),
+                ChildChunk.tenant_id == current_tenant_id,
+                ChildChunk.segment_id == segment.id,
+                ChildChunk.document_id == document_id,
+            )
+            .first()
+        )
+        if not child_chunk:
+            raise NotFound("Child chunk not found.")
+        # The role of the current user in the ta table must be admin, owner, dataset_operator, or editor
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+        try:
+            SegmentService.delete_child_chunk(child_chunk, dataset)
+        except ChildChunkDeleteIndexServiceError as e:
+            raise ChildChunkDeleteIndexError(str(e))
+        return {"result": "success"}, 204
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("vector_space")
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    @console_ns.expect(console_ns.models[ChildChunkUpdatePayload.__name__])
+    def patch(self, dataset_id, document_id, segment_id, child_chunk_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        # check dataset
+        dataset_id = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        # check user's model setting
+        DatasetService.check_dataset_model_setting(dataset)
+        # check document
+        document_id = str(document_id)
+        document = DocumentService.get_document(dataset_id, document_id)
+        if not document:
+            raise NotFound("Document not found.")
+            # check segment
+        segment_id = str(segment_id)
+        segment = (
+            db.session.query(DocumentSegment)
+            .where(DocumentSegment.id == str(segment_id), DocumentSegment.tenant_id == current_tenant_id)
+            .first()
+        )
+        if not segment:
+            raise NotFound("Segment not found.")
+        # check child chunk
+        child_chunk_id = str(child_chunk_id)
+        child_chunk = (
+            db.session.query(ChildChunk)
+            .where(
+                ChildChunk.id == str(child_chunk_id),
+                ChildChunk.tenant_id == current_tenant_id,
+                ChildChunk.segment_id == segment.id,
+                ChildChunk.document_id == document_id,
+            )
+            .first()
+        )
+        if not child_chunk:
+            raise NotFound("Child chunk not found.")
+        # The role of the current user in the ta table must be admin, owner, dataset_operator, or editor
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+        # validate args
+        try:
+            payload = ChildChunkUpdatePayload.model_validate(console_ns.payload or {})
+            child_chunk = SegmentService.update_child_chunk(payload.content, child_chunk, segment, document, dataset)
+        except ChildChunkIndexingServiceError as e:
+            raise ChildChunkIndexingError(str(e))
+        return {"data": marshal(child_chunk, child_chunk_fields)}, 200

dify_1.11.1/api/controllers/console/datasets/error.py

@@ -0,0 +1,79 @@
+from libs.exception import BaseHTTPException
+
+
+class DatasetNotInitializedError(BaseHTTPException):
+    error_code = "dataset_not_initialized"
+    description = "The dataset is still being initialized or indexing. Please wait a moment."
+    code = 400
+
+
+class ArchivedDocumentImmutableError(BaseHTTPException):
+    error_code = "archived_document_immutable"
+    description = "The archived document is not editable."
+    code = 403
+
+
+class DatasetNameDuplicateError(BaseHTTPException):
+    error_code = "dataset_name_duplicate"
+    description = "The dataset name already exists. Please modify your dataset name."
+    code = 409
+
+
+class InvalidActionError(BaseHTTPException):
+    error_code = "invalid_action"
+    description = "Invalid action."
+    code = 400
+
+
+class DocumentAlreadyFinishedError(BaseHTTPException):
+    error_code = "document_already_finished"
+    description = "The document has been processed. Please refresh the page or go to the document details."
+    code = 400
+
+
+class DocumentIndexingError(BaseHTTPException):
+    error_code = "document_indexing"
+    description = "The document is being processed and cannot be edited."
+    code = 400
+
+
+class InvalidMetadataError(BaseHTTPException):
+    error_code = "invalid_metadata"
+    description = "The metadata content is incorrect. Please check and verify."
+    code = 400
+
+
+class WebsiteCrawlError(BaseHTTPException):
+    error_code = "crawl_failed"
+    description = "{message}"
+    code = 500
+
+
+class DatasetInUseError(BaseHTTPException):
+    error_code = "dataset_in_use"
+    description = "The dataset is being used by some apps. Please remove the dataset from the apps before deleting it."
+    code = 409
+
+
+class IndexingEstimateError(BaseHTTPException):
+    error_code = "indexing_estimate_error"
+    description = "Knowledge indexing estimate failed: {message}"
+    code = 500
+
+
+class ChildChunkIndexingError(BaseHTTPException):
+    error_code = "child_chunk_indexing_error"
+    description = "Create child chunk index failed: {message}"
+    code = 500
+
+
+class ChildChunkDeleteIndexError(BaseHTTPException):
+    error_code = "child_chunk_delete_index_error"
+    description = "Delete child chunk index failed: {message}"
+    code = 500
+
+
+class PipelineNotFoundError(BaseHTTPException):
+    error_code = "pipeline_not_found"
+    description = "Pipeline not found."
+    code = 404

dify_1.11.1/api/controllers/console/datasets/external.py

@@ -0,0 +1,326 @@
+from flask import request
+from flask_restx import Resource, fields, marshal
+from pydantic import BaseModel, Field
+from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
+
+import services
+from controllers.common.schema import register_schema_models
+from controllers.console import console_ns
+from controllers.console.datasets.error import DatasetNameDuplicateError
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
+from fields.dataset_fields import (
+    dataset_detail_fields,
+    dataset_retrieval_model_fields,
+    doc_metadata_fields,
+    external_knowledge_info_fields,
+    external_retrieval_model_fields,
+    icon_info_fields,
+    keyword_setting_fields,
+    reranking_model_fields,
+    tag_fields,
+    vector_setting_fields,
+    weighted_score_fields,
+)
+from libs.login import current_account_with_tenant, login_required
+from services.dataset_service import DatasetService
+from services.external_knowledge_service import ExternalDatasetService
+from services.hit_testing_service import HitTestingService
+from services.knowledge_service import ExternalDatasetTestService
+
+
+def _get_or_create_model(model_name: str, field_def):
+    existing = console_ns.models.get(model_name)
+    if existing is None:
+        existing = console_ns.model(model_name, field_def)
+    return existing
+
+
+def _build_dataset_detail_model():
+    keyword_setting_model = _get_or_create_model("DatasetKeywordSetting", keyword_setting_fields)
+    vector_setting_model = _get_or_create_model("DatasetVectorSetting", vector_setting_fields)
+
+    weighted_score_fields_copy = weighted_score_fields.copy()
+    weighted_score_fields_copy["keyword_setting"] = fields.Nested(keyword_setting_model)
+    weighted_score_fields_copy["vector_setting"] = fields.Nested(vector_setting_model)
+    weighted_score_model = _get_or_create_model("DatasetWeightedScore", weighted_score_fields_copy)
+
+    reranking_model = _get_or_create_model("DatasetRerankingModel", reranking_model_fields)
+
+    dataset_retrieval_model_fields_copy = dataset_retrieval_model_fields.copy()
+    dataset_retrieval_model_fields_copy["reranking_model"] = fields.Nested(reranking_model)
+    dataset_retrieval_model_fields_copy["weights"] = fields.Nested(weighted_score_model, allow_null=True)
+    dataset_retrieval_model = _get_or_create_model("DatasetRetrievalModel", dataset_retrieval_model_fields_copy)
+
+    tag_model = _get_or_create_model("Tag", tag_fields)
+    doc_metadata_model = _get_or_create_model("DatasetDocMetadata", doc_metadata_fields)
+    external_knowledge_info_model = _get_or_create_model("ExternalKnowledgeInfo", external_knowledge_info_fields)
+    external_retrieval_model = _get_or_create_model("ExternalRetrievalModel", external_retrieval_model_fields)
+    icon_info_model = _get_or_create_model("DatasetIconInfo", icon_info_fields)
+
+    dataset_detail_fields_copy = dataset_detail_fields.copy()
+    dataset_detail_fields_copy["retrieval_model_dict"] = fields.Nested(dataset_retrieval_model)
+    dataset_detail_fields_copy["tags"] = fields.List(fields.Nested(tag_model))
+    dataset_detail_fields_copy["external_knowledge_info"] = fields.Nested(external_knowledge_info_model)
+    dataset_detail_fields_copy["external_retrieval_model"] = fields.Nested(external_retrieval_model, allow_null=True)
+    dataset_detail_fields_copy["doc_metadata"] = fields.List(fields.Nested(doc_metadata_model))
+    dataset_detail_fields_copy["icon_info"] = fields.Nested(icon_info_model)
+    return _get_or_create_model("DatasetDetail", dataset_detail_fields_copy)
+
+
+try:
+    dataset_detail_model = console_ns.models["DatasetDetail"]
+except KeyError:
+    dataset_detail_model = _build_dataset_detail_model()
+
+
+class ExternalKnowledgeApiPayload(BaseModel):
+    name: str = Field(..., min_length=1, max_length=40)
+    settings: dict[str, object]
+
+
+class ExternalDatasetCreatePayload(BaseModel):
+    external_knowledge_api_id: str
+    external_knowledge_id: str
+    name: str = Field(..., min_length=1, max_length=40)
+    description: str | None = Field(None, max_length=400)
+    external_retrieval_model: dict[str, object] | None = None
+
+
+class ExternalHitTestingPayload(BaseModel):
+    query: str
+    external_retrieval_model: dict[str, object] | None = None
+    metadata_filtering_conditions: dict[str, object] | None = None
+
+
+class BedrockRetrievalPayload(BaseModel):
+    retrieval_setting: dict[str, object]
+    query: str
+    knowledge_id: str
+
+
+register_schema_models(
+    console_ns,
+    ExternalKnowledgeApiPayload,
+    ExternalDatasetCreatePayload,
+    ExternalHitTestingPayload,
+    BedrockRetrievalPayload,
+)
+
+
+@console_ns.route("/datasets/external-knowledge-api")
+class ExternalApiTemplateListApi(Resource):
+    @console_ns.doc("get_external_api_templates")
+    @console_ns.doc(description="Get external knowledge API templates")
+    @console_ns.doc(
+        params={
+            "page": "Page number (default: 1)",
+            "limit": "Number of items per page (default: 20)",
+            "keyword": "Search keyword",
+        }
+    )
+    @console_ns.response(200, "External API templates retrieved successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, current_tenant_id = current_account_with_tenant()
+        page = request.args.get("page", default=1, type=int)
+        limit = request.args.get("limit", default=20, type=int)
+        search = request.args.get("keyword", default=None, type=str)
+
+        external_knowledge_apis, total = ExternalDatasetService.get_external_knowledge_apis(
+            page, limit, current_tenant_id, search
+        )
+        response = {
+            "data": [item.to_dict() for item in external_knowledge_apis],
+            "has_more": len(external_knowledge_apis) == limit,
+            "limit": limit,
+            "total": total,
+            "page": page,
+        }
+        return response, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @console_ns.expect(console_ns.models[ExternalKnowledgeApiPayload.__name__])
+    def post(self):
+        current_user, current_tenant_id = current_account_with_tenant()
+        payload = ExternalKnowledgeApiPayload.model_validate(console_ns.payload or {})
+
+        ExternalDatasetService.validate_api_list(payload.settings)
+
+        # The role of the current user in the ta table must be admin, owner, or editor, or dataset_operator
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+
+        try:
+            external_knowledge_api = ExternalDatasetService.create_external_knowledge_api(
+                tenant_id=current_tenant_id, user_id=current_user.id, args=payload.model_dump()
+            )
+        except services.errors.dataset.DatasetNameDuplicateError:
+            raise DatasetNameDuplicateError()
+
+        return external_knowledge_api.to_dict(), 201
+
+
+@console_ns.route("/datasets/external-knowledge-api/<uuid:external_knowledge_api_id>")
+class ExternalApiTemplateApi(Resource):
+    @console_ns.doc("get_external_api_template")
+    @console_ns.doc(description="Get external knowledge API template details")
+    @console_ns.doc(params={"external_knowledge_api_id": "External knowledge API ID"})
+    @console_ns.response(200, "External API template retrieved successfully")
+    @console_ns.response(404, "Template not found")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, external_knowledge_api_id):
+        external_knowledge_api_id = str(external_knowledge_api_id)
+        external_knowledge_api = ExternalDatasetService.get_external_knowledge_api(external_knowledge_api_id)
+        if external_knowledge_api is None:
+            raise NotFound("API template not found.")
+
+        return external_knowledge_api.to_dict(), 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @console_ns.expect(console_ns.models[ExternalKnowledgeApiPayload.__name__])
+    def patch(self, external_knowledge_api_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+        external_knowledge_api_id = str(external_knowledge_api_id)
+
+        payload = ExternalKnowledgeApiPayload.model_validate(console_ns.payload or {})
+        ExternalDatasetService.validate_api_list(payload.settings)
+
+        external_knowledge_api = ExternalDatasetService.update_external_knowledge_api(
+            tenant_id=current_tenant_id,
+            user_id=current_user.id,
+            external_knowledge_api_id=external_knowledge_api_id,
+            args=payload.model_dump(),
+        )
+
+        return external_knowledge_api.to_dict(), 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def delete(self, external_knowledge_api_id):
+        current_user, current_tenant_id = current_account_with_tenant()
+        external_knowledge_api_id = str(external_knowledge_api_id)
+
+        if not (current_user.has_edit_permission or current_user.is_dataset_operator):
+            raise Forbidden()
+
+        ExternalDatasetService.delete_external_knowledge_api(current_tenant_id, external_knowledge_api_id)
+        return {"result": "success"}, 204
+
+
+@console_ns.route("/datasets/external-knowledge-api/<uuid:external_knowledge_api_id>/use-check")
+class ExternalApiUseCheckApi(Resource):
+    @console_ns.doc("check_external_api_usage")
+    @console_ns.doc(description="Check if external knowledge API is being used")
+    @console_ns.doc(params={"external_knowledge_api_id": "External knowledge API ID"})
+    @console_ns.response(200, "Usage check completed successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, external_knowledge_api_id):
+        external_knowledge_api_id = str(external_knowledge_api_id)
+
+        external_knowledge_api_is_using, count = ExternalDatasetService.external_knowledge_api_use_check(
+            external_knowledge_api_id
+        )
+        return {"is_using": external_knowledge_api_is_using, "count": count}, 200
+
+
+@console_ns.route("/datasets/external")
+class ExternalDatasetCreateApi(Resource):
+    @console_ns.doc("create_external_dataset")
+    @console_ns.doc(description="Create external knowledge dataset")
+    @console_ns.expect(console_ns.models[ExternalDatasetCreatePayload.__name__])
+    @console_ns.response(201, "External dataset created successfully", dataset_detail_model)
+    @console_ns.response(400, "Invalid parameters")
+    @console_ns.response(403, "Permission denied")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def post(self):
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, current_tenant_id = current_account_with_tenant()
+        payload = ExternalDatasetCreatePayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump(exclude_none=True)
+
+        # The role of the current user in the ta table must be admin, owner, or editor, or dataset_operator
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+
+        try:
+            dataset = ExternalDatasetService.create_external_dataset(
+                tenant_id=current_tenant_id,
+                user_id=current_user.id,
+                args=args,
+            )
+        except services.errors.dataset.DatasetNameDuplicateError:
+            raise DatasetNameDuplicateError()
+
+        return marshal(dataset, dataset_detail_fields), 201
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/external-hit-testing")
+class ExternalKnowledgeHitTestingApi(Resource):
+    @console_ns.doc("test_external_knowledge_retrieval")
+    @console_ns.doc(description="Test external knowledge retrieval for dataset")
+    @console_ns.doc(params={"dataset_id": "Dataset ID"})
+    @console_ns.expect(console_ns.models[ExternalHitTestingPayload.__name__])
+    @console_ns.response(200, "External hit testing completed successfully")
+    @console_ns.response(404, "Dataset not found")
+    @console_ns.response(400, "Invalid parameters")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, dataset_id):
+        current_user, _ = current_account_with_tenant()
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+
+        payload = ExternalHitTestingPayload.model_validate(console_ns.payload or {})
+        HitTestingService.hit_testing_args_check(payload.model_dump())
+
+        try:
+            response = HitTestingService.external_retrieve(
+                dataset=dataset,
+                query=payload.query,
+                account=current_user,
+                external_retrieval_model=payload.external_retrieval_model,
+                metadata_filtering_conditions=payload.metadata_filtering_conditions,
+            )
+
+            return response
+        except Exception as e:
+            raise InternalServerError(str(e))
+
+
+@console_ns.route("/test/retrieval")
+class BedrockRetrievalApi(Resource):
+    # this api is only for internal testing
+    @console_ns.doc("bedrock_retrieval_test")
+    @console_ns.doc(description="Bedrock retrieval test (internal use only)")
+    @console_ns.expect(console_ns.models[BedrockRetrievalPayload.__name__])
+    @console_ns.response(200, "Bedrock retrieval test completed")
+    def post(self):
+        payload = BedrockRetrievalPayload.model_validate(console_ns.payload or {})
+
+        # Call the knowledge retrieval service
+        result = ExternalDatasetTestService.knowledge_retrieval(
+            payload.retrieval_setting, payload.query, payload.knowledge_id
+        )
+        return result, 200

dify_1.11.1/api/controllers/console/datasets/hit_testing.py

@@ -0,0 +1,38 @@
+from flask_restx import Resource
+
+from controllers.common.schema import register_schema_model
+from libs.login import login_required
+
+from .. import console_ns
+from ..datasets.hit_testing_base import DatasetsHitTestingBase, HitTestingPayload
+from ..wraps import (
+    account_initialization_required,
+    cloud_edition_billing_rate_limit_check,
+    setup_required,
+)
+
+register_schema_model(console_ns, HitTestingPayload)
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/hit-testing")
+class HitTestingApi(Resource, DatasetsHitTestingBase):
+    @console_ns.doc("test_dataset_retrieval")
+    @console_ns.doc(description="Test dataset knowledge retrieval")
+    @console_ns.doc(params={"dataset_id": "Dataset ID"})
+    @console_ns.expect(console_ns.models[HitTestingPayload.__name__])
+    @console_ns.response(200, "Hit testing completed successfully")
+    @console_ns.response(404, "Dataset not found")
+    @console_ns.response(400, "Invalid parameters")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def post(self, dataset_id):
+        dataset_id_str = str(dataset_id)
+
+        dataset = self.get_and_validate_dataset(dataset_id_str)
+        payload = HitTestingPayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump(exclude_none=True)
+        self.hit_testing_args_check(args)
+
+        return self.perform_hit_testing(dataset, args)

dify_1.11.1/api/controllers/console/datasets/hit_testing_base.py

@@ -0,0 +1,102 @@
+import logging
+from typing import Any
+
+from flask_restx import marshal, reqparse
+from pydantic import BaseModel, Field
+from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
+
+import services
+from controllers.console.app.error import (
+    CompletionRequestError,
+    ProviderModelCurrentlyNotSupportError,
+    ProviderNotInitializeError,
+    ProviderQuotaExceededError,
+)
+from controllers.console.datasets.error import DatasetNotInitializedError
+from core.errors.error import (
+    LLMBadRequestError,
+    ModelCurrentlyNotSupportError,
+    ProviderTokenNotInitError,
+    QuotaExceededError,
+)
+from core.model_runtime.errors.invoke import InvokeError
+from fields.hit_testing_fields import hit_testing_record_fields
+from libs.login import current_user
+from models.account import Account
+from services.dataset_service import DatasetService
+from services.hit_testing_service import HitTestingService
+
+logger = logging.getLogger(__name__)
+
+
+class HitTestingPayload(BaseModel):
+    query: str = Field(max_length=250)
+    retrieval_model: dict[str, Any] | None = None
+    external_retrieval_model: dict[str, Any] | None = None
+    attachment_ids: list[str] | None = None
+
+
+class DatasetsHitTestingBase:
+    @staticmethod
+    def get_and_validate_dataset(dataset_id: str):
+        assert isinstance(current_user, Account)
+        dataset = DatasetService.get_dataset(dataset_id)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except services.errors.account.NoPermissionError as e:
+            raise Forbidden(str(e))
+
+        return dataset
+
+    @staticmethod
+    def hit_testing_args_check(args: dict[str, Any]):
+        HitTestingService.hit_testing_args_check(args)
+
+    @staticmethod
+    def parse_args():
+        parser = (
+            reqparse.RequestParser()
+            .add_argument("query", type=str, required=False, location="json")
+            .add_argument("attachment_ids", type=list, required=False, location="json")
+            .add_argument("retrieval_model", type=dict, required=False, location="json")
+            .add_argument("external_retrieval_model", type=dict, required=False, location="json")
+        )
+        return parser.parse_args()
+
+    @staticmethod
+    def perform_hit_testing(dataset, args):
+        assert isinstance(current_user, Account)
+        try:
+            response = HitTestingService.retrieve(
+                dataset=dataset,
+                query=args.get("query"),
+                account=current_user,
+                retrieval_model=args.get("retrieval_model"),
+                external_retrieval_model=args.get("external_retrieval_model"),
+                attachment_ids=args.get("attachment_ids"),
+                limit=10,
+            )
+            return {"query": response["query"], "records": marshal(response["records"], hit_testing_record_fields)}
+        except services.errors.index.IndexNotInitializedError:
+            raise DatasetNotInitializedError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except LLMBadRequestError:
+            raise ProviderNotInitializeError(
+                "No Embedding Model or Reranking Model available. Please configure a valid provider "
+                "in the Settings -> Model Provider."
+            )
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except ValueError as e:
+            raise ValueError(str(e))
+        except Exception as e:
+            logger.exception("Hit testing failed.")
+            raise InternalServerError(str(e))

dify_1.11.1/api/controllers/console/datasets/metadata.py

@@ -0,0 +1,152 @@
+from typing import Literal
+
+from flask_restx import Resource, marshal_with
+from pydantic import BaseModel
+from werkzeug.exceptions import NotFound
+
+from controllers.common.schema import register_schema_model, register_schema_models
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, enterprise_license_required, setup_required
+from fields.dataset_fields import dataset_metadata_fields
+from libs.login import current_account_with_tenant, login_required
+from services.dataset_service import DatasetService
+from services.entities.knowledge_entities.knowledge_entities import (
+    MetadataArgs,
+    MetadataOperationData,
+)
+from services.metadata_service import MetadataService
+
+
+class MetadataUpdatePayload(BaseModel):
+    name: str
+
+
+register_schema_models(console_ns, MetadataArgs, MetadataOperationData)
+register_schema_model(console_ns, MetadataUpdatePayload)
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/metadata")
+class DatasetMetadataCreateApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    @marshal_with(dataset_metadata_fields)
+    @console_ns.expect(console_ns.models[MetadataArgs.__name__])
+    def post(self, dataset_id):
+        current_user, _ = current_account_with_tenant()
+        metadata_args = MetadataArgs.model_validate(console_ns.payload or {})
+
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+        DatasetService.check_dataset_permission(dataset, current_user)
+
+        metadata = MetadataService.create_metadata(dataset_id_str, metadata_args)
+        return metadata, 201
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def get(self, dataset_id):
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+        return MetadataService.get_dataset_metadatas(dataset), 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/metadata/<uuid:metadata_id>")
+class DatasetMetadataApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    @marshal_with(dataset_metadata_fields)
+    @console_ns.expect(console_ns.models[MetadataUpdatePayload.__name__])
+    def patch(self, dataset_id, metadata_id):
+        current_user, _ = current_account_with_tenant()
+        payload = MetadataUpdatePayload.model_validate(console_ns.payload or {})
+        name = payload.name
+
+        dataset_id_str = str(dataset_id)
+        metadata_id_str = str(metadata_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+        DatasetService.check_dataset_permission(dataset, current_user)
+
+        metadata = MetadataService.update_metadata_name(dataset_id_str, metadata_id_str, name)
+        return metadata, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def delete(self, dataset_id, metadata_id):
+        current_user, _ = current_account_with_tenant()
+        dataset_id_str = str(dataset_id)
+        metadata_id_str = str(metadata_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+        DatasetService.check_dataset_permission(dataset, current_user)
+
+        MetadataService.delete_metadata(dataset_id_str, metadata_id_str)
+        return {"result": "success"}, 204
+
+
+@console_ns.route("/datasets/metadata/built-in")
+class DatasetMetadataBuiltInFieldApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def get(self):
+        built_in_fields = MetadataService.get_built_in_fields()
+        return {"fields": built_in_fields}, 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/metadata/built-in/<string:action>")
+class DatasetMetadataBuiltInFieldActionApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def post(self, dataset_id, action: Literal["enable", "disable"]):
+        current_user, _ = current_account_with_tenant()
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+        DatasetService.check_dataset_permission(dataset, current_user)
+
+        if action == "enable":
+            MetadataService.enable_built_in_field(dataset)
+        elif action == "disable":
+            MetadataService.disable_built_in_field(dataset)
+        return {"result": "success"}, 200
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/documents/metadata")
+class DocumentMetadataEditApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    @console_ns.expect(console_ns.models[MetadataOperationData.__name__])
+    def post(self, dataset_id):
+        current_user, _ = current_account_with_tenant()
+        dataset_id_str = str(dataset_id)
+        dataset = DatasetService.get_dataset(dataset_id_str)
+        if dataset is None:
+            raise NotFound("Dataset not found.")
+        DatasetService.check_dataset_permission(dataset, current_user)
+
+        metadata_args = MetadataOperationData.model_validate(console_ns.payload or {})
+
+        MetadataService.update_documents_metadata(dataset, metadata_args)
+
+        return {"result": "success"}, 200

dify_1.11.1/api/controllers/console/datasets/rag_pipeline/datasource_auth.py

@@ -0,0 +1,360 @@
+from typing import Any
+
+from flask import make_response, redirect, request
+from flask_restx import Resource
+from pydantic import BaseModel, Field
+from werkzeug.exceptions import Forbidden, NotFound
+
+from configs import dify_config
+from controllers.common.schema import register_schema_models
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
+from core.model_runtime.errors.validate import CredentialsValidateFailedError
+from core.model_runtime.utils.encoders import jsonable_encoder
+from core.plugin.impl.oauth import OAuthHandler
+from libs.login import current_account_with_tenant, login_required
+from models.provider_ids import DatasourceProviderID
+from services.datasource_provider_service import DatasourceProviderService
+from services.plugin.oauth_service import OAuthProxyService
+
+
+class DatasourceCredentialPayload(BaseModel):
+    name: str | None = Field(default=None, max_length=100)
+    credentials: dict[str, Any]
+
+
+class DatasourceCredentialDeletePayload(BaseModel):
+    credential_id: str
+
+
+class DatasourceCredentialUpdatePayload(BaseModel):
+    credential_id: str
+    name: str | None = Field(default=None, max_length=100)
+    credentials: dict[str, Any] | None = None
+
+
+class DatasourceCustomClientPayload(BaseModel):
+    client_params: dict[str, Any] | None = None
+    enable_oauth_custom_client: bool | None = None
+
+
+class DatasourceDefaultPayload(BaseModel):
+    id: str
+
+
+class DatasourceUpdateNamePayload(BaseModel):
+    credential_id: str
+    name: str = Field(max_length=100)
+
+
+register_schema_models(
+    console_ns,
+    DatasourceCredentialPayload,
+    DatasourceCredentialDeletePayload,
+    DatasourceCredentialUpdatePayload,
+    DatasourceCustomClientPayload,
+    DatasourceDefaultPayload,
+    DatasourceUpdateNamePayload,
+)
+
+
+@console_ns.route("/oauth/plugin/<path:provider_id>/datasource/get-authorization-url")
+class DatasourcePluginOAuthAuthorizationUrl(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def get(self, provider_id: str):
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        tenant_id = current_tenant_id
+
+        credential_id = request.args.get("credential_id")
+        datasource_provider_id = DatasourceProviderID(provider_id)
+        provider_name = datasource_provider_id.provider_name
+        plugin_id = datasource_provider_id.plugin_id
+        oauth_config = DatasourceProviderService().get_oauth_client(
+            tenant_id=tenant_id,
+            datasource_provider_id=datasource_provider_id,
+        )
+        if not oauth_config:
+            raise ValueError(f"No OAuth Client Config for {provider_id}")
+
+        context_id = OAuthProxyService.create_proxy_context(
+            user_id=current_user.id,
+            tenant_id=tenant_id,
+            plugin_id=plugin_id,
+            provider=provider_name,
+            credential_id=credential_id,
+        )
+        oauth_handler = OAuthHandler()
+        redirect_uri = f"{dify_config.CONSOLE_API_URL}/console/api/oauth/plugin/{provider_id}/datasource/callback"
+        authorization_url_response = oauth_handler.get_authorization_url(
+            tenant_id=tenant_id,
+            user_id=current_user.id,
+            plugin_id=plugin_id,
+            provider=provider_name,
+            redirect_uri=redirect_uri,
+            system_credentials=oauth_config,
+        )
+        response = make_response(jsonable_encoder(authorization_url_response))
+        response.set_cookie(
+            "context_id",
+            context_id,
+            httponly=True,
+            samesite="Lax",
+            max_age=OAuthProxyService.__MAX_AGE__,
+        )
+        return response
+
+
+@console_ns.route("/oauth/plugin/<path:provider_id>/datasource/callback")
+class DatasourceOAuthCallback(Resource):
+    @setup_required
+    def get(self, provider_id: str):
+        context_id = request.cookies.get("context_id") or request.args.get("context_id")
+        if not context_id:
+            raise Forbidden("context_id not found")
+
+        context = OAuthProxyService.use_proxy_context(context_id)
+        if context is None:
+            raise Forbidden("Invalid context_id")
+
+        user_id, tenant_id = context.get("user_id"), context.get("tenant_id")
+        datasource_provider_id = DatasourceProviderID(provider_id)
+        plugin_id = datasource_provider_id.plugin_id
+        datasource_provider_service = DatasourceProviderService()
+        oauth_client_params = datasource_provider_service.get_oauth_client(
+            tenant_id=tenant_id,
+            datasource_provider_id=datasource_provider_id,
+        )
+        if not oauth_client_params:
+            raise NotFound()
+        redirect_uri = f"{dify_config.CONSOLE_API_URL}/console/api/oauth/plugin/{provider_id}/datasource/callback"
+        oauth_handler = OAuthHandler()
+        oauth_response = oauth_handler.get_credentials(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            plugin_id=plugin_id,
+            provider=datasource_provider_id.provider_name,
+            redirect_uri=redirect_uri,
+            system_credentials=oauth_client_params,
+            request=request,
+        )
+        credential_id = context.get("credential_id")
+        if credential_id:
+            datasource_provider_service.reauthorize_datasource_oauth_provider(
+                tenant_id=tenant_id,
+                provider_id=datasource_provider_id,
+                avatar_url=oauth_response.metadata.get("avatar_url") or None,
+                name=oauth_response.metadata.get("name") or None,
+                expire_at=oauth_response.expires_at,
+                credentials=dict(oauth_response.credentials),
+                credential_id=context.get("credential_id"),
+            )
+        else:
+            datasource_provider_service.add_datasource_oauth_provider(
+                tenant_id=tenant_id,
+                provider_id=datasource_provider_id,
+                avatar_url=oauth_response.metadata.get("avatar_url") or None,
+                name=oauth_response.metadata.get("name") or None,
+                expire_at=oauth_response.expires_at,
+                credentials=dict(oauth_response.credentials),
+            )
+        return redirect(f"{dify_config.CONSOLE_WEB_URL}/oauth-callback")
+
+
+@console_ns.route("/auth/plugin/datasource/<path:provider_id>")
+class DatasourceAuth(Resource):
+    @console_ns.expect(console_ns.models[DatasourceCredentialPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def post(self, provider_id: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        payload = DatasourceCredentialPayload.model_validate(console_ns.payload or {})
+        datasource_provider_id = DatasourceProviderID(provider_id)
+        datasource_provider_service = DatasourceProviderService()
+
+        try:
+            datasource_provider_service.add_datasource_api_key_provider(
+                tenant_id=current_tenant_id,
+                provider_id=datasource_provider_id,
+                credentials=payload.credentials,
+                name=payload.name,
+            )
+        except CredentialsValidateFailedError as ex:
+            raise ValueError(str(ex))
+        return {"result": "success"}, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider_id: str):
+        datasource_provider_id = DatasourceProviderID(provider_id)
+        datasource_provider_service = DatasourceProviderService()
+        _, current_tenant_id = current_account_with_tenant()
+
+        datasources = datasource_provider_service.list_datasource_credentials(
+            tenant_id=current_tenant_id,
+            provider=datasource_provider_id.provider_name,
+            plugin_id=datasource_provider_id.plugin_id,
+        )
+        return {"result": datasources}, 200
+
+
+@console_ns.route("/auth/plugin/datasource/<path:provider_id>/delete")
+class DatasourceAuthDeleteApi(Resource):
+    @console_ns.expect(console_ns.models[DatasourceCredentialDeletePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def post(self, provider_id: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        datasource_provider_id = DatasourceProviderID(provider_id)
+        plugin_id = datasource_provider_id.plugin_id
+        provider_name = datasource_provider_id.provider_name
+
+        payload = DatasourceCredentialDeletePayload.model_validate(console_ns.payload or {})
+        datasource_provider_service = DatasourceProviderService()
+        datasource_provider_service.remove_datasource_credentials(
+            tenant_id=current_tenant_id,
+            auth_id=payload.credential_id,
+            provider=provider_name,
+            plugin_id=plugin_id,
+        )
+        return {"result": "success"}, 200
+
+
+@console_ns.route("/auth/plugin/datasource/<path:provider_id>/update")
+class DatasourceAuthUpdateApi(Resource):
+    @console_ns.expect(console_ns.models[DatasourceCredentialUpdatePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def post(self, provider_id: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        datasource_provider_id = DatasourceProviderID(provider_id)
+        payload = DatasourceCredentialUpdatePayload.model_validate(console_ns.payload or {})
+
+        datasource_provider_service = DatasourceProviderService()
+        datasource_provider_service.update_datasource_credentials(
+            tenant_id=current_tenant_id,
+            auth_id=payload.credential_id,
+            provider=datasource_provider_id.provider_name,
+            plugin_id=datasource_provider_id.plugin_id,
+            credentials=payload.credentials or {},
+            name=payload.name,
+        )
+        return {"result": "success"}, 201
+
+
+@console_ns.route("/auth/plugin/datasource/list")
+class DatasourceAuthListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, current_tenant_id = current_account_with_tenant()
+
+        datasource_provider_service = DatasourceProviderService()
+        datasources = datasource_provider_service.get_all_datasource_credentials(tenant_id=current_tenant_id)
+        return {"result": jsonable_encoder(datasources)}, 200
+
+
+@console_ns.route("/auth/plugin/datasource/default-list")
+class DatasourceHardCodeAuthListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, current_tenant_id = current_account_with_tenant()
+
+        datasource_provider_service = DatasourceProviderService()
+        datasources = datasource_provider_service.get_hard_code_datasource_credentials(tenant_id=current_tenant_id)
+        return {"result": jsonable_encoder(datasources)}, 200
+
+
+@console_ns.route("/auth/plugin/datasource/<path:provider_id>/custom-client")
+class DatasourceAuthOauthCustomClient(Resource):
+    @console_ns.expect(console_ns.models[DatasourceCustomClientPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def post(self, provider_id: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        payload = DatasourceCustomClientPayload.model_validate(console_ns.payload or {})
+        datasource_provider_id = DatasourceProviderID(provider_id)
+        datasource_provider_service = DatasourceProviderService()
+        datasource_provider_service.setup_oauth_custom_client_params(
+            tenant_id=current_tenant_id,
+            datasource_provider_id=datasource_provider_id,
+            client_params=payload.client_params or {},
+            enabled=payload.enable_oauth_custom_client or False,
+        )
+        return {"result": "success"}, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def delete(self, provider_id: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        datasource_provider_id = DatasourceProviderID(provider_id)
+        datasource_provider_service = DatasourceProviderService()
+        datasource_provider_service.remove_oauth_custom_client_params(
+            tenant_id=current_tenant_id,
+            datasource_provider_id=datasource_provider_id,
+        )
+        return {"result": "success"}, 200
+
+
+@console_ns.route("/auth/plugin/datasource/<path:provider_id>/default")
+class DatasourceAuthDefaultApi(Resource):
+    @console_ns.expect(console_ns.models[DatasourceDefaultPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def post(self, provider_id: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        payload = DatasourceDefaultPayload.model_validate(console_ns.payload or {})
+        datasource_provider_id = DatasourceProviderID(provider_id)
+        datasource_provider_service = DatasourceProviderService()
+        datasource_provider_service.set_default_datasource_provider(
+            tenant_id=current_tenant_id,
+            datasource_provider_id=datasource_provider_id,
+            credential_id=payload.id,
+        )
+        return {"result": "success"}, 200
+
+
+@console_ns.route("/auth/plugin/datasource/<path:provider_id>/update-name")
+class DatasourceUpdateProviderNameApi(Resource):
+    @console_ns.expect(console_ns.models[DatasourceUpdateNamePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def post(self, provider_id: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        payload = DatasourceUpdateNamePayload.model_validate(console_ns.payload or {})
+        datasource_provider_id = DatasourceProviderID(provider_id)
+        datasource_provider_service = DatasourceProviderService()
+        datasource_provider_service.update_datasource_provider_name(
+            tenant_id=current_tenant_id,
+            datasource_provider_id=datasource_provider_id,
+            name=payload.name,
+            credential_id=payload.credential_id,
+        )
+        return {"result": "success"}, 200

dify_1.11.1/api/controllers/console/datasets/rag_pipeline/datasource_content_preview.py

@@ -0,0 +1,55 @@
+from flask_restx import (  # type: ignore
+    Resource,  # type: ignore
+)
+from pydantic import BaseModel
+from werkzeug.exceptions import Forbidden
+
+from controllers.console import console_ns
+from controllers.console.datasets.wraps import get_rag_pipeline
+from controllers.console.wraps import account_initialization_required, setup_required
+from libs.login import current_user, login_required
+from models import Account
+from models.dataset import Pipeline
+from services.rag_pipeline.rag_pipeline import RagPipelineService
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class Parser(BaseModel):
+    inputs: dict
+    datasource_type: str
+    credential_id: str | None = None
+
+
+console_ns.schema_model(Parser.__name__, Parser.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/published/datasource/nodes/<string:node_id>/preview")
+class DataSourceContentPreviewApi(Resource):
+    @console_ns.expect(console_ns.models[Parser.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    def post(self, pipeline: Pipeline, node_id: str):
+        """
+        Run datasource content preview
+        """
+        if not isinstance(current_user, Account):
+            raise Forbidden()
+
+        args = Parser.model_validate(console_ns.payload)
+
+        inputs = args.inputs
+        datasource_type = args.datasource_type
+        rag_pipeline_service = RagPipelineService()
+        preview_content = rag_pipeline_service.run_datasource_node_preview(
+            pipeline=pipeline,
+            node_id=node_id,
+            user_inputs=inputs,
+            account=current_user,
+            datasource_type=datasource_type,
+            is_published=True,
+            credential_id=args.credential_id,
+        )
+        return preview_content, 200

dify_1.11.1/api/controllers/console/datasets/rag_pipeline/rag_pipeline.py

@@ -0,0 +1,108 @@
+import logging
+
+from flask import request
+from flask_restx import Resource
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+from controllers.common.schema import register_schema_models
+from controllers.console import console_ns
+from controllers.console.wraps import (
+    account_initialization_required,
+    enterprise_license_required,
+    knowledge_pipeline_publish_enabled,
+    setup_required,
+)
+from extensions.ext_database import db
+from libs.login import login_required
+from models.dataset import PipelineCustomizedTemplate
+from services.entities.knowledge_entities.rag_pipeline_entities import PipelineTemplateInfoEntity
+from services.rag_pipeline.rag_pipeline import RagPipelineService
+
+logger = logging.getLogger(__name__)
+
+
+@console_ns.route("/rag/pipeline/templates")
+class PipelineTemplateListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def get(self):
+        type = request.args.get("type", default="built-in", type=str)
+        language = request.args.get("language", default="en-US", type=str)
+        # get pipeline templates
+        pipeline_templates = RagPipelineService.get_pipeline_templates(type, language)
+        return pipeline_templates, 200
+
+
+@console_ns.route("/rag/pipeline/templates/<string:template_id>")
+class PipelineTemplateDetailApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def get(self, template_id: str):
+        type = request.args.get("type", default="built-in", type=str)
+        rag_pipeline_service = RagPipelineService()
+        pipeline_template = rag_pipeline_service.get_pipeline_template_detail(template_id, type)
+        return pipeline_template, 200
+
+
+class Payload(BaseModel):
+    name: str = Field(..., min_length=1, max_length=40)
+    description: str = Field(default="", max_length=400)
+    icon_info: dict[str, object] | None = None
+
+
+register_schema_models(console_ns, Payload)
+
+
+@console_ns.route("/rag/pipeline/customized/templates/<string:template_id>")
+class CustomizedPipelineTemplateApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def patch(self, template_id: str):
+        payload = Payload.model_validate(console_ns.payload or {})
+        pipeline_template_info = PipelineTemplateInfoEntity.model_validate(payload.model_dump())
+        RagPipelineService.update_customized_pipeline_template(template_id, pipeline_template_info)
+        return 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def delete(self, template_id: str):
+        RagPipelineService.delete_customized_pipeline_template(template_id)
+        return 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    def post(self, template_id: str):
+        with Session(db.engine) as session:
+            template = (
+                session.query(PipelineCustomizedTemplate).where(PipelineCustomizedTemplate.id == template_id).first()
+            )
+            if not template:
+                raise ValueError("Customized pipeline template not found.")
+
+        return {"data": template.yaml_content}, 200
+
+
+@console_ns.route("/rag/pipelines/<string:pipeline_id>/customized/publish")
+class PublishCustomizedPipelineTemplateApi(Resource):
+    @console_ns.expect(console_ns.models[Payload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @enterprise_license_required
+    @knowledge_pipeline_publish_enabled
+    def post(self, pipeline_id: str):
+        payload = Payload.model_validate(console_ns.payload or {})
+        rag_pipeline_service = RagPipelineService()
+        rag_pipeline_service.publish_customized_pipeline_template(pipeline_id, payload.model_dump())
+        return {"result": "success"}

dify_1.11.1/api/controllers/console/datasets/rag_pipeline/rag_pipeline_datasets.py

@@ -0,0 +1,101 @@
+from flask_restx import Resource, marshal
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import Forbidden
+
+import services
+from controllers.common.schema import register_schema_model
+from controllers.console import console_ns
+from controllers.console.datasets.error import DatasetNameDuplicateError
+from controllers.console.wraps import (
+    account_initialization_required,
+    cloud_edition_billing_rate_limit_check,
+    setup_required,
+)
+from extensions.ext_database import db
+from fields.dataset_fields import dataset_detail_fields
+from libs.login import current_account_with_tenant, login_required
+from models.dataset import DatasetPermissionEnum
+from services.dataset_service import DatasetPermissionService, DatasetService
+from services.entities.knowledge_entities.rag_pipeline_entities import IconInfo, RagPipelineDatasetCreateEntity
+from services.rag_pipeline.rag_pipeline_dsl_service import RagPipelineDslService
+
+
+class RagPipelineDatasetImportPayload(BaseModel):
+    yaml_content: str
+
+
+register_schema_model(console_ns, RagPipelineDatasetImportPayload)
+
+
+@console_ns.route("/rag/pipeline/dataset")
+class CreateRagPipelineDatasetApi(Resource):
+    @console_ns.expect(console_ns.models[RagPipelineDatasetImportPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def post(self):
+        payload = RagPipelineDatasetImportPayload.model_validate(console_ns.payload or {})
+        current_user, current_tenant_id = current_account_with_tenant()
+        # The role of the current user in the ta table must be admin, owner, or editor, or dataset_operator
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+        rag_pipeline_dataset_create_entity = RagPipelineDatasetCreateEntity(
+            name="",
+            description="",
+            icon_info=IconInfo(
+                icon="📙",
+                icon_background="#FFF4ED",
+                icon_type="emoji",
+            ),
+            permission=DatasetPermissionEnum.ONLY_ME,
+            partial_member_list=None,
+            yaml_content=payload.yaml_content,
+        )
+        try:
+            with Session(db.engine) as session:
+                rag_pipeline_dsl_service = RagPipelineDslService(session)
+                import_info = rag_pipeline_dsl_service.create_rag_pipeline_dataset(
+                    tenant_id=current_tenant_id,
+                    rag_pipeline_dataset_create_entity=rag_pipeline_dataset_create_entity,
+                )
+            if rag_pipeline_dataset_create_entity.permission == "partial_members":
+                DatasetPermissionService.update_partial_member_list(
+                    current_tenant_id,
+                    import_info["dataset_id"],
+                    rag_pipeline_dataset_create_entity.partial_member_list,
+                )
+        except services.errors.dataset.DatasetNameDuplicateError:
+            raise DatasetNameDuplicateError()
+
+        return import_info, 201
+
+
+@console_ns.route("/rag/pipeline/empty-dataset")
+class CreateEmptyRagPipelineDatasetApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def post(self):
+        # The role of the current user in the ta table must be admin, owner, or editor, or dataset_operator
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        if not current_user.is_dataset_editor:
+            raise Forbidden()
+        dataset = DatasetService.create_empty_rag_pipeline_dataset(
+            tenant_id=current_tenant_id,
+            rag_pipeline_dataset_create_entity=RagPipelineDatasetCreateEntity(
+                name="",
+                description="",
+                icon_info=IconInfo(
+                    icon="📙",
+                    icon_background="#FFF4ED",
+                    icon_type="emoji",
+                ),
+                permission=DatasetPermissionEnum.ONLY_ME,
+                partial_member_list=None,
+            ),
+        )
+        return marshal(dataset, dataset_detail_fields), 201

dify_1.11.1/api/controllers/console/datasets/rag_pipeline/rag_pipeline_draft_variable.py

@@ -0,0 +1,347 @@
+import logging
+from typing import Any, NoReturn
+
+from flask import Response, request
+from flask_restx import Resource, fields, marshal, marshal_with
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import Forbidden
+
+from controllers.common.schema import register_schema_models
+from controllers.console import console_ns
+from controllers.console.app.error import (
+    DraftWorkflowNotExist,
+)
+from controllers.console.app.workflow_draft_variable import (
+    _WORKFLOW_DRAFT_VARIABLE_FIELDS,  # type: ignore[private-usage]
+    _WORKFLOW_DRAFT_VARIABLE_WITHOUT_VALUE_FIELDS,  # type: ignore[private-usage]
+)
+from controllers.console.datasets.wraps import get_rag_pipeline
+from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.web.error import InvalidArgumentError, NotFoundError
+from core.variables.types import SegmentType
+from core.workflow.constants import CONVERSATION_VARIABLE_NODE_ID, SYSTEM_VARIABLE_NODE_ID
+from extensions.ext_database import db
+from factories.file_factory import build_from_mapping, build_from_mappings
+from factories.variable_factory import build_segment_with_type
+from libs.login import current_user, login_required
+from models import Account
+from models.dataset import Pipeline
+from models.workflow import WorkflowDraftVariable
+from services.rag_pipeline.rag_pipeline import RagPipelineService
+from services.workflow_draft_variable_service import WorkflowDraftVariableList, WorkflowDraftVariableService
+
+logger = logging.getLogger(__name__)
+
+
+def _create_pagination_parser():
+    class PaginationQuery(BaseModel):
+        page: int = Field(default=1, ge=1, le=100_000)
+        limit: int = Field(default=20, ge=1, le=100)
+
+    register_schema_models(console_ns, PaginationQuery)
+
+    return PaginationQuery
+
+
+class WorkflowDraftVariablePatchPayload(BaseModel):
+    name: str | None = None
+    value: Any | None = None
+
+
+register_schema_models(console_ns, WorkflowDraftVariablePatchPayload)
+
+
+def _get_items(var_list: WorkflowDraftVariableList) -> list[WorkflowDraftVariable]:
+    return var_list.variables
+
+
+_WORKFLOW_DRAFT_VARIABLE_LIST_WITHOUT_VALUE_FIELDS = {
+    "items": fields.List(fields.Nested(_WORKFLOW_DRAFT_VARIABLE_WITHOUT_VALUE_FIELDS), attribute=_get_items),
+    "total": fields.Raw(),
+}
+
+_WORKFLOW_DRAFT_VARIABLE_LIST_FIELDS = {
+    "items": fields.List(fields.Nested(_WORKFLOW_DRAFT_VARIABLE_FIELDS), attribute=_get_items),
+}
+
+
+def _api_prerequisite(f):
+    """Common prerequisites for all draft workflow variable APIs.
+
+    It ensures the following conditions are satisfied:
+
+    - Dify has been property setup.
+    - The request user has logged in and initialized.
+    - The requested app is a workflow or a chat flow.
+    - The request user has the edit permission for the app.
+    """
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    def wrapper(*args, **kwargs):
+        if not isinstance(current_user, Account) or not current_user.has_edit_permission:
+            raise Forbidden()
+        return f(*args, **kwargs)
+
+    return wrapper
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/variables")
+class RagPipelineVariableCollectionApi(Resource):
+    @_api_prerequisite
+    @marshal_with(_WORKFLOW_DRAFT_VARIABLE_LIST_WITHOUT_VALUE_FIELDS)
+    def get(self, pipeline: Pipeline):
+        """
+        Get draft workflow
+        """
+        pagination = _create_pagination_parser()
+        query = pagination.model_validate(request.args.to_dict())
+
+        # fetch draft workflow by app_model
+        rag_pipeline_service = RagPipelineService()
+        workflow_exist = rag_pipeline_service.is_workflow_exist(pipeline=pipeline)
+        if not workflow_exist:
+            raise DraftWorkflowNotExist()
+
+        # fetch draft workflow by app_model
+        with Session(bind=db.engine, expire_on_commit=False) as session:
+            draft_var_srv = WorkflowDraftVariableService(
+                session=session,
+            )
+        workflow_vars = draft_var_srv.list_variables_without_values(
+            app_id=pipeline.id,
+            page=query.page,
+            limit=query.limit,
+        )
+
+        return workflow_vars
+
+    @_api_prerequisite
+    def delete(self, pipeline: Pipeline):
+        draft_var_srv = WorkflowDraftVariableService(
+            session=db.session(),
+        )
+        draft_var_srv.delete_workflow_variables(pipeline.id)
+        db.session.commit()
+        return Response("", 204)
+
+
+def validate_node_id(node_id: str) -> NoReturn | None:
+    if node_id in [
+        CONVERSATION_VARIABLE_NODE_ID,
+        SYSTEM_VARIABLE_NODE_ID,
+    ]:
+        # NOTE(QuantumGhost): While we store the system and conversation variables as node variables
+        # with specific `node_id` in database, we still want to make the API separated. By disallowing
+        # accessing system and conversation variables in `WorkflowDraftNodeVariableListApi`,
+        # we mitigate the risk that user of the API depending on the implementation detail of the API.
+        #
+        # ref: [Hyrum's Law](https://www.hyrumslaw.com/)
+
+        raise InvalidArgumentError(
+            f"invalid node_id, please use correspond api for conversation and system variables, node_id={node_id}",
+        )
+    return None
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/nodes/<string:node_id>/variables")
+class RagPipelineNodeVariableCollectionApi(Resource):
+    @_api_prerequisite
+    @marshal_with(_WORKFLOW_DRAFT_VARIABLE_LIST_FIELDS)
+    def get(self, pipeline: Pipeline, node_id: str):
+        validate_node_id(node_id)
+        with Session(bind=db.engine, expire_on_commit=False) as session:
+            draft_var_srv = WorkflowDraftVariableService(
+                session=session,
+            )
+            node_vars = draft_var_srv.list_node_variables(pipeline.id, node_id)
+
+        return node_vars
+
+    @_api_prerequisite
+    def delete(self, pipeline: Pipeline, node_id: str):
+        validate_node_id(node_id)
+        srv = WorkflowDraftVariableService(db.session())
+        srv.delete_node_variables(pipeline.id, node_id)
+        db.session.commit()
+        return Response("", 204)
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/variables/<uuid:variable_id>")
+class RagPipelineVariableApi(Resource):
+    _PATCH_NAME_FIELD = "name"
+    _PATCH_VALUE_FIELD = "value"
+
+    @_api_prerequisite
+    @marshal_with(_WORKFLOW_DRAFT_VARIABLE_FIELDS)
+    def get(self, pipeline: Pipeline, variable_id: str):
+        draft_var_srv = WorkflowDraftVariableService(
+            session=db.session(),
+        )
+        variable = draft_var_srv.get_variable(variable_id=variable_id)
+        if variable is None:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        if variable.app_id != pipeline.id:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        return variable
+
+    @_api_prerequisite
+    @marshal_with(_WORKFLOW_DRAFT_VARIABLE_FIELDS)
+    @console_ns.expect(console_ns.models[WorkflowDraftVariablePatchPayload.__name__])
+    def patch(self, pipeline: Pipeline, variable_id: str):
+        # Request payload for file types:
+        #
+        # Local File:
+        #
+        #     {
+        #         "type": "image",
+        #         "transfer_method": "local_file",
+        #         "url": "",
+        #         "upload_file_id": "daded54f-72c7-4f8e-9d18-9b0abdd9f190"
+        #     }
+        #
+        # Remote File:
+        #
+        #
+        #     {
+        #         "type": "image",
+        #         "transfer_method": "remote_url",
+        #         "url": "http://127.0.0.1:5001/files/1602650a-4fe4-423c-85a2-af76c083e3c4/file-preview?timestamp=1750041099&nonce=...&sign=...=",
+        #         "upload_file_id": "1602650a-4fe4-423c-85a2-af76c083e3c4"
+        #     }
+
+        draft_var_srv = WorkflowDraftVariableService(
+            session=db.session(),
+        )
+        payload = WorkflowDraftVariablePatchPayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump(exclude_none=True)
+
+        variable = draft_var_srv.get_variable(variable_id=variable_id)
+        if variable is None:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        if variable.app_id != pipeline.id:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+
+        new_name = args.get(self._PATCH_NAME_FIELD, None)
+        raw_value = args.get(self._PATCH_VALUE_FIELD, None)
+        if new_name is None and raw_value is None:
+            return variable
+
+        new_value = None
+        if raw_value is not None:
+            if variable.value_type == SegmentType.FILE:
+                if not isinstance(raw_value, dict):
+                    raise InvalidArgumentError(description=f"expected dict for file, got {type(raw_value)}")
+                raw_value = build_from_mapping(mapping=raw_value, tenant_id=pipeline.tenant_id)
+            elif variable.value_type == SegmentType.ARRAY_FILE:
+                if not isinstance(raw_value, list):
+                    raise InvalidArgumentError(description=f"expected list for files, got {type(raw_value)}")
+                if len(raw_value) > 0 and not isinstance(raw_value[0], dict):
+                    raise InvalidArgumentError(description=f"expected dict for files[0], got {type(raw_value)}")
+                raw_value = build_from_mappings(mappings=raw_value, tenant_id=pipeline.tenant_id)
+            new_value = build_segment_with_type(variable.value_type, raw_value)
+        draft_var_srv.update_variable(variable, name=new_name, value=new_value)
+        db.session.commit()
+        return variable
+
+    @_api_prerequisite
+    def delete(self, pipeline: Pipeline, variable_id: str):
+        draft_var_srv = WorkflowDraftVariableService(
+            session=db.session(),
+        )
+        variable = draft_var_srv.get_variable(variable_id=variable_id)
+        if variable is None:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        if variable.app_id != pipeline.id:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        draft_var_srv.delete_variable(variable)
+        db.session.commit()
+        return Response("", 204)
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/variables/<uuid:variable_id>/reset")
+class RagPipelineVariableResetApi(Resource):
+    @_api_prerequisite
+    def put(self, pipeline: Pipeline, variable_id: str):
+        draft_var_srv = WorkflowDraftVariableService(
+            session=db.session(),
+        )
+
+        rag_pipeline_service = RagPipelineService()
+        draft_workflow = rag_pipeline_service.get_draft_workflow(pipeline=pipeline)
+        if draft_workflow is None:
+            raise NotFoundError(
+                f"Draft workflow not found, pipeline_id={pipeline.id}",
+            )
+        variable = draft_var_srv.get_variable(variable_id=variable_id)
+        if variable is None:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+        if variable.app_id != pipeline.id:
+            raise NotFoundError(description=f"variable not found, id={variable_id}")
+
+        resetted = draft_var_srv.reset_variable(draft_workflow, variable)
+        db.session.commit()
+        if resetted is None:
+            return Response("", 204)
+        else:
+            return marshal(resetted, _WORKFLOW_DRAFT_VARIABLE_FIELDS)
+
+
+def _get_variable_list(pipeline: Pipeline, node_id) -> WorkflowDraftVariableList:
+    with Session(bind=db.engine, expire_on_commit=False) as session:
+        draft_var_srv = WorkflowDraftVariableService(
+            session=session,
+        )
+        if node_id == CONVERSATION_VARIABLE_NODE_ID:
+            draft_vars = draft_var_srv.list_conversation_variables(pipeline.id)
+        elif node_id == SYSTEM_VARIABLE_NODE_ID:
+            draft_vars = draft_var_srv.list_system_variables(pipeline.id)
+        else:
+            draft_vars = draft_var_srv.list_node_variables(app_id=pipeline.id, node_id=node_id)
+    return draft_vars
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/system-variables")
+class RagPipelineSystemVariableCollectionApi(Resource):
+    @_api_prerequisite
+    @marshal_with(_WORKFLOW_DRAFT_VARIABLE_LIST_FIELDS)
+    def get(self, pipeline: Pipeline):
+        return _get_variable_list(pipeline, SYSTEM_VARIABLE_NODE_ID)
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/environment-variables")
+class RagPipelineEnvironmentVariableCollectionApi(Resource):
+    @_api_prerequisite
+    def get(self, pipeline: Pipeline):
+        """
+        Get draft workflow
+        """
+        # fetch draft workflow by app_model
+        rag_pipeline_service = RagPipelineService()
+        workflow = rag_pipeline_service.get_draft_workflow(pipeline=pipeline)
+        if workflow is None:
+            raise DraftWorkflowNotExist()
+
+        env_vars = workflow.environment_variables
+        env_vars_list = []
+        for v in env_vars:
+            env_vars_list.append(
+                {
+                    "id": v.id,
+                    "type": "env",
+                    "name": v.name,
+                    "description": v.description,
+                    "selector": v.selector,
+                    "value_type": v.value_type.value,
+                    "value": v.value,
+                    # Do not track edited for env vars.
+                    "edited": False,
+                    "visible": True,
+                    "editable": True,
+                }
+            )
+
+        return {"items": env_vars_list}

dify_1.11.1/api/controllers/console/datasets/rag_pipeline/rag_pipeline_import.py

@@ -0,0 +1,135 @@
+from flask import request
+from flask_restx import Resource, marshal_with  # type: ignore
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+from controllers.common.schema import register_schema_models
+from controllers.console import console_ns
+from controllers.console.datasets.wraps import get_rag_pipeline
+from controllers.console.wraps import (
+    account_initialization_required,
+    edit_permission_required,
+    setup_required,
+)
+from extensions.ext_database import db
+from fields.rag_pipeline_fields import pipeline_import_check_dependencies_fields, pipeline_import_fields
+from libs.login import current_account_with_tenant, login_required
+from models.dataset import Pipeline
+from services.app_dsl_service import ImportStatus
+from services.rag_pipeline.rag_pipeline_dsl_service import RagPipelineDslService
+
+
+class RagPipelineImportPayload(BaseModel):
+    mode: str
+    yaml_content: str | None = None
+    yaml_url: str | None = None
+    name: str | None = None
+    description: str | None = None
+    icon_type: str | None = None
+    icon: str | None = None
+    icon_background: str | None = None
+    pipeline_id: str | None = None
+
+
+class IncludeSecretQuery(BaseModel):
+    include_secret: str = Field(default="false")
+
+
+register_schema_models(console_ns, RagPipelineImportPayload, IncludeSecretQuery)
+
+
+@console_ns.route("/rag/pipelines/imports")
+class RagPipelineImportApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @marshal_with(pipeline_import_fields)
+    @console_ns.expect(console_ns.models[RagPipelineImportPayload.__name__])
+    def post(self):
+        # Check user role first
+        current_user, _ = current_account_with_tenant()
+        payload = RagPipelineImportPayload.model_validate(console_ns.payload or {})
+
+        # Create service with session
+        with Session(db.engine) as session:
+            import_service = RagPipelineDslService(session)
+            # Import app
+            account = current_user
+            result = import_service.import_rag_pipeline(
+                account=account,
+                import_mode=payload.mode,
+                yaml_content=payload.yaml_content,
+                yaml_url=payload.yaml_url,
+                pipeline_id=payload.pipeline_id,
+                dataset_name=payload.name,
+            )
+            session.commit()
+
+        # Return appropriate status code based on result
+        status = result.status
+        if status == ImportStatus.FAILED:
+            return result.model_dump(mode="json"), 400
+        elif status == ImportStatus.PENDING:
+            return result.model_dump(mode="json"), 202
+        return result.model_dump(mode="json"), 200
+
+
+@console_ns.route("/rag/pipelines/imports/<string:import_id>/confirm")
+class RagPipelineImportConfirmApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @marshal_with(pipeline_import_fields)
+    def post(self, import_id):
+        current_user, _ = current_account_with_tenant()
+
+        # Create service with session
+        with Session(db.engine) as session:
+            import_service = RagPipelineDslService(session)
+            # Confirm import
+            account = current_user
+            result = import_service.confirm_import(import_id=import_id, account=account)
+            session.commit()
+
+        # Return appropriate status code based on result
+        if result.status == ImportStatus.FAILED:
+            return result.model_dump(mode="json"), 400
+        return result.model_dump(mode="json"), 200
+
+
+@console_ns.route("/rag/pipelines/imports/<string:pipeline_id>/check-dependencies")
+class RagPipelineImportCheckDependenciesApi(Resource):
+    @setup_required
+    @login_required
+    @get_rag_pipeline
+    @account_initialization_required
+    @edit_permission_required
+    @marshal_with(pipeline_import_check_dependencies_fields)
+    def get(self, pipeline: Pipeline):
+        with Session(db.engine) as session:
+            import_service = RagPipelineDslService(session)
+            result = import_service.check_dependencies(pipeline=pipeline)
+
+        return result.model_dump(mode="json"), 200
+
+
+@console_ns.route("/rag/pipelines/<string:pipeline_id>/exports")
+class RagPipelineExportApi(Resource):
+    @setup_required
+    @login_required
+    @get_rag_pipeline
+    @account_initialization_required
+    @edit_permission_required
+    def get(self, pipeline: Pipeline):
+        # Add include_secret params
+        query = IncludeSecretQuery.model_validate(request.args.to_dict())
+
+        with Session(db.engine) as session:
+            export_service = RagPipelineDslService(session)
+            result = export_service.export_rag_pipeline_dsl(
+                pipeline=pipeline, include_secret=query.include_secret == "true"
+            )
+
+        return {"data": result}, 200

dify_1.11.1/api/controllers/console/datasets/rag_pipeline/rag_pipeline_workflow.py

@@ -0,0 +1,980 @@
+import json
+import logging
+from typing import Any, Literal, cast
+from uuid import UUID
+
+from flask import abort, request
+from flask_restx import Resource, marshal_with  # type: ignore
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
+
+import services
+from controllers.common.schema import register_schema_models
+from controllers.console import console_ns
+from controllers.console.app.error import (
+    ConversationCompletedError,
+    DraftWorkflowNotExist,
+    DraftWorkflowNotSync,
+)
+from controllers.console.datasets.wraps import get_rag_pipeline
+from controllers.console.wraps import (
+    account_initialization_required,
+    edit_permission_required,
+    setup_required,
+)
+from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
+from core.app.apps.base_app_queue_manager import AppQueueManager
+from core.app.apps.pipeline.pipeline_generator import PipelineGenerator
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.model_runtime.utils.encoders import jsonable_encoder
+from extensions.ext_database import db
+from factories import variable_factory
+from fields.workflow_fields import workflow_fields, workflow_pagination_fields
+from fields.workflow_run_fields import (
+    workflow_run_detail_fields,
+    workflow_run_node_execution_fields,
+    workflow_run_node_execution_list_fields,
+    workflow_run_pagination_fields,
+)
+from libs import helper
+from libs.helper import TimestampField
+from libs.login import current_account_with_tenant, current_user, login_required
+from models import Account
+from models.dataset import Pipeline
+from models.model import EndUser
+from services.errors.app import WorkflowHashNotEqualError
+from services.errors.llm import InvokeRateLimitError
+from services.rag_pipeline.pipeline_generate_service import PipelineGenerateService
+from services.rag_pipeline.rag_pipeline import RagPipelineService
+from services.rag_pipeline.rag_pipeline_manage_service import RagPipelineManageService
+from services.rag_pipeline.rag_pipeline_transform_service import RagPipelineTransformService
+
+logger = logging.getLogger(__name__)
+
+
+class DraftWorkflowSyncPayload(BaseModel):
+    graph: dict[str, Any]
+    hash: str | None = None
+    environment_variables: list[dict[str, Any]] | None = None
+    conversation_variables: list[dict[str, Any]] | None = None
+    rag_pipeline_variables: list[dict[str, Any]] | None = None
+    features: dict[str, Any] | None = None
+
+
+class NodeRunPayload(BaseModel):
+    inputs: dict[str, Any] | None = None
+
+
+class NodeRunRequiredPayload(BaseModel):
+    inputs: dict[str, Any]
+
+
+class DatasourceNodeRunPayload(BaseModel):
+    inputs: dict[str, Any]
+    datasource_type: str
+    credential_id: str | None = None
+
+
+class DraftWorkflowRunPayload(BaseModel):
+    inputs: dict[str, Any]
+    datasource_type: str
+    datasource_info_list: list[dict[str, Any]]
+    start_node_id: str
+
+
+class PublishedWorkflowRunPayload(DraftWorkflowRunPayload):
+    is_preview: bool = False
+    response_mode: Literal["streaming", "blocking"] = "streaming"
+    original_document_id: str | None = None
+
+
+class DefaultBlockConfigQuery(BaseModel):
+    q: str | None = None
+
+
+class WorkflowListQuery(BaseModel):
+    page: int = Field(default=1, ge=1, le=99999)
+    limit: int = Field(default=10, ge=1, le=100)
+    user_id: str | None = None
+    named_only: bool = False
+
+
+class WorkflowUpdatePayload(BaseModel):
+    marked_name: str | None = Field(default=None, max_length=20)
+    marked_comment: str | None = Field(default=None, max_length=100)
+
+
+class NodeIdQuery(BaseModel):
+    node_id: str
+
+
+class WorkflowRunQuery(BaseModel):
+    last_id: UUID | None = None
+    limit: int = Field(default=20, ge=1, le=100)
+
+
+class DatasourceVariablesPayload(BaseModel):
+    datasource_type: str
+    datasource_info: dict[str, Any]
+    start_node_id: str
+    start_node_title: str
+
+
+register_schema_models(
+    console_ns,
+    DraftWorkflowSyncPayload,
+    NodeRunPayload,
+    NodeRunRequiredPayload,
+    DatasourceNodeRunPayload,
+    DraftWorkflowRunPayload,
+    PublishedWorkflowRunPayload,
+    DefaultBlockConfigQuery,
+    WorkflowListQuery,
+    WorkflowUpdatePayload,
+    NodeIdQuery,
+    WorkflowRunQuery,
+    DatasourceVariablesPayload,
+)
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft")
+class DraftRagPipelineApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @edit_permission_required
+    @marshal_with(workflow_fields)
+    def get(self, pipeline: Pipeline):
+        """
+        Get draft rag pipeline's workflow
+        """
+        # fetch draft workflow by app_model
+        rag_pipeline_service = RagPipelineService()
+        workflow = rag_pipeline_service.get_draft_workflow(pipeline=pipeline)
+
+        if not workflow:
+            raise DraftWorkflowNotExist()
+
+        # return workflow, if not found, return None (initiate graph by frontend)
+        return workflow
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @edit_permission_required
+    def post(self, pipeline: Pipeline):
+        """
+        Sync draft workflow
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+
+        content_type = request.headers.get("Content-Type", "")
+
+        if "application/json" in content_type:
+            payload_dict = console_ns.payload or {}
+        elif "text/plain" in content_type:
+            try:
+                data = json.loads(request.data.decode("utf-8"))
+                if "graph" not in data or "features" not in data:
+                    raise ValueError("graph or features not found in data")
+
+                if not isinstance(data.get("graph"), dict):
+                    raise ValueError("graph is not a dict")
+
+                payload_dict = {
+                    "graph": data.get("graph"),
+                    "features": data.get("features"),
+                    "hash": data.get("hash"),
+                    "environment_variables": data.get("environment_variables"),
+                    "conversation_variables": data.get("conversation_variables"),
+                    "rag_pipeline_variables": data.get("rag_pipeline_variables"),
+                }
+            except json.JSONDecodeError:
+                return {"message": "Invalid JSON data"}, 400
+        else:
+            abort(415)
+
+        payload = DraftWorkflowSyncPayload.model_validate(payload_dict)
+
+        try:
+            environment_variables_list = payload.environment_variables or []
+            environment_variables = [
+                variable_factory.build_environment_variable_from_mapping(obj) for obj in environment_variables_list
+            ]
+            conversation_variables_list = payload.conversation_variables or []
+            conversation_variables = [
+                variable_factory.build_conversation_variable_from_mapping(obj) for obj in conversation_variables_list
+            ]
+            rag_pipeline_service = RagPipelineService()
+            workflow = rag_pipeline_service.sync_draft_workflow(
+                pipeline=pipeline,
+                graph=payload.graph,
+                unique_hash=payload.hash,
+                account=current_user,
+                environment_variables=environment_variables,
+                conversation_variables=conversation_variables,
+                rag_pipeline_variables=payload.rag_pipeline_variables or [],
+            )
+        except WorkflowHashNotEqualError:
+            raise DraftWorkflowNotSync()
+
+        return {
+            "result": "success",
+            "hash": workflow.unique_hash,
+            "updated_at": TimestampField().format(workflow.updated_at or workflow.created_at),
+        }
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/iteration/nodes/<string:node_id>/run")
+class RagPipelineDraftRunIterationNodeApi(Resource):
+    @console_ns.expect(console_ns.models[NodeRunPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @edit_permission_required
+    def post(self, pipeline: Pipeline, node_id: str):
+        """
+        Run draft workflow iteration node
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+
+        payload = NodeRunPayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump(exclude_none=True)
+
+        try:
+            response = PipelineGenerateService.generate_single_iteration(
+                pipeline=pipeline, user=current_user, node_id=node_id, args=args, streaming=True
+            )
+
+            return helper.compact_generate_response(response)
+        except services.errors.conversation.ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+        except services.errors.conversation.ConversationCompletedError:
+            raise ConversationCompletedError()
+        except ValueError as e:
+            raise e
+        except Exception:
+            logging.exception("internal server error.")
+            raise InternalServerError()
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/loop/nodes/<string:node_id>/run")
+class RagPipelineDraftRunLoopNodeApi(Resource):
+    @console_ns.expect(console_ns.models[NodeRunPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_rag_pipeline
+    def post(self, pipeline: Pipeline, node_id: str):
+        """
+        Run draft workflow loop node
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+
+        payload = NodeRunPayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump(exclude_none=True)
+
+        try:
+            response = PipelineGenerateService.generate_single_loop(
+                pipeline=pipeline, user=current_user, node_id=node_id, args=args, streaming=True
+            )
+
+            return helper.compact_generate_response(response)
+        except services.errors.conversation.ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+        except services.errors.conversation.ConversationCompletedError:
+            raise ConversationCompletedError()
+        except ValueError as e:
+            raise e
+        except Exception:
+            logging.exception("internal server error.")
+            raise InternalServerError()
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/run")
+class DraftRagPipelineRunApi(Resource):
+    @console_ns.expect(console_ns.models[DraftWorkflowRunPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_rag_pipeline
+    def post(self, pipeline: Pipeline):
+        """
+        Run draft workflow
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+
+        payload = DraftWorkflowRunPayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump()
+
+        try:
+            response = PipelineGenerateService.generate(
+                pipeline=pipeline,
+                user=current_user,
+                args=args,
+                invoke_from=InvokeFrom.DEBUGGER,
+                streaming=True,
+            )
+
+            return helper.compact_generate_response(response)
+        except InvokeRateLimitError as ex:
+            raise InvokeRateLimitHttpError(ex.description)
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/published/run")
+class PublishedRagPipelineRunApi(Resource):
+    @console_ns.expect(console_ns.models[PublishedWorkflowRunPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_rag_pipeline
+    def post(self, pipeline: Pipeline):
+        """
+        Run published workflow
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+
+        payload = PublishedWorkflowRunPayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump(exclude_none=True)
+        streaming = payload.response_mode == "streaming"
+
+        try:
+            response = PipelineGenerateService.generate(
+                pipeline=pipeline,
+                user=current_user,
+                args=args,
+                invoke_from=InvokeFrom.DEBUGGER if payload.is_preview else InvokeFrom.PUBLISHED,
+                streaming=streaming,
+            )
+
+            return helper.compact_generate_response(response)
+        except InvokeRateLimitError as ex:
+            raise InvokeRateLimitHttpError(ex.description)
+
+
+# class RagPipelinePublishedDatasourceNodeRunStatusApi(Resource):
+#     @setup_required
+#     @login_required
+#     @account_initialization_required
+#     @get_rag_pipeline
+#     def post(self, pipeline: Pipeline, node_id: str):
+#         """
+#         Run rag pipeline datasource
+#         """
+#         # The role of the current user in the ta table must be admin, owner, or editor
+#         if not current_user.has_edit_permission:
+#             raise Forbidden()
+#
+#         if not isinstance(current_user, Account):
+#             raise Forbidden()
+#
+#         parser = (reqparse.RequestParser()
+#             .add_argument("job_id", type=str, required=True, nullable=False, location="json")
+#             .add_argument("datasource_type", type=str, required=True, location="json")
+#         )
+#         args = parser.parse_args()
+#
+#         job_id = args.get("job_id")
+#         if job_id == None:
+#             raise ValueError("missing job_id")
+#         datasource_type = args.get("datasource_type")
+#         if datasource_type == None:
+#             raise ValueError("missing datasource_type")
+#
+#         rag_pipeline_service = RagPipelineService()
+#         result = rag_pipeline_service.run_datasource_workflow_node_status(
+#             pipeline=pipeline,
+#             node_id=node_id,
+#             job_id=job_id,
+#             account=current_user,
+#             datasource_type=datasource_type,
+#             is_published=True
+#         )
+#
+#         return result
+
+
+# class RagPipelineDraftDatasourceNodeRunStatusApi(Resource):
+#     @setup_required
+#     @login_required
+#     @account_initialization_required
+#     @get_rag_pipeline
+#     def post(self, pipeline: Pipeline, node_id: str):
+#         """
+#         Run rag pipeline datasource
+#         """
+#         # The role of the current user in the ta table must be admin, owner, or editor
+#         if not current_user.has_edit_permission:
+#             raise Forbidden()
+#
+#         if not isinstance(current_user, Account):
+#             raise Forbidden()
+#
+#         parser = (reqparse.RequestParser()
+#             .add_argument("job_id", type=str, required=True, nullable=False, location="json")
+#             .add_argument("datasource_type", type=str, required=True, location="json")
+#         )
+#         args = parser.parse_args()
+#
+#         job_id = args.get("job_id")
+#         if job_id == None:
+#             raise ValueError("missing job_id")
+#         datasource_type = args.get("datasource_type")
+#         if datasource_type == None:
+#             raise ValueError("missing datasource_type")
+#
+#         rag_pipeline_service = RagPipelineService()
+#         result = rag_pipeline_service.run_datasource_workflow_node_status(
+#             pipeline=pipeline,
+#             node_id=node_id,
+#             job_id=job_id,
+#             account=current_user,
+#             datasource_type=datasource_type,
+#             is_published=False
+#         )
+#
+#         return result
+#
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/published/datasource/nodes/<string:node_id>/run")
+class RagPipelinePublishedDatasourceNodeRunApi(Resource):
+    @console_ns.expect(console_ns.models[DatasourceNodeRunPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_rag_pipeline
+    def post(self, pipeline: Pipeline, node_id: str):
+        """
+        Run rag pipeline datasource
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+
+        payload = DatasourceNodeRunPayload.model_validate(console_ns.payload or {})
+
+        rag_pipeline_service = RagPipelineService()
+        return helper.compact_generate_response(
+            PipelineGenerator.convert_to_event_stream(
+                rag_pipeline_service.run_datasource_workflow_node(
+                    pipeline=pipeline,
+                    node_id=node_id,
+                    user_inputs=payload.inputs,
+                    account=current_user,
+                    datasource_type=payload.datasource_type,
+                    is_published=False,
+                    credential_id=payload.credential_id,
+                )
+            )
+        )
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/datasource/nodes/<string:node_id>/run")
+class RagPipelineDraftDatasourceNodeRunApi(Resource):
+    @console_ns.expect(console_ns.models[DatasourceNodeRunPayload.__name__])
+    @setup_required
+    @login_required
+    @edit_permission_required
+    @account_initialization_required
+    @get_rag_pipeline
+    def post(self, pipeline: Pipeline, node_id: str):
+        """
+        Run rag pipeline datasource
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+
+        payload = DatasourceNodeRunPayload.model_validate(console_ns.payload or {})
+
+        rag_pipeline_service = RagPipelineService()
+        return helper.compact_generate_response(
+            PipelineGenerator.convert_to_event_stream(
+                rag_pipeline_service.run_datasource_workflow_node(
+                    pipeline=pipeline,
+                    node_id=node_id,
+                    user_inputs=payload.inputs,
+                    account=current_user,
+                    datasource_type=payload.datasource_type,
+                    is_published=False,
+                    credential_id=payload.credential_id,
+                )
+            )
+        )
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/nodes/<string:node_id>/run")
+class RagPipelineDraftNodeRunApi(Resource):
+    @console_ns.expect(console_ns.models[NodeRunRequiredPayload.__name__])
+    @setup_required
+    @login_required
+    @edit_permission_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @marshal_with(workflow_run_node_execution_fields)
+    def post(self, pipeline: Pipeline, node_id: str):
+        """
+        Run draft workflow node
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+
+        payload = NodeRunRequiredPayload.model_validate(console_ns.payload or {})
+        inputs = payload.inputs
+
+        rag_pipeline_service = RagPipelineService()
+        workflow_node_execution = rag_pipeline_service.run_draft_workflow_node(
+            pipeline=pipeline, node_id=node_id, user_inputs=inputs, account=current_user
+        )
+
+        if workflow_node_execution is None:
+            raise ValueError("Workflow node execution not found")
+
+        return workflow_node_execution
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflow-runs/tasks/<string:task_id>/stop")
+class RagPipelineTaskStopApi(Resource):
+    @setup_required
+    @login_required
+    @edit_permission_required
+    @account_initialization_required
+    @get_rag_pipeline
+    def post(self, pipeline: Pipeline, task_id: str):
+        """
+        Stop workflow task
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+
+        AppQueueManager.set_stop_flag(task_id, InvokeFrom.DEBUGGER, current_user.id)
+
+        return {"result": "success"}
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/publish")
+class PublishedRagPipelineApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_rag_pipeline
+    @marshal_with(workflow_fields)
+    def get(self, pipeline: Pipeline):
+        """
+        Get published pipeline
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        if not pipeline.is_published:
+            return None
+        # fetch published workflow by pipeline
+        rag_pipeline_service = RagPipelineService()
+        workflow = rag_pipeline_service.get_published_workflow(pipeline=pipeline)
+
+        # return workflow, if not found, return None
+        return workflow
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_rag_pipeline
+    def post(self, pipeline: Pipeline):
+        """
+        Publish workflow
+        """
+        # The role of the current user in the ta table must be admin, owner, or editor
+        current_user, _ = current_account_with_tenant()
+        rag_pipeline_service = RagPipelineService()
+        with Session(db.engine) as session:
+            pipeline = session.merge(pipeline)
+            workflow = rag_pipeline_service.publish_workflow(
+                session=session,
+                pipeline=pipeline,
+                account=current_user,
+            )
+            pipeline.is_published = True
+            pipeline.workflow_id = workflow.id
+            session.add(pipeline)
+            workflow_created_at = TimestampField().format(workflow.created_at)
+
+            session.commit()
+
+        return {
+            "result": "success",
+            "created_at": workflow_created_at,
+        }
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/default-workflow-block-configs")
+class DefaultRagPipelineBlockConfigsApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_rag_pipeline
+    def get(self, pipeline: Pipeline):
+        """
+        Get default block config
+        """
+        # Get default block configs
+        rag_pipeline_service = RagPipelineService()
+        return rag_pipeline_service.get_default_block_configs()
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/default-workflow-block-configs/<string:block_type>")
+class DefaultRagPipelineBlockConfigApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_rag_pipeline
+    def get(self, pipeline: Pipeline, block_type: str):
+        """
+        Get default block config
+        """
+        query = DefaultBlockConfigQuery.model_validate(request.args.to_dict())
+
+        filters = None
+        if query.q:
+            try:
+                filters = json.loads(query.q)
+            except json.JSONDecodeError:
+                raise ValueError("Invalid filters")
+
+        # Get default block configs
+        rag_pipeline_service = RagPipelineService()
+        return rag_pipeline_service.get_default_block_config(node_type=block_type, filters=filters)
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows")
+class PublishedAllRagPipelineApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_rag_pipeline
+    @marshal_with(workflow_pagination_fields)
+    def get(self, pipeline: Pipeline):
+        """
+        Get published workflows
+        """
+        current_user, _ = current_account_with_tenant()
+
+        query = WorkflowListQuery.model_validate(request.args.to_dict())
+
+        page = query.page
+        limit = query.limit
+        user_id = query.user_id
+        named_only = query.named_only
+
+        if user_id:
+            if user_id != current_user.id:
+                raise Forbidden()
+
+        rag_pipeline_service = RagPipelineService()
+        with Session(db.engine) as session:
+            workflows, has_more = rag_pipeline_service.get_all_published_workflow(
+                session=session,
+                pipeline=pipeline,
+                page=page,
+                limit=limit,
+                user_id=user_id,
+                named_only=named_only,
+            )
+
+            return {
+                "items": workflows,
+                "page": page,
+                "limit": limit,
+                "has_more": has_more,
+            }
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/<string:workflow_id>")
+class RagPipelineByIdApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    @get_rag_pipeline
+    @marshal_with(workflow_fields)
+    def patch(self, pipeline: Pipeline, workflow_id: str):
+        """
+        Update workflow attributes
+        """
+        # Check permission
+        current_user, _ = current_account_with_tenant()
+
+        payload = WorkflowUpdatePayload.model_validate(console_ns.payload or {})
+        update_data = payload.model_dump(exclude_unset=True)
+
+        if not update_data:
+            return {"message": "No valid fields to update"}, 400
+
+        rag_pipeline_service = RagPipelineService()
+
+        # Create a session and manage the transaction
+        with Session(db.engine, expire_on_commit=False) as session:
+            workflow = rag_pipeline_service.update_workflow(
+                session=session,
+                workflow_id=workflow_id,
+                tenant_id=pipeline.tenant_id,
+                account_id=current_user.id,
+                data=update_data,
+            )
+
+            if not workflow:
+                raise NotFound("Workflow not found")
+
+            # Commit the transaction in the controller
+            session.commit()
+
+        return workflow
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/published/processing/parameters")
+class PublishedRagPipelineSecondStepApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @edit_permission_required
+    def get(self, pipeline: Pipeline):
+        """
+        Get second step parameters of rag pipeline
+        """
+        query = NodeIdQuery.model_validate(request.args.to_dict())
+        node_id = query.node_id
+        rag_pipeline_service = RagPipelineService()
+        variables = rag_pipeline_service.get_second_step_parameters(pipeline=pipeline, node_id=node_id, is_draft=False)
+        return {
+            "variables": variables,
+        }
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/published/pre-processing/parameters")
+class PublishedRagPipelineFirstStepApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @edit_permission_required
+    def get(self, pipeline: Pipeline):
+        """
+        Get first step parameters of rag pipeline
+        """
+        query = NodeIdQuery.model_validate(request.args.to_dict())
+        node_id = query.node_id
+        rag_pipeline_service = RagPipelineService()
+        variables = rag_pipeline_service.get_first_step_parameters(pipeline=pipeline, node_id=node_id, is_draft=False)
+        return {
+            "variables": variables,
+        }
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/pre-processing/parameters")
+class DraftRagPipelineFirstStepApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @edit_permission_required
+    def get(self, pipeline: Pipeline):
+        """
+        Get first step parameters of rag pipeline
+        """
+        query = NodeIdQuery.model_validate(request.args.to_dict())
+        node_id = query.node_id
+        rag_pipeline_service = RagPipelineService()
+        variables = rag_pipeline_service.get_first_step_parameters(pipeline=pipeline, node_id=node_id, is_draft=True)
+        return {
+            "variables": variables,
+        }
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/processing/parameters")
+class DraftRagPipelineSecondStepApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @edit_permission_required
+    def get(self, pipeline: Pipeline):
+        """
+        Get second step parameters of rag pipeline
+        """
+        query = NodeIdQuery.model_validate(request.args.to_dict())
+        node_id = query.node_id
+
+        rag_pipeline_service = RagPipelineService()
+        variables = rag_pipeline_service.get_second_step_parameters(pipeline=pipeline, node_id=node_id, is_draft=True)
+        return {
+            "variables": variables,
+        }
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflow-runs")
+class RagPipelineWorkflowRunListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @marshal_with(workflow_run_pagination_fields)
+    def get(self, pipeline: Pipeline):
+        """
+        Get workflow run list
+        """
+        query = WorkflowRunQuery.model_validate(
+            {
+                "last_id": request.args.get("last_id"),
+                "limit": request.args.get("limit", type=int, default=20),
+            }
+        )
+        args = {
+            "last_id": str(query.last_id) if query.last_id else None,
+            "limit": query.limit,
+        }
+
+        rag_pipeline_service = RagPipelineService()
+        result = rag_pipeline_service.get_rag_pipeline_paginate_workflow_runs(pipeline=pipeline, args=args)
+
+        return result
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflow-runs/<uuid:run_id>")
+class RagPipelineWorkflowRunDetailApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @marshal_with(workflow_run_detail_fields)
+    def get(self, pipeline: Pipeline, run_id):
+        """
+        Get workflow run detail
+        """
+        run_id = str(run_id)
+
+        rag_pipeline_service = RagPipelineService()
+        workflow_run = rag_pipeline_service.get_rag_pipeline_workflow_run(pipeline=pipeline, run_id=run_id)
+
+        return workflow_run
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflow-runs/<uuid:run_id>/node-executions")
+class RagPipelineWorkflowRunNodeExecutionListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @marshal_with(workflow_run_node_execution_list_fields)
+    def get(self, pipeline: Pipeline, run_id: str):
+        """
+        Get workflow run node execution list
+        """
+        run_id = str(run_id)
+
+        rag_pipeline_service = RagPipelineService()
+        user = cast("Account | EndUser", current_user)
+        node_executions = rag_pipeline_service.get_rag_pipeline_workflow_run_node_executions(
+            pipeline=pipeline,
+            run_id=run_id,
+            user=user,
+        )
+
+        return {"data": node_executions}
+
+
+@console_ns.route("/rag/pipelines/datasource-plugins")
+class DatasourceListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, current_tenant_id = current_account_with_tenant()
+        return jsonable_encoder(RagPipelineManageService.list_rag_pipeline_datasources(current_tenant_id))
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/nodes/<string:node_id>/last-run")
+class RagPipelineWorkflowLastRunApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @marshal_with(workflow_run_node_execution_fields)
+    def get(self, pipeline: Pipeline, node_id: str):
+        rag_pipeline_service = RagPipelineService()
+        workflow = rag_pipeline_service.get_draft_workflow(pipeline=pipeline)
+        if not workflow:
+            raise NotFound("Workflow not found")
+        node_exec = rag_pipeline_service.get_node_last_run(
+            pipeline=pipeline,
+            workflow=workflow,
+            node_id=node_id,
+        )
+        if node_exec is None:
+            raise NotFound("last run not found")
+        return node_exec
+
+
+@console_ns.route("/rag/pipelines/transform/datasets/<uuid:dataset_id>")
+class RagPipelineTransformApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, dataset_id: str):
+        current_user, _ = current_account_with_tenant()
+
+        if not (current_user.has_edit_permission or current_user.is_dataset_operator):
+            raise Forbidden()
+
+        dataset_id = str(dataset_id)
+        rag_pipeline_transform_service = RagPipelineTransformService()
+        result = rag_pipeline_transform_service.transform_dataset(dataset_id)
+        return result
+
+
+@console_ns.route("/rag/pipelines/<uuid:pipeline_id>/workflows/draft/datasource/variables-inspect")
+class RagPipelineDatasourceVariableApi(Resource):
+    @console_ns.expect(console_ns.models[DatasourceVariablesPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_rag_pipeline
+    @edit_permission_required
+    @marshal_with(workflow_run_node_execution_fields)
+    def post(self, pipeline: Pipeline):
+        """
+        Set datasource variables
+        """
+        current_user, _ = current_account_with_tenant()
+        args = DatasourceVariablesPayload.model_validate(console_ns.payload or {}).model_dump()
+
+        rag_pipeline_service = RagPipelineService()
+        workflow_node_execution = rag_pipeline_service.set_datasource_variables(
+            pipeline=pipeline,
+            args=args,
+            current_user=current_user,
+        )
+        return workflow_node_execution
+
+
+@console_ns.route("/rag/pipelines/recommended-plugins")
+class RagPipelineRecommendedPluginApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        rag_pipeline_service = RagPipelineService()
+        recommended_plugins = rag_pipeline_service.get_recommended_plugins()
+        return recommended_plugins

dify_1.11.1/api/controllers/console/datasets/website.py

@@ -0,0 +1,81 @@
+from typing import Literal
+
+from flask import request
+from flask_restx import Resource
+from pydantic import BaseModel
+
+from controllers.common.schema import register_schema_models
+from controllers.console import console_ns
+from controllers.console.datasets.error import WebsiteCrawlError
+from controllers.console.wraps import account_initialization_required, setup_required
+from libs.login import login_required
+from services.website_service import WebsiteCrawlApiRequest, WebsiteCrawlStatusApiRequest, WebsiteService
+
+
+class WebsiteCrawlPayload(BaseModel):
+    provider: Literal["firecrawl", "watercrawl", "jinareader"]
+    url: str
+    options: dict[str, object]
+
+
+class WebsiteCrawlStatusQuery(BaseModel):
+    provider: Literal["firecrawl", "watercrawl", "jinareader"]
+
+
+register_schema_models(console_ns, WebsiteCrawlPayload, WebsiteCrawlStatusQuery)
+
+
+@console_ns.route("/website/crawl")
+class WebsiteCrawlApi(Resource):
+    @console_ns.doc("crawl_website")
+    @console_ns.doc(description="Crawl website content")
+    @console_ns.expect(console_ns.models[WebsiteCrawlPayload.__name__])
+    @console_ns.response(200, "Website crawl initiated successfully")
+    @console_ns.response(400, "Invalid crawl parameters")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        payload = WebsiteCrawlPayload.model_validate(console_ns.payload or {})
+
+        # Create typed request and validate
+        try:
+            api_request = WebsiteCrawlApiRequest.from_args(payload.model_dump())
+        except ValueError as e:
+            raise WebsiteCrawlError(str(e))
+
+        # Crawl URL using typed request
+        try:
+            result = WebsiteService.crawl_url(api_request)
+        except Exception as e:
+            raise WebsiteCrawlError(str(e))
+        return result, 200
+
+
+@console_ns.route("/website/crawl/status/<string:job_id>")
+class WebsiteCrawlStatusApi(Resource):
+    @console_ns.doc("get_crawl_status")
+    @console_ns.doc(description="Get website crawl status")
+    @console_ns.doc(params={"job_id": "Crawl job ID", "provider": "Crawl provider (firecrawl/watercrawl/jinareader)"})
+    @console_ns.expect(console_ns.models[WebsiteCrawlStatusQuery.__name__])
+    @console_ns.response(200, "Crawl status retrieved successfully")
+    @console_ns.response(404, "Crawl job not found")
+    @console_ns.response(400, "Invalid provider")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, job_id: str):
+        args = WebsiteCrawlStatusQuery.model_validate(request.args.to_dict())
+
+        # Create typed request and validate
+        try:
+            api_request = WebsiteCrawlStatusApiRequest.from_args(args.model_dump(), job_id)
+        except ValueError as e:
+            raise WebsiteCrawlError(str(e))
+
+        # Get crawl status using typed request
+        try:
+            result = WebsiteService.get_crawl_status_typed(api_request)
+        except Exception as e:
+            raise WebsiteCrawlError(str(e))
+        return result, 200

dify_1.11.1/api/controllers/console/datasets/wraps.py

@@ -0,0 +1,40 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import ParamSpec, TypeVar
+
+from controllers.console.datasets.error import PipelineNotFoundError
+from extensions.ext_database import db
+from libs.login import current_account_with_tenant
+from models.dataset import Pipeline
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def get_rag_pipeline(view_func: Callable[P, R]):
+    @wraps(view_func)
+    def decorated_view(*args: P.args, **kwargs: P.kwargs):
+        if not kwargs.get("pipeline_id"):
+            raise ValueError("missing pipeline_id in path parameters")
+
+        _, current_tenant_id = current_account_with_tenant()
+
+        pipeline_id = kwargs.get("pipeline_id")
+        pipeline_id = str(pipeline_id)
+
+        del kwargs["pipeline_id"]
+
+        pipeline = (
+            db.session.query(Pipeline)
+            .where(Pipeline.id == pipeline_id, Pipeline.tenant_id == current_tenant_id)
+            .first()
+        )
+
+        if not pipeline:
+            raise PipelineNotFoundError()
+
+        kwargs["pipeline"] = pipeline
+
+        return view_func(*args, **kwargs)
+
+    return decorated_view

dify_1.11.1/api/controllers/console/error.py

@@ -0,0 +1,109 @@
+from libs.exception import BaseHTTPException
+
+
+class AlreadySetupError(BaseHTTPException):
+    error_code = "already_setup"
+    description = "Dify has been successfully installed. Please refresh the page or return to the dashboard homepage."
+    code = 403
+
+
+class NotSetupError(BaseHTTPException):
+    error_code = "not_setup"
+    description = (
+        "Dify has not been initialized and installed yet. "
+        "Please proceed with the initialization and installation process first."
+    )
+    code = 401
+
+
+class NotInitValidateError(BaseHTTPException):
+    error_code = "not_init_validated"
+    description = "Init validation has not been completed yet. Please proceed with the init validation process first."
+    code = 401
+
+
+class InitValidateFailedError(BaseHTTPException):
+    error_code = "init_validate_failed"
+    description = "Init validation failed. Please check the password and try again."
+    code = 401
+
+
+class AccountNotLinkTenantError(BaseHTTPException):
+    error_code = "account_not_link_tenant"
+    description = "Account not link tenant."
+    code = 403
+
+
+class AlreadyActivateError(BaseHTTPException):
+    error_code = "already_activate"
+    description = "Auth Token is invalid or account already activated, please check again."
+    code = 403
+
+
+class NotAllowedCreateWorkspace(BaseHTTPException):
+    error_code = "not_allowed_create_workspace"
+    description = "Workspace not found, please contact system admin to invite you to join in a workspace."
+    code = 400
+
+
+class WorkspaceMembersLimitExceeded(BaseHTTPException):
+    error_code = "limit_exceeded"
+    description = "Unable to add member because the maximum workspace's member limit was exceeded"
+    code = 400
+
+
+class WorkspacesLimitExceeded(BaseHTTPException):
+    error_code = "limit_exceeded"
+    description = "Unable to create workspace because the maximum workspace limit was exceeded"
+    code = 400
+
+
+class AccountBannedError(BaseHTTPException):
+    error_code = "account_banned"
+    description = "Account is banned."
+    code = 400
+
+
+class AccountNotFound(BaseHTTPException):
+    error_code = "account_not_found"
+    description = "Account not found."
+    code = 400
+
+
+class EmailSendIpLimitError(BaseHTTPException):
+    error_code = "email_send_ip_limit"
+    description = "Too many emails have been sent from this IP address recently. Please try again later."
+    code = 429
+
+
+class UnauthorizedAndForceLogout(BaseHTTPException):
+    error_code = "unauthorized_and_force_logout"
+    description = "Unauthorized and force logout."
+    code = 401
+
+
+class AccountInFreezeError(BaseHTTPException):
+    error_code = "account_in_freeze"
+    code = 400
+    description = (
+        "This email account has been deleted within the past 30 days"
+        "and is temporarily unavailable for new account registration."
+    )
+
+
+class EducationVerifyLimitError(BaseHTTPException):
+    error_code = "education_verify_limit"
+    description = "Rate limit exceeded"
+    code = 429
+
+
+class EducationActivateLimitError(BaseHTTPException):
+    error_code = "education_activate_limit"
+    description = "Rate limit exceeded"
+    code = 429
+
+
+class ComplianceRateLimitError(BaseHTTPException):
+    error_code = "compliance_rate_limit"
+    description = "Rate limit exceeded for downloading compliance report."
+    code = 429

dify_1.11.1/api/controllers/console/explore/audio.py

@@ -0,0 +1,126 @@
+import logging
+
+from flask import request
+from pydantic import BaseModel, Field
+from werkzeug.exceptions import InternalServerError
+
+import services
+from controllers.common.schema import register_schema_model
+from controllers.console.app.error import (
+    AppUnavailableError,
+    AudioTooLargeError,
+    CompletionRequestError,
+    NoAudioUploadedError,
+    ProviderModelCurrentlyNotSupportError,
+    ProviderNotInitializeError,
+    ProviderNotSupportSpeechToTextError,
+    ProviderQuotaExceededError,
+    UnsupportedAudioTypeError,
+)
+from controllers.console.explore.wraps import InstalledAppResource
+from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
+from core.model_runtime.errors.invoke import InvokeError
+from services.audio_service import AudioService
+from services.errors.audio import (
+    AudioTooLargeServiceError,
+    NoAudioUploadedServiceError,
+    ProviderNotSupportSpeechToTextServiceError,
+    UnsupportedAudioTypeServiceError,
+)
+
+from .. import console_ns
+
+logger = logging.getLogger(__name__)
+
+
+class TextToAudioPayload(BaseModel):
+    message_id: str | None = None
+    voice: str | None = None
+    text: str | None = None
+    streaming: bool | None = Field(default=None, description="Enable streaming response")
+
+
+register_schema_model(console_ns, TextToAudioPayload)
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/audio-to-text",
+    endpoint="installed_app_audio",
+)
+class ChatAudioApi(InstalledAppResource):
+    def post(self, installed_app):
+        app_model = installed_app.app
+
+        file = request.files["file"]
+
+        try:
+            response = AudioService.transcript_asr(app_model=app_model, file=file, end_user=None)
+
+            return response
+        except services.errors.app_model_config.AppModelConfigBrokenError:
+            logger.exception("App model config broken.")
+            raise AppUnavailableError()
+        except NoAudioUploadedServiceError:
+            raise NoAudioUploadedError()
+        except AudioTooLargeServiceError as e:
+            raise AudioTooLargeError(str(e))
+        except UnsupportedAudioTypeServiceError:
+            raise UnsupportedAudioTypeError()
+        except ProviderNotSupportSpeechToTextServiceError:
+            raise ProviderNotSupportSpeechToTextError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except ValueError as e:
+            raise e
+        except Exception as e:
+            logger.exception("internal server error.")
+            raise InternalServerError()
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/text-to-audio",
+    endpoint="installed_app_text",
+)
+class ChatTextApi(InstalledAppResource):
+    @console_ns.expect(console_ns.models[TextToAudioPayload.__name__])
+    def post(self, installed_app):
+        app_model = installed_app.app
+        try:
+            payload = TextToAudioPayload.model_validate(console_ns.payload or {})
+
+            message_id = payload.message_id
+            text = payload.text
+            voice = payload.voice
+
+            response = AudioService.transcript_tts(app_model=app_model, text=text, voice=voice, message_id=message_id)
+            return response
+        except services.errors.app_model_config.AppModelConfigBrokenError:
+            logger.exception("App model config broken.")
+            raise AppUnavailableError()
+        except NoAudioUploadedServiceError:
+            raise NoAudioUploadedError()
+        except AudioTooLargeServiceError as e:
+            raise AudioTooLargeError(str(e))
+        except UnsupportedAudioTypeServiceError:
+            raise UnsupportedAudioTypeError()
+        except ProviderNotSupportSpeechToTextServiceError:
+            raise ProviderNotSupportSpeechToTextError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except ValueError as e:
+            raise e
+        except Exception as e:
+            logger.exception("internal server error.")
+            raise InternalServerError()

dify_1.11.1/api/controllers/console/explore/completion.py

@@ -0,0 +1,224 @@
+import logging
+from typing import Any, Literal
+from uuid import UUID
+
+from pydantic import BaseModel, Field, field_validator
+from werkzeug.exceptions import InternalServerError, NotFound
+
+import services
+from controllers.common.schema import register_schema_models
+from controllers.console.app.error import (
+    AppUnavailableError,
+    CompletionRequestError,
+    ConversationCompletedError,
+    ProviderModelCurrentlyNotSupportError,
+    ProviderNotInitializeError,
+    ProviderQuotaExceededError,
+)
+from controllers.console.explore.error import NotChatAppError, NotCompletionAppError
+from controllers.console.explore.wraps import InstalledAppResource
+from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.errors.error import (
+    ModelCurrentlyNotSupportError,
+    ProviderTokenNotInitError,
+    QuotaExceededError,
+)
+from core.model_runtime.errors.invoke import InvokeError
+from extensions.ext_database import db
+from libs import helper
+from libs.datetime_utils import naive_utc_now
+from libs.login import current_user
+from models import Account
+from models.model import AppMode
+from services.app_generate_service import AppGenerateService
+from services.app_task_service import AppTaskService
+from services.errors.llm import InvokeRateLimitError
+
+from .. import console_ns
+
+logger = logging.getLogger(__name__)
+
+
+class CompletionMessagePayload(BaseModel):
+    inputs: dict[str, Any]
+    query: str = ""
+    files: list[dict[str, Any]] | None = None
+    response_mode: Literal["blocking", "streaming"] | None = None
+    retriever_from: str = Field(default="explore_app")
+
+
+class ChatMessagePayload(BaseModel):
+    inputs: dict[str, Any]
+    query: str
+    files: list[dict[str, Any]] | None = None
+    conversation_id: str | None = None
+    parent_message_id: str | None = None
+    retriever_from: str = Field(default="explore_app")
+
+    @field_validator("conversation_id", "parent_message_id", mode="before")
+    @classmethod
+    def normalize_uuid(cls, value: str | UUID | None) -> str | None:
+        """
+        Accept blank IDs and validate UUID format when provided.
+        """
+        if not value:
+            return None
+
+        try:
+            return helper.uuid_value(value)
+        except ValueError as exc:
+            raise ValueError("must be a valid UUID") from exc
+
+
+register_schema_models(console_ns, CompletionMessagePayload, ChatMessagePayload)
+
+
+# define completion api for user
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/completion-messages",
+    endpoint="installed_app_completion",
+)
+class CompletionApi(InstalledAppResource):
+    @console_ns.expect(console_ns.models[CompletionMessagePayload.__name__])
+    def post(self, installed_app):
+        app_model = installed_app.app
+        if app_model.mode != AppMode.COMPLETION:
+            raise NotCompletionAppError()
+
+        payload = CompletionMessagePayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump(exclude_none=True)
+
+        streaming = payload.response_mode == "streaming"
+        args["auto_generate_name"] = False
+
+        installed_app.last_used_at = naive_utc_now()
+        db.session.commit()
+
+        try:
+            if not isinstance(current_user, Account):
+                raise ValueError("current_user must be an Account instance")
+            response = AppGenerateService.generate(
+                app_model=app_model, user=current_user, args=args, invoke_from=InvokeFrom.EXPLORE, streaming=streaming
+            )
+
+            return helper.compact_generate_response(response)
+        except services.errors.conversation.ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+        except services.errors.conversation.ConversationCompletedError:
+            raise ConversationCompletedError()
+        except services.errors.app_model_config.AppModelConfigBrokenError:
+            logger.exception("App model config broken.")
+            raise AppUnavailableError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except ValueError as e:
+            raise e
+        except Exception:
+            logger.exception("internal server error.")
+            raise InternalServerError()
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/completion-messages/<string:task_id>/stop",
+    endpoint="installed_app_stop_completion",
+)
+class CompletionStopApi(InstalledAppResource):
+    def post(self, installed_app, task_id):
+        app_model = installed_app.app
+        if app_model.mode != AppMode.COMPLETION:
+            raise NotCompletionAppError()
+
+        if not isinstance(current_user, Account):
+            raise ValueError("current_user must be an Account instance")
+
+        AppTaskService.stop_task(
+            task_id=task_id,
+            invoke_from=InvokeFrom.EXPLORE,
+            user_id=current_user.id,
+            app_mode=AppMode.value_of(app_model.mode),
+        )
+
+        return {"result": "success"}, 200
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/chat-messages",
+    endpoint="installed_app_chat_completion",
+)
+class ChatApi(InstalledAppResource):
+    @console_ns.expect(console_ns.models[ChatMessagePayload.__name__])
+    def post(self, installed_app):
+        app_model = installed_app.app
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
+            raise NotChatAppError()
+
+        payload = ChatMessagePayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump(exclude_none=True)
+
+        args["auto_generate_name"] = False
+
+        installed_app.last_used_at = naive_utc_now()
+        db.session.commit()
+
+        try:
+            if not isinstance(current_user, Account):
+                raise ValueError("current_user must be an Account instance")
+            response = AppGenerateService.generate(
+                app_model=app_model, user=current_user, args=args, invoke_from=InvokeFrom.EXPLORE, streaming=True
+            )
+
+            return helper.compact_generate_response(response)
+        except services.errors.conversation.ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+        except services.errors.conversation.ConversationCompletedError:
+            raise ConversationCompletedError()
+        except services.errors.app_model_config.AppModelConfigBrokenError:
+            logger.exception("App model config broken.")
+            raise AppUnavailableError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except InvokeRateLimitError as ex:
+            raise InvokeRateLimitHttpError(ex.description)
+        except ValueError as e:
+            raise e
+        except Exception:
+            logger.exception("internal server error.")
+            raise InternalServerError()
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/chat-messages/<string:task_id>/stop",
+    endpoint="installed_app_stop_chat_completion",
+)
+class ChatStopApi(InstalledAppResource):
+    def post(self, installed_app, task_id):
+        app_model = installed_app.app
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
+            raise NotChatAppError()
+
+        if not isinstance(current_user, Account):
+            raise ValueError("current_user must be an Account instance")
+
+        AppTaskService.stop_task(
+            task_id=task_id,
+            invoke_from=InvokeFrom.EXPLORE,
+            user_id=current_user.id,
+            app_mode=app_mode,
+        )
+
+        return {"result": "success"}, 200

dify_1.11.1/api/controllers/console/explore/conversation.py

@@ -0,0 +1,177 @@
+from typing import Any
+from uuid import UUID
+
+from flask import request
+from flask_restx import marshal_with
+from pydantic import BaseModel, Field, model_validator
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import NotFound
+
+from controllers.common.schema import register_schema_models
+from controllers.console.explore.error import NotChatAppError
+from controllers.console.explore.wraps import InstalledAppResource
+from core.app.entities.app_invoke_entities import InvokeFrom
+from extensions.ext_database import db
+from fields.conversation_fields import conversation_infinite_scroll_pagination_fields, simple_conversation_fields
+from libs.login import current_user
+from models import Account
+from models.model import AppMode
+from services.conversation_service import ConversationService
+from services.errors.conversation import ConversationNotExistsError, LastConversationNotExistsError
+from services.web_conversation_service import WebConversationService
+
+from .. import console_ns
+
+
+class ConversationListQuery(BaseModel):
+    last_id: UUID | None = None
+    limit: int = Field(default=20, ge=1, le=100)
+    pinned: bool | None = None
+
+
+class ConversationRenamePayload(BaseModel):
+    name: str | None = None
+    auto_generate: bool = False
+
+    @model_validator(mode="after")
+    def validate_name_requirement(self):
+        if not self.auto_generate:
+            if self.name is None or not self.name.strip():
+                raise ValueError("name is required when auto_generate is false")
+        return self
+
+
+register_schema_models(console_ns, ConversationListQuery, ConversationRenamePayload)
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/conversations",
+    endpoint="installed_app_conversations",
+)
+class ConversationListApi(InstalledAppResource):
+    @marshal_with(conversation_infinite_scroll_pagination_fields)
+    @console_ns.expect(console_ns.models[ConversationListQuery.__name__])
+    def get(self, installed_app):
+        app_model = installed_app.app
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
+            raise NotChatAppError()
+
+        raw_args: dict[str, Any] = {
+            "last_id": request.args.get("last_id"),
+            "limit": request.args.get("limit", default=20, type=int),
+            "pinned": request.args.get("pinned"),
+        }
+        if raw_args["last_id"] is None:
+            raw_args["last_id"] = None
+        pinned_value = raw_args["pinned"]
+        if isinstance(pinned_value, str):
+            raw_args["pinned"] = pinned_value == "true"
+        args = ConversationListQuery.model_validate(raw_args)
+
+        try:
+            if not isinstance(current_user, Account):
+                raise ValueError("current_user must be an Account instance")
+            with Session(db.engine) as session:
+                return WebConversationService.pagination_by_last_id(
+                    session=session,
+                    app_model=app_model,
+                    user=current_user,
+                    last_id=str(args.last_id) if args.last_id else None,
+                    limit=args.limit,
+                    invoke_from=InvokeFrom.EXPLORE,
+                    pinned=args.pinned,
+                )
+        except LastConversationNotExistsError:
+            raise NotFound("Last Conversation Not Exists.")
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/conversations/<uuid:c_id>",
+    endpoint="installed_app_conversation",
+)
+class ConversationApi(InstalledAppResource):
+    def delete(self, installed_app, c_id):
+        app_model = installed_app.app
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
+            raise NotChatAppError()
+
+        conversation_id = str(c_id)
+        try:
+            if not isinstance(current_user, Account):
+                raise ValueError("current_user must be an Account instance")
+            ConversationService.delete(app_model, conversation_id, current_user)
+        except ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+
+        return {"result": "success"}, 204
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/conversations/<uuid:c_id>/name",
+    endpoint="installed_app_conversation_rename",
+)
+class ConversationRenameApi(InstalledAppResource):
+    @marshal_with(simple_conversation_fields)
+    @console_ns.expect(console_ns.models[ConversationRenamePayload.__name__])
+    def post(self, installed_app, c_id):
+        app_model = installed_app.app
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
+            raise NotChatAppError()
+
+        conversation_id = str(c_id)
+
+        payload = ConversationRenamePayload.model_validate(console_ns.payload or {})
+
+        try:
+            if not isinstance(current_user, Account):
+                raise ValueError("current_user must be an Account instance")
+            return ConversationService.rename(
+                app_model, conversation_id, current_user, payload.name, payload.auto_generate
+            )
+        except ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/conversations/<uuid:c_id>/pin",
+    endpoint="installed_app_conversation_pin",
+)
+class ConversationPinApi(InstalledAppResource):
+    def patch(self, installed_app, c_id):
+        app_model = installed_app.app
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
+            raise NotChatAppError()
+
+        conversation_id = str(c_id)
+
+        try:
+            if not isinstance(current_user, Account):
+                raise ValueError("current_user must be an Account instance")
+            WebConversationService.pin(app_model, conversation_id, current_user)
+        except ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+
+        return {"result": "success"}
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/conversations/<uuid:c_id>/unpin",
+    endpoint="installed_app_conversation_unpin",
+)
+class ConversationUnPinApi(InstalledAppResource):
+    def patch(self, installed_app, c_id):
+        app_model = installed_app.app
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
+            raise NotChatAppError()
+
+        conversation_id = str(c_id)
+        if not isinstance(current_user, Account):
+            raise ValueError("current_user must be an Account instance")
+        WebConversationService.unpin(app_model, conversation_id, current_user)
+
+        return {"result": "success"}

dify_1.11.1/api/controllers/console/explore/error.py

@@ -0,0 +1,31 @@
+from libs.exception import BaseHTTPException
+
+
+class NotCompletionAppError(BaseHTTPException):
+    error_code = "not_completion_app"
+    description = "Not Completion App"
+    code = 400
+
+
+class NotChatAppError(BaseHTTPException):
+    error_code = "not_chat_app"
+    description = "App mode is invalid."
+    code = 400
+
+
+class NotWorkflowAppError(BaseHTTPException):
+    error_code = "not_workflow_app"
+    description = "Only support workflow app."
+    code = 400
+
+
+class AppSuggestedQuestionsAfterAnswerDisabledError(BaseHTTPException):
+    error_code = "app_suggested_questions_after_answer_disabled"
+    description = "Function Suggested questions after answer disabled."
+    code = 403
+
+
+class AppAccessDeniedError(BaseHTTPException):
+    error_code = "access_denied"
+    description = "App access denied."
+    code = 403

dify_1.11.1/api/controllers/console/explore/installed_app.py

@@ -0,0 +1,177 @@
+import logging
+from typing import Any
+
+from flask import request
+from flask_restx import Resource, inputs, marshal_with, reqparse
+from sqlalchemy import and_, select
+from werkzeug.exceptions import BadRequest, Forbidden, NotFound
+
+from controllers.console import console_ns
+from controllers.console.explore.wraps import InstalledAppResource
+from controllers.console.wraps import account_initialization_required, cloud_edition_billing_resource_check
+from extensions.ext_database import db
+from fields.installed_app_fields import installed_app_list_fields
+from libs.datetime_utils import naive_utc_now
+from libs.login import current_account_with_tenant, login_required
+from models import App, InstalledApp, RecommendedApp
+from services.account_service import TenantService
+from services.enterprise.enterprise_service import EnterpriseService
+from services.feature_service import FeatureService
+
+logger = logging.getLogger(__name__)
+
+
+@console_ns.route("/installed-apps")
+class InstalledAppsListApi(Resource):
+    @login_required
+    @account_initialization_required
+    @marshal_with(installed_app_list_fields)
+    def get(self):
+        app_id = request.args.get("app_id", default=None, type=str)
+        current_user, current_tenant_id = current_account_with_tenant()
+
+        if app_id:
+            installed_apps = db.session.scalars(
+                select(InstalledApp).where(
+                    and_(InstalledApp.tenant_id == current_tenant_id, InstalledApp.app_id == app_id)
+                )
+            ).all()
+        else:
+            installed_apps = db.session.scalars(
+                select(InstalledApp).where(InstalledApp.tenant_id == current_tenant_id)
+            ).all()
+
+        if current_user.current_tenant is None:
+            raise ValueError("current_user.current_tenant must not be None")
+        current_user.role = TenantService.get_user_role(current_user, current_user.current_tenant)
+        installed_app_list: list[dict[str, Any]] = [
+            {
+                "id": installed_app.id,
+                "app": installed_app.app,
+                "app_owner_tenant_id": installed_app.app_owner_tenant_id,
+                "is_pinned": installed_app.is_pinned,
+                "last_used_at": installed_app.last_used_at,
+                "editable": current_user.role in {"owner", "admin"},
+                "uninstallable": current_tenant_id == installed_app.app_owner_tenant_id,
+            }
+            for installed_app in installed_apps
+            if installed_app.app is not None
+        ]
+
+        # filter out apps that user doesn't have access to
+        if FeatureService.get_system_features().webapp_auth.enabled:
+            user_id = current_user.id
+            app_ids = [installed_app["app"].id for installed_app in installed_app_list]
+            webapp_settings = EnterpriseService.WebAppAuth.batch_get_app_access_mode_by_id(app_ids)
+
+            # Pre-filter out apps without setting or with sso_verified
+            filtered_installed_apps = []
+
+            for installed_app in installed_app_list:
+                app_id = installed_app["app"].id
+                webapp_setting = webapp_settings.get(app_id)
+                if not webapp_setting or webapp_setting.access_mode == "sso_verified":
+                    continue
+                filtered_installed_apps.append(installed_app)
+
+            # Batch permission check
+            app_ids = [installed_app["app"].id for installed_app in filtered_installed_apps]
+            permissions = EnterpriseService.WebAppAuth.batch_is_user_allowed_to_access_webapps(
+                user_id=user_id,
+                app_ids=app_ids,
+            )
+
+            # Keep only allowed apps
+            res = []
+            for installed_app in filtered_installed_apps:
+                app_id = installed_app["app"].id
+                if permissions.get(app_id):
+                    res.append(installed_app)
+
+            installed_app_list = res
+            logger.debug("installed_app_list: %s, user_id: %s", installed_app_list, user_id)
+
+        installed_app_list.sort(
+            key=lambda app: (
+                -app["is_pinned"],
+                app["last_used_at"] is None,
+                -app["last_used_at"].timestamp() if app["last_used_at"] is not None else 0,
+            )
+        )
+
+        return {"installed_apps": installed_app_list}
+
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("apps")
+    def post(self):
+        parser = reqparse.RequestParser().add_argument("app_id", type=str, required=True, help="Invalid app_id")
+        args = parser.parse_args()
+
+        recommended_app = db.session.query(RecommendedApp).where(RecommendedApp.app_id == args["app_id"]).first()
+        if recommended_app is None:
+            raise NotFound("App not found")
+
+        _, current_tenant_id = current_account_with_tenant()
+
+        app = db.session.query(App).where(App.id == args["app_id"]).first()
+
+        if app is None:
+            raise NotFound("App not found")
+
+        if not app.is_public:
+            raise Forbidden("You can't install a non-public app")
+
+        installed_app = (
+            db.session.query(InstalledApp)
+            .where(and_(InstalledApp.app_id == args["app_id"], InstalledApp.tenant_id == current_tenant_id))
+            .first()
+        )
+
+        if installed_app is None:
+            # todo: position
+            recommended_app.install_count += 1
+
+            new_installed_app = InstalledApp(
+                app_id=args["app_id"],
+                tenant_id=current_tenant_id,
+                app_owner_tenant_id=app.tenant_id,
+                is_pinned=False,
+                last_used_at=naive_utc_now(),
+            )
+            db.session.add(new_installed_app)
+            db.session.commit()
+
+        return {"message": "App installed successfully"}
+
+
+@console_ns.route("/installed-apps/<uuid:installed_app_id>")
+class InstalledAppApi(InstalledAppResource):
+    """
+    update and delete an installed app
+    use InstalledAppResource to apply default decorators and get installed_app
+    """
+
+    def delete(self, installed_app):
+        _, current_tenant_id = current_account_with_tenant()
+        if installed_app.app_owner_tenant_id == current_tenant_id:
+            raise BadRequest("You can't uninstall an app owned by the current tenant")
+
+        db.session.delete(installed_app)
+        db.session.commit()
+
+        return {"result": "success", "message": "App uninstalled successfully"}, 204
+
+    def patch(self, installed_app):
+        parser = reqparse.RequestParser().add_argument("is_pinned", type=inputs.boolean)
+        args = parser.parse_args()
+
+        commit_args = False
+        if "is_pinned" in args:
+            installed_app.is_pinned = args["is_pinned"]
+            commit_args = True
+
+        if commit_args:
+            db.session.commit()
+
+        return {"result": "success", "message": "App info updated successfully"}

dify_1.11.1/api/controllers/console/explore/message.py

@@ -0,0 +1,204 @@
+import logging
+from typing import Literal
+from uuid import UUID
+
+from flask import request
+from flask_restx import marshal_with
+from pydantic import BaseModel, Field
+from werkzeug.exceptions import InternalServerError, NotFound
+
+from controllers.common.schema import register_schema_models
+from controllers.console.app.error import (
+    AppMoreLikeThisDisabledError,
+    CompletionRequestError,
+    ProviderModelCurrentlyNotSupportError,
+    ProviderNotInitializeError,
+    ProviderQuotaExceededError,
+)
+from controllers.console.explore.error import (
+    AppSuggestedQuestionsAfterAnswerDisabledError,
+    NotChatAppError,
+    NotCompletionAppError,
+)
+from controllers.console.explore.wraps import InstalledAppResource
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
+from core.model_runtime.errors.invoke import InvokeError
+from fields.message_fields import message_infinite_scroll_pagination_fields
+from libs import helper
+from libs.login import current_account_with_tenant
+from models.model import AppMode
+from services.app_generate_service import AppGenerateService
+from services.errors.app import MoreLikeThisDisabledError
+from services.errors.conversation import ConversationNotExistsError
+from services.errors.message import (
+    FirstMessageNotExistsError,
+    MessageNotExistsError,
+    SuggestedQuestionsAfterAnswerDisabledError,
+)
+from services.message_service import MessageService
+
+from .. import console_ns
+
+logger = logging.getLogger(__name__)
+
+
+class MessageListQuery(BaseModel):
+    conversation_id: UUID
+    first_id: UUID | None = None
+    limit: int = Field(default=20, ge=1, le=100)
+
+
+class MessageFeedbackPayload(BaseModel):
+    rating: Literal["like", "dislike"] | None = None
+    content: str | None = None
+
+
+class MoreLikeThisQuery(BaseModel):
+    response_mode: Literal["blocking", "streaming"]
+
+
+register_schema_models(console_ns, MessageListQuery, MessageFeedbackPayload, MoreLikeThisQuery)
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/messages",
+    endpoint="installed_app_messages",
+)
+class MessageListApi(InstalledAppResource):
+    @marshal_with(message_infinite_scroll_pagination_fields)
+    @console_ns.expect(console_ns.models[MessageListQuery.__name__])
+    def get(self, installed_app):
+        current_user, _ = current_account_with_tenant()
+        app_model = installed_app.app
+
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
+            raise NotChatAppError()
+        args = MessageListQuery.model_validate(request.args.to_dict())
+
+        try:
+            return MessageService.pagination_by_first_id(
+                app_model,
+                current_user,
+                str(args.conversation_id),
+                str(args.first_id) if args.first_id else None,
+                args.limit,
+            )
+        except ConversationNotExistsError:
+            raise NotFound("Conversation Not Exists.")
+        except FirstMessageNotExistsError:
+            raise NotFound("First Message Not Exists.")
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/messages/<uuid:message_id>/feedbacks",
+    endpoint="installed_app_message_feedback",
+)
+class MessageFeedbackApi(InstalledAppResource):
+    @console_ns.expect(console_ns.models[MessageFeedbackPayload.__name__])
+    def post(self, installed_app, message_id):
+        current_user, _ = current_account_with_tenant()
+        app_model = installed_app.app
+
+        message_id = str(message_id)
+
+        payload = MessageFeedbackPayload.model_validate(console_ns.payload or {})
+
+        try:
+            MessageService.create_feedback(
+                app_model=app_model,
+                message_id=message_id,
+                user=current_user,
+                rating=payload.rating,
+                content=payload.content,
+            )
+        except MessageNotExistsError:
+            raise NotFound("Message Not Exists.")
+
+        return {"result": "success"}
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/messages/<uuid:message_id>/more-like-this",
+    endpoint="installed_app_more_like_this",
+)
+class MessageMoreLikeThisApi(InstalledAppResource):
+    @console_ns.expect(console_ns.models[MoreLikeThisQuery.__name__])
+    def get(self, installed_app, message_id):
+        current_user, _ = current_account_with_tenant()
+        app_model = installed_app.app
+        if app_model.mode != "completion":
+            raise NotCompletionAppError()
+
+        message_id = str(message_id)
+
+        args = MoreLikeThisQuery.model_validate(request.args.to_dict())
+
+        streaming = args.response_mode == "streaming"
+
+        try:
+            response = AppGenerateService.generate_more_like_this(
+                app_model=app_model,
+                user=current_user,
+                message_id=message_id,
+                invoke_from=InvokeFrom.EXPLORE,
+                streaming=streaming,
+            )
+            return helper.compact_generate_response(response)
+        except MessageNotExistsError:
+            raise NotFound("Message Not Exists.")
+        except MoreLikeThisDisabledError:
+            raise AppMoreLikeThisDisabledError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except ValueError as e:
+            raise e
+        except Exception:
+            logger.exception("internal server error.")
+            raise InternalServerError()
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/messages/<uuid:message_id>/suggested-questions",
+    endpoint="installed_app_suggested_question",
+)
+class MessageSuggestedQuestionApi(InstalledAppResource):
+    def get(self, installed_app, message_id):
+        current_user, _ = current_account_with_tenant()
+        app_model = installed_app.app
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
+            raise NotChatAppError()
+
+        message_id = str(message_id)
+
+        try:
+            questions = MessageService.get_suggested_questions_after_answer(
+                app_model=app_model, user=current_user, message_id=message_id, invoke_from=InvokeFrom.EXPLORE
+            )
+        except MessageNotExistsError:
+            raise NotFound("Message not found")
+        except ConversationNotExistsError:
+            raise NotFound("Conversation not found")
+        except SuggestedQuestionsAfterAnswerDisabledError:
+            raise AppSuggestedQuestionsAfterAnswerDisabledError()
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except Exception:
+            logger.exception("internal server error.")
+            raise InternalServerError()
+
+        return {"data": questions}

dify_1.11.1/api/controllers/console/explore/parameter.py

@@ -0,0 +1,50 @@
+from flask_restx import marshal_with
+
+from controllers.common import fields
+from controllers.console import console_ns
+from controllers.console.app.error import AppUnavailableError
+from controllers.console.explore.wraps import InstalledAppResource
+from core.app.app_config.common.parameters_mapping import get_parameters_from_feature_dict
+from models.model import AppMode, InstalledApp
+from services.app_service import AppService
+
+
+@console_ns.route("/installed-apps/<uuid:installed_app_id>/parameters", endpoint="installed_app_parameters")
+class AppParameterApi(InstalledAppResource):
+    """Resource for app variables."""
+
+    @marshal_with(fields.parameters_fields)
+    def get(self, installed_app: InstalledApp):
+        """Retrieve app parameters."""
+        app_model = installed_app.app
+
+        if app_model is None:
+            raise AppUnavailableError()
+
+        if app_model.mode in {AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}:
+            workflow = app_model.workflow
+            if workflow is None:
+                raise AppUnavailableError()
+
+            features_dict = workflow.features_dict
+            user_input_form = workflow.user_input_form(to_old_structure=True)
+        else:
+            app_model_config = app_model.app_model_config
+            if app_model_config is None:
+                raise AppUnavailableError()
+
+            features_dict = app_model_config.to_dict()
+
+            user_input_form = features_dict.get("user_input_form", [])
+
+        return get_parameters_from_feature_dict(features_dict=features_dict, user_input_form=user_input_form)
+
+
+@console_ns.route("/installed-apps/<uuid:installed_app_id>/meta", endpoint="installed_app_meta")
+class ExploreAppMetaApi(InstalledAppResource):
+    def get(self, installed_app: InstalledApp):
+        """Get app meta"""
+        app_model = installed_app.app
+        if not app_model:
+            raise ValueError("App not found")
+        return AppService().get_app_meta(app_model)

dify_1.11.1/api/controllers/console/explore/recommended_app.py

@@ -0,0 +1,76 @@
+from flask import request
+from flask_restx import Resource, fields, marshal_with
+from pydantic import BaseModel, Field
+
+from constants.languages import languages
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required
+from libs.helper import AppIconUrlField
+from libs.login import current_user, login_required
+from services.recommended_app_service import RecommendedAppService
+
+app_fields = {
+    "id": fields.String,
+    "name": fields.String,
+    "mode": fields.String,
+    "icon": fields.String,
+    "icon_type": fields.String,
+    "icon_url": AppIconUrlField,
+    "icon_background": fields.String,
+}
+
+recommended_app_fields = {
+    "app": fields.Nested(app_fields, attribute="app"),
+    "app_id": fields.String,
+    "description": fields.String(attribute="description"),
+    "copyright": fields.String,
+    "privacy_policy": fields.String,
+    "custom_disclaimer": fields.String,
+    "category": fields.String,
+    "position": fields.Integer,
+    "is_listed": fields.Boolean,
+}
+
+recommended_app_list_fields = {
+    "recommended_apps": fields.List(fields.Nested(recommended_app_fields)),
+    "categories": fields.List(fields.String),
+}
+
+
+class RecommendedAppsQuery(BaseModel):
+    language: str | None = Field(default=None)
+
+
+console_ns.schema_model(
+    RecommendedAppsQuery.__name__,
+    RecommendedAppsQuery.model_json_schema(ref_template="#/definitions/{model}"),
+)
+
+
+@console_ns.route("/explore/apps")
+class RecommendedAppListApi(Resource):
+    @console_ns.expect(console_ns.models[RecommendedAppsQuery.__name__])
+    @login_required
+    @account_initialization_required
+    @marshal_with(recommended_app_list_fields)
+    def get(self):
+        # language args
+        args = RecommendedAppsQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        language = args.language
+        if language and language in languages:
+            language_prefix = language
+        elif current_user and current_user.interface_language:
+            language_prefix = current_user.interface_language
+        else:
+            language_prefix = languages[0]
+
+        return RecommendedAppService.get_recommended_apps_and_categories(language_prefix)
+
+
+@console_ns.route("/explore/apps/<uuid:app_id>")
+class RecommendedAppApi(Resource):
+    @login_required
+    @account_initialization_required
+    def get(self, app_id):
+        app_id = str(app_id)
+        return RecommendedAppService.get_recommend_app_detail(app_id)

dify_1.11.1/api/controllers/console/explore/saved_message.py

@@ -0,0 +1,101 @@
+from uuid import UUID
+
+from flask import request
+from flask_restx import fields, marshal_with
+from pydantic import BaseModel, Field
+from werkzeug.exceptions import NotFound
+
+from controllers.common.schema import register_schema_models
+from controllers.console import console_ns
+from controllers.console.explore.error import NotCompletionAppError
+from controllers.console.explore.wraps import InstalledAppResource
+from fields.conversation_fields import message_file_fields
+from libs.helper import TimestampField
+from libs.login import current_account_with_tenant
+from services.errors.message import MessageNotExistsError
+from services.saved_message_service import SavedMessageService
+
+
+class SavedMessageListQuery(BaseModel):
+    last_id: UUID | None = None
+    limit: int = Field(default=20, ge=1, le=100)
+
+
+class SavedMessageCreatePayload(BaseModel):
+    message_id: UUID
+
+
+register_schema_models(console_ns, SavedMessageListQuery, SavedMessageCreatePayload)
+
+
+feedback_fields = {"rating": fields.String}
+
+message_fields = {
+    "id": fields.String,
+    "inputs": fields.Raw,
+    "query": fields.String,
+    "answer": fields.String,
+    "message_files": fields.List(fields.Nested(message_file_fields)),
+    "feedback": fields.Nested(feedback_fields, attribute="user_feedback", allow_null=True),
+    "created_at": TimestampField,
+}
+
+
+@console_ns.route("/installed-apps/<uuid:installed_app_id>/saved-messages", endpoint="installed_app_saved_messages")
+class SavedMessageListApi(InstalledAppResource):
+    saved_message_infinite_scroll_pagination_fields = {
+        "limit": fields.Integer,
+        "has_more": fields.Boolean,
+        "data": fields.List(fields.Nested(message_fields)),
+    }
+
+    @marshal_with(saved_message_infinite_scroll_pagination_fields)
+    @console_ns.expect(console_ns.models[SavedMessageListQuery.__name__])
+    def get(self, installed_app):
+        current_user, _ = current_account_with_tenant()
+        app_model = installed_app.app
+        if app_model.mode != "completion":
+            raise NotCompletionAppError()
+
+        args = SavedMessageListQuery.model_validate(request.args.to_dict())
+
+        return SavedMessageService.pagination_by_last_id(
+            app_model,
+            current_user,
+            str(args.last_id) if args.last_id else None,
+            args.limit,
+        )
+
+    @console_ns.expect(console_ns.models[SavedMessageCreatePayload.__name__])
+    def post(self, installed_app):
+        current_user, _ = current_account_with_tenant()
+        app_model = installed_app.app
+        if app_model.mode != "completion":
+            raise NotCompletionAppError()
+
+        payload = SavedMessageCreatePayload.model_validate(console_ns.payload or {})
+
+        try:
+            SavedMessageService.save(app_model, current_user, str(payload.message_id))
+        except MessageNotExistsError:
+            raise NotFound("Message Not Exists.")
+
+        return {"result": "success"}
+
+
+@console_ns.route(
+    "/installed-apps/<uuid:installed_app_id>/saved-messages/<uuid:message_id>", endpoint="installed_app_saved_message"
+)
+class SavedMessageApi(InstalledAppResource):
+    def delete(self, installed_app, message_id):
+        current_user, _ = current_account_with_tenant()
+        app_model = installed_app.app
+
+        message_id = str(message_id)
+
+        if app_model.mode != "completion":
+            raise NotCompletionAppError()
+
+        SavedMessageService.delete(app_model, current_user, message_id)
+
+        return {"result": "success"}, 204

dify_1.11.1/api/controllers/console/explore/workflow.py

@@ -0,0 +1,105 @@
+import logging
+from typing import Any
+
+from pydantic import BaseModel
+from werkzeug.exceptions import InternalServerError
+
+from controllers.common.schema import register_schema_model
+from controllers.console.app.error import (
+    CompletionRequestError,
+    ProviderModelCurrentlyNotSupportError,
+    ProviderNotInitializeError,
+    ProviderQuotaExceededError,
+)
+from controllers.console.explore.error import NotWorkflowAppError
+from controllers.console.explore.wraps import InstalledAppResource
+from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
+from core.app.apps.base_app_queue_manager import AppQueueManager
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.errors.error import (
+    ModelCurrentlyNotSupportError,
+    ProviderTokenNotInitError,
+    QuotaExceededError,
+)
+from core.model_runtime.errors.invoke import InvokeError
+from core.workflow.graph_engine.manager import GraphEngineManager
+from libs import helper
+from libs.login import current_account_with_tenant
+from models.model import AppMode, InstalledApp
+from services.app_generate_service import AppGenerateService
+from services.errors.llm import InvokeRateLimitError
+
+from .. import console_ns
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowRunPayload(BaseModel):
+    inputs: dict[str, Any]
+    files: list[dict[str, Any]] | None = None
+
+
+register_schema_model(console_ns, WorkflowRunPayload)
+
+
+@console_ns.route("/installed-apps/<uuid:installed_app_id>/workflows/run")
+class InstalledAppWorkflowRunApi(InstalledAppResource):
+    @console_ns.expect(console_ns.models[WorkflowRunPayload.__name__])
+    def post(self, installed_app: InstalledApp):
+        """
+        Run workflow
+        """
+        current_user, _ = current_account_with_tenant()
+        app_model = installed_app.app
+        if not app_model:
+            raise NotWorkflowAppError()
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode != AppMode.WORKFLOW:
+            raise NotWorkflowAppError()
+
+        payload = WorkflowRunPayload.model_validate(console_ns.payload or {})
+        args = payload.model_dump(exclude_none=True)
+        try:
+            response = AppGenerateService.generate(
+                app_model=app_model, user=current_user, args=args, invoke_from=InvokeFrom.EXPLORE, streaming=True
+            )
+
+            return helper.compact_generate_response(response)
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+        except InvokeRateLimitError as ex:
+            raise InvokeRateLimitHttpError(ex.description)
+        except ValueError as e:
+            raise e
+        except Exception:
+            logger.exception("internal server error.")
+            raise InternalServerError()
+
+
+@console_ns.route("/installed-apps/<uuid:installed_app_id>/workflows/tasks/<string:task_id>/stop")
+class InstalledAppWorkflowTaskStopApi(InstalledAppResource):
+    def post(self, installed_app: InstalledApp, task_id: str):
+        """
+        Stop workflow task
+        """
+        app_model = installed_app.app
+        if not app_model:
+            raise NotWorkflowAppError()
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode != AppMode.WORKFLOW:
+            raise NotWorkflowAppError()
+
+        # Stop using both mechanisms for backward compatibility
+        # Legacy stop flag mechanism (without user check)
+        AppQueueManager.set_stop_flag_no_user_check(task_id)
+
+        # New graph engine command channel mechanism
+        GraphEngineManager.send_stop_command(task_id)
+
+        return {"result": "success"}

dify_1.11.1/api/controllers/console/explore/wraps.py

@@ -0,0 +1,82 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import Concatenate, ParamSpec, TypeVar
+
+from flask_restx import Resource
+from werkzeug.exceptions import NotFound
+
+from controllers.console.explore.error import AppAccessDeniedError
+from controllers.console.wraps import account_initialization_required
+from extensions.ext_database import db
+from libs.login import current_account_with_tenant, login_required
+from models import InstalledApp
+from services.enterprise.enterprise_service import EnterpriseService
+from services.feature_service import FeatureService
+
+P = ParamSpec("P")
+R = TypeVar("R")
+T = TypeVar("T")
+
+
+def installed_app_required(view: Callable[Concatenate[InstalledApp, P], R] | None = None):
+    def decorator(view: Callable[Concatenate[InstalledApp, P], R]):
+        @wraps(view)
+        def decorated(installed_app_id: str, *args: P.args, **kwargs: P.kwargs):
+            _, current_tenant_id = current_account_with_tenant()
+            installed_app = (
+                db.session.query(InstalledApp)
+                .where(InstalledApp.id == str(installed_app_id), InstalledApp.tenant_id == current_tenant_id)
+                .first()
+            )
+
+            if installed_app is None:
+                raise NotFound("Installed app not found")
+
+            if not installed_app.app:
+                db.session.delete(installed_app)
+                db.session.commit()
+
+                raise NotFound("Installed app not found")
+
+            return view(installed_app, *args, **kwargs)
+
+        return decorated
+
+    if view:
+        return decorator(view)
+    return decorator
+
+
+def user_allowed_to_access_app(view: Callable[Concatenate[InstalledApp, P], R] | None = None):
+    def decorator(view: Callable[Concatenate[InstalledApp, P], R]):
+        @wraps(view)
+        def decorated(installed_app: InstalledApp, *args: P.args, **kwargs: P.kwargs):
+            current_user, _ = current_account_with_tenant()
+            feature = FeatureService.get_system_features()
+            if feature.webapp_auth.enabled:
+                app_id = installed_app.app_id
+                res = EnterpriseService.WebAppAuth.is_user_allowed_to_access_webapp(
+                    user_id=str(current_user.id),
+                    app_id=app_id,
+                )
+                if not res:
+                    raise AppAccessDeniedError()
+
+            return view(installed_app, *args, **kwargs)
+
+        return decorated
+
+    if view:
+        return decorator(view)
+    return decorator
+
+
+class InstalledAppResource(Resource):
+    # must be reversed if there are multiple decorators
+
+    method_decorators = [
+        user_allowed_to_access_app,
+        installed_app_required,
+        account_initialization_required,
+        login_required,
+    ]

dify_1.11.1/api/controllers/console/extension.py

@@ -0,0 +1,153 @@
+from flask_restx import Resource, fields, marshal_with, reqparse
+
+from constants import HIDDEN_VALUE
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, setup_required
+from fields.api_based_extension_fields import api_based_extension_fields
+from libs.login import current_account_with_tenant, login_required
+from models.api_based_extension import APIBasedExtension
+from services.api_based_extension_service import APIBasedExtensionService
+from services.code_based_extension_service import CodeBasedExtensionService
+
+api_based_extension_model = console_ns.model("ApiBasedExtensionModel", api_based_extension_fields)
+
+api_based_extension_list_model = fields.List(fields.Nested(api_based_extension_model))
+
+
+@console_ns.route("/code-based-extension")
+class CodeBasedExtensionAPI(Resource):
+    @console_ns.doc("get_code_based_extension")
+    @console_ns.doc(description="Get code-based extension data by module name")
+    @console_ns.expect(
+        console_ns.parser().add_argument(
+            "module", type=str, required=True, location="args", help="Extension module name"
+        )
+    )
+    @console_ns.response(
+        200,
+        "Success",
+        console_ns.model(
+            "CodeBasedExtensionResponse",
+            {"module": fields.String(description="Module name"), "data": fields.Raw(description="Extension data")},
+        ),
+    )
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        parser = reqparse.RequestParser().add_argument("module", type=str, required=True, location="args")
+        args = parser.parse_args()
+
+        return {"module": args["module"], "data": CodeBasedExtensionService.get_code_based_extension(args["module"])}
+
+
+@console_ns.route("/api-based-extension")
+class APIBasedExtensionAPI(Resource):
+    @console_ns.doc("get_api_based_extensions")
+    @console_ns.doc(description="Get all API-based extensions for current tenant")
+    @console_ns.response(200, "Success", api_based_extension_list_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(api_based_extension_model)
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+        return APIBasedExtensionService.get_all_by_tenant_id(tenant_id)
+
+    @console_ns.doc("create_api_based_extension")
+    @console_ns.doc(description="Create a new API-based extension")
+    @console_ns.expect(
+        console_ns.model(
+            "CreateAPIBasedExtensionRequest",
+            {
+                "name": fields.String(required=True, description="Extension name"),
+                "api_endpoint": fields.String(required=True, description="API endpoint URL"),
+                "api_key": fields.String(required=True, description="API key for authentication"),
+            },
+        )
+    )
+    @console_ns.response(201, "Extension created successfully", api_based_extension_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(api_based_extension_model)
+    def post(self):
+        args = console_ns.payload
+        _, current_tenant_id = current_account_with_tenant()
+
+        extension_data = APIBasedExtension(
+            tenant_id=current_tenant_id,
+            name=args["name"],
+            api_endpoint=args["api_endpoint"],
+            api_key=args["api_key"],
+        )
+
+        return APIBasedExtensionService.save(extension_data)
+
+
+@console_ns.route("/api-based-extension/<uuid:id>")
+class APIBasedExtensionDetailAPI(Resource):
+    @console_ns.doc("get_api_based_extension")
+    @console_ns.doc(description="Get API-based extension by ID")
+    @console_ns.doc(params={"id": "Extension ID"})
+    @console_ns.response(200, "Success", api_based_extension_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(api_based_extension_model)
+    def get(self, id):
+        api_based_extension_id = str(id)
+        _, tenant_id = current_account_with_tenant()
+
+        return APIBasedExtensionService.get_with_tenant_id(tenant_id, api_based_extension_id)
+
+    @console_ns.doc("update_api_based_extension")
+    @console_ns.doc(description="Update API-based extension")
+    @console_ns.doc(params={"id": "Extension ID"})
+    @console_ns.expect(
+        console_ns.model(
+            "UpdateAPIBasedExtensionRequest",
+            {
+                "name": fields.String(required=True, description="Extension name"),
+                "api_endpoint": fields.String(required=True, description="API endpoint URL"),
+                "api_key": fields.String(required=True, description="API key for authentication"),
+            },
+        )
+    )
+    @console_ns.response(200, "Extension updated successfully", api_based_extension_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(api_based_extension_model)
+    def post(self, id):
+        api_based_extension_id = str(id)
+        _, current_tenant_id = current_account_with_tenant()
+
+        extension_data_from_db = APIBasedExtensionService.get_with_tenant_id(current_tenant_id, api_based_extension_id)
+
+        args = console_ns.payload
+
+        extension_data_from_db.name = args["name"]
+        extension_data_from_db.api_endpoint = args["api_endpoint"]
+
+        if args["api_key"] != HIDDEN_VALUE:
+            extension_data_from_db.api_key = args["api_key"]
+
+        return APIBasedExtensionService.save(extension_data_from_db)
+
+    @console_ns.doc("delete_api_based_extension")
+    @console_ns.doc(description="Delete API-based extension")
+    @console_ns.doc(params={"id": "Extension ID"})
+    @console_ns.response(204, "Extension deleted successfully")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def delete(self, id):
+        api_based_extension_id = str(id)
+        _, current_tenant_id = current_account_with_tenant()
+
+        extension_data_from_db = APIBasedExtensionService.get_with_tenant_id(current_tenant_id, api_based_extension_id)
+
+        APIBasedExtensionService.delete(extension_data_from_db)
+
+        return {"result": "success"}, 204

dify_1.11.1/api/controllers/console/feature.py

@@ -0,0 +1,43 @@
+from flask_restx import Resource, fields
+
+from libs.login import current_account_with_tenant, login_required
+from services.feature_service import FeatureService
+
+from . import console_ns
+from .wraps import account_initialization_required, cloud_utm_record, setup_required
+
+
+@console_ns.route("/features")
+class FeatureApi(Resource):
+    @console_ns.doc("get_tenant_features")
+    @console_ns.doc(description="Get feature configuration for current tenant")
+    @console_ns.response(
+        200,
+        "Success",
+        console_ns.model("FeatureResponse", {"features": fields.Raw(description="Feature configuration object")}),
+    )
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_utm_record
+    def get(self):
+        """Get feature configuration for current tenant"""
+        _, current_tenant_id = current_account_with_tenant()
+
+        return FeatureService.get_features(current_tenant_id).model_dump()
+
+
+@console_ns.route("/system-features")
+class SystemFeatureApi(Resource):
+    @console_ns.doc("get_system_features")
+    @console_ns.doc(description="Get system-wide feature configuration")
+    @console_ns.response(
+        200,
+        "Success",
+        console_ns.model(
+            "SystemFeatureResponse", {"features": fields.Raw(description="System feature configuration object")}
+        ),
+    )
+    def get(self):
+        """Get system-wide feature configuration"""
+        return FeatureService.get_system_features().model_dump()

dify_1.11.1/api/controllers/console/files.py

@@ -0,0 +1,113 @@
+from typing import Literal
+
+from flask import request
+from flask_restx import Resource, marshal_with
+from werkzeug.exceptions import Forbidden
+
+import services
+from configs import dify_config
+from constants import DOCUMENT_EXTENSIONS
+from controllers.common.errors import (
+    BlockedFileExtensionError,
+    FilenameNotExistsError,
+    FileTooLargeError,
+    NoFileUploadedError,
+    TooManyFilesError,
+    UnsupportedFileTypeError,
+)
+from controllers.console.wraps import (
+    account_initialization_required,
+    cloud_edition_billing_resource_check,
+    setup_required,
+)
+from extensions.ext_database import db
+from fields.file_fields import file_fields, upload_config_fields
+from libs.login import current_account_with_tenant, login_required
+from services.file_service import FileService
+
+from . import console_ns
+
+PREVIEW_WORDS_LIMIT = 3000
+
+
+@console_ns.route("/files/upload")
+class FileApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(upload_config_fields)
+    def get(self):
+        return {
+            "file_size_limit": dify_config.UPLOAD_FILE_SIZE_LIMIT,
+            "batch_count_limit": dify_config.UPLOAD_FILE_BATCH_LIMIT,
+            "file_upload_limit": dify_config.BATCH_UPLOAD_LIMIT,
+            "image_file_size_limit": dify_config.UPLOAD_IMAGE_FILE_SIZE_LIMIT,
+            "video_file_size_limit": dify_config.UPLOAD_VIDEO_FILE_SIZE_LIMIT,
+            "audio_file_size_limit": dify_config.UPLOAD_AUDIO_FILE_SIZE_LIMIT,
+            "workflow_file_upload_limit": dify_config.WORKFLOW_FILE_UPLOAD_LIMIT,
+            "image_file_batch_limit": dify_config.IMAGE_FILE_BATCH_LIMIT,
+            "single_chunk_attachment_limit": dify_config.SINGLE_CHUNK_ATTACHMENT_LIMIT,
+            "attachment_image_file_size_limit": dify_config.ATTACHMENT_IMAGE_FILE_SIZE_LIMIT,
+        }, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(file_fields)
+    @cloud_edition_billing_resource_check("documents")
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        source_str = request.form.get("source")
+        source: Literal["datasets"] | None = "datasets" if source_str == "datasets" else None
+
+        if "file" not in request.files:
+            raise NoFileUploadedError()
+
+        if len(request.files) > 1:
+            raise TooManyFilesError()
+        file = request.files["file"]
+
+        if not file.filename:
+            raise FilenameNotExistsError
+        if source == "datasets" and not current_user.is_dataset_editor:
+            raise Forbidden()
+
+        if source not in ("datasets", None):
+            source = None
+
+        try:
+            upload_file = FileService(db.engine).upload_file(
+                filename=file.filename,
+                content=file.read(),
+                mimetype=file.mimetype,
+                user=current_user,
+                source=source,
+            )
+        except services.errors.file.FileTooLargeError as file_too_large_error:
+            raise FileTooLargeError(file_too_large_error.description)
+        except services.errors.file.UnsupportedFileTypeError:
+            raise UnsupportedFileTypeError()
+        except services.errors.file.BlockedFileExtensionError as blocked_extension_error:
+            raise BlockedFileExtensionError(blocked_extension_error.description)
+
+        return upload_file, 201
+
+
+@console_ns.route("/files/<uuid:file_id>/preview")
+class FilePreviewApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, file_id):
+        file_id = str(file_id)
+        text = FileService(db.engine).get_file_preview(file_id)
+        return {"content": text}
+
+
+@console_ns.route("/files/support-type")
+class FileSupportTypeApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        return {"allowed_extensions": list(DOCUMENT_EXTENSIONS)}

dify_1.11.1/api/controllers/console/init_validate.py

@@ -0,0 +1,87 @@
+import os
+
+from flask import session
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from configs import dify_config
+from extensions.ext_database import db
+from models.model import DifySetup
+from services.account_service import TenantService
+
+from . import console_ns
+from .error import AlreadySetupError, InitValidateFailedError
+from .wraps import only_edition_self_hosted
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class InitValidatePayload(BaseModel):
+    password: str = Field(..., max_length=30)
+
+
+console_ns.schema_model(
+    InitValidatePayload.__name__,
+    InitValidatePayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+
+@console_ns.route("/init")
+class InitValidateAPI(Resource):
+    @console_ns.doc("get_init_status")
+    @console_ns.doc(description="Get initialization validation status")
+    @console_ns.response(
+        200,
+        "Success",
+        model=console_ns.model(
+            "InitStatusResponse",
+            {"status": fields.String(description="Initialization status", enum=["finished", "not_started"])},
+        ),
+    )
+    def get(self):
+        """Get initialization validation status"""
+        init_status = get_init_validate_status()
+        if init_status:
+            return {"status": "finished"}
+        return {"status": "not_started"}
+
+    @console_ns.doc("validate_init_password")
+    @console_ns.doc(description="Validate initialization password for self-hosted edition")
+    @console_ns.expect(console_ns.models[InitValidatePayload.__name__])
+    @console_ns.response(
+        201,
+        "Success",
+        model=console_ns.model("InitValidateResponse", {"result": fields.String(description="Operation result")}),
+    )
+    @console_ns.response(400, "Already setup or validation failed")
+    @only_edition_self_hosted
+    def post(self):
+        """Validate initialization password"""
+        # is tenant created
+        tenant_count = TenantService.get_tenant_count()
+        if tenant_count > 0:
+            raise AlreadySetupError()
+
+        payload = InitValidatePayload.model_validate(console_ns.payload)
+        input_password = payload.password
+
+        if input_password != os.environ.get("INIT_PASSWORD"):
+            session["is_init_validated"] = False
+            raise InitValidateFailedError()
+
+        session["is_init_validated"] = True
+        return {"result": "success"}, 201
+
+
+def get_init_validate_status():
+    if dify_config.EDITION == "SELF_HOSTED":
+        if os.environ.get("INIT_PASSWORD"):
+            if session.get("is_init_validated"):
+                return True
+
+            with Session(db.engine) as db_session:
+                return db_session.execute(select(DifySetup)).scalar_one_or_none()
+
+    return True

dify_1.11.1/api/controllers/console/ping.py

@@ -0,0 +1,17 @@
+from flask_restx import Resource, fields
+
+from . import console_ns
+
+
+@console_ns.route("/ping")
+class PingApi(Resource):
+    @console_ns.doc("health_check")
+    @console_ns.doc(description="Health check endpoint for connection testing")
+    @console_ns.response(
+        200,
+        "Success",
+        console_ns.model("PingResponse", {"result": fields.String(description="Health check result", example="pong")}),
+    )
+    def get(self):
+        """Health check endpoint for connection testing"""
+        return {"result": "pong"}

dify_1.11.1/api/controllers/console/remote_files.py

@@ -0,0 +1,97 @@
+import urllib.parse
+
+import httpx
+from flask_restx import Resource, marshal_with
+from pydantic import BaseModel, Field
+
+import services
+from controllers.common import helpers
+from controllers.common.errors import (
+    FileTooLargeError,
+    RemoteFileUploadError,
+    UnsupportedFileTypeError,
+)
+from core.file import helpers as file_helpers
+from core.helper import ssrf_proxy
+from extensions.ext_database import db
+from fields.file_fields import file_fields_with_signed_url, remote_file_info_fields
+from libs.login import current_account_with_tenant
+from services.file_service import FileService
+
+from . import console_ns
+
+
+@console_ns.route("/remote-files/<path:url>")
+class RemoteFileInfoApi(Resource):
+    @marshal_with(remote_file_info_fields)
+    def get(self, url):
+        decoded_url = urllib.parse.unquote(url)
+        resp = ssrf_proxy.head(decoded_url)
+        if resp.status_code != httpx.codes.OK:
+            # failed back to get method
+            resp = ssrf_proxy.get(decoded_url, timeout=3)
+        resp.raise_for_status()
+        return {
+            "file_type": resp.headers.get("Content-Type", "application/octet-stream"),
+            "file_length": int(resp.headers.get("Content-Length", 0)),
+        }
+
+
+class RemoteFileUploadPayload(BaseModel):
+    url: str = Field(..., description="URL to fetch")
+
+
+console_ns.schema_model(
+    RemoteFileUploadPayload.__name__,
+    RemoteFileUploadPayload.model_json_schema(ref_template="#/definitions/{model}"),
+)
+
+
+@console_ns.route("/remote-files/upload")
+class RemoteFileUploadApi(Resource):
+    @console_ns.expect(console_ns.models[RemoteFileUploadPayload.__name__])
+    @marshal_with(file_fields_with_signed_url)
+    def post(self):
+        args = RemoteFileUploadPayload.model_validate(console_ns.payload)
+        url = args.url
+
+        try:
+            resp = ssrf_proxy.head(url=url)
+            if resp.status_code != httpx.codes.OK:
+                resp = ssrf_proxy.get(url=url, timeout=3, follow_redirects=True)
+            if resp.status_code != httpx.codes.OK:
+                raise RemoteFileUploadError(f"Failed to fetch file from {url}: {resp.text}")
+        except httpx.RequestError as e:
+            raise RemoteFileUploadError(f"Failed to fetch file from {url}: {str(e)}")
+
+        file_info = helpers.guess_file_info_from_response(resp)
+
+        if not FileService.is_file_size_within_limit(extension=file_info.extension, file_size=file_info.size):
+            raise FileTooLargeError
+
+        content = resp.content if resp.request.method == "GET" else ssrf_proxy.get(url).content
+
+        try:
+            user, _ = current_account_with_tenant()
+            upload_file = FileService(db.engine).upload_file(
+                filename=file_info.filename,
+                content=content,
+                mimetype=file_info.mimetype,
+                user=user,
+                source_url=url,
+            )
+        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,
+            "name": upload_file.name,
+            "size": upload_file.size,
+            "extension": upload_file.extension,
+            "url": file_helpers.get_signed_file_url(upload_file_id=upload_file.id),
+            "mime_type": upload_file.mime_type,
+            "created_by": upload_file.created_by,
+            "created_at": upload_file.created_at,
+        }, 201

dify_1.11.1/api/controllers/console/setup.py

@@ -0,0 +1,104 @@
+from flask import request
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field, field_validator
+
+from configs import dify_config
+from libs.helper import EmailStr, extract_remote_ip
+from libs.password import valid_password
+from models.model import DifySetup, db
+from services.account_service import RegisterService, TenantService
+
+from . import console_ns
+from .error import AlreadySetupError, NotInitValidateError
+from .init_validate import get_init_validate_status
+from .wraps import only_edition_self_hosted
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class SetupRequestPayload(BaseModel):
+    email: EmailStr = Field(..., description="Admin email address")
+    name: str = Field(..., max_length=30, description="Admin name (max 30 characters)")
+    password: str = Field(..., description="Admin password")
+    language: str | None = Field(default=None, description="Admin language")
+
+    @field_validator("password")
+    @classmethod
+    def validate_password(cls, value: str) -> str:
+        return valid_password(value)
+
+
+console_ns.schema_model(
+    SetupRequestPayload.__name__,
+    SetupRequestPayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)
+
+
+@console_ns.route("/setup")
+class SetupApi(Resource):
+    @console_ns.doc("get_setup_status")
+    @console_ns.doc(description="Get system setup status")
+    @console_ns.response(
+        200,
+        "Success",
+        console_ns.model(
+            "SetupStatusResponse",
+            {
+                "step": fields.String(description="Setup step status", enum=["not_started", "finished"]),
+                "setup_at": fields.String(description="Setup completion time (ISO format)", required=False),
+            },
+        ),
+    )
+    def get(self):
+        """Get system setup status"""
+        if dify_config.EDITION == "SELF_HOSTED":
+            setup_status = get_setup_status()
+            # Check if setup_status is a DifySetup object rather than a bool
+            if setup_status and not isinstance(setup_status, bool):
+                return {"step": "finished", "setup_at": setup_status.setup_at.isoformat()}
+            elif setup_status:
+                return {"step": "finished"}
+            return {"step": "not_started"}
+        return {"step": "finished"}
+
+    @console_ns.doc("setup_system")
+    @console_ns.doc(description="Initialize system setup with admin account")
+    @console_ns.expect(console_ns.models[SetupRequestPayload.__name__])
+    @console_ns.response(
+        201, "Success", console_ns.model("SetupResponse", {"result": fields.String(description="Setup result")})
+    )
+    @console_ns.response(400, "Already setup or validation failed")
+    @only_edition_self_hosted
+    def post(self):
+        """Initialize system setup with admin account"""
+        # is set up
+        if get_setup_status():
+            raise AlreadySetupError()
+
+        # is tenant created
+        tenant_count = TenantService.get_tenant_count()
+        if tenant_count > 0:
+            raise AlreadySetupError()
+
+        if not get_init_validate_status():
+            raise NotInitValidateError()
+
+        args = SetupRequestPayload.model_validate(console_ns.payload)
+
+        # setup
+        RegisterService.setup(
+            email=args.email,
+            name=args.name,
+            password=args.password,
+            ip_address=extract_remote_ip(request),
+            language=args.language,
+        )
+
+        return {"result": "success"}, 201
+
+
+def get_setup_status():
+    if dify_config.EDITION == "SELF_HOSTED":
+        return db.session.query(DifySetup).first()
+    else:
+        return True

dify_1.11.1/api/controllers/console/spec.py

@@ -0,0 +1,34 @@
+import logging
+
+from flask_restx import Resource
+
+from controllers.console.wraps import (
+    account_initialization_required,
+    setup_required,
+)
+from core.schemas.schema_manager import SchemaManager
+from libs.login import login_required
+
+from . import console_ns
+
+logger = logging.getLogger(__name__)
+
+
+@console_ns.route("/spec/schema-definitions")
+class SpecSchemaDefinitionsApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        """
+        Get system JSON Schema definitions specification
+        Used for frontend component type mapping
+        """
+        try:
+            schema_manager = SchemaManager()
+            schema_definitions = schema_manager.get_all_schema_definitions()
+            return schema_definitions, 200
+        except Exception:
+            logger.exception("Failed to get schema definitions from local registry")
+            # Return empty array as fallback
+            return [], 200

dify_1.11.1/api/controllers/console/tag/tags.py

@@ -0,0 +1,152 @@
+from flask import request
+from flask_restx import Resource, marshal_with, reqparse
+from werkzeug.exceptions import Forbidden
+
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
+from fields.tag_fields import dataset_tag_fields
+from libs.login import current_account_with_tenant, login_required
+from models.model import Tag
+from services.tag_service import TagService
+
+
+def _validate_name(name):
+    if not name or len(name) < 1 or len(name) > 50:
+        raise ValueError("Name must be between 1 to 50 characters.")
+    return name
+
+
+parser_tags = (
+    reqparse.RequestParser()
+    .add_argument(
+        "name",
+        nullable=False,
+        required=True,
+        help="Name must be between 1 to 50 characters.",
+        type=_validate_name,
+    )
+    .add_argument("type", type=str, location="json", choices=Tag.TAG_TYPE_LIST, nullable=True, help="Invalid tag type.")
+)
+
+
+@console_ns.route("/tags")
+class TagListApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(dataset_tag_fields)
+    def get(self):
+        _, current_tenant_id = current_account_with_tenant()
+        tag_type = request.args.get("type", type=str, default="")
+        keyword = request.args.get("keyword", default=None, type=str)
+        tags = TagService.get_tags(tag_type, current_tenant_id, keyword)
+
+        return tags, 200
+
+    @console_ns.expect(parser_tags)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        # The role of the current user in the ta table must be admin, owner, or editor
+        if not (current_user.has_edit_permission or current_user.is_dataset_editor):
+            raise Forbidden()
+
+        args = parser_tags.parse_args()
+        tag = TagService.save_tags(args)
+
+        response = {"id": tag.id, "name": tag.name, "type": tag.type, "binding_count": 0}
+
+        return response, 200
+
+
+parser_tag_id = reqparse.RequestParser().add_argument(
+    "name", nullable=False, required=True, help="Name must be between 1 to 50 characters.", type=_validate_name
+)
+
+
+@console_ns.route("/tags/<uuid:tag_id>")
+class TagUpdateDeleteApi(Resource):
+    @console_ns.expect(parser_tag_id)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def patch(self, tag_id):
+        current_user, _ = current_account_with_tenant()
+        tag_id = str(tag_id)
+        # The role of the current user in the ta table must be admin, owner, or editor
+        if not (current_user.has_edit_permission or current_user.is_dataset_editor):
+            raise Forbidden()
+
+        args = parser_tag_id.parse_args()
+        tag = TagService.update_tags(args, tag_id)
+
+        binding_count = TagService.get_tag_binding_count(tag_id)
+
+        response = {"id": tag.id, "name": tag.name, "type": tag.type, "binding_count": binding_count}
+
+        return response, 200
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @edit_permission_required
+    def delete(self, tag_id):
+        tag_id = str(tag_id)
+
+        TagService.delete_tag(tag_id)
+
+        return 204
+
+
+parser_create = (
+    reqparse.RequestParser()
+    .add_argument("tag_ids", type=list, nullable=False, required=True, location="json", help="Tag IDs is required.")
+    .add_argument("target_id", type=str, nullable=False, required=True, location="json", help="Target ID is required.")
+    .add_argument("type", type=str, location="json", choices=Tag.TAG_TYPE_LIST, nullable=True, help="Invalid tag type.")
+)
+
+
+@console_ns.route("/tag-bindings/create")
+class TagBindingCreateApi(Resource):
+    @console_ns.expect(parser_create)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        # The role of the current user in the ta table must be admin, owner, editor, or dataset_operator
+        if not (current_user.has_edit_permission or current_user.is_dataset_editor):
+            raise Forbidden()
+
+        args = parser_create.parse_args()
+        TagService.save_tag_binding(args)
+
+        return {"result": "success"}, 200
+
+
+parser_remove = (
+    reqparse.RequestParser()
+    .add_argument("tag_id", type=str, nullable=False, required=True, help="Tag ID is required.")
+    .add_argument("target_id", type=str, nullable=False, required=True, help="Target ID is required.")
+    .add_argument("type", type=str, location="json", choices=Tag.TAG_TYPE_LIST, nullable=True, help="Invalid tag type.")
+)
+
+
+@console_ns.route("/tag-bindings/remove")
+class TagBindingDeleteApi(Resource):
+    @console_ns.expect(parser_remove)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        # The role of the current user in the ta table must be admin, owner, editor, or dataset_operator
+        if not (current_user.has_edit_permission or current_user.is_dataset_editor):
+            raise Forbidden()
+
+        args = parser_remove.parse_args()
+        TagService.delete_tag_binding(args)
+
+        return {"result": "success"}, 200

dify_1.11.1/api/controllers/console/version.py

@@ -0,0 +1,94 @@
+import json
+import logging
+
+import httpx
+from flask import request
+from flask_restx import Resource, fields
+from packaging import version
+from pydantic import BaseModel, Field
+
+from configs import dify_config
+
+from . import console_ns
+
+logger = logging.getLogger(__name__)
+
+
+class VersionQuery(BaseModel):
+    current_version: str = Field(..., description="Current application version")
+
+
+console_ns.schema_model(
+    VersionQuery.__name__,
+    VersionQuery.model_json_schema(ref_template="#/definitions/{model}"),
+)
+
+
+@console_ns.route("/version")
+class VersionApi(Resource):
+    @console_ns.doc("check_version_update")
+    @console_ns.doc(description="Check for application version updates")
+    @console_ns.expect(console_ns.models[VersionQuery.__name__])
+    @console_ns.response(
+        200,
+        "Success",
+        console_ns.model(
+            "VersionResponse",
+            {
+                "version": fields.String(description="Latest version number"),
+                "release_date": fields.String(description="Release date of latest version"),
+                "release_notes": fields.String(description="Release notes for latest version"),
+                "can_auto_update": fields.Boolean(description="Whether auto-update is supported"),
+                "features": fields.Raw(description="Feature flags and capabilities"),
+            },
+        ),
+    )
+    def get(self):
+        """Check for application version updates"""
+        args = VersionQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        check_update_url = dify_config.CHECK_UPDATE_URL
+
+        result = {
+            "version": dify_config.project.version,
+            "release_date": "",
+            "release_notes": "",
+            "can_auto_update": False,
+            "features": {
+                "can_replace_logo": dify_config.CAN_REPLACE_LOGO,
+                "model_load_balancing_enabled": dify_config.MODEL_LB_ENABLED,
+            },
+        }
+
+        if not check_update_url:
+            return result
+
+        try:
+            response = httpx.get(
+                check_update_url,
+                params={"current_version": args.current_version},
+                timeout=httpx.Timeout(timeout=10.0, connect=3.0),
+            )
+        except Exception as error:
+            logger.warning("Check update version error: %s.", str(error))
+            result["version"] = args.current_version
+            return result
+
+        content = json.loads(response.content)
+        if _has_new_version(latest_version=content["version"], current_version=f"{args.current_version}"):
+            result["version"] = content["version"]
+            result["release_date"] = content["releaseDate"]
+            result["release_notes"] = content["releaseNotes"]
+            result["can_auto_update"] = content["canAutoUpdate"]
+        return result
+
+
+def _has_new_version(*, latest_version: str, current_version: str) -> bool:
+    try:
+        latest = version.parse(latest_version)
+        current = version.parse(current_version)
+
+        # Compare versions
+        return latest > current
+    except version.InvalidVersion:
+        logger.warning("Invalid version format: latest=%s, current=%s", latest_version, current_version)
+        return False

dify_1.11.1/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_1.11.1/api/controllers/console/workspace/account.py

@@ -0,0 +1,650 @@
+from datetime import datetime
+from typing import Literal
+
+import pytz
+from flask import request
+from flask_restx import Resource, fields, marshal_with
+from pydantic import BaseModel, Field, field_validator, model_validator
+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 EmailStr, TimestampField, 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
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class AccountInitPayload(BaseModel):
+    interface_language: str
+    timezone: str
+    invitation_code: str | None = None
+
+    @field_validator("interface_language")
+    @classmethod
+    def validate_language(cls, value: str) -> str:
+        return supported_language(value)
+
+    @field_validator("timezone")
+    @classmethod
+    def validate_timezone(cls, value: str) -> str:
+        return timezone(value)
+
+
+class AccountNamePayload(BaseModel):
+    name: str = Field(min_length=3, max_length=30)
+
+
+class AccountAvatarPayload(BaseModel):
+    avatar: str
+
+
+class AccountInterfaceLanguagePayload(BaseModel):
+    interface_language: str
+
+    @field_validator("interface_language")
+    @classmethod
+    def validate_language(cls, value: str) -> str:
+        return supported_language(value)
+
+
+class AccountInterfaceThemePayload(BaseModel):
+    interface_theme: Literal["light", "dark"]
+
+
+class AccountTimezonePayload(BaseModel):
+    timezone: str
+
+    @field_validator("timezone")
+    @classmethod
+    def validate_timezone(cls, value: str) -> str:
+        return timezone(value)
+
+
+class AccountPasswordPayload(BaseModel):
+    password: str | None = None
+    new_password: str
+    repeat_new_password: str
+
+    @model_validator(mode="after")
+    def check_passwords_match(self) -> "AccountPasswordPayload":
+        if self.new_password != self.repeat_new_password:
+            raise RepeatPasswordNotMatchError()
+        return self
+
+
+class AccountDeletePayload(BaseModel):
+    token: str
+    code: str
+
+
+class AccountDeletionFeedbackPayload(BaseModel):
+    email: EmailStr
+    feedback: str
+
+
+class EducationActivatePayload(BaseModel):
+    token: str
+    institution: str
+    role: str
+
+
+class EducationAutocompleteQuery(BaseModel):
+    keywords: str
+    page: int = 0
+    limit: int = 20
+
+
+class ChangeEmailSendPayload(BaseModel):
+    email: EmailStr
+    language: str | None = None
+    phase: str | None = None
+    token: str | None = None
+
+
+class ChangeEmailValidityPayload(BaseModel):
+    email: EmailStr
+    code: str
+    token: str
+
+
+class ChangeEmailResetPayload(BaseModel):
+    new_email: EmailStr
+    token: str
+
+
+class CheckEmailUniquePayload(BaseModel):
+    email: EmailStr
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(AccountInitPayload)
+reg(AccountNamePayload)
+reg(AccountAvatarPayload)
+reg(AccountInterfaceLanguagePayload)
+reg(AccountInterfaceThemePayload)
+reg(AccountTimezonePayload)
+reg(AccountPasswordPayload)
+reg(AccountDeletePayload)
+reg(AccountDeletionFeedbackPayload)
+reg(EducationActivatePayload)
+reg(EducationAutocompleteQuery)
+reg(ChangeEmailSendPayload)
+reg(ChangeEmailValidityPayload)
+reg(ChangeEmailResetPayload)
+reg(CheckEmailUniquePayload)
+
+
+@console_ns.route("/account/init")
+class AccountInitApi(Resource):
+    @console_ns.expect(console_ns.models[AccountInitPayload.__name__])
+    @setup_required
+    @login_required
+    def post(self):
+        account, _ = current_account_with_tenant()
+
+        if account.status == "active":
+            raise AccountAlreadyInitedError()
+
+        payload = console_ns.payload or {}
+        args = AccountInitPayload.model_validate(payload)
+
+        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
+
+
+@console_ns.route("/account/name")
+class AccountNameApi(Resource):
+    @console_ns.expect(console_ns.models[AccountNamePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = AccountNamePayload.model_validate(payload)
+        updated_account = AccountService.update_account(current_user, name=args.name)
+
+        return updated_account
+
+
+@console_ns.route("/account/avatar")
+class AccountAvatarApi(Resource):
+    @console_ns.expect(console_ns.models[AccountAvatarPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = AccountAvatarPayload.model_validate(payload)
+
+        updated_account = AccountService.update_account(current_user, avatar=args.avatar)
+
+        return updated_account
+
+
+@console_ns.route("/account/interface-language")
+class AccountInterfaceLanguageApi(Resource):
+    @console_ns.expect(console_ns.models[AccountInterfaceLanguagePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = AccountInterfaceLanguagePayload.model_validate(payload)
+
+        updated_account = AccountService.update_account(current_user, interface_language=args.interface_language)
+
+        return updated_account
+
+
+@console_ns.route("/account/interface-theme")
+class AccountInterfaceThemeApi(Resource):
+    @console_ns.expect(console_ns.models[AccountInterfaceThemePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = AccountInterfaceThemePayload.model_validate(payload)
+
+        updated_account = AccountService.update_account(current_user, interface_theme=args.interface_theme)
+
+        return updated_account
+
+
+@console_ns.route("/account/timezone")
+class AccountTimezoneApi(Resource):
+    @console_ns.expect(console_ns.models[AccountTimezonePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = AccountTimezonePayload.model_validate(payload)
+
+        updated_account = AccountService.update_account(current_user, timezone=args.timezone)
+
+        return updated_account
+
+
+@console_ns.route("/account/password")
+class AccountPasswordApi(Resource):
+    @console_ns.expect(console_ns.models[AccountPasswordPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = AccountPasswordPayload.model_validate(payload)
+
+        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}
+
+
+@console_ns.route("/account/delete")
+class AccountDeleteApi(Resource):
+    @console_ns.expect(console_ns.models[AccountDeletePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        account, _ = current_account_with_tenant()
+
+        payload = console_ns.payload or {}
+        args = AccountDeletePayload.model_validate(payload)
+
+        if not AccountService.verify_account_deletion_code(args.token, args.code):
+            raise InvalidAccountDeletionCodeError()
+
+        AccountService.delete_account(account)
+
+        return {"result": "success"}
+
+
+@console_ns.route("/account/delete/feedback")
+class AccountDeleteUpdateFeedbackApi(Resource):
+    @console_ns.expect(console_ns.models[AccountDeletionFeedbackPayload.__name__])
+    @setup_required
+    def post(self):
+        payload = console_ns.payload or {}
+        args = AccountDeletionFeedbackPayload.model_validate(payload)
+
+        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)
+
+
+@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(console_ns.models[EducationActivatePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @only_edition_cloud
+    @cloud_edition_billing_enabled
+    def post(self):
+        account, _ = current_account_with_tenant()
+
+        payload = console_ns.payload or {}
+        args = EducationActivatePayload.model_validate(payload)
+
+        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
+
+
+@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(console_ns.models[EducationAutocompleteQuery.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @only_edition_cloud
+    @cloud_edition_billing_enabled
+    @marshal_with(data_fields)
+    def get(self):
+        payload = request.args.to_dict(flat=True)  # type: ignore
+        args = EducationAutocompleteQuery.model_validate(payload)
+
+        return BillingService.EducationIdentity.autocomplete(args.keywords, args.page, args.limit)
+
+
+@console_ns.route("/account/change-email")
+class ChangeEmailSendEmailApi(Resource):
+    @console_ns.expect(console_ns.models[ChangeEmailSendPayload.__name__])
+    @enable_change_email
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = ChangeEmailSendPayload.model_validate(payload)
+
+        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}
+
+
+@console_ns.route("/account/change-email/validity")
+class ChangeEmailCheckApi(Resource):
+    @console_ns.expect(console_ns.models[ChangeEmailValidityPayload.__name__])
+    @enable_change_email
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        payload = console_ns.payload or {}
+        args = ChangeEmailValidityPayload.model_validate(payload)
+
+        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}
+
+
+@console_ns.route("/account/change-email/reset")
+class ChangeEmailResetApi(Resource):
+    @console_ns.expect(console_ns.models[ChangeEmailResetPayload.__name__])
+    @enable_change_email
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(account_fields)
+    def post(self):
+        payload = console_ns.payload or {}
+        args = ChangeEmailResetPayload.model_validate(payload)
+
+        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
+
+
+@console_ns.route("/account/change-email/check-email-unique")
+class CheckEmailUnique(Resource):
+    @console_ns.expect(console_ns.models[CheckEmailUniquePayload.__name__])
+    @setup_required
+    def post(self):
+        payload = console_ns.payload or {}
+        args = CheckEmailUniquePayload.model_validate(payload)
+        if AccountService.is_account_in_freeze(args.email):
+            raise AccountInFreezeError()
+        if not AccountService.check_email_unique(args.email):
+            raise EmailAlreadyInUseError()
+        return {"result": "success"}

dify_1.11.1/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_1.11.1/api/controllers/console/workspace/endpoint.py

@@ -0,0 +1,267 @@
+from typing import Any
+
+from flask import request
+from flask_restx import Resource, fields
+from pydantic import BaseModel, Field
+
+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
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class EndpointCreatePayload(BaseModel):
+    plugin_unique_identifier: str
+    settings: dict[str, Any]
+    name: str = Field(min_length=1)
+
+
+class EndpointIdPayload(BaseModel):
+    endpoint_id: str
+
+
+class EndpointUpdatePayload(EndpointIdPayload):
+    settings: dict[str, Any]
+    name: str = Field(min_length=1)
+
+
+class EndpointListQuery(BaseModel):
+    page: int = Field(ge=1)
+    page_size: int = Field(gt=0)
+
+
+class EndpointListForPluginQuery(EndpointListQuery):
+    plugin_id: str
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(EndpointCreatePayload)
+reg(EndpointIdPayload)
+reg(EndpointUpdatePayload)
+reg(EndpointListQuery)
+reg(EndpointListForPluginQuery)
+
+
+@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.models[EndpointCreatePayload.__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()
+
+        args = EndpointCreatePayload.model_validate(console_ns.payload)
+
+        try:
+            return {
+                "success": EndpointService.create_endpoint(
+                    tenant_id=tenant_id,
+                    user_id=user.id,
+                    plugin_unique_identifier=args.plugin_unique_identifier,
+                    name=args.name,
+                    settings=args.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.models[EndpointListQuery.__name__])
+    @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()
+
+        args = EndpointListQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        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.models[EndpointListForPluginQuery.__name__])
+    @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()
+
+        args = EndpointListForPluginQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        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.models[EndpointIdPayload.__name__])
+    @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()
+
+        args = EndpointIdPayload.model_validate(console_ns.payload)
+
+        return {
+            "success": EndpointService.delete_endpoint(
+                tenant_id=tenant_id, user_id=user.id, endpoint_id=args.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.models[EndpointUpdatePayload.__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()
+
+        args = EndpointUpdatePayload.model_validate(console_ns.payload)
+
+        return {
+            "success": EndpointService.update_endpoint(
+                tenant_id=tenant_id,
+                user_id=user.id,
+                endpoint_id=args.endpoint_id,
+                name=args.name,
+                settings=args.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.models[EndpointIdPayload.__name__])
+    @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()
+
+        args = EndpointIdPayload.model_validate(console_ns.payload)
+
+        return {
+            "success": EndpointService.enable_endpoint(
+                tenant_id=tenant_id, user_id=user.id, endpoint_id=args.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.models[EndpointIdPayload.__name__])
+    @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()
+
+        args = EndpointIdPayload.model_validate(console_ns.payload)
+
+        return {
+            "success": EndpointService.disable_endpoint(
+                tenant_id=tenant_id, user_id=user.id, endpoint_id=args.endpoint_id
+            )
+        }

dify_1.11.1/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_1.11.1/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_1.11.1/api/controllers/console/workspace/members.py

@@ -0,0 +1,371 @@
+from urllib import parse
+
+from flask import abort, request
+from flask_restx import Resource, marshal_with
+from pydantic import BaseModel, Field
+
+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
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class MemberInvitePayload(BaseModel):
+    emails: list[str] = Field(default_factory=list)
+    role: TenantAccountRole
+    language: str | None = None
+
+
+class MemberRoleUpdatePayload(BaseModel):
+    role: str
+
+
+class OwnerTransferEmailPayload(BaseModel):
+    language: str | None = None
+
+
+class OwnerTransferCheckPayload(BaseModel):
+    code: str
+    token: str
+
+
+class OwnerTransferPayload(BaseModel):
+    token: str
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(MemberInvitePayload)
+reg(MemberRoleUpdatePayload)
+reg(OwnerTransferEmailPayload)
+reg(OwnerTransferCheckPayload)
+reg(OwnerTransferPayload)
+
+
+@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
+
+
+@console_ns.route("/workspaces/current/members/invite-email")
+class MemberInviteEmailApi(Resource):
+    """Invite a new member by email."""
+
+    @console_ns.expect(console_ns.models[MemberInvitePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("members")
+    def post(self):
+        payload = console_ns.payload or {}
+        args = MemberInvitePayload.model_validate(payload)
+
+        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
+
+
+@console_ns.route("/workspaces/current/members/<uuid:member_id>/update-role")
+class MemberUpdateRoleApi(Resource):
+    """Update member role."""
+
+    @console_ns.expect(console_ns.models[MemberRoleUpdatePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def put(self, member_id):
+        payload = console_ns.payload or {}
+        args = MemberRoleUpdatePayload.model_validate(payload)
+        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
+
+
+@console_ns.route("/workspaces/current/members/send-owner-transfer-confirm-email")
+class SendOwnerTransferEmailApi(Resource):
+    """Send owner transfer email."""
+
+    @console_ns.expect(console_ns.models[OwnerTransferEmailPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @is_allow_transfer_owner
+    def post(self):
+        payload = console_ns.payload or {}
+        args = OwnerTransferEmailPayload.model_validate(payload)
+        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}
+
+
+@console_ns.route("/workspaces/current/members/owner-transfer-check")
+class OwnerTransferCheckApi(Resource):
+    @console_ns.expect(console_ns.models[OwnerTransferCheckPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @is_allow_transfer_owner
+    def post(self):
+        payload = console_ns.payload or {}
+        args = OwnerTransferCheckPayload.model_validate(payload)
+        # 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}
+
+
+@console_ns.route("/workspaces/current/members/<uuid:member_id>/owner-transfer")
+class OwnerTransfer(Resource):
+    @console_ns.expect(console_ns.models[OwnerTransferPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @is_allow_transfer_owner
+    def post(self, member_id):
+        payload = console_ns.payload or {}
+        args = OwnerTransferPayload.model_validate(payload)
+
+        # 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_1.11.1/api/controllers/console/workspace/model_providers.py

@@ -0,0 +1,312 @@
+import io
+from typing import Any, Literal
+
+from flask import request, send_file
+from flask_restx import Resource
+from pydantic import BaseModel, Field, field_validator
+
+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 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
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class ParserModelList(BaseModel):
+    model_type: ModelType | None = None
+
+
+class ParserCredentialId(BaseModel):
+    credential_id: str | None = None
+
+    @field_validator("credential_id")
+    @classmethod
+    def validate_optional_credential_id(cls, value: str | None) -> str | None:
+        if value is None:
+            return value
+        return uuid_value(value)
+
+
+class ParserCredentialCreate(BaseModel):
+    credentials: dict[str, Any]
+    name: str | None = Field(default=None, max_length=30)
+
+
+class ParserCredentialUpdate(BaseModel):
+    credential_id: str
+    credentials: dict[str, Any]
+    name: str | None = Field(default=None, max_length=30)
+
+    @field_validator("credential_id")
+    @classmethod
+    def validate_update_credential_id(cls, value: str) -> str:
+        return uuid_value(value)
+
+
+class ParserCredentialDelete(BaseModel):
+    credential_id: str
+
+    @field_validator("credential_id")
+    @classmethod
+    def validate_delete_credential_id(cls, value: str) -> str:
+        return uuid_value(value)
+
+
+class ParserCredentialSwitch(BaseModel):
+    credential_id: str
+
+    @field_validator("credential_id")
+    @classmethod
+    def validate_switch_credential_id(cls, value: str) -> str:
+        return uuid_value(value)
+
+
+class ParserCredentialValidate(BaseModel):
+    credentials: dict[str, Any]
+
+
+class ParserPreferredProviderType(BaseModel):
+    preferred_provider_type: Literal["system", "custom"]
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(ParserModelList)
+reg(ParserCredentialId)
+reg(ParserCredentialCreate)
+reg(ParserCredentialUpdate)
+reg(ParserCredentialDelete)
+reg(ParserCredentialSwitch)
+reg(ParserCredentialValidate)
+reg(ParserPreferredProviderType)
+
+
+@console_ns.route("/workspaces/current/model-providers")
+class ModelProviderListApi(Resource):
+    @console_ns.expect(console_ns.models[ParserModelList.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, current_tenant_id = current_account_with_tenant()
+        tenant_id = current_tenant_id
+
+        payload = request.args.to_dict(flat=True)  # type: ignore
+        args = ParserModelList.model_validate(payload)
+
+        model_provider_service = ModelProviderService()
+        provider_list = model_provider_service.get_provider_list(tenant_id=tenant_id, model_type=args.model_type)
+
+        return jsonable_encoder({"data": provider_list})
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/credentials")
+class ModelProviderCredentialApi(Resource):
+    @console_ns.expect(console_ns.models[ParserCredentialId.__name__])
+    @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
+        payload = request.args.to_dict(flat=True)  # type: ignore
+        args = ParserCredentialId.model_validate(payload)
+
+        model_provider_service = ModelProviderService()
+        credentials = model_provider_service.get_provider_credential(
+            tenant_id=tenant_id, provider=provider, credential_id=args.credential_id
+        )
+
+        return {"credentials": credentials}
+
+    @console_ns.expect(console_ns.models[ParserCredentialCreate.__name__])
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = ParserCredentialCreate.model_validate(payload)
+
+        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(console_ns.models[ParserCredentialUpdate.__name__])
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def put(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+
+        payload = console_ns.payload or {}
+        args = ParserCredentialUpdate.model_validate(payload)
+
+        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(console_ns.models[ParserCredentialDelete.__name__])
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def delete(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = ParserCredentialDelete.model_validate(payload)
+
+        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
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/credentials/switch")
+class ModelProviderCredentialSwitchApi(Resource):
+    @console_ns.expect(console_ns.models[ParserCredentialSwitch.__name__])
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = ParserCredentialSwitch.model_validate(payload)
+
+        service = ModelProviderService()
+        service.switch_active_provider_credential(
+            tenant_id=current_tenant_id,
+            provider=provider,
+            credential_id=args.credential_id,
+        )
+        return {"result": "success"}
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/credentials/validate")
+class ModelProviderValidateApi(Resource):
+    @console_ns.expect(console_ns.models[ParserCredentialValidate.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, current_tenant_id = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = ParserCredentialValidate.model_validate(payload)
+
+        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)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/preferred-provider-type")
+class PreferredProviderTypeUpdateApi(Resource):
+    @console_ns.expect(console_ns.models[ParserPreferredProviderType.__name__])
+    @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
+
+        payload = console_ns.payload or {}
+        args = ParserPreferredProviderType.model_validate(payload)
+
+        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_1.11.1/api/controllers/console/workspace/models.py

@@ -0,0 +1,533 @@
+import logging
+from typing import Any, cast
+
+from flask import request
+from flask_restx import Resource
+from pydantic import BaseModel, Field, field_validator
+
+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 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__)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class ParserGetDefault(BaseModel):
+    model_type: ModelType
+
+
+class ParserPostDefault(BaseModel):
+    class Inner(BaseModel):
+        model_type: ModelType
+        model: str | None = None
+        provider: str | None = None
+
+    model_settings: list[Inner]
+
+
+class ParserDeleteModels(BaseModel):
+    model: str
+    model_type: ModelType
+
+
+class LoadBalancingPayload(BaseModel):
+    configs: list[dict[str, Any]] | None = None
+    enabled: bool | None = None
+
+
+class ParserPostModels(BaseModel):
+    model: str
+    model_type: ModelType
+    load_balancing: LoadBalancingPayload | None = None
+    config_from: str | None = None
+    credential_id: str | None = None
+
+    @field_validator("credential_id")
+    @classmethod
+    def validate_credential_id(cls, value: str | None) -> str | None:
+        if value is None:
+            return value
+        return uuid_value(value)
+
+
+class ParserGetCredentials(BaseModel):
+    model: str
+    model_type: ModelType
+    config_from: str | None = None
+    credential_id: str | None = None
+
+    @field_validator("credential_id")
+    @classmethod
+    def validate_get_credential_id(cls, value: str | None) -> str | None:
+        if value is None:
+            return value
+        return uuid_value(value)
+
+
+class ParserCredentialBase(BaseModel):
+    model: str
+    model_type: ModelType
+
+
+class ParserCreateCredential(ParserCredentialBase):
+    name: str | None = Field(default=None, max_length=30)
+    credentials: dict[str, Any]
+
+
+class ParserUpdateCredential(ParserCredentialBase):
+    credential_id: str
+    credentials: dict[str, Any]
+    name: str | None = Field(default=None, max_length=30)
+
+    @field_validator("credential_id")
+    @classmethod
+    def validate_update_credential_id(cls, value: str) -> str:
+        return uuid_value(value)
+
+
+class ParserDeleteCredential(ParserCredentialBase):
+    credential_id: str
+
+    @field_validator("credential_id")
+    @classmethod
+    def validate_delete_credential_id(cls, value: str) -> str:
+        return uuid_value(value)
+
+
+class ParserParameter(BaseModel):
+    model: str
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(ParserGetDefault)
+reg(ParserPostDefault)
+reg(ParserDeleteModels)
+reg(ParserPostModels)
+reg(ParserGetCredentials)
+reg(ParserCreateCredential)
+reg(ParserUpdateCredential)
+reg(ParserDeleteCredential)
+reg(ParserParameter)
+
+
+@console_ns.route("/workspaces/current/default-model")
+class DefaultModelApi(Resource):
+    @console_ns.expect(console_ns.models[ParserGetDefault.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserGetDefault.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        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(console_ns.models[ParserPostDefault.__name__])
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserPostDefault.model_validate(console_ns.payload)
+        model_provider_service = ModelProviderService()
+        model_settings = args.model_settings
+        for model_setting in model_settings:
+            if model_setting.provider is None:
+                continue
+
+            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=cast(str, 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.model,
+                )
+                raise ex
+
+        return {"result": "success"}
+
+
+@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(console_ns.models[ParserPostModels.__name__])
+    @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 = ParserPostModels.model_validate(console_ns.payload)
+
+        if args.config_from == "custom-model":
+            if not args.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 args.load_balancing and args.load_balancing.configs:
+            # 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.config_from or "",
+            )
+
+            if args.load_balancing.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(console_ns.models[ParserDeleteModels.__name__])
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def delete(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserDeleteModels.model_validate(console_ns.payload)
+
+        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
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/models/credentials")
+class ModelProviderModelCredentialApi(Resource):
+    @console_ns.expect(console_ns.models[ParserGetCredentials.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserGetCredentials.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        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.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.config_from or "",
+        )
+
+        if args.config_from == "predefined-model":
+            available_credentials = model_provider_service.provider_manager.get_provider_available_credentials(
+                tenant_id=tenant_id, provider_name=provider
+            )
+        else:
+            # Normalize model_type to the origin value stored in DB (e.g., "text-generation" for LLM)
+            normalized_model_type = 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=normalized_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(console_ns.models[ParserCreateCredential.__name__])
+    @setup_required
+    @login_required
+    @is_admin_or_owner_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserCreateCredential.model_validate(console_ns.payload)
+
+        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.model,
+                args.model_type,
+            )
+            raise ValueError(str(ex))
+
+        return {"result": "success"}, 201
+
+    @console_ns.expect(console_ns.models[ParserUpdateCredential.__name__])
+    @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 = ParserUpdateCredential.model_validate(console_ns.payload)
+
+        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(console_ns.models[ParserDeleteCredential.__name__])
+    @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 = ParserDeleteCredential.model_validate(console_ns.payload)
+
+        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
+
+
+class ParserSwitch(BaseModel):
+    model: str
+    model_type: ModelType
+    credential_id: str
+
+
+console_ns.schema_model(
+    ParserSwitch.__name__, ParserSwitch.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/models/credentials/switch")
+class ModelProviderModelCredentialSwitchApi(Resource):
+    @console_ns.expect(console_ns.models[ParserSwitch.__name__])
+    @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 = ParserSwitch.model_validate(console_ns.payload)
+
+        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"}
+
+
+@console_ns.route(
+    "/workspaces/current/model-providers/<path:provider>/models/enable", endpoint="model-provider-model-enable"
+)
+class ModelProviderModelEnableApi(Resource):
+    @console_ns.expect(console_ns.models[ParserDeleteModels.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def patch(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserDeleteModels.model_validate(console_ns.payload)
+
+        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(console_ns.models[ParserDeleteModels.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def patch(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserDeleteModels.model_validate(console_ns.payload)
+
+        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"}
+
+
+class ParserValidate(BaseModel):
+    model: str
+    model_type: ModelType
+    credentials: dict
+
+
+console_ns.schema_model(
+    ParserValidate.__name__, ParserValidate.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/models/credentials/validate")
+class ModelProviderModelValidateApi(Resource):
+    @console_ns.expect(console_ns.models[ParserValidate.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self, provider: str):
+        _, tenant_id = current_account_with_tenant()
+        args = ParserValidate.model_validate(console_ns.payload)
+
+        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
+
+
+@console_ns.route("/workspaces/current/model-providers/<path:provider>/models/parameter-rules")
+class ModelProviderModelParameterRuleApi(Resource):
+    @console_ns.expect(console_ns.models[ParserParameter.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, provider: str):
+        args = ParserParameter.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        _, 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_1.11.1/api/controllers/console/workspace/plugin.py

@@ -0,0 +1,775 @@
+import io
+from typing import Literal
+
+from flask import request, send_file
+from flask_restx import Resource
+from pydantic import BaseModel, Field
+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
+
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+@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)
+
+
+class ParserList(BaseModel):
+    page: int = Field(default=1)
+    page_size: int = Field(default=256)
+
+
+reg(ParserList)
+
+
+@console_ns.route("/workspaces/current/plugin/list")
+class PluginListApi(Resource):
+    @console_ns.expect(console_ns.models[ParserList.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+        args = ParserList.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        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})
+
+
+class ParserLatest(BaseModel):
+    plugin_ids: list[str]
+
+
+class ParserIcon(BaseModel):
+    tenant_id: str
+    filename: str
+
+
+class ParserAsset(BaseModel):
+    plugin_unique_identifier: str
+    file_name: str
+
+
+class ParserGithubUpload(BaseModel):
+    repo: str
+    version: str
+    package: str
+
+
+class ParserPluginIdentifiers(BaseModel):
+    plugin_unique_identifiers: list[str]
+
+
+class ParserGithubInstall(BaseModel):
+    plugin_unique_identifier: str
+    repo: str
+    version: str
+    package: str
+
+
+class ParserPluginIdentifierQuery(BaseModel):
+    plugin_unique_identifier: str
+
+
+class ParserTasks(BaseModel):
+    page: int
+    page_size: int
+
+
+class ParserMarketplaceUpgrade(BaseModel):
+    original_plugin_unique_identifier: str
+    new_plugin_unique_identifier: str
+
+
+class ParserGithubUpgrade(BaseModel):
+    original_plugin_unique_identifier: str
+    new_plugin_unique_identifier: str
+    repo: str
+    version: str
+    package: str
+
+
+class ParserUninstall(BaseModel):
+    plugin_installation_id: str
+
+
+class ParserPermissionChange(BaseModel):
+    install_permission: TenantPluginPermission.InstallPermission
+    debug_permission: TenantPluginPermission.DebugPermission
+
+
+class ParserDynamicOptions(BaseModel):
+    plugin_id: str
+    provider: str
+    action: str
+    parameter: str
+    credential_id: str | None = None
+    provider_type: Literal["tool", "trigger"]
+
+
+class PluginPermissionSettingsPayload(BaseModel):
+    install_permission: TenantPluginPermission.InstallPermission = TenantPluginPermission.InstallPermission.EVERYONE
+    debug_permission: TenantPluginPermission.DebugPermission = TenantPluginPermission.DebugPermission.EVERYONE
+
+
+class PluginAutoUpgradeSettingsPayload(BaseModel):
+    strategy_setting: TenantPluginAutoUpgradeStrategy.StrategySetting = (
+        TenantPluginAutoUpgradeStrategy.StrategySetting.FIX_ONLY
+    )
+    upgrade_time_of_day: int = 0
+    upgrade_mode: TenantPluginAutoUpgradeStrategy.UpgradeMode = TenantPluginAutoUpgradeStrategy.UpgradeMode.EXCLUDE
+    exclude_plugins: list[str] = Field(default_factory=list)
+    include_plugins: list[str] = Field(default_factory=list)
+
+
+class ParserPreferencesChange(BaseModel):
+    permission: PluginPermissionSettingsPayload
+    auto_upgrade: PluginAutoUpgradeSettingsPayload
+
+
+class ParserExcludePlugin(BaseModel):
+    plugin_id: str
+
+
+class ParserReadme(BaseModel):
+    plugin_unique_identifier: str
+    language: str = Field(default="en-US")
+
+
+reg(ParserLatest)
+reg(ParserIcon)
+reg(ParserAsset)
+reg(ParserGithubUpload)
+reg(ParserPluginIdentifiers)
+reg(ParserGithubInstall)
+reg(ParserPluginIdentifierQuery)
+reg(ParserTasks)
+reg(ParserMarketplaceUpgrade)
+reg(ParserGithubUpgrade)
+reg(ParserUninstall)
+reg(ParserPermissionChange)
+reg(ParserDynamicOptions)
+reg(ParserPreferencesChange)
+reg(ParserExcludePlugin)
+reg(ParserReadme)
+
+
+@console_ns.route("/workspaces/current/plugin/list/latest-versions")
+class PluginListLatestVersionsApi(Resource):
+    @console_ns.expect(console_ns.models[ParserLatest.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        args = ParserLatest.model_validate(console_ns.payload)
+
+        try:
+            versions = PluginService.list_latest_versions(args.plugin_ids)
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder({"versions": versions})
+
+
+@console_ns.route("/workspaces/current/plugin/list/installations/ids")
+class PluginListInstallationsFromIdsApi(Resource):
+    @console_ns.expect(console_ns.models[ParserLatest.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserLatest.model_validate(console_ns.payload)
+
+        try:
+            plugins = PluginService.list_installations_from_ids(tenant_id, args.plugin_ids)
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder({"plugins": plugins})
+
+
+@console_ns.route("/workspaces/current/plugin/icon")
+class PluginIconApi(Resource):
+    @console_ns.expect(console_ns.models[ParserIcon.__name__])
+    @setup_required
+    def get(self):
+        args = ParserIcon.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        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):
+    @console_ns.expect(console_ns.models[ParserAsset.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        args = ParserAsset.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        _, 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)
+
+
+@console_ns.route("/workspaces/current/plugin/upload/github")
+class PluginUploadFromGithubApi(Resource):
+    @console_ns.expect(console_ns.models[ParserGithubUpload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserGithubUpload.model_validate(console_ns.payload)
+
+        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)
+
+
+@console_ns.route("/workspaces/current/plugin/install/pkg")
+class PluginInstallFromPkgApi(Resource):
+    @console_ns.expect(console_ns.models[ParserPluginIdentifiers.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+        args = ParserPluginIdentifiers.model_validate(console_ns.payload)
+
+        try:
+            response = PluginService.install_from_local_pkg(tenant_id, args.plugin_unique_identifiers)
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder(response)
+
+
+@console_ns.route("/workspaces/current/plugin/install/github")
+class PluginInstallFromGithubApi(Resource):
+    @console_ns.expect(console_ns.models[ParserGithubInstall.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserGithubInstall.model_validate(console_ns.payload)
+
+        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)
+
+
+@console_ns.route("/workspaces/current/plugin/install/marketplace")
+class PluginInstallFromMarketplaceApi(Resource):
+    @console_ns.expect(console_ns.models[ParserPluginIdentifiers.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserPluginIdentifiers.model_validate(console_ns.payload)
+
+        try:
+            response = PluginService.install_from_marketplace_pkg(tenant_id, args.plugin_unique_identifiers)
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+        return jsonable_encoder(response)
+
+
+@console_ns.route("/workspaces/current/plugin/marketplace/pkg")
+class PluginFetchMarketplacePkgApi(Resource):
+    @console_ns.expect(console_ns.models[ParserPluginIdentifierQuery.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+        args = ParserPluginIdentifierQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        try:
+            return jsonable_encoder(
+                {
+                    "manifest": PluginService.fetch_marketplace_pkg(
+                        tenant_id,
+                        args.plugin_unique_identifier,
+                    )
+                }
+            )
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+@console_ns.route("/workspaces/current/plugin/fetch-manifest")
+class PluginFetchManifestApi(Resource):
+    @console_ns.expect(console_ns.models[ParserPluginIdentifierQuery.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserPluginIdentifierQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        try:
+            return jsonable_encoder(
+                {"manifest": PluginService.fetch_plugin_manifest(tenant_id, args.plugin_unique_identifier).model_dump()}
+            )
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+@console_ns.route("/workspaces/current/plugin/tasks")
+class PluginFetchInstallTasksApi(Resource):
+    @console_ns.expect(console_ns.models[ParserTasks.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserTasks.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        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)
+
+
+@console_ns.route("/workspaces/current/plugin/upgrade/marketplace")
+class PluginUpgradeFromMarketplaceApi(Resource):
+    @console_ns.expect(console_ns.models[ParserMarketplaceUpgrade.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserMarketplaceUpgrade.model_validate(console_ns.payload)
+
+        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)
+
+
+@console_ns.route("/workspaces/current/plugin/upgrade/github")
+class PluginUpgradeFromGithubApi(Resource):
+    @console_ns.expect(console_ns.models[ParserGithubUpgrade.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserGithubUpgrade.model_validate(console_ns.payload)
+
+        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)
+
+
+@console_ns.route("/workspaces/current/plugin/uninstall")
+class PluginUninstallApi(Resource):
+    @console_ns.expect(console_ns.models[ParserUninstall.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @plugin_permission_required(install_required=True)
+    def post(self):
+        args = ParserUninstall.model_validate(console_ns.payload)
+
+        _, tenant_id = current_account_with_tenant()
+
+        try:
+            return {"success": PluginService.uninstall(tenant_id, args.plugin_installation_id)}
+        except PluginDaemonClientSideError as e:
+            raise ValueError(e)
+
+
+@console_ns.route("/workspaces/current/plugin/permission/change")
+class PluginChangePermissionApi(Resource):
+    @console_ns.expect(console_ns.models[ParserPermissionChange.__name__])
+    @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 = ParserPermissionChange.model_validate(console_ns.payload)
+
+        tenant_id = current_tenant_id
+
+        return {
+            "success": PluginPermissionService.change_permission(
+                tenant_id, args.install_permission, args.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,
+            }
+        )
+
+
+@console_ns.route("/workspaces/current/plugin/parameters/dynamic-options")
+class PluginFetchDynamicSelectOptionsApi(Resource):
+    @console_ns.expect(console_ns.models[ParserDynamicOptions.__name__])
+    @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 = ParserDynamicOptions.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        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})
+
+
+@console_ns.route("/workspaces/current/plugin/preferences/change")
+class PluginChangePreferencesApi(Resource):
+    @console_ns.expect(console_ns.models[ParserPreferencesChange.__name__])
+    @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 = ParserPreferencesChange.model_validate(console_ns.payload)
+
+        permission = args.permission
+
+        install_permission = permission.install_permission
+        debug_permission = permission.debug_permission
+
+        auto_upgrade = args.auto_upgrade
+
+        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
+
+        # 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})
+
+
+@console_ns.route("/workspaces/current/plugin/preferences/autoupgrade/exclude")
+class PluginAutoUpgradeExcludePluginApi(Resource):
+    @console_ns.expect(console_ns.models[ParserExcludePlugin.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        # exclude one single plugin
+        _, tenant_id = current_account_with_tenant()
+
+        args = ParserExcludePlugin.model_validate(console_ns.payload)
+
+        return jsonable_encoder({"success": PluginAutoUpgradeService.exclude_plugin(tenant_id, args.plugin_id)})
+
+
+@console_ns.route("/workspaces/current/plugin/readme")
+class PluginReadmeApi(Resource):
+    @console_ns.expect(console_ns.models[ParserReadme.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self):
+        _, tenant_id = current_account_with_tenant()
+        args = ParserReadme.model_validate(request.args.to_dict(flat=True))  # type: ignore
+        return jsonable_encoder(
+            {"readme": PluginService.fetch_plugin_readme(tenant_id, args.plugin_unique_identifier, args.language)}
+        )

dify_1.11.1/api/controllers/console/workspace/trigger_providers.py

@@ -0,0 +1,578 @@
+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,
+    edit_permission_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
+    @edit_permission_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
+    @edit_permission_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
+    @edit_permission_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
+    @edit_permission_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
+    @edit_permission_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
+    @edit_permission_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
+    @edit_permission_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_1.11.1/api/controllers/console/workspace/workspace.py

@@ -0,0 +1,287 @@
+import logging
+
+from flask import request
+from flask_restx import Resource, fields, marshal, marshal_with
+from pydantic import BaseModel, Field
+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__)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class WorkspaceListQuery(BaseModel):
+    page: int = Field(default=1, ge=1, le=99999)
+    limit: int = Field(default=20, ge=1, le=100)
+
+
+class SwitchWorkspacePayload(BaseModel):
+    tenant_id: str
+
+
+class WorkspaceCustomConfigPayload(BaseModel):
+    remove_webapp_brand: bool | None = None
+    replace_webapp_logo: str | None = None
+
+
+class WorkspaceInfoPayload(BaseModel):
+    name: str
+
+
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
+
+
+reg(WorkspaceListQuery)
+reg(SwitchWorkspacePayload)
+reg(WorkspaceCustomConfigPayload)
+reg(WorkspaceInfoPayload)
+
+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):
+    @console_ns.expect(console_ns.models[WorkspaceListQuery.__name__])
+    @setup_required
+    @admin_required
+    def get(self):
+        payload = request.args.to_dict(flat=True)  # type: ignore
+        args = WorkspaceListQuery.model_validate(payload)
+
+        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
+
+
+@console_ns.route("/workspaces/switch")
+class SwitchWorkspaceApi(Resource):
+    @console_ns.expect(console_ns.models[SwitchWorkspacePayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        current_user, _ = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = SwitchWorkspacePayload.model_validate(payload)
+
+        # 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):
+    @console_ns.expect(console_ns.models[WorkspaceCustomConfigPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_resource_check("workspace_custom")
+    def post(self):
+        _, current_tenant_id = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = WorkspaceCustomConfigPayload.model_validate(payload)
+        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
+
+
+@console_ns.route("/workspaces/info")
+class WorkspaceInfoApi(Resource):
+    @console_ns.expect(console_ns.models[WorkspaceInfoPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    # Change workspace name
+    def post(self):
+        _, current_tenant_id = current_account_with_tenant()
+        payload = console_ns.payload or {}
+        args = WorkspaceInfoPayload.model_validate(payload)
+
+        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)}

dify_1.11.1/api/controllers/console/wraps.py

@@ -0,0 +1,333 @@
+import contextlib
+import json
+import os
+import time
+from collections.abc import Callable
+from functools import wraps
+from typing import ParamSpec, TypeVar
+
+from flask import abort, request
+
+from configs import dify_config
+from controllers.console.workspace.error import AccountNotInitializedError
+from enums.cloud_plan import CloudPlan
+from extensions.ext_database import db
+from extensions.ext_redis import redis_client
+from libs.login import current_account_with_tenant
+from models.account import AccountStatus
+from models.dataset import RateLimitLog
+from models.model import DifySetup
+from services.feature_service import FeatureService, LicenseStatus
+from services.operation_service import OperationService
+
+from .error import NotInitValidateError, NotSetupError, UnauthorizedAndForceLogout
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def account_initialization_required(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        # check account initialization
+        current_user, _ = current_account_with_tenant()
+        if current_user.status == AccountStatus.UNINITIALIZED:
+            raise AccountNotInitializedError()
+
+        return view(*args, **kwargs)
+
+    return decorated
+
+
+def only_edition_cloud(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        if dify_config.EDITION != "CLOUD":
+            abort(404)
+
+        return view(*args, **kwargs)
+
+    return decorated
+
+
+def only_edition_enterprise(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        if not dify_config.ENTERPRISE_ENABLED:
+            abort(404)
+
+        return view(*args, **kwargs)
+
+    return decorated
+
+
+def only_edition_self_hosted(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        if dify_config.EDITION != "SELF_HOSTED":
+            abort(404)
+
+        return view(*args, **kwargs)
+
+    return decorated
+
+
+def cloud_edition_billing_enabled(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        _, current_tenant_id = current_account_with_tenant()
+        features = FeatureService.get_features(current_tenant_id)
+        if not features.billing.enabled:
+            abort(403, "Billing feature is not enabled.")
+        return view(*args, **kwargs)
+
+    return decorated
+
+
+def cloud_edition_billing_resource_check(resource: str):
+    def interceptor(view: Callable[P, R]):
+        @wraps(view)
+        def decorated(*args: P.args, **kwargs: P.kwargs):
+            _, current_tenant_id = current_account_with_tenant()
+            features = FeatureService.get_features(current_tenant_id)
+            if features.billing.enabled:
+                members = features.members
+                apps = features.apps
+                vector_space = features.vector_space
+                documents_upload_quota = features.documents_upload_quota
+                annotation_quota_limit = features.annotation_quota_limit
+                if resource == "members" and 0 < members.limit <= members.size:
+                    abort(403, "The number of members has reached the limit of your subscription.")
+                elif resource == "apps" and 0 < apps.limit <= apps.size:
+                    abort(403, "The number of apps has reached the limit of your subscription.")
+                elif resource == "vector_space" and 0 < vector_space.limit <= vector_space.size:
+                    abort(
+                        403, "The capacity of the knowledge storage space has reached the limit of your subscription."
+                    )
+                elif resource == "documents" and 0 < documents_upload_quota.limit <= documents_upload_quota.size:
+                    # The api of file upload is used in the multiple places,
+                    # so we need to check the source of the request from datasets
+                    source = request.args.get("source")
+                    if source == "datasets":
+                        abort(403, "The number of documents has reached the limit of your subscription.")
+                    else:
+                        return view(*args, **kwargs)
+                elif resource == "workspace_custom" and not features.can_replace_logo:
+                    abort(403, "The workspace custom feature has reached the limit of your subscription.")
+                elif resource == "annotation" and 0 < annotation_quota_limit.limit < annotation_quota_limit.size:
+                    abort(403, "The annotation quota has reached the limit of your subscription.")
+                else:
+                    return view(*args, **kwargs)
+
+            return view(*args, **kwargs)
+
+        return decorated
+
+    return interceptor
+
+
+def cloud_edition_billing_knowledge_limit_check(resource: str):
+    def interceptor(view: Callable[P, R]):
+        @wraps(view)
+        def decorated(*args: P.args, **kwargs: P.kwargs):
+            _, current_tenant_id = current_account_with_tenant()
+            features = FeatureService.get_features(current_tenant_id)
+            if features.billing.enabled:
+                if resource == "add_segment":
+                    if features.billing.subscription.plan == CloudPlan.SANDBOX:
+                        abort(
+                            403,
+                            "To unlock this feature and elevate your Dify experience, please upgrade to a paid plan.",
+                        )
+                else:
+                    return view(*args, **kwargs)
+
+            return view(*args, **kwargs)
+
+        return decorated
+
+    return interceptor
+
+
+def cloud_edition_billing_rate_limit_check(resource: str):
+    def interceptor(view: Callable[P, R]):
+        @wraps(view)
+        def decorated(*args: P.args, **kwargs: P.kwargs):
+            if resource == "knowledge":
+                _, current_tenant_id = current_account_with_tenant()
+                knowledge_rate_limit = FeatureService.get_knowledge_rate_limit(current_tenant_id)
+                if knowledge_rate_limit.enabled:
+                    current_time = int(time.time() * 1000)
+                    key = f"rate_limit_{current_tenant_id}"
+
+                    redis_client.zadd(key, {current_time: current_time})
+
+                    redis_client.zremrangebyscore(key, 0, current_time - 60000)
+
+                    request_count = redis_client.zcard(key)
+
+                    if request_count > knowledge_rate_limit.limit:
+                        # add ratelimit record
+                        rate_limit_log = RateLimitLog(
+                            tenant_id=current_tenant_id,
+                            subscription_plan=knowledge_rate_limit.subscription_plan,
+                            operation="knowledge",
+                        )
+                        db.session.add(rate_limit_log)
+                        db.session.commit()
+                        abort(
+                            403, "Sorry, you have reached the knowledge base request rate limit of your subscription."
+                        )
+            return view(*args, **kwargs)
+
+        return decorated
+
+    return interceptor
+
+
+def cloud_utm_record(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        with contextlib.suppress(Exception):
+            _, current_tenant_id = current_account_with_tenant()
+            features = FeatureService.get_features(current_tenant_id)
+
+            if features.billing.enabled:
+                utm_info = request.cookies.get("utm_info")
+
+                if utm_info:
+                    utm_info_dict: dict = json.loads(utm_info)
+                    OperationService.record_utm(current_tenant_id, utm_info_dict)
+
+        return view(*args, **kwargs)
+
+    return decorated
+
+
+def setup_required(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        # check setup
+        if (
+            dify_config.EDITION == "SELF_HOSTED"
+            and os.environ.get("INIT_PASSWORD")
+            and not db.session.query(DifySetup).first()
+        ):
+            raise NotInitValidateError()
+        elif dify_config.EDITION == "SELF_HOSTED" and not db.session.query(DifySetup).first():
+            raise NotSetupError()
+
+        return view(*args, **kwargs)
+
+    return decorated
+
+
+def enterprise_license_required(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        settings = FeatureService.get_system_features()
+        if settings.license.status in [LicenseStatus.INACTIVE, LicenseStatus.EXPIRED, LicenseStatus.LOST]:
+            raise UnauthorizedAndForceLogout("Your license is invalid. Please contact your administrator.")
+
+        return view(*args, **kwargs)
+
+    return decorated
+
+
+def email_password_login_enabled(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        features = FeatureService.get_system_features()
+        if features.enable_email_password_login:
+            return view(*args, **kwargs)
+
+        # otherwise, return 403
+        abort(403)
+
+    return decorated
+
+
+def email_register_enabled(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        features = FeatureService.get_system_features()
+        if features.is_allow_register:
+            return view(*args, **kwargs)
+
+        # otherwise, return 403
+        abort(403)
+
+    return decorated
+
+
+def enable_change_email(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        features = FeatureService.get_system_features()
+        if features.enable_change_email:
+            return view(*args, **kwargs)
+
+        # otherwise, return 403
+        abort(403)
+
+    return decorated
+
+
+def is_allow_transfer_owner(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        _, current_tenant_id = current_account_with_tenant()
+        features = FeatureService.get_features(current_tenant_id)
+        if features.is_allow_transfer_workspace:
+            return view(*args, **kwargs)
+
+        # otherwise, return 403
+        abort(403)
+
+    return decorated
+
+
+def knowledge_pipeline_publish_enabled(view: Callable[P, R]):
+    @wraps(view)
+    def decorated(*args: P.args, **kwargs: P.kwargs):
+        _, current_tenant_id = current_account_with_tenant()
+        features = FeatureService.get_features(current_tenant_id)
+        if features.knowledge_pipeline.publish_enabled:
+            return view(*args, **kwargs)
+        abort(403)
+
+    return decorated
+
+
+def edit_permission_required(f: Callable[P, R]):
+    @wraps(f)
+    def decorated_function(*args: P.args, **kwargs: P.kwargs):
+        from werkzeug.exceptions import Forbidden
+
+        from libs.login import current_user
+        from models import Account
+
+        user = current_user._get_current_object()  # type: ignore
+        if not isinstance(user, Account):
+            raise Forbidden()
+        if not current_user.has_edit_permission:
+            raise Forbidden()
+        return f(*args, **kwargs)
+
+    return decorated_function
+
+
+def is_admin_or_owner_required(f: Callable[P, R]):
+    @wraps(f)
+    def decorated_function(*args: P.args, **kwargs: P.kwargs):
+        from werkzeug.exceptions import Forbidden
+
+        from libs.login import current_user
+        from models import Account
+
+        user = current_user._get_current_object()
+        if not isinstance(user, Account) or not user.is_admin_or_owner:
+            raise Forbidden()
+        return f(*args, **kwargs)
+
+    return decorated_function

dify_1.11.1/api/controllers/files/__init__.py

@@ -0,0 +1,28 @@
+from flask import Blueprint
+from flask_restx import Namespace
+
+from libs.external_api import ExternalApi
+
+bp = Blueprint("files", __name__, url_prefix="/files")
+
+api = ExternalApi(
+    bp,
+    version="1.0",
+    title="Files API",
+    description="API for file operations including upload and preview",
+)
+
+files_ns = Namespace("files", description="File operations", path="/")
+
+from . import image_preview, tool_files, upload
+
+api.add_namespace(files_ns)
+
+__all__ = [
+    "api",
+    "bp",
+    "files_ns",
+    "image_preview",
+    "tool_files",
+    "upload",
+]