chore: workflow performance

Signed-off-by: yihong0618 <zouzou0208@gmail.com>

api/.env.example

@@ -379,19 +379,6 @@ SMTP_USERNAME=123
 SMTP_PASSWORD=abc
 SMTP_USE_TLS=true
 SMTP_OPPORTUNISTIC_TLS=false
-
-# SMTP authentication type: 'basic' for username/password, 'oauth2' for Microsoft OAuth 2.0
-# Use 'oauth2' for Microsoft Exchange/Outlook due to Basic Auth retirement (September 2025)
-SMTP_AUTH_TYPE=basic
-
-# Microsoft OAuth 2.0 configuration for SMTP authentication
-# Required when SMTP_AUTH_TYPE=oauth2 and using Microsoft Exchange/Outlook
-# Setup: Create Azure AD app → Add Mail.Send + SMTP.Send permissions → Get Client ID/Secret
-# For Exchange Online: SMTP_SERVER=smtp.office365.com, SMTP_PORT=587, SMTP_USE_TLS=true
-MICROSOFT_OAUTH2_CLIENT_ID=
-MICROSOFT_OAUTH2_CLIENT_SECRET=
-MICROSOFT_OAUTH2_TENANT_ID=common
-MICROSOFT_OAUTH2_ACCESS_TOKEN=
 # Sendgid configuration
 SENDGRID_API_KEY=
 # Sentry configuration
@@ -440,8 +427,8 @@ CODE_EXECUTION_POOL_MAX_KEEPALIVE_CONNECTIONS=20
 CODE_EXECUTION_POOL_KEEPALIVE_EXPIRY=5.0
 CODE_MAX_NUMBER=9223372036854775807
 CODE_MIN_NUMBER=-9223372036854775808
-CODE_MAX_STRING_LENGTH=80000
-TEMPLATE_TRANSFORM_MAX_LENGTH=80000
+CODE_MAX_STRING_LENGTH=400000
+TEMPLATE_TRANSFORM_MAX_LENGTH=400000
 CODE_MAX_STRING_ARRAY_LENGTH=30
 CODE_MAX_OBJECT_ARRAY_LENGTH=30
 CODE_MAX_NUMBER_ARRAY_LENGTH=1000

api/configs/feature/__init__.py

@@ -150,7 +150,7 @@ class CodeExecutionSandboxConfig(BaseSettings):
 
     CODE_MAX_STRING_LENGTH: PositiveInt = Field(
         description="Maximum allowed length for strings in code execution",
-        default=80000,
+        default=400_000,
     )
 
     CODE_MAX_STRING_ARRAY_LENGTH: PositiveInt = Field(
@@ -582,6 +582,11 @@ class WorkflowConfig(BaseSettings):
         default=200 * 1024,
     )
 
+    TEMPLATE_TRANSFORM_MAX_LENGTH: PositiveInt = Field(
+        description="Maximum number of characters allowed in Template Transform node output",
+        default=400_000,
+    )
+
     # GraphEngine Worker Pool Configuration
     GRAPH_ENGINE_MIN_WORKERS: PositiveInt = Field(
         description="Minimum number of workers per GraphEngine instance",
@@ -821,32 +826,6 @@ class MailConfig(BaseSettings):
         default=False,
     )
 
-    SMTP_AUTH_TYPE: str = Field(
-        description="SMTP authentication type ('basic' or 'oauth2')",
-        default="basic",
-    )
-
-    # Microsoft OAuth 2.0 configuration for SMTP
-    MICROSOFT_OAUTH2_CLIENT_ID: str | None = Field(
-        description="Microsoft OAuth 2.0 client ID for SMTP authentication",
-        default=None,
-    )
-
-    MICROSOFT_OAUTH2_CLIENT_SECRET: str | None = Field(
-        description="Microsoft OAuth 2.0 client secret for SMTP authentication",
-        default=None,
-    )
-
-    MICROSOFT_OAUTH2_TENANT_ID: str = Field(
-        description="Microsoft OAuth 2.0 tenant ID (use 'common' for multi-tenant)",
-        default="common",
-    )
-
-    MICROSOFT_OAUTH2_ACCESS_TOKEN: str | None = Field(
-        description="Microsoft OAuth 2.0 access token for SMTP authentication",
-        default=None,
-    )
-
     EMAIL_SEND_IP_LIMIT_PER_MINUTE: PositiveInt = Field(
         description="Maximum number of emails allowed to be sent from the same IP address in a minute",
         default=50,

api/constants/__init__.py

@@ -1,4 +1,5 @@
 from configs import dify_config
+from libs.collection_utils import convert_to_lower_and_upper_set
 
 HIDDEN_VALUE = "[__HIDDEN__]"
 UNKNOWN_VALUE = "[__UNKNOWN__]"
@@ -6,24 +7,39 @@ UUID_NIL = "00000000-0000-0000-0000-000000000000"
 
 DEFAULT_FILE_NUMBER_LIMITS = 3
 
-IMAGE_EXTENSIONS = ["jpg", "jpeg", "png", "webp", "gif", "svg"]
-IMAGE_EXTENSIONS.extend([ext.upper() for ext in IMAGE_EXTENSIONS])
+IMAGE_EXTENSIONS = convert_to_lower_and_upper_set({"jpg", "jpeg", "png", "webp", "gif", "svg"})
 
-VIDEO_EXTENSIONS = ["mp4", "mov", "mpeg", "webm"]
-VIDEO_EXTENSIONS.extend([ext.upper() for ext in VIDEO_EXTENSIONS])
+VIDEO_EXTENSIONS = convert_to_lower_and_upper_set({"mp4", "mov", "mpeg", "webm"})
 
-AUDIO_EXTENSIONS = ["mp3", "m4a", "wav", "amr", "mpga"]
-AUDIO_EXTENSIONS.extend([ext.upper() for ext in AUDIO_EXTENSIONS])
+AUDIO_EXTENSIONS = convert_to_lower_and_upper_set({"mp3", "m4a", "wav", "amr", "mpga"})
 
-
-_doc_extensions: list[str]
+_doc_extensions: set[str]
 if dify_config.ETL_TYPE == "Unstructured":
-    _doc_extensions = ["txt", "markdown", "md", "mdx", "pdf", "html", "htm", "xlsx", "xls", "vtt", "properties"]
-    _doc_extensions.extend(("doc", "docx", "csv", "eml", "msg", "pptx", "xml", "epub"))
+    _doc_extensions = {
+        "txt",
+        "markdown",
+        "md",
+        "mdx",
+        "pdf",
+        "html",
+        "htm",
+        "xlsx",
+        "xls",
+        "vtt",
+        "properties",
+        "doc",
+        "docx",
+        "csv",
+        "eml",
+        "msg",
+        "pptx",
+        "xml",
+        "epub",
+    }
     if dify_config.UNSTRUCTURED_API_URL:
-        _doc_extensions.append("ppt")
+        _doc_extensions.add("ppt")
 else:
-    _doc_extensions = [
+    _doc_extensions = {
         "txt",
         "markdown",
         "md",
@@ -37,5 +53,5 @@ else:
         "csv",
         "vtt",
         "properties",
-    ]
-DOCUMENT_EXTENSIONS = _doc_extensions + [ext.upper() for ext in _doc_extensions]
+    }
+DOCUMENT_EXTENSIONS: set[str] = convert_to_lower_and_upper_set(_doc_extensions)

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

@@ -1,4 +1,3 @@
-from fastapi.encoders import jsonable_encoder
 from flask import make_response, redirect, request
 from flask_login import current_user
 from flask_restx import Resource, reqparse
@@ -11,6 +10,7 @@ from controllers.console.wraps import (
     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.helper import StrLen
 from libs.login import login_required

api/core/app/app_config/easy_ui_based_app/dataset/manager.py

@@ -1,4 +1,5 @@
 import uuid
+from typing import Literal, cast
 
 from core.app.app_config.entities import (
     DatasetEntity,
@@ -74,6 +75,9 @@ class DatasetConfigManager:
             return None
         query_variable = config.get("dataset_query_variable")
 
+        metadata_model_config_dict = dataset_configs.get("metadata_model_config")
+        metadata_filtering_conditions_dict = dataset_configs.get("metadata_filtering_conditions")
+
         if dataset_configs["retrieval_model"] == "single":
             return DatasetEntity(
                 dataset_ids=dataset_ids,
@@ -82,18 +86,23 @@ class DatasetConfigManager:
                     retrieve_strategy=DatasetRetrieveConfigEntity.RetrieveStrategy.value_of(
                         dataset_configs["retrieval_model"]
                     ),
-                    metadata_filtering_mode=dataset_configs.get("metadata_filtering_mode", "disabled"),
-                    metadata_model_config=ModelConfig(**dataset_configs.get("metadata_model_config"))
-                    if dataset_configs.get("metadata_model_config")
+                    metadata_filtering_mode=cast(
+                        Literal["disabled", "automatic", "manual"],
+                        dataset_configs.get("metadata_filtering_mode", "disabled"),
+                    ),
+                    metadata_model_config=ModelConfig(**metadata_model_config_dict)
+                    if isinstance(metadata_model_config_dict, dict)
                     else None,
-                    metadata_filtering_conditions=MetadataFilteringCondition(
-                        **dataset_configs.get("metadata_filtering_conditions", {})
-                    )
-                    if dataset_configs.get("metadata_filtering_conditions")
+                    metadata_filtering_conditions=MetadataFilteringCondition(**metadata_filtering_conditions_dict)
+                    if isinstance(metadata_filtering_conditions_dict, dict)
                     else None,
                 ),
             )
         else:
+            score_threshold_val = dataset_configs.get("score_threshold")
+            reranking_model_val = dataset_configs.get("reranking_model")
+            weights_val = dataset_configs.get("weights")
+
             return DatasetEntity(
                 dataset_ids=dataset_ids,
                 retrieve_config=DatasetRetrieveConfigEntity(
@@ -101,22 +110,23 @@ class DatasetConfigManager:
                     retrieve_strategy=DatasetRetrieveConfigEntity.RetrieveStrategy.value_of(
                         dataset_configs["retrieval_model"]
                     ),
-                    top_k=dataset_configs.get("top_k", 4),
-                    score_threshold=dataset_configs.get("score_threshold")
-                    if dataset_configs.get("score_threshold_enabled", False)
+                    top_k=int(dataset_configs.get("top_k", 4)),
+                    score_threshold=float(score_threshold_val)
+                    if dataset_configs.get("score_threshold_enabled", False) and score_threshold_val is not None
                     else None,
-                    reranking_model=dataset_configs.get("reranking_model"),
-                    weights=dataset_configs.get("weights"),
-                    reranking_enabled=dataset_configs.get("reranking_enabled", True),
+                    reranking_model=reranking_model_val if isinstance(reranking_model_val, dict) else None,
+                    weights=weights_val if isinstance(weights_val, dict) else None,
+                    reranking_enabled=bool(dataset_configs.get("reranking_enabled", True)),
                     rerank_mode=dataset_configs.get("reranking_mode", "reranking_model"),
-                    metadata_filtering_mode=dataset_configs.get("metadata_filtering_mode", "disabled"),
-                    metadata_model_config=ModelConfig(**dataset_configs.get("metadata_model_config"))
-                    if dataset_configs.get("metadata_model_config")
+                    metadata_filtering_mode=cast(
+                        Literal["disabled", "automatic", "manual"],
+                        dataset_configs.get("metadata_filtering_mode", "disabled"),
+                    ),
+                    metadata_model_config=ModelConfig(**metadata_model_config_dict)
+                    if isinstance(metadata_model_config_dict, dict)
                     else None,
-                    metadata_filtering_conditions=MetadataFilteringCondition(
-                        **dataset_configs.get("metadata_filtering_conditions", {})
-                    )
-                    if dataset_configs.get("metadata_filtering_conditions")
+                    metadata_filtering_conditions=MetadataFilteringCondition(**metadata_filtering_conditions_dict)
+                    if isinstance(metadata_filtering_conditions_dict, dict)
                     else None,
                 ),
             )
@@ -134,18 +144,17 @@ class DatasetConfigManager:
         config = cls.extract_dataset_config_for_legacy_compatibility(tenant_id, app_mode, config)
 
         # dataset_configs
-        if not config.get("dataset_configs"):
-            config["dataset_configs"] = {"retrieval_model": "single"}
+        if "dataset_configs" not in config or not config.get("dataset_configs"):
+            config["dataset_configs"] = {}
+        config["dataset_configs"]["retrieval_model"] = config["dataset_configs"].get("retrieval_model", "single")
 
         if not isinstance(config["dataset_configs"], dict):
             raise ValueError("dataset_configs must be of object type")
 
-        if not config["dataset_configs"].get("datasets"):
+        if "datasets" not in config["dataset_configs"] or not config["dataset_configs"].get("datasets"):
             config["dataset_configs"]["datasets"] = {"strategy": "router", "datasets": []}
 
-        need_manual_query_datasets = config.get("dataset_configs") and config["dataset_configs"].get(
-            "datasets", {}
-        ).get("datasets")
+        need_manual_query_datasets = config.get("dataset_configs", {}).get("datasets", {}).get("datasets")
 
         if need_manual_query_datasets and app_mode == AppMode.COMPLETION:
             # Only check when mode is completion
@@ -166,8 +175,8 @@ class DatasetConfigManager:
         :param config: app model config args
         """
         # Extract dataset config for legacy compatibility
-        if not config.get("agent_mode"):
-            config["agent_mode"] = {"enabled": False, "tools": []}
+        if "agent_mode" not in config or not config.get("agent_mode"):
+            config["agent_mode"] = {}
 
         if not isinstance(config["agent_mode"], dict):
             raise ValueError("agent_mode must be of object type")
@@ -180,19 +189,22 @@ class DatasetConfigManager:
             raise ValueError("enabled in agent_mode must be of boolean type")
 
         # tools
-        if not config["agent_mode"].get("tools"):
+        if "tools" not in config["agent_mode"] or not config["agent_mode"].get("tools"):
             config["agent_mode"]["tools"] = []
 
         if not isinstance(config["agent_mode"]["tools"], list):
             raise ValueError("tools in agent_mode must be a list of objects")
 
         # strategy
-        if not config["agent_mode"].get("strategy"):
+        if "strategy" not in config["agent_mode"] or not config["agent_mode"].get("strategy"):
             config["agent_mode"]["strategy"] = PlanningStrategy.ROUTER.value
 
         has_datasets = False
-        if config["agent_mode"]["strategy"] in {PlanningStrategy.ROUTER.value, PlanningStrategy.REACT_ROUTER.value}:
-            for tool in config["agent_mode"]["tools"]:
+        if config.get("agent_mode", {}).get("strategy") in {
+            PlanningStrategy.ROUTER.value,
+            PlanningStrategy.REACT_ROUTER.value,
+        }:
+            for tool in config.get("agent_mode", {}).get("tools", []):
                 key = list(tool.keys())[0]
                 if key == "dataset":
                     # old style, use tool name as key
@@ -217,7 +229,7 @@ class DatasetConfigManager:
 
                     has_datasets = True
 
-        need_manual_query_datasets = has_datasets and config["agent_mode"]["enabled"]
+        need_manual_query_datasets = has_datasets and config.get("agent_mode", {}).get("enabled")
 
         if need_manual_query_datasets and app_mode == AppMode.COMPLETION:
             # Only check when mode is completion

api/core/app/task_pipeline/message_cycle_manager.py

@@ -107,7 +107,6 @@ class MessageCycleManager:
                     if dify_config.DEBUG:
                         logger.exception("generate conversation name failed, conversation_id: %s", conversation_id)
 
-                db.session.merge(conversation)
                 db.session.commit()
                 db.session.close()
 

api/core/datasource/__base/datasource_runtime.py

@@ -1,7 +1,6 @@
 from typing import TYPE_CHECKING, Any, Optional
 
-from openai import BaseModel
-from pydantic import Field
+from pydantic import BaseModel, Field
 
 # Import InvokeFrom locally to avoid circular import
 from core.app.entities.app_invoke_entities import InvokeFrom

api/core/tools/__base/tool_runtime.py

@@ -1,7 +1,6 @@
 from typing import Any
 
-from openai import BaseModel
-from pydantic import Field
+from pydantic import BaseModel, Field
 
 from core.app.entities.app_invoke_entities import InvokeFrom
 from core.tools.entities.tool_entities import CredentialType, ToolInvokeFrom

api/core/workflow/nodes/template_transform/template_transform_node.py

@@ -1,7 +1,7 @@
-import os
 from collections.abc import Mapping, Sequence
 from typing import Any
 
+from configs import dify_config
 from core.helper.code_executor.code_executor import CodeExecutionError, CodeExecutor, CodeLanguage
 from core.workflow.enums import ErrorStrategy, NodeType, WorkflowNodeExecutionStatus
 from core.workflow.node_events import NodeRunResult
@@ -9,7 +9,7 @@ from core.workflow.nodes.base.entities import BaseNodeData, RetryConfig
 from core.workflow.nodes.base.node import Node
 from core.workflow.nodes.template_transform.entities import TemplateTransformNodeData
 
-MAX_TEMPLATE_TRANSFORM_OUTPUT_LENGTH = int(os.environ.get("TEMPLATE_TRANSFORM_MAX_LENGTH", "80000"))
+MAX_TEMPLATE_TRANSFORM_OUTPUT_LENGTH = dify_config.TEMPLATE_TRANSFORM_MAX_LENGTH
 
 
 class TemplateTransformNode(Node):

api/extensions/ext_mail.py

@@ -16,7 +16,7 @@ class Mail:
     def is_inited(self) -> bool:
         return self._client is not None
 
-    def init_app(self, _: Flask):
+    def init_app(self, app: Flask):
         mail_type = dify_config.MAIL_TYPE
         if not mail_type:
             logger.warning("MAIL_TYPE is not set")
@@ -40,36 +40,20 @@ class Mail:
                 resend.api_key = api_key
                 self._client = resend.Emails
             case "smtp":
-                from libs.mail import SMTPClient
+                from libs.smtp import SMTPClient
 
                 if not dify_config.SMTP_SERVER or not dify_config.SMTP_PORT:
                     raise ValueError("SMTP_SERVER and SMTP_PORT are required for smtp mail type")
                 if not dify_config.SMTP_USE_TLS and dify_config.SMTP_OPPORTUNISTIC_TLS:
                     raise ValueError("SMTP_OPPORTUNISTIC_TLS is not supported without enabling SMTP_USE_TLS")
-
-                # Validate OAuth 2.0 configuration if auth_type is oauth2
-                oauth_access_token = None
-
-                if dify_config.SMTP_AUTH_TYPE == "oauth2":
-                    oauth_access_token = dify_config.MICROSOFT_OAUTH2_ACCESS_TOKEN
-                    if not oauth_access_token:
-                        # Try to get token using client credentials flow
-                        if dify_config.MICROSOFT_OAUTH2_CLIENT_ID and dify_config.MICROSOFT_OAUTH2_CLIENT_SECRET:
-                            oauth_access_token = self._get_oauth_token()
-
-                        if not oauth_access_token:
-                            raise ValueError("OAuth 2.0 access token is required for oauth2 auth_type")
-
                 self._client = SMTPClient(
                     server=dify_config.SMTP_SERVER,
                     port=dify_config.SMTP_PORT,
                     username=dify_config.SMTP_USERNAME or "",
                     password=dify_config.SMTP_PASSWORD or "",
-                    from_addr=dify_config.MAIL_DEFAULT_SEND_FROM or "",
+                    _from=dify_config.MAIL_DEFAULT_SEND_FROM or "",
                     use_tls=dify_config.SMTP_USE_TLS,
                     opportunistic_tls=dify_config.SMTP_OPPORTUNISTIC_TLS,
-                    oauth_access_token=oauth_access_token,
-                    auth_type=dify_config.SMTP_AUTH_TYPE,
                 )
             case "sendgrid":
                 from libs.sendgrid import SendGridClient
@@ -83,33 +67,6 @@ class Mail:
             case _:
                 raise ValueError(f"Unsupported mail type {mail_type}")
 
-    def _get_oauth_token(self) -> str | None:
-        """Get OAuth access token using client credentials flow"""
-        try:
-            from libs.mail.oauth_email import MicrosoftEmailOAuth
-
-            client_id = dify_config.MICROSOFT_OAUTH2_CLIENT_ID
-            client_secret = dify_config.MICROSOFT_OAUTH2_CLIENT_SECRET
-            tenant_id = dify_config.MICROSOFT_OAUTH2_TENANT_ID or "common"
-
-            if not client_id or not client_secret:
-                return None
-
-            oauth_client = MicrosoftEmailOAuth(
-                client_id=client_id,
-                client_secret=client_secret,
-                redirect_uri="",  # Not needed for client credentials flow
-                tenant_id=tenant_id,
-            )
-
-            token_response = oauth_client.get_access_token_client_credentials()
-            access_token = token_response.get("access_token")
-            return str(access_token) if access_token is not None else None
-
-        except Exception as e:
-            logging.warning("Failed to obtain OAuth 2.0 access token: %s", str(e))
-            return None
-
     def send(self, to: str, subject: str, html: str, from_: str | None = None):
         if not self._client:
             raise ValueError("Mail client is not initialized")

api/extensions/ext_otel.py

@@ -136,6 +136,7 @@ def init_app(app: DifyApp):
     from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter as HTTPSpanExporter
     from opentelemetry.instrumentation.celery import CeleryInstrumentor
     from opentelemetry.instrumentation.flask import FlaskInstrumentor
+    from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
     from opentelemetry.instrumentation.redis import RedisInstrumentor
     from opentelemetry.instrumentation.requests import RequestsInstrumentor
     from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
@@ -238,6 +239,7 @@ def init_app(app: DifyApp):
     init_sqlalchemy_instrumentor(app)
     RedisInstrumentor().instrument()
     RequestsInstrumentor().instrument()
+    HTTPXClientInstrumentor().instrument()
     atexit.register(shutdown_tracer)
 
 

api/extensions/ext_sentry.py

@@ -4,7 +4,6 @@ from dify_app import DifyApp
 
 def init_app(app: DifyApp):
     if dify_config.SENTRY_DSN:
-        import openai
         import sentry_sdk
         from langfuse import parse_error  # type: ignore
         from sentry_sdk.integrations.celery import CeleryIntegration
@@ -28,7 +27,6 @@ def init_app(app: DifyApp):
                 HTTPException,
                 ValueError,
                 FileNotFoundError,
-                openai.APIStatusError,
                 InvokeRateLimitError,
                 parse_error.defaultErrorResponse,
             ],

api/extensions/storage/opendal_storage.py

@@ -3,9 +3,9 @@ import os
 from collections.abc import Generator
 from pathlib import Path
 
+import opendal
 from dotenv import dotenv_values
 from opendal import Operator
-from opendal.layers import RetryLayer
 
 from extensions.storage.base_storage import BaseStorage
 
@@ -35,7 +35,7 @@ class OpenDALStorage(BaseStorage):
             root = kwargs.get("root", "storage")
             Path(root).mkdir(parents=True, exist_ok=True)
 
-        retry_layer = RetryLayer(max_times=3, factor=2.0, jitter=True)
+        retry_layer = opendal.layers.RetryLayer(max_times=3, factor=2.0, jitter=True)
         self.op = Operator(scheme=scheme, **kwargs).layer(retry_layer)
         logger.debug("opendal operator created with scheme %s", scheme)
         logger.debug("added retry layer to opendal operator")

api/libs/collection_utils.py

@@ -0,0 +1,14 @@
+def convert_to_lower_and_upper_set(inputs: list[str] | set[str]) -> set[str]:
+    """
+    Convert a list or set of strings to a set containing both lower and upper case versions of each string.
+
+    Args:
+        inputs (list[str] | set[str]): A list or set of strings to be converted.
+
+    Returns:
+        set[str]: A set containing both lower and upper case versions of each string.
+    """
+    if not inputs:
+        return set()
+    else:
+        return {case for s in inputs if s for case in (s.lower(), s.upper())}

api/libs/mail/README.md

@@ -1,281 +0,0 @@
-# Email Module
-
-This module provides email functionality for Dify, including SMTP with OAuth 2.0 support for Microsoft Exchange/Outlook.
-
-## Features
-
-- Basic SMTP authentication
-- OAuth 2.0 authentication for Microsoft Exchange/Outlook
-- Multiple email providers: SMTP, SendGrid, Resend
-- TLS/SSL support
-- Microsoft Exchange compliance (Basic Auth retirement September 2025)
-
-## Configuration
-
-### Basic SMTP Configuration
-
-```env
-MAIL_TYPE=smtp
-MAIL_DEFAULT_SEND_FROM=your-email@company.com
-SMTP_SERVER=smtp.company.com
-SMTP_PORT=587
-SMTP_USERNAME=your-email@company.com
-SMTP_PASSWORD=your-password
-SMTP_USE_TLS=true
-SMTP_OPPORTUNISTIC_TLS=true
-SMTP_AUTH_TYPE=basic
-```
-
-### Microsoft Exchange OAuth 2.0 Configuration
-
-For Microsoft Exchange/Outlook compatibility:
-
-```env
-MAIL_TYPE=smtp
-MAIL_DEFAULT_SEND_FROM=your-email@company.com
-SMTP_SERVER=smtp.office365.com
-SMTP_PORT=587
-SMTP_USERNAME=your-email@company.com
-SMTP_USE_TLS=true
-SMTP_OPPORTUNISTIC_TLS=true
-SMTP_AUTH_TYPE=oauth2
-
-# Microsoft OAuth 2.0 Settings
-MICROSOFT_OAUTH2_CLIENT_ID=your-azure-app-client-id
-MICROSOFT_OAUTH2_CLIENT_SECRET=your-azure-app-client-secret
-MICROSOFT_OAUTH2_TENANT_ID=your-tenant-id
-```
-
-## Microsoft Azure AD App Setup
-
-### 1. Create Azure AD Application
-
-1. Go to [Azure Portal](https://portal.azure.com) → Azure Active Directory → App registrations
-1. Click "New registration"
-1. Enter application name (e.g., "Dify Email Service")
-1. Select "Accounts in this organizational directory only"
-1. Click "Register"
-
-### 2. Configure API Permissions
-
-1. Go to "API permissions"
-1. Click "Add a permission" → Microsoft Graph
-1. Select "Application permissions"
-1. Add these permissions:
-   - `Mail.Send` - Send mail as any user
-   - `SMTP.Send` - Send email via SMTP AUTH
-1. Click "Grant admin consent"
-
-### 3. Create Client Secret
-
-1. Go to "Certificates & secrets"
-1. Click "New client secret"
-1. Enter description and expiration
-1. Copy the secret value (you won't see it again)
-
-### 4. Get Configuration Values
-
-- **Client ID**: Application (client) ID from Overview page
-- **Client Secret**: The secret value you just created
-- **Tenant ID**: Directory (tenant) ID from Overview page
-
-## Usage Examples
-
-### Basic Usage
-
-The email service is automatically configured based on environment variables. Simply use the mail extension:
-
-```python
-from extensions.ext_mail import mail
-
-# Send email
-mail_data = {
-    "to": "recipient@example.com",
-    "subject": "Test Email",
-    "html": "<h1>Hello World</h1>"
-}
-
-try:
-    mail._client.send(mail_data)
-    print("Email sent successfully")
-except Exception as e:
-    print(f"Failed to send email: {e}")
-```
-
-### OAuth Token Management
-
-For service accounts using client credentials flow:
-
-```python
-from libs.mail.oauth_email import MicrosoftEmailOAuth
-
-# Initialize OAuth client
-oauth_client = MicrosoftEmailOAuth(
-    client_id="your-client-id",
-    client_secret="your-client-secret",
-    redirect_uri="",  # Not needed for client credentials
-    tenant_id="your-tenant-id"
-)
-
-# Get access token
-try:
-    token_response = oauth_client.get_access_token_client_credentials()
-    access_token = token_response["access_token"]
-    print(f"Access token obtained: {access_token[:10]}...")
-except Exception as e:
-    print(f"Failed to get OAuth token: {e}")
-```
-
-### Custom SMTP Client
-
-For direct SMTP usage with OAuth:
-
-```python
-from libs.mail import SMTPClient
-
-# Create SMTP client with OAuth
-client = SMTPClient(
-    server="smtp.office365.com",
-    port=587,
-    username="your-email@company.com",
-    password="",  # Not used with OAuth
-    from_addr="your-email@company.com",
-    use_tls=True,
-    opportunistic_tls=True,
-    oauth_access_token="your-access-token",
-    auth_type="oauth2"
-)
-
-# Send email
-mail_data = {
-    "to": "recipient@example.com",
-    "subject": "OAuth Test",
-    "html": "<p>Sent via OAuth 2.0</p>"
-}
-
-client.send(mail_data)
-```
-
-## Migration from Basic Auth
-
-### Microsoft Exchange Migration
-
-Microsoft is retiring Basic Authentication for Exchange Online in September 2025. Follow these steps to migrate:
-
-1. **Set up Azure AD Application** (see setup instructions above)
-
-1. **Update configuration** to use OAuth 2.0:
-
-   ```env
-   SMTP_AUTH_TYPE=oauth2
-   MICROSOFT_OAUTH2_CLIENT_ID=your-client-id
-   MICROSOFT_OAUTH2_CLIENT_SECRET=your-client-secret
-   MICROSOFT_OAUTH2_TENANT_ID=your-tenant-id
-   ```
-
-1. **Test the configuration** before the migration deadline
-
-1. **Remove old password-based settings** once OAuth is working
-
-### Backward Compatibility
-
-The system maintains backward compatibility:
-
-- Existing Basic Auth configurations continue to work
-- OAuth settings are optional and only used when `SMTP_AUTH_TYPE=oauth2`
-- Gradual migration is supported
-
-## Troubleshooting
-
-### Common OAuth Issues
-
-1. **Token acquisition fails**:
-
-   - Verify Client ID and Secret are correct
-   - Check that admin consent was granted for API permissions
-   - Ensure Tenant ID is correct
-
-1. **SMTP authentication fails**:
-
-   - Verify the access token is valid and not expired
-   - Check that SMTP.Send permission is granted
-   - Ensure the user has Send As permissions
-
-1. **Configuration issues**:
-
-   - Verify all required environment variables are set
-   - Check SMTP server and port settings
-   - Ensure TLS settings match your server requirements
-
-### Testing Token Acquisition
-
-```python
-from libs.mail.oauth_email import MicrosoftEmailOAuth
-
-def test_oauth_token():
-    oauth_client = MicrosoftEmailOAuth(
-        client_id="your-client-id",
-        client_secret="your-client-secret",
-        redirect_uri="",
-        tenant_id="your-tenant-id"
-    )
-    
-    try:
-        response = oauth_client.get_access_token_client_credentials()
-        print("✓ OAuth token acquired successfully")
-        print(f"Token type: {response.get('token_type')}")
-        print(f"Expires in: {response.get('expires_in')} seconds")
-        return True
-    except Exception as e:
-        print(f"✗ OAuth token acquisition failed: {e}")
-        return False
-
-if __name__ == "__main__":
-    test_oauth_token()
-```
-
-## Security Considerations
-
-### Token Management
-
-- Access tokens are automatically obtained when needed
-- Tokens are not stored permanently
-- Client credentials flow is used for service accounts
-- Secrets should be stored securely in environment variables
-
-### Network Security
-
-- Always use TLS for SMTP connections (`SMTP_USE_TLS=true`)
-- Use opportunistic TLS when supported (`SMTP_OPPORTUNISTIC_TLS=true`)
-- Verify SMTP server certificates in production
-
-### Access Control
-
-- Grant minimum required permissions in Azure AD
-- Use dedicated service accounts for email sending
-- Regularly rotate client secrets
-- Monitor access logs for suspicious activity
-
-## Dependencies
-
-The email module uses these internal components:
-
-- `libs.mail.smtp`: Core SMTP client with OAuth support
-- `libs.mail.oauth_email`: Microsoft OAuth 2.0 implementation
-- `libs.mail.oauth_http_client`: HTTP client abstraction
-- `libs.mail.smtp_connection`: SMTP connection management
-- `extensions.ext_mail`: Flask extension for email integration
-
-## Testing
-
-The module includes comprehensive tests with proper mocking:
-
-- `tests/unit_tests/libs/mail/test_oauth_email.py`: OAuth functionality tests
-- `tests/unit_tests/libs/mail/test_smtp_enhanced.py`: SMTP client tests
-
-Run tests with:
-
-```bash
-uv run pytest tests/unit_tests/libs/mail/test_oauth_email.py -v
-uv run pytest tests/unit_tests/libs/mail/test_smtp_enhanced.py -v
-```

api/libs/mail/__init__.py

@@ -1,26 +0,0 @@
-"""Mail module for email functionality
-
-This module provides comprehensive email support including:
-- SMTP clients with OAuth 2.0 support
-- Microsoft Exchange/Outlook integration
-- Email authentication and connection management
-- Support for TLS/SSL encryption
-"""
-
-from .oauth_email import EmailOAuth, MicrosoftEmailOAuth, OAuthUserInfo
-from .oauth_http_client import OAuthHTTPClient, OAuthHTTPClientProtocol
-from .smtp import SMTPAuthenticator, SMTPClient, SMTPMessageBuilder
-from .smtp_connection import SMTPConnectionFactory, SMTPConnectionProtocol
-
-__all__ = [
-    "EmailOAuth",
-    "MicrosoftEmailOAuth",
-    "OAuthHTTPClient",
-    "OAuthHTTPClientProtocol",
-    "OAuthUserInfo",
-    "SMTPAuthenticator",
-    "SMTPClient",
-    "SMTPConnectionFactory",
-    "SMTPConnectionProtocol",
-    "SMTPMessageBuilder",
-]

api/libs/mail/oauth_email.py

@@ -1,175 +0,0 @@
-"""Email OAuth implementation with dependency injection for better testability"""
-
-import base64
-import urllib.parse
-from dataclasses import dataclass
-from typing import Union
-
-from .oauth_http_client import OAuthHTTPClient, OAuthHTTPClientProtocol
-
-
-@dataclass
-class OAuthUserInfo:
-    id: str
-    name: str
-    email: str
-
-
-class EmailOAuth:
-    """Base OAuth class with dependency injection"""
-
-    def __init__(
-        self,
-        client_id: str,
-        client_secret: str,
-        redirect_uri: str,
-        http_client: OAuthHTTPClientProtocol | None = None,
-    ):
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self.redirect_uri = redirect_uri
-        self.http_client = http_client or OAuthHTTPClient()
-
-    def get_authorization_url(self):
-        raise NotImplementedError()
-
-    def get_access_token(self, code: str):
-        raise NotImplementedError()
-
-    def get_raw_user_info(self, token: str):
-        raise NotImplementedError()
-
-    def get_user_info(self, token: str) -> OAuthUserInfo:
-        raw_info = self.get_raw_user_info(token)
-        return self._transform_user_info(raw_info)
-
-    def _transform_user_info(self, raw_info: dict) -> OAuthUserInfo:
-        raise NotImplementedError()
-
-
-class MicrosoftEmailOAuth(EmailOAuth):
-    """Microsoft OAuth 2.0 implementation with dependency injection
-
-    References:
-    - Microsoft identity platform OAuth 2.0: https://learn.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-auth-code-flow
-    - Microsoft Graph API permissions: https://learn.microsoft.com/en-us/graph/permissions-reference
-    - OAuth 2.0 client credentials flow: https://learn.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow
-    - SMTP OAuth 2.0 authentication: https://learn.microsoft.com/en-us/exchange/client-developer/legacy-protocols/how-to-authenticate-an-imap-pop-smtp-application-by-using-oauth
-    """
-
-    _AUTH_URL = "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/authorize"
-    _TOKEN_URL = "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"
-    _USER_INFO_URL = "https://graph.microsoft.com/v1.0/me"
-
-    def __init__(
-        self,
-        client_id: str,
-        client_secret: str,
-        redirect_uri: str,
-        tenant_id: str = "common",
-        http_client: OAuthHTTPClientProtocol | None = None,
-    ):
-        super().__init__(client_id, client_secret, redirect_uri, http_client)
-        self.tenant_id = tenant_id
-
-    def get_authorization_url(self, invite_token: str | None = None) -> str:
-        """Generate OAuth authorization URL"""
-        params = {
-            "client_id": self.client_id,
-            "response_type": "code",
-            "redirect_uri": self.redirect_uri,
-            "scope": "https://outlook.office.com/SMTP.Send offline_access",
-            "response_mode": "query",
-        }
-        if invite_token:
-            params["state"] = invite_token
-
-        auth_url = self._AUTH_URL.format(tenant=self.tenant_id)
-        return f"{auth_url}?{urllib.parse.urlencode(params)}"
-
-    def get_access_token(self, code: str) -> dict[str, Union[str, int]]:
-        """Get access token using authorization code flow"""
-        data: dict[str, Union[str, int]] = {
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "code": code,
-            "grant_type": "authorization_code",
-            "redirect_uri": self.redirect_uri,
-            "scope": "https://outlook.office.com/SMTP.Send offline_access",
-        }
-        headers = {"Content-Type": "application/x-www-form-urlencoded"}
-
-        token_url = self._TOKEN_URL.format(tenant=self.tenant_id)
-        response = self.http_client.post(token_url, data=data, headers=headers)
-
-        if response["status_code"] != 200:
-            raise ValueError(f"Error in Microsoft OAuth: {response['json']}")
-
-        json_response = response["json"]
-        if isinstance(json_response, dict):
-            return json_response
-        raise ValueError("Unexpected response format")
-
-    def get_access_token_client_credentials(
-        self, scope: str = "https://outlook.office365.com/.default"
-    ) -> dict[str, Union[str, int]]:
-        """Get access token using client credentials flow (for service accounts)"""
-        data: dict[str, Union[str, int]] = {
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "grant_type": "client_credentials",
-            "scope": scope,
-        }
-        headers = {"Content-Type": "application/x-www-form-urlencoded"}
-
-        token_url = self._TOKEN_URL.format(tenant=self.tenant_id)
-        response = self.http_client.post(token_url, data=data, headers=headers)
-
-        if response["status_code"] != 200:
-            raise ValueError(f"Error in Microsoft OAuth Client Credentials: {response['json']}")
-
-        json_response = response["json"]
-        if isinstance(json_response, dict):
-            return json_response
-        raise ValueError("Unexpected response format")
-
-    def refresh_access_token(self, refresh_token: str) -> dict[str, Union[str, int]]:
-        """Refresh access token using refresh token"""
-        data: dict[str, Union[str, int]] = {
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "refresh_token": refresh_token,
-            "grant_type": "refresh_token",
-            "scope": "https://outlook.office.com/SMTP.Send offline_access",
-        }
-        headers = {"Content-Type": "application/x-www-form-urlencoded"}
-
-        token_url = self._TOKEN_URL.format(tenant=self.tenant_id)
-        response = self.http_client.post(token_url, data=data, headers=headers)
-
-        if response["status_code"] != 200:
-            raise ValueError(f"Error refreshing Microsoft OAuth token: {response['json']}")
-
-        json_response = response["json"]
-        if isinstance(json_response, dict):
-            return json_response
-        raise ValueError("Unexpected response format")
-
-    def get_raw_user_info(self, token: str) -> dict[str, Union[str, int, dict, list]]:
-        """Get user info from Microsoft Graph API"""
-        headers = {"Authorization": f"Bearer {token}"}
-        return self.http_client.get(self._USER_INFO_URL, headers=headers)
-
-    def _transform_user_info(self, raw_info: dict) -> OAuthUserInfo:
-        """Transform raw user info to OAuthUserInfo"""
-        return OAuthUserInfo(
-            id=str(raw_info["id"]),
-            name=raw_info.get("displayName", ""),
-            email=raw_info.get("mail", raw_info.get("userPrincipalName", "")),
-        )
-
-    @staticmethod
-    def create_sasl_xoauth2_string(username: str, access_token: str) -> str:
-        """Create SASL XOAUTH2 authentication string for SMTP"""
-        auth_string = f"user={username}\x01auth=Bearer {access_token}\x01\x01"
-        return base64.b64encode(auth_string.encode()).decode()

api/libs/mail/oauth_http_client.py

@@ -1,45 +0,0 @@
-"""HTTP client abstraction for OAuth requests"""
-
-from abc import ABC, abstractmethod
-from typing import Union
-
-import requests
-
-
-class OAuthHTTPClientProtocol(ABC):
-    """Abstract interface for OAuth HTTP operations"""
-
-    @abstractmethod
-    def post(
-        self, url: str, data: dict[str, Union[str, int]], headers: dict[str, str] | None = None
-    ) -> dict[str, Union[str, int, dict, list]]:
-        """Make a POST request"""
-        pass
-
-    @abstractmethod
-    def get(self, url: str, headers: dict[str, str] | None = None) -> dict[str, Union[str, int, dict, list]]:
-        """Make a GET request"""
-        pass
-
-
-class OAuthHTTPClient(OAuthHTTPClientProtocol):
-    """Default implementation using requests library"""
-
-    def post(
-        self, url: str, data: dict[str, Union[str, int]], headers: dict[str, str] | None = None
-    ) -> dict[str, Union[str, int, dict, list]]:
-        """Make a POST request"""
-        response = requests.post(url, data=data, headers=headers or {})
-        return {
-            "status_code": response.status_code,
-            "json": response.json() if response.headers.get("content-type", "").startswith("application/json") else {},
-            "text": response.text,
-            "headers": dict(response.headers),
-        }
-
-    def get(self, url: str, headers: dict[str, str] | None = None) -> dict[str, Union[str, int, dict, list]]:
-        """Make a GET request"""
-        response = requests.get(url, headers=headers or {})
-        response.raise_for_status()
-        json_data = response.json()
-        return dict(json_data)

api/libs/mail/smtp.py

@@ -1,163 +0,0 @@
-"""Enhanced SMTP client with dependency injection for better testability"""
-
-import base64
-import logging
-import smtplib
-from email.mime.multipart import MIMEMultipart
-from email.mime.text import MIMEText
-
-from .smtp_connection import (
-    SMTPConnectionFactory,
-    SMTPConnectionProtocol,
-    SSLSMTPConnectionFactory,
-    StandardSMTPConnectionFactory,
-)
-
-
-class SMTPAuthenticator:
-    """Handles SMTP authentication logic"""
-
-    @staticmethod
-    def create_sasl_xoauth2_string(username: str, access_token: str) -> str:
-        """Create SASL XOAUTH2 authentication string for SMTP OAuth2
-
-        References:
-        - SASL XOAUTH2 Mechanism: https://developers.google.com/gmail/imap/xoauth2-protocol
-        - Microsoft XOAUTH2 Format: https://learn.microsoft.com/en-us/exchange/client-developer/legacy-protocols/how-to-authenticate-an-imap-pop-smtp-application-by-using-oauth#sasl-xoauth2
-        """
-        auth_string = f"user={username}\x01auth=Bearer {access_token}\x01\x01"
-        return base64.b64encode(auth_string.encode()).decode()
-
-    def authenticate_basic(self, connection: SMTPConnectionProtocol, username: str, password: str) -> None:
-        """Perform basic authentication"""
-        if username and password and username.strip() and password.strip():
-            connection.login(username, password)
-
-    def authenticate_oauth2(self, connection: SMTPConnectionProtocol, username: str, access_token: str) -> None:
-        """Perform OAuth 2.0 authentication using SASL XOAUTH2 mechanism
-
-        References:
-        - Microsoft OAuth 2.0 and SMTP: https://learn.microsoft.com/en-us/exchange/client-developer/legacy-protocols/how-to-authenticate-an-imap-pop-smtp-application-by-using-oauth
-        - SASL XOAUTH2 Mechanism: https://developers.google.com/gmail/imap/xoauth2-protocol
-        - RFC 4954 - SMTP AUTH: https://tools.ietf.org/html/rfc4954
-        """
-        if not username or not access_token:
-            raise ValueError("Username and OAuth access token are required for OAuth2 authentication")
-
-        auth_string = self.create_sasl_xoauth2_string(username, access_token)
-
-        try:
-            connection.docmd("AUTH", f"XOAUTH2 {auth_string}")
-        except smtplib.SMTPAuthenticationError as e:
-            logging.exception("OAuth2 authentication failed for user %s", username)
-            raise ValueError(f"OAuth2 authentication failed: {str(e)}")
-        except Exception:
-            logging.exception("Unexpected error during OAuth2 authentication for user %s", username)
-            raise
-
-
-class SMTPMessageBuilder:
-    """Builds SMTP messages"""
-
-    @staticmethod
-    def build_message(mail_data: dict[str, str], from_addr: str) -> MIMEMultipart:
-        """Build a MIME message from mail data"""
-        msg = MIMEMultipart()
-        msg["Subject"] = mail_data["subject"]
-        msg["From"] = from_addr
-        msg["To"] = mail_data["to"]
-        msg.attach(MIMEText(mail_data["html"], "html"))
-        return msg
-
-
-class SMTPClient:
-    """SMTP client with OAuth 2.0 support and dependency injection for better testability"""
-
-    def __init__(
-        self,
-        server: str,
-        port: int,
-        username: str,
-        password: str,
-        from_addr: str,
-        use_tls: bool = False,
-        opportunistic_tls: bool = False,
-        oauth_access_token: str | None = None,
-        auth_type: str = "basic",
-        connection_factory: SMTPConnectionFactory | None = None,
-        ssl_connection_factory: SMTPConnectionFactory | None = None,
-        authenticator: SMTPAuthenticator | None = None,
-        message_builder: SMTPMessageBuilder | None = None,
-    ):
-        self.server = server
-        self.port = port
-        self.from_addr = from_addr
-        self.username = username
-        self.password = password
-        self.use_tls = use_tls
-        self.opportunistic_tls = opportunistic_tls
-        self.oauth_access_token = oauth_access_token
-        self.auth_type = auth_type
-
-        # Use injected dependencies or create defaults
-        self.connection_factory = connection_factory or StandardSMTPConnectionFactory()
-        self.ssl_connection_factory = ssl_connection_factory or SSLSMTPConnectionFactory()
-        self.authenticator = authenticator or SMTPAuthenticator()
-        self.message_builder = message_builder or SMTPMessageBuilder()
-
-    def _create_connection(self) -> SMTPConnectionProtocol:
-        """Create appropriate SMTP connection based on TLS settings"""
-        if self.use_tls and not self.opportunistic_tls:
-            return self.ssl_connection_factory.create_connection(self.server, self.port)
-        else:
-            return self.connection_factory.create_connection(self.server, self.port)
-
-    def _setup_tls_if_needed(self, connection: SMTPConnectionProtocol) -> None:
-        """Setup TLS if opportunistic TLS is enabled"""
-        if self.use_tls and self.opportunistic_tls:
-            connection.ehlo(self.server)
-            connection.starttls()
-            connection.ehlo(self.server)
-
-    def _authenticate(self, connection: SMTPConnectionProtocol) -> None:
-        """Authenticate with the SMTP server"""
-        if self.auth_type == "oauth2":
-            if not self.oauth_access_token:
-                raise ValueError("OAuth access token is required for oauth2 auth_type")
-            self.authenticator.authenticate_oauth2(connection, self.username, self.oauth_access_token)
-        else:
-            self.authenticator.authenticate_basic(connection, self.username, self.password)
-
-    def send(self, mail: dict[str, str]) -> None:
-        """Send email using SMTP"""
-        connection = None
-        try:
-            # Create connection
-            connection = self._create_connection()
-
-            # Setup TLS if needed
-            self._setup_tls_if_needed(connection)
-
-            # Authenticate
-            self._authenticate(connection)
-
-            # Build and send message
-            msg = self.message_builder.build_message(mail, self.from_addr)
-            connection.sendmail(self.from_addr, mail["to"], msg.as_string())
-
-        except smtplib.SMTPException:
-            logging.exception("SMTP error occurred")
-            raise
-        except TimeoutError:
-            logging.exception("Timeout occurred while sending email")
-            raise
-        except Exception:
-            logging.exception("Unexpected error occurred while sending email to %s", mail["to"])
-            raise
-        finally:
-            if connection:
-                try:
-                    connection.quit()
-                except Exception:
-                    # Ignore errors during cleanup
-                    pass

api/libs/mail/smtp_connection.py

@@ -1,79 +0,0 @@
-"""SMTP connection abstraction for better testability"""
-
-import smtplib
-from abc import ABC, abstractmethod
-from typing import Protocol, Union
-
-
-class SMTPConnectionProtocol(Protocol):
-    """Protocol defining SMTP connection interface"""
-
-    def ehlo(self, name: str = "") -> tuple[int, bytes]: ...
-
-    def starttls(self) -> tuple[int, bytes]: ...
-
-    def login(self, user: str, password: str) -> tuple[int, bytes]: ...
-
-    def docmd(self, cmd: str, args: str = "") -> tuple[int, bytes]: ...
-
-    def sendmail(self, from_addr: str, to_addrs: str, msg: str) -> dict: ...
-
-    def quit(self) -> tuple[int, bytes]: ...
-
-
-class SMTPConnectionFactory(ABC):
-    """Abstract factory for creating SMTP connections"""
-
-    @abstractmethod
-    def create_connection(self, server: str, port: int, timeout: int = 10) -> SMTPConnectionProtocol:
-        """Create an SMTP connection"""
-        pass
-
-
-class SMTPConnectionWrapper:
-    """Wrapper to adapt smtplib.SMTP to our protocol"""
-
-    def __init__(self, smtp_obj: Union[smtplib.SMTP, smtplib.SMTP_SSL]):
-        self._smtp = smtp_obj
-
-    def ehlo(self, name: str = "") -> tuple[int, bytes]:
-        result = self._smtp.ehlo(name)
-        return (result[0], result[1])
-
-    def starttls(self) -> tuple[int, bytes]:
-        result = self._smtp.starttls()
-        return (result[0], result[1])
-
-    def login(self, user: str, password: str) -> tuple[int, bytes]:
-        result = self._smtp.login(user, password)
-        return (result[0], result[1])
-
-    def docmd(self, cmd: str, args: str = "") -> tuple[int, bytes]:
-        result = self._smtp.docmd(cmd, args)
-        return (result[0], result[1])
-
-    def sendmail(self, from_addr: str, to_addrs: str, msg: str) -> dict:
-        result = self._smtp.sendmail(from_addr, to_addrs, msg)
-        return dict(result)
-
-    def quit(self) -> tuple[int, bytes]:
-        result = self._smtp.quit()
-        return (result[0], result[1])
-
-
-class StandardSMTPConnectionFactory(SMTPConnectionFactory):
-    """Factory for creating standard SMTP connections"""
-
-    def create_connection(self, server: str, port: int, timeout: int = 10) -> SMTPConnectionProtocol:
-        """Create a standard SMTP connection"""
-        smtp_obj = smtplib.SMTP(server, port, timeout=timeout)
-        return SMTPConnectionWrapper(smtp_obj)
-
-
-class SSLSMTPConnectionFactory(SMTPConnectionFactory):
-    """Factory for creating SSL SMTP connections"""
-
-    def create_connection(self, server: str, port: int, timeout: int = 10) -> SMTPConnectionProtocol:
-        """Create an SSL SMTP connection"""
-        smtp_obj = smtplib.SMTP_SSL(server, port, timeout=timeout)
-        return SMTPConnectionWrapper(smtp_obj)

api/libs/smtp.py

@@ -0,0 +1,59 @@
+import logging
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+logger = logging.getLogger(__name__)
+
+
+class SMTPClient:
+    def __init__(
+        self, server: str, port: int, username: str, password: str, _from: str, use_tls=False, opportunistic_tls=False
+    ):
+        self.server = server
+        self.port = port
+        self._from = _from
+        self.username = username
+        self.password = password
+        self.use_tls = use_tls
+        self.opportunistic_tls = opportunistic_tls
+
+    def send(self, mail: dict):
+        smtp = None
+        try:
+            if self.use_tls:
+                if self.opportunistic_tls:
+                    smtp = smtplib.SMTP(self.server, self.port, timeout=10)
+                    # Send EHLO command with the HELO domain name as the server address
+                    smtp.ehlo(self.server)
+                    smtp.starttls()
+                    # Resend EHLO command to identify the TLS session
+                    smtp.ehlo(self.server)
+                else:
+                    smtp = smtplib.SMTP_SSL(self.server, self.port, timeout=10)
+            else:
+                smtp = smtplib.SMTP(self.server, self.port, timeout=10)
+
+            # Only authenticate if both username and password are non-empty
+            if self.username and self.password and self.username.strip() and self.password.strip():
+                smtp.login(self.username, self.password)
+
+            msg = MIMEMultipart()
+            msg["Subject"] = mail["subject"]
+            msg["From"] = self._from
+            msg["To"] = mail["to"]
+            msg.attach(MIMEText(mail["html"], "html"))
+
+            smtp.sendmail(self._from, mail["to"], msg.as_string())
+        except smtplib.SMTPException:
+            logger.exception("SMTP error occurred")
+            raise
+        except TimeoutError:
+            logger.exception("Timeout occurred while sending email")
+            raise
+        except Exception:
+            logger.exception("Unexpected error occurred while sending email to %s", mail["to"])
+            raise
+        finally:
+            if smtp:
+                smtp.quit()

api/pyproject.toml

@@ -5,7 +5,6 @@ requires-python = ">=3.11,<3.13"
 
 dependencies = [
     "arize-phoenix-otel~=0.9.2",
-    "authlib==1.6.4",
     "azure-identity==1.16.1",
     "beautifulsoup4==4.12.2",
     "boto3==1.35.99",
@@ -34,10 +33,8 @@ dependencies = [
     "json-repair>=0.41.1",
     "langfuse~=2.51.3",
     "langsmith~=0.1.77",
-    "mailchimp-transactional~=1.0.50",
     "markdown~=3.5.1",
     "numpy~=1.26.4",
-    "openai~=1.61.0",
     "openpyxl~=3.1.5",
     "opik~=1.7.25",
     "opentelemetry-api==1.27.0",
@@ -49,6 +46,7 @@ dependencies = [
     "opentelemetry-instrumentation==0.48b0",
     "opentelemetry-instrumentation-celery==0.48b0",
     "opentelemetry-instrumentation-flask==0.48b0",
+    "opentelemetry-instrumentation-httpx==0.48b0",
     "opentelemetry-instrumentation-redis==0.48b0",
     "opentelemetry-instrumentation-requests==0.48b0",
     "opentelemetry-instrumentation-sqlalchemy==0.48b0",
@@ -60,7 +58,6 @@ dependencies = [
     "opentelemetry-semantic-conventions==0.48b0",
     "opentelemetry-util-http==0.48b0",
     "pandas[excel,output-formatting,performance]~=2.2.2",
-    "pandoc~=2.4",
     "psycogreen~=1.0.2",
     "psycopg2-binary~=2.9.6",
     "pycryptodome==3.19.1",
@@ -178,10 +175,10 @@ dev = [
 # Required for storage clients
 ############################################################
 storage = [
-    "azure-storage-blob==12.13.0",
+    "azure-storage-blob==12.26.0",
     "bce-python-sdk~=0.9.23",
     "cos-python-sdk-v5==1.9.38",
-    "esdk-obs-python==3.24.6.1",
+    "esdk-obs-python==3.25.8",
     "google-cloud-storage==2.16.0",
     "opendal~=0.46.0",
     "oss2==2.18.5",

api/pyrightconfig.json

@@ -4,8 +4,7 @@
     "tests/",
     ".venv",
     "migrations/",
-    "core/rag",
-    "core/app/app_config/easy_ui_based_app/dataset"
+    "core/rag"
   ],
   "typeCheckingMode": "strict",
   "allowedUntypedLibraries": [
@@ -13,6 +12,7 @@
     "flask_login",
     "opentelemetry.instrumentation.celery",
     "opentelemetry.instrumentation.flask",
+    "opentelemetry.instrumentation.httpx",
     "opentelemetry.instrumentation.requests",
     "opentelemetry.instrumentation.sqlalchemy",
     "opentelemetry.instrumentation.redis"

api/pytest.ini

@@ -7,7 +7,7 @@ env =
     CHATGLM_API_BASE = http://a.abc.com:11451
     CODE_EXECUTION_API_KEY = dify-sandbox
     CODE_EXECUTION_ENDPOINT = http://127.0.0.1:8194
-    CODE_MAX_STRING_LENGTH = 80000
+    CODE_MAX_STRING_LENGTH = 400000
     PLUGIN_DAEMON_KEY=lYkiYYT6owG+71oLerGzA7GXCgOT++6ovaezWAjpCjf+Sjc3ZtU+qUEi
     PLUGIN_DAEMON_URL=http://127.0.0.1:5002
     PLUGIN_MAX_PACKAGE_SIZE=15728640

api/services/app_generate_service.py

@@ -2,8 +2,6 @@ import uuid
 from collections.abc import Generator, Mapping
 from typing import Any, Union
 
-from openai._exceptions import RateLimitError
-
 from configs import dify_config
 from core.app.apps.advanced_chat.app_generator import AdvancedChatAppGenerator
 from core.app.apps.agent_chat.app_generator import AgentChatAppGenerator
@@ -122,8 +120,6 @@ class AppGenerateService:
                 )
             else:
                 raise ValueError(f"Invalid app mode {app_model.mode}")
-        except RateLimitError as e:
-            raise InvokeRateLimitError(str(e))
         except Exception:
             rate_limit.exit(request_id)
             raise

api/services/rag_pipeline/rag_pipeline_transform_service.py

@@ -149,8 +149,7 @@ class RagPipelineTransformService:
         file_extensions = node.get("data", {}).get("fileExtensions", [])
         if not file_extensions:
             return node
-        file_extensions = [file_extension.lower() for file_extension in file_extensions]
-        node["data"]["fileExtensions"] = DOCUMENT_EXTENSIONS
+        node["data"]["fileExtensions"] = [ext.lower() for ext in file_extensions if ext in DOCUMENT_EXTENSIONS]
         return node
 
     def _deal_knowledge_index(

api/services/tools/builtin_tools_manage_service.py

@@ -349,14 +349,10 @@ class BuiltinToolManageService:
             provider_controller = ToolManager.get_builtin_provider(default_provider.provider, tenant_id)
 
             credentials: list[ToolProviderCredentialApiEntity] = []
-            encrypters = {}
             for provider in providers:
-                credential_type = provider.credential_type
-                if credential_type not in encrypters:
-                    encrypters[credential_type] = BuiltinToolManageService.create_tool_encrypter(
-                        tenant_id, provider, provider.provider, provider_controller
-                    )[0]
-                encrypter = encrypters[credential_type]
+                encrypter, _ = BuiltinToolManageService.create_tool_encrypter(
+                    tenant_id, provider, provider.provider, provider_controller
+                )
                 decrypt_credential = encrypter.mask_tool_credentials(encrypter.decrypt(provider.credentials))
                 credential_entity = ToolTransformService.convert_builtin_provider_to_credential_entity(
                     provider=provider,

api/tasks/rag_pipeline/priority_rag_pipeline_run_task.py

@@ -29,23 +29,10 @@ def priority_rag_pipeline_run_task(
     tenant_id: str,
 ):
     """
-    Async Run rag pipeline
-    :param rag_pipeline_invoke_entities: Rag pipeline invoke entities
-    rag_pipeline_invoke_entities include:
-    :param pipeline_id: Pipeline ID
-    :param user_id: User ID
-    :param tenant_id: Tenant ID
-    :param workflow_id: Workflow ID
-    :param invoke_from: Invoke source (debugger, published, etc.)
-    :param streaming: Whether to stream results
-    :param datasource_type: Type of datasource
-    :param datasource_info: Datasource information dict
-    :param batch: Batch identifier
-    :param document_id: Document ID (optional)
-    :param start_node_id: Starting node ID
-    :param inputs: Input parameters dict
-    :param workflow_execution_id: Workflow execution ID
-    :param workflow_thread_pool_id: Thread pool ID for workflow execution
+    Async Run rag pipeline task using high priority queue.
+
+    :param rag_pipeline_invoke_entities_file_id: File ID containing serialized RAG pipeline invoke entities
+    :param tenant_id: Tenant ID for the pipeline execution
     """
     # run with threading, thread pool size is 10
 

api/tasks/rag_pipeline/rag_pipeline_run_task.py

@@ -30,23 +30,10 @@ def rag_pipeline_run_task(
     tenant_id: str,
 ):
     """
-    Async Run rag pipeline
-    :param rag_pipeline_invoke_entities: Rag pipeline invoke entities
-    rag_pipeline_invoke_entities include:
-    :param pipeline_id: Pipeline ID
-    :param user_id: User ID
-    :param tenant_id: Tenant ID
-    :param workflow_id: Workflow ID
-    :param invoke_from: Invoke source (debugger, published, etc.)
-    :param streaming: Whether to stream results
-    :param datasource_type: Type of datasource
-    :param datasource_info: Datasource information dict
-    :param batch: Batch identifier
-    :param document_id: Document ID (optional)
-    :param start_node_id: Starting node ID
-    :param inputs: Input parameters dict
-    :param workflow_execution_id: Workflow execution ID
-    :param workflow_thread_pool_id: Thread pool ID for workflow execution
+    Async Run rag pipeline task using regular priority queue.
+
+    :param rag_pipeline_invoke_entities_file_id: File ID containing serialized RAG pipeline invoke entities
+    :param tenant_id: Tenant ID for the pipeline execution
     """
     # run with threading, thread pool size is 10
 

api/tasks/workflow_draft_var_tasks.py

@@ -5,15 +5,10 @@ These tasks provide asynchronous storage capabilities for workflow execution dat
 improving performance by offloading storage operations to background workers.
 """
 
-import logging
-
 from celery import shared_task  # type: ignore[import-untyped]
 from sqlalchemy.orm import Session
 
 from extensions.ext_database import db
-
-_logger = logging.getLogger(__name__)
-
 from services.workflow_draft_variable_service import DraftVarFileDeletion, WorkflowDraftVariableService
 
 

api/tests/integration_tests/workflow/nodes/test_code.py

@@ -1,9 +1,9 @@
 import time
 import uuid
-from os import getenv
 
 import pytest
 
+from configs import dify_config
 from core.app.entities.app_invoke_entities import InvokeFrom
 from core.workflow.entities import GraphInitParams, GraphRuntimeState, VariablePool
 from core.workflow.enums import WorkflowNodeExecutionStatus
@@ -15,7 +15,7 @@ from core.workflow.system_variable import SystemVariable
 from models.enums import UserFrom
 from tests.integration_tests.workflow.nodes.__mock.code_executor import setup_code_executor_mock
 
-CODE_MAX_STRING_LENGTH = int(getenv("CODE_MAX_STRING_LENGTH", "10000"))
+CODE_MAX_STRING_LENGTH = dify_config.CODE_MAX_STRING_LENGTH
 
 
 def init_code_node(code_config: dict):

api/tests/test_containers_integration_tests/services/test_app_generate_service.py

@@ -3,7 +3,6 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 from faker import Faker
-from openai._exceptions import RateLimitError
 
 from core.app.entities.app_invoke_entities import InvokeFrom
 from models.model import EndUser
@@ -484,36 +483,6 @@ class TestAppGenerateService:
             # Verify error message
             assert "Rate limit exceeded" in str(exc_info.value)
 
-    def test_generate_with_rate_limit_error_from_openai(
-        self, db_session_with_containers, mock_external_service_dependencies
-    ):
-        """
-        Test generation when OpenAI rate limit error occurs.
-        """
-        fake = Faker()
-        app, account = self._create_test_app_and_account(
-            db_session_with_containers, mock_external_service_dependencies, mode="completion"
-        )
-
-        # Setup completion generator to raise RateLimitError
-        mock_response = MagicMock()
-        mock_response.request = MagicMock()
-        mock_external_service_dependencies["completion_generator"].return_value.generate.side_effect = RateLimitError(
-            "Rate limit exceeded", response=mock_response, body=None
-        )
-
-        # Setup test arguments
-        args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
-
-        # Execute the method under test and expect rate limit error
-        with pytest.raises(InvokeRateLimitError) as exc_info:
-            AppGenerateService.generate(
-                app_model=app, user=account, args=args, invoke_from=InvokeFrom.SERVICE_API, streaming=True
-            )
-
-        # Verify error message
-        assert "Rate limit exceeded" in str(exc_info.value)
-
     def test_generate_with_invalid_app_mode(self, db_session_with_containers, mock_external_service_dependencies):
         """
         Test generation with invalid app mode.

api/tests/test_containers_integration_tests/tasks/test_mail_change_mail_task.py

@@ -0,0 +1,282 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from faker import Faker
+
+from libs.email_i18n import EmailType
+from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole
+from tasks.mail_change_mail_task import send_change_mail_completed_notification_task, send_change_mail_task
+
+
+class TestMailChangeMailTask:
+    """Integration tests for mail_change_mail_task using testcontainers."""
+
+    @pytest.fixture
+    def mock_external_service_dependencies(self):
+        """Mock setup for external service dependencies."""
+        with (
+            patch("tasks.mail_change_mail_task.mail") as mock_mail,
+            patch("tasks.mail_change_mail_task.get_email_i18n_service") as mock_get_email_i18n_service,
+        ):
+            # Setup mock mail service
+            mock_mail.is_inited.return_value = True
+
+            # Setup mock email i18n service
+            mock_email_service = MagicMock()
+            mock_get_email_i18n_service.return_value = mock_email_service
+
+            yield {
+                "mail": mock_mail,
+                "email_i18n_service": mock_email_service,
+                "get_email_i18n_service": mock_get_email_i18n_service,
+            }
+
+    def _create_test_account(self, db_session_with_containers):
+        """
+        Helper method to create a test account for testing.
+
+        Args:
+            db_session_with_containers: Database session from testcontainers infrastructure
+
+        Returns:
+            Account: Created account instance
+        """
+        fake = Faker()
+
+        # Create account
+        account = Account(
+            email=fake.email(),
+            name=fake.name(),
+            interface_language="en-US",
+            status="active",
+        )
+        db_session_with_containers.add(account)
+        db_session_with_containers.commit()
+
+        # Create tenant
+        tenant = Tenant(
+            name=fake.company(),
+            status="normal",
+        )
+        db_session_with_containers.add(tenant)
+        db_session_with_containers.commit()
+
+        # Create tenant-account join
+        join = TenantAccountJoin(
+            tenant_id=tenant.id,
+            account_id=account.id,
+            role=TenantAccountRole.OWNER.value,
+            current=True,
+        )
+        db_session_with_containers.add(join)
+        db_session_with_containers.commit()
+
+        return account
+
+    def test_send_change_mail_task_success_old_email_phase(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test successful change email task execution for old_email phase.
+
+        This test verifies:
+        - Proper mail service initialization check
+        - Correct email service method call with old_email phase
+        - Successful task completion
+        """
+        # Arrange: Create test data
+        account = self._create_test_account(db_session_with_containers)
+        test_language = "en-US"
+        test_email = account.email
+        test_code = "123456"
+        test_phase = "old_email"
+
+        # Act: Execute the task
+        send_change_mail_task(test_language, test_email, test_code, test_phase)
+
+        # Assert: Verify the expected outcomes
+        mock_external_service_dependencies["mail"].is_inited.assert_called_once()
+        mock_external_service_dependencies["get_email_i18n_service"].assert_called_once()
+        mock_external_service_dependencies["email_i18n_service"].send_change_email.assert_called_once_with(
+            language_code=test_language,
+            to=test_email,
+            code=test_code,
+            phase=test_phase,
+        )
+
+    def test_send_change_mail_task_success_new_email_phase(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test successful change email task execution for new_email phase.
+
+        This test verifies:
+        - Proper mail service initialization check
+        - Correct email service method call with new_email phase
+        - Successful task completion
+        """
+        # Arrange: Create test data
+        account = self._create_test_account(db_session_with_containers)
+        test_language = "zh-Hans"
+        test_email = "new@example.com"
+        test_code = "789012"
+        test_phase = "new_email"
+
+        # Act: Execute the task
+        send_change_mail_task(test_language, test_email, test_code, test_phase)
+
+        # Assert: Verify the expected outcomes
+        mock_external_service_dependencies["mail"].is_inited.assert_called_once()
+        mock_external_service_dependencies["get_email_i18n_service"].assert_called_once()
+        mock_external_service_dependencies["email_i18n_service"].send_change_email.assert_called_once_with(
+            language_code=test_language,
+            to=test_email,
+            code=test_code,
+            phase=test_phase,
+        )
+
+    def test_send_change_mail_task_mail_not_initialized(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test change email task when mail service is not initialized.
+
+        This test verifies:
+        - Early return when mail service is not initialized
+        - No email service calls when mail is not available
+        """
+        # Arrange: Setup mail service as not initialized
+        mock_external_service_dependencies["mail"].is_inited.return_value = False
+        test_language = "en-US"
+        test_email = "test@example.com"
+        test_code = "123456"
+        test_phase = "old_email"
+
+        # Act: Execute the task
+        send_change_mail_task(test_language, test_email, test_code, test_phase)
+
+        # Assert: Verify no email service calls
+        mock_external_service_dependencies["mail"].is_inited.assert_called_once()
+        mock_external_service_dependencies["get_email_i18n_service"].assert_not_called()
+        mock_external_service_dependencies["email_i18n_service"].send_change_email.assert_not_called()
+
+    def test_send_change_mail_task_email_service_exception(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test change email task when email service raises an exception.
+
+        This test verifies:
+        - Exception is properly caught and logged
+        - Task completes without raising exception
+        """
+        # Arrange: Setup email service to raise exception
+        mock_external_service_dependencies["email_i18n_service"].send_change_email.side_effect = Exception(
+            "Email service failed"
+        )
+        test_language = "en-US"
+        test_email = "test@example.com"
+        test_code = "123456"
+        test_phase = "old_email"
+
+        # Act: Execute the task (should not raise exception)
+        send_change_mail_task(test_language, test_email, test_code, test_phase)
+
+        # Assert: Verify email service was called despite exception
+        mock_external_service_dependencies["mail"].is_inited.assert_called_once()
+        mock_external_service_dependencies["get_email_i18n_service"].assert_called_once()
+        mock_external_service_dependencies["email_i18n_service"].send_change_email.assert_called_once_with(
+            language_code=test_language,
+            to=test_email,
+            code=test_code,
+            phase=test_phase,
+        )
+
+    def test_send_change_mail_completed_notification_task_success(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test successful change email completed notification task execution.
+
+        This test verifies:
+        - Proper mail service initialization check
+        - Correct email service method call with CHANGE_EMAIL_COMPLETED type
+        - Template context is properly constructed
+        - Successful task completion
+        """
+        # Arrange: Create test data
+        account = self._create_test_account(db_session_with_containers)
+        test_language = "en-US"
+        test_email = account.email
+
+        # Act: Execute the task
+        send_change_mail_completed_notification_task(test_language, test_email)
+
+        # Assert: Verify the expected outcomes
+        mock_external_service_dependencies["mail"].is_inited.assert_called_once()
+        mock_external_service_dependencies["get_email_i18n_service"].assert_called_once()
+        mock_external_service_dependencies["email_i18n_service"].send_email.assert_called_once_with(
+            email_type=EmailType.CHANGE_EMAIL_COMPLETED,
+            language_code=test_language,
+            to=test_email,
+            template_context={
+                "to": test_email,
+                "email": test_email,
+            },
+        )
+
+    def test_send_change_mail_completed_notification_task_mail_not_initialized(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test change email completed notification task when mail service is not initialized.
+
+        This test verifies:
+        - Early return when mail service is not initialized
+        - No email service calls when mail is not available
+        """
+        # Arrange: Setup mail service as not initialized
+        mock_external_service_dependencies["mail"].is_inited.return_value = False
+        test_language = "en-US"
+        test_email = "test@example.com"
+
+        # Act: Execute the task
+        send_change_mail_completed_notification_task(test_language, test_email)
+
+        # Assert: Verify no email service calls
+        mock_external_service_dependencies["mail"].is_inited.assert_called_once()
+        mock_external_service_dependencies["get_email_i18n_service"].assert_not_called()
+        mock_external_service_dependencies["email_i18n_service"].send_email.assert_not_called()
+
+    def test_send_change_mail_completed_notification_task_email_service_exception(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test change email completed notification task when email service raises an exception.
+
+        This test verifies:
+        - Exception is properly caught and logged
+        - Task completes without raising exception
+        """
+        # Arrange: Setup email service to raise exception
+        mock_external_service_dependencies["email_i18n_service"].send_email.side_effect = Exception(
+            "Email service failed"
+        )
+        test_language = "en-US"
+        test_email = "test@example.com"
+
+        # Act: Execute the task (should not raise exception)
+        send_change_mail_completed_notification_task(test_language, test_email)
+
+        # Assert: Verify email service was called despite exception
+        mock_external_service_dependencies["mail"].is_inited.assert_called_once()
+        mock_external_service_dependencies["get_email_i18n_service"].assert_called_once()
+        mock_external_service_dependencies["email_i18n_service"].send_email.assert_called_once_with(
+            email_type=EmailType.CHANGE_EMAIL_COMPLETED,
+            language_code=test_language,
+            to=test_email,
+            template_context={
+                "to": test_email,
+                "email": test_email,
+            },
+        )

api/tests/test_containers_integration_tests/tasks/test_mail_inner_task.py

@@ -0,0 +1,261 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from faker import Faker
+
+from tasks.mail_inner_task import send_inner_email_task
+
+
+class TestMailInnerTask:
+    """Integration tests for send_inner_email_task using testcontainers."""
+
+    @pytest.fixture
+    def mock_external_service_dependencies(self):
+        """Mock setup for external service dependencies."""
+        with (
+            patch("tasks.mail_inner_task.mail") as mock_mail,
+            patch("tasks.mail_inner_task.get_email_i18n_service") as mock_get_email_i18n_service,
+            patch("tasks.mail_inner_task._render_template_with_strategy") as mock_render_template,
+        ):
+            # Setup mock mail service
+            mock_mail.is_inited.return_value = True
+
+            # Setup mock email i18n service
+            mock_email_service = MagicMock()
+            mock_get_email_i18n_service.return_value = mock_email_service
+
+            # Setup mock template rendering
+            mock_render_template.return_value = "<html>Test email content</html>"
+
+            yield {
+                "mail": mock_mail,
+                "email_service": mock_email_service,
+                "render_template": mock_render_template,
+            }
+
+    def _create_test_email_data(self, fake: Faker) -> dict:
+        """
+        Helper method to create test email data for testing.
+
+        Args:
+            fake: Faker instance for generating test data
+
+        Returns:
+            dict: Test email data including recipients, subject, body, and substitutions
+        """
+        return {
+            "to": [fake.email() for _ in range(3)],
+            "subject": fake.sentence(nb_words=4),
+            "body": "Hello {{name}}, this is a test email from {{company}}.",
+            "substitutions": {
+                "name": fake.name(),
+                "company": fake.company(),
+                "date": fake.date(),
+            },
+        }
+
+    def test_send_inner_email_success(self, db_session_with_containers, mock_external_service_dependencies):
+        """
+        Test successful email sending with valid data.
+
+        This test verifies:
+        - Proper email service initialization check
+        - Template rendering with substitutions
+        - Email service integration
+        - Multiple recipient handling
+        """
+        # Arrange: Create test data
+        fake = Faker()
+        email_data = self._create_test_email_data(fake)
+
+        # Act: Execute the task
+        send_inner_email_task(
+            to=email_data["to"],
+            subject=email_data["subject"],
+            body=email_data["body"],
+            substitutions=email_data["substitutions"],
+        )
+
+        # Assert: Verify the expected outcomes
+        # Verify mail service was checked for initialization
+        mock_external_service_dependencies["mail"].is_inited.assert_called_once()
+
+        # Verify template rendering was called with correct parameters
+        mock_external_service_dependencies["render_template"].assert_called_once_with(
+            email_data["body"], email_data["substitutions"]
+        )
+
+        # Verify email service was called once with the full recipient list
+        mock_email_service = mock_external_service_dependencies["email_service"]
+        mock_email_service.send_raw_email.assert_called_once_with(
+            to=email_data["to"],
+            subject=email_data["subject"],
+            html_content="<html>Test email content</html>",
+        )
+
+    def test_send_inner_email_single_recipient(self, db_session_with_containers, mock_external_service_dependencies):
+        """
+        Test email sending with single recipient.
+
+        This test verifies:
+        - Single recipient handling
+        - Template rendering
+        - Email service integration
+        """
+        # Arrange: Create test data with single recipient
+        fake = Faker()
+        email_data = {
+            "to": [fake.email()],
+            "subject": fake.sentence(nb_words=3),
+            "body": "Welcome {{user_name}}!",
+            "substitutions": {
+                "user_name": fake.name(),
+            },
+        }
+
+        # Act: Execute the task
+        send_inner_email_task(
+            to=email_data["to"],
+            subject=email_data["subject"],
+            body=email_data["body"],
+            substitutions=email_data["substitutions"],
+        )
+
+        # Assert: Verify the expected outcomes
+        mock_email_service = mock_external_service_dependencies["email_service"]
+        mock_email_service.send_raw_email.assert_called_once_with(
+            to=email_data["to"],
+            subject=email_data["subject"],
+            html_content="<html>Test email content</html>",
+        )
+
+    def test_send_inner_email_empty_substitutions(self, db_session_with_containers, mock_external_service_dependencies):
+        """
+        Test email sending with empty substitutions.
+
+        This test verifies:
+        - Template rendering with empty substitutions
+        - Email service integration
+        - Handling of minimal template context
+        """
+        # Arrange: Create test data with empty substitutions
+        fake = Faker()
+        email_data = {
+            "to": [fake.email()],
+            "subject": fake.sentence(nb_words=3),
+            "body": "This is a simple email without variables.",
+            "substitutions": {},
+        }
+
+        # Act: Execute the task
+        send_inner_email_task(
+            to=email_data["to"],
+            subject=email_data["subject"],
+            body=email_data["body"],
+            substitutions=email_data["substitutions"],
+        )
+
+        # Assert: Verify the expected outcomes
+        mock_external_service_dependencies["render_template"].assert_called_once_with(email_data["body"], {})
+
+        mock_email_service = mock_external_service_dependencies["email_service"]
+        mock_email_service.send_raw_email.assert_called_once_with(
+            to=email_data["to"],
+            subject=email_data["subject"],
+            html_content="<html>Test email content</html>",
+        )
+
+    def test_send_inner_email_mail_not_initialized(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test email sending when mail service is not initialized.
+
+        This test verifies:
+        - Early return when mail service is not initialized
+        - No template rendering occurs
+        - No email service calls
+        - No exceptions raised
+        """
+        # Arrange: Setup mail service as not initialized
+        mock_external_service_dependencies["mail"].is_inited.return_value = False
+
+        fake = Faker()
+        email_data = self._create_test_email_data(fake)
+
+        # Act: Execute the task
+        send_inner_email_task(
+            to=email_data["to"],
+            subject=email_data["subject"],
+            body=email_data["body"],
+            substitutions=email_data["substitutions"],
+        )
+
+        # Assert: Verify no processing occurred
+        mock_external_service_dependencies["render_template"].assert_not_called()
+        mock_external_service_dependencies["email_service"].send_raw_email.assert_not_called()
+
+    def test_send_inner_email_template_rendering_error(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test email sending when template rendering fails.
+
+        This test verifies:
+        - Exception handling during template rendering
+        - No email service calls when template fails
+        """
+        # Arrange: Setup template rendering to raise an exception
+        mock_external_service_dependencies["render_template"].side_effect = Exception("Template rendering failed")
+
+        fake = Faker()
+        email_data = self._create_test_email_data(fake)
+
+        # Act: Execute the task
+        send_inner_email_task(
+            to=email_data["to"],
+            subject=email_data["subject"],
+            body=email_data["body"],
+            substitutions=email_data["substitutions"],
+        )
+
+        # Assert: Verify template rendering was attempted
+        mock_external_service_dependencies["render_template"].assert_called_once()
+
+        # Verify no email service calls due to exception
+        mock_external_service_dependencies["email_service"].send_raw_email.assert_not_called()
+
+    def test_send_inner_email_service_error(self, db_session_with_containers, mock_external_service_dependencies):
+        """
+        Test email sending when email service fails.
+
+        This test verifies:
+        - Exception handling during email sending
+        - Graceful error handling
+        """
+        # Arrange: Setup email service to raise an exception
+        mock_external_service_dependencies["email_service"].send_raw_email.side_effect = Exception(
+            "Email service failed"
+        )
+
+        fake = Faker()
+        email_data = self._create_test_email_data(fake)
+
+        # Act: Execute the task
+        send_inner_email_task(
+            to=email_data["to"],
+            subject=email_data["subject"],
+            body=email_data["body"],
+            substitutions=email_data["substitutions"],
+        )
+
+        # Assert: Verify template rendering occurred
+        mock_external_service_dependencies["render_template"].assert_called_once()
+
+        # Verify email service was called (and failed)
+        mock_email_service = mock_external_service_dependencies["email_service"]
+        mock_email_service.send_raw_email.assert_called_once_with(
+            to=email_data["to"],
+            subject=email_data["subject"],
+            html_content="<html>Test email content</html>",
+        )

api/tests/test_containers_integration_tests/tasks/test_mail_invite_member_task.py

@@ -0,0 +1,543 @@
+"""
+Integration tests for mail_invite_member_task using testcontainers.
+
+This module provides integration tests for the invite member email task
+using TestContainers infrastructure. The tests ensure that the task properly sends
+invitation emails with internationalization support, handles error scenarios,
+and integrates correctly with the database and Redis for token management.
+
+All tests use the testcontainers infrastructure to ensure proper database isolation
+and realistic testing scenarios with actual PostgreSQL and Redis instances.
+"""
+
+import json
+import uuid
+from datetime import UTC, datetime
+from unittest.mock import MagicMock, patch
+
+import pytest
+from faker import Faker
+
+from extensions.ext_redis import redis_client
+from libs.email_i18n import EmailType
+from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole
+from tasks.mail_invite_member_task import send_invite_member_mail_task
+
+
+class TestMailInviteMemberTask:
+    """
+    Integration tests for send_invite_member_mail_task using testcontainers.
+
+    This test class covers the core functionality of the invite member email task:
+    - Email sending with proper internationalization
+    - Template context generation and URL construction
+    - Error handling for failure scenarios
+    - Integration with Redis for token validation
+    - Mail service initialization checks
+    - Real database integration with actual invitation flow
+
+    All tests use the testcontainers infrastructure to ensure proper database isolation
+    and realistic testing environment with actual database and Redis interactions.
+    """
+
+    @pytest.fixture(autouse=True)
+    def cleanup_database(self, db_session_with_containers):
+        """Clean up database before each test to ensure isolation."""
+        # Clear all test data
+        db_session_with_containers.query(TenantAccountJoin).delete()
+        db_session_with_containers.query(Tenant).delete()
+        db_session_with_containers.query(Account).delete()
+        db_session_with_containers.commit()
+
+        # Clear Redis cache
+        redis_client.flushdb()
+
+    @pytest.fixture
+    def mock_external_service_dependencies(self):
+        """Mock setup for external service dependencies."""
+        with (
+            patch("tasks.mail_invite_member_task.mail") as mock_mail,
+            patch("tasks.mail_invite_member_task.get_email_i18n_service") as mock_email_service,
+            patch("tasks.mail_invite_member_task.dify_config") as mock_config,
+        ):
+            # Setup mail service mock
+            mock_mail.is_inited.return_value = True
+
+            # Setup email service mock
+            mock_email_service_instance = MagicMock()
+            mock_email_service_instance.send_email.return_value = None
+            mock_email_service.return_value = mock_email_service_instance
+
+            # Setup config mock
+            mock_config.CONSOLE_WEB_URL = "https://console.dify.ai"
+
+            yield {
+                "mail": mock_mail,
+                "email_service": mock_email_service_instance,
+                "config": mock_config,
+            }
+
+    def _create_test_account_and_tenant(self, db_session_with_containers):
+        """
+        Helper method to create a test account and tenant for testing.
+
+        Args:
+            db_session_with_containers: Database session from testcontainers infrastructure
+
+        Returns:
+            tuple: (Account, Tenant) created instances
+        """
+        fake = Faker()
+
+        # Create account
+        account = Account(
+            email=fake.email(),
+            name=fake.name(),
+            password=fake.password(),
+            interface_language="en-US",
+            status=AccountStatus.ACTIVE.value,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        )
+        db_session_with_containers.add(account)
+        db_session_with_containers.commit()
+        db_session_with_containers.refresh(account)
+
+        # Create tenant
+        tenant = Tenant(
+            name=fake.company(),
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        )
+        db_session_with_containers.add(tenant)
+        db_session_with_containers.commit()
+        db_session_with_containers.refresh(tenant)
+
+        # Create tenant member relationship
+        tenant_join = TenantAccountJoin(
+            tenant_id=tenant.id,
+            account_id=account.id,
+            role=TenantAccountRole.OWNER.value,
+            created_at=datetime.now(UTC),
+        )
+        db_session_with_containers.add(tenant_join)
+        db_session_with_containers.commit()
+
+        return account, tenant
+
+    def _create_invitation_token(self, tenant, account):
+        """
+        Helper method to create a valid invitation token in Redis.
+
+        Args:
+            tenant: Tenant instance
+            account: Account instance
+
+        Returns:
+            str: Generated invitation token
+        """
+        token = str(uuid.uuid4())
+        invitation_data = {
+            "account_id": account.id,
+            "email": account.email,
+            "workspace_id": tenant.id,
+        }
+        cache_key = f"member_invite:token:{token}"
+        redis_client.setex(cache_key, 24 * 60 * 60, json.dumps(invitation_data))  # 24 hours
+        return token
+
+    def _create_pending_account_for_invitation(self, db_session_with_containers, email, tenant):
+        """
+        Helper method to create a pending account for invitation testing.
+
+        Args:
+            db_session_with_containers: Database session
+            email: Email address for the account
+            tenant: Tenant instance
+
+        Returns:
+            Account: Created pending account
+        """
+        account = Account(
+            email=email,
+            name=email.split("@")[0],
+            password="",
+            interface_language="en-US",
+            status=AccountStatus.PENDING.value,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        )
+        db_session_with_containers.add(account)
+        db_session_with_containers.commit()
+        db_session_with_containers.refresh(account)
+
+        # Create tenant member relationship
+        tenant_join = TenantAccountJoin(
+            tenant_id=tenant.id,
+            account_id=account.id,
+            role=TenantAccountRole.NORMAL.value,
+            created_at=datetime.now(UTC),
+        )
+        db_session_with_containers.add(tenant_join)
+        db_session_with_containers.commit()
+
+        return account
+
+    def test_send_invite_member_mail_success(self, db_session_with_containers, mock_external_service_dependencies):
+        """
+        Test successful invitation email sending with all parameters.
+
+        This test verifies:
+        - Email service is called with correct parameters
+        - Template context includes all required fields
+        - URL is constructed correctly with token
+        - Performance logging is recorded
+        - No exceptions are raised
+        """
+        # Arrange: Create test data
+        inviter, tenant = self._create_test_account_and_tenant(db_session_with_containers)
+        invitee_email = "test@example.com"
+        language = "en-US"
+        token = self._create_invitation_token(tenant, inviter)
+        inviter_name = inviter.name
+        workspace_name = tenant.name
+
+        # Act: Execute the task
+        send_invite_member_mail_task(
+            language=language,
+            to=invitee_email,
+            token=token,
+            inviter_name=inviter_name,
+            workspace_name=workspace_name,
+        )
+
+        # Assert: Verify email service was called correctly
+        mock_email_service = mock_external_service_dependencies["email_service"]
+        mock_email_service.send_email.assert_called_once()
+
+        # Verify call arguments
+        call_args = mock_email_service.send_email.call_args
+        assert call_args[1]["email_type"] == EmailType.INVITE_MEMBER
+        assert call_args[1]["language_code"] == language
+        assert call_args[1]["to"] == invitee_email
+
+        # Verify template context
+        template_context = call_args[1]["template_context"]
+        assert template_context["to"] == invitee_email
+        assert template_context["inviter_name"] == inviter_name
+        assert template_context["workspace_name"] == workspace_name
+        assert template_context["url"] == f"https://console.dify.ai/activate?token={token}"
+
+    def test_send_invite_member_mail_different_languages(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test invitation email sending with different language codes.
+
+        This test verifies:
+        - Email service handles different language codes correctly
+        - Template context is passed correctly for each language
+        - No language-specific errors occur
+        """
+        # Arrange: Create test data
+        inviter, tenant = self._create_test_account_and_tenant(db_session_with_containers)
+        token = self._create_invitation_token(tenant, inviter)
+
+        test_languages = ["en-US", "zh-CN", "ja-JP", "fr-FR", "de-DE", "es-ES"]
+
+        for language in test_languages:
+            # Act: Execute the task with different language
+            send_invite_member_mail_task(
+                language=language,
+                to="test@example.com",
+                token=token,
+                inviter_name=inviter.name,
+                workspace_name=tenant.name,
+            )
+
+            # Assert: Verify language code was passed correctly
+            mock_email_service = mock_external_service_dependencies["email_service"]
+            call_args = mock_email_service.send_email.call_args
+            assert call_args[1]["language_code"] == language
+
+    def test_send_invite_member_mail_mail_not_initialized(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test behavior when mail service is not initialized.
+
+        This test verifies:
+        - Task returns early when mail is not initialized
+        - Email service is not called
+        - No exceptions are raised
+        """
+        # Arrange: Setup mail service as not initialized
+        mock_mail = mock_external_service_dependencies["mail"]
+        mock_mail.is_inited.return_value = False
+
+        # Act: Execute the task
+        result = send_invite_member_mail_task(
+            language="en-US",
+            to="test@example.com",
+            token="test-token",
+            inviter_name="Test User",
+            workspace_name="Test Workspace",
+        )
+
+        # Assert: Verify early return
+        assert result is None
+        mock_email_service = mock_external_service_dependencies["email_service"]
+        mock_email_service.send_email.assert_not_called()
+
+    def test_send_invite_member_mail_email_service_exception(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test error handling when email service raises an exception.
+
+        This test verifies:
+        - Exception is caught and logged
+        - Task completes without raising exception
+        - Error logging is performed
+        """
+        # Arrange: Setup email service to raise exception
+        mock_email_service = mock_external_service_dependencies["email_service"]
+        mock_email_service.send_email.side_effect = Exception("Email service failed")
+
+        # Act & Assert: Execute task and verify exception is handled
+        with patch("tasks.mail_invite_member_task.logger") as mock_logger:
+            send_invite_member_mail_task(
+                language="en-US",
+                to="test@example.com",
+                token="test-token",
+                inviter_name="Test User",
+                workspace_name="Test Workspace",
+            )
+
+            # Verify error was logged
+            mock_logger.exception.assert_called_once()
+            error_call = mock_logger.exception.call_args[0][0]
+            assert "Send invite member mail to %s failed" in error_call
+
+    def test_send_invite_member_mail_template_context_validation(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test template context contains all required fields for email rendering.
+
+        This test verifies:
+        - All required template context fields are present
+        - Field values match expected data
+        - URL construction is correct
+        - No missing or None values in context
+        """
+        # Arrange: Create test data with specific values
+        inviter, tenant = self._create_test_account_and_tenant(db_session_with_containers)
+        token = "test-token-123"
+        invitee_email = "invitee@example.com"
+        inviter_name = "John Doe"
+        workspace_name = "Acme Corp"
+
+        # Act: Execute the task
+        send_invite_member_mail_task(
+            language="en-US",
+            to=invitee_email,
+            token=token,
+            inviter_name=inviter_name,
+            workspace_name=workspace_name,
+        )
+
+        # Assert: Verify template context
+        mock_email_service = mock_external_service_dependencies["email_service"]
+        call_args = mock_email_service.send_email.call_args
+        template_context = call_args[1]["template_context"]
+
+        # Verify all required fields are present
+        required_fields = ["to", "inviter_name", "workspace_name", "url"]
+        for field in required_fields:
+            assert field in template_context
+            assert template_context[field] is not None
+            assert template_context[field] != ""
+
+        # Verify specific values
+        assert template_context["to"] == invitee_email
+        assert template_context["inviter_name"] == inviter_name
+        assert template_context["workspace_name"] == workspace_name
+        assert template_context["url"] == f"https://console.dify.ai/activate?token={token}"
+
+    def test_send_invite_member_mail_integration_with_redis_token(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test integration with Redis token validation.
+
+        This test verifies:
+        - Task works with real Redis token data
+        - Token validation can be performed after email sending
+        - Redis data integrity is maintained
+        """
+        # Arrange: Create test data and store token in Redis
+        inviter, tenant = self._create_test_account_and_tenant(db_session_with_containers)
+        token = self._create_invitation_token(tenant, inviter)
+
+        # Verify token exists in Redis before sending email
+        cache_key = f"member_invite:token:{token}"
+        assert redis_client.exists(cache_key) == 1
+
+        # Act: Execute the task
+        send_invite_member_mail_task(
+            language="en-US",
+            to=inviter.email,
+            token=token,
+            inviter_name=inviter.name,
+            workspace_name=tenant.name,
+        )
+
+        # Assert: Verify token still exists after email sending
+        assert redis_client.exists(cache_key) == 1
+
+        # Verify token data integrity
+        token_data = redis_client.get(cache_key)
+        assert token_data is not None
+        invitation_data = json.loads(token_data)
+        assert invitation_data["account_id"] == inviter.id
+        assert invitation_data["email"] == inviter.email
+        assert invitation_data["workspace_id"] == tenant.id
+
+    def test_send_invite_member_mail_with_special_characters(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test email sending with special characters in names and workspace names.
+
+        This test verifies:
+        - Special characters are handled correctly in template context
+        - Email service receives properly formatted data
+        - No encoding issues occur
+        """
+        # Arrange: Create test data with special characters
+        inviter, tenant = self._create_test_account_and_tenant(db_session_with_containers)
+        token = self._create_invitation_token(tenant, inviter)
+
+        special_cases = [
+            ("John O'Connor", "Acme & Co."),
+            ("José María", "Café & Restaurant"),
+            ("李小明", "北京科技有限公司"),
+            ("François & Marie", "L'École Internationale"),
+            ("Александр", "ООО Технологии"),
+            ("محمد أحمد", "شركة التقنية المتقدمة"),
+        ]
+
+        for inviter_name, workspace_name in special_cases:
+            # Act: Execute the task
+            send_invite_member_mail_task(
+                language="en-US",
+                to="test@example.com",
+                token=token,
+                inviter_name=inviter_name,
+                workspace_name=workspace_name,
+            )
+
+            # Assert: Verify special characters are preserved
+            mock_email_service = mock_external_service_dependencies["email_service"]
+            call_args = mock_email_service.send_email.call_args
+            template_context = call_args[1]["template_context"]
+
+            assert template_context["inviter_name"] == inviter_name
+            assert template_context["workspace_name"] == workspace_name
+
+    def test_send_invite_member_mail_real_database_integration(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test real database integration with actual invitation flow.
+
+        This test verifies:
+        - Task works with real database entities
+        - Account and tenant relationships are properly maintained
+        - Database state is consistent after email sending
+        - Real invitation data flow is tested
+        """
+        # Arrange: Create real database entities
+        inviter, tenant = self._create_test_account_and_tenant(db_session_with_containers)
+        invitee_email = "newmember@example.com"
+
+        # Create a pending account for invitation (simulating real invitation flow)
+        pending_account = self._create_pending_account_for_invitation(db_session_with_containers, invitee_email, tenant)
+
+        # Create invitation token with real account data
+        token = self._create_invitation_token(tenant, pending_account)
+
+        # Act: Execute the task with real data
+        send_invite_member_mail_task(
+            language="en-US",
+            to=invitee_email,
+            token=token,
+            inviter_name=inviter.name,
+            workspace_name=tenant.name,
+        )
+
+        # Assert: Verify email service was called with real data
+        mock_email_service = mock_external_service_dependencies["email_service"]
+        mock_email_service.send_email.assert_called_once()
+
+        # Verify database state is maintained
+        db_session_with_containers.refresh(pending_account)
+        db_session_with_containers.refresh(tenant)
+
+        assert pending_account.status == AccountStatus.PENDING.value
+        assert pending_account.email == invitee_email
+        assert tenant.name is not None
+
+        # Verify tenant relationship exists
+        tenant_join = (
+            db_session_with_containers.query(TenantAccountJoin)
+            .filter_by(tenant_id=tenant.id, account_id=pending_account.id)
+            .first()
+        )
+        assert tenant_join is not None
+        assert tenant_join.role == TenantAccountRole.NORMAL.value
+
+    def test_send_invite_member_mail_token_lifecycle_management(
+        self, db_session_with_containers, mock_external_service_dependencies
+    ):
+        """
+        Test token lifecycle management and validation.
+
+        This test verifies:
+        - Token is properly stored in Redis with correct TTL
+        - Token data structure is correct
+        - Token can be retrieved and validated after email sending
+        - Token expiration is handled correctly
+        """
+        # Arrange: Create test data
+        inviter, tenant = self._create_test_account_and_tenant(db_session_with_containers)
+        token = self._create_invitation_token(tenant, inviter)
+
+        # Act: Execute the task
+        send_invite_member_mail_task(
+            language="en-US",
+            to=inviter.email,
+            token=token,
+            inviter_name=inviter.name,
+            workspace_name=tenant.name,
+        )
+
+        # Assert: Verify token lifecycle
+        cache_key = f"member_invite:token:{token}"
+
+        # Token should still exist
+        assert redis_client.exists(cache_key) == 1
+
+        # Token should have correct TTL (approximately 24 hours)
+        ttl = redis_client.ttl(cache_key)
+        assert 23 * 60 * 60 <= ttl <= 24 * 60 * 60  # Allow some tolerance
+
+        # Token data should be valid
+        token_data = redis_client.get(cache_key)
+        assert token_data is not None
+
+        invitation_data = json.loads(token_data)
+        assert invitation_data["account_id"] == inviter.id
+        assert invitation_data["email"] == inviter.email
+        assert invitation_data["workspace_id"] == tenant.id

api/tests/unit_tests/configs/test_dify_config.py

@@ -33,6 +33,7 @@ def test_dify_config(monkeypatch: pytest.MonkeyPatch):
     assert config.EDITION == "SELF_HOSTED"
     assert config.API_COMPRESSION_ENABLED is False
     assert config.SENTRY_TRACES_SAMPLE_RATE == 1.0
+    assert config.TEMPLATE_TRANSFORM_MAX_LENGTH == 400_000
 
     # annotated field with default value
     assert config.HTTP_REQUEST_MAX_READ_TIMEOUT == 600

api/tests/unit_tests/libs/mail/test_oauth_email.py

@@ -1,375 +0,0 @@
-"""Comprehensive tests for email OAuth implementation"""
-
-import base64
-from typing import Union
-
-import pytest
-
-from libs.mail.oauth_email import MicrosoftEmailOAuth, OAuthUserInfo
-from libs.mail.oauth_http_client import OAuthHTTPClientProtocol
-
-
-class MockHTTPClient(OAuthHTTPClientProtocol):
-    """Mock HTTP client for testing OAuth without real network calls"""
-
-    def __init__(self):
-        self.post_responses = []
-        self.get_responses = []
-        self.post_calls = []
-        self.get_calls = []
-        self.post_index = 0
-        self.get_index = 0
-
-    def add_post_response(self, status_code: int, json_data: dict[str, Union[str, int]]):
-        """Add a mocked POST response"""
-        self.post_responses.append(
-            {
-                "status_code": status_code,
-                "json": json_data,
-                "text": str(json_data),
-                "headers": {"content-type": "application/json"},
-            }
-        )
-
-    def add_get_response(self, json_data: dict[str, Union[str, int, dict, list]]):
-        """Add a mocked GET response"""
-        self.get_responses.append(json_data)
-
-    def post(
-        self, url: str, data: dict[str, Union[str, int]], headers: dict[str, str] | None = None
-    ) -> dict[str, Union[str, int, dict, list]]:
-        """Mock POST request"""
-        self.post_calls.append({"url": url, "data": data, "headers": headers})
-
-        if self.post_index < len(self.post_responses):
-            response = self.post_responses[self.post_index]
-            self.post_index += 1
-            return response
-
-        # Default error response
-        return {
-            "status_code": 500,
-            "json": {"error": "No mock response configured"},
-            "text": "No mock response configured",
-            "headers": {},
-        }
-
-    def get(self, url: str, headers: dict[str, str] | None = None) -> dict[str, Union[str, int, dict, list]]:
-        """Mock GET request"""
-        self.get_calls.append({"url": url, "headers": headers})
-
-        if self.get_index < len(self.get_responses):
-            response = self.get_responses[self.get_index]
-            self.get_index += 1
-            return response
-
-        # Default error response
-        raise Exception("No mock response configured")
-
-
-class TestMicrosoftEmailOAuth:
-    """Test cases for MicrosoftEmailOAuth"""
-
-    @pytest.fixture
-    def mock_http_client(self):
-        """Create a mock HTTP client"""
-        return MockHTTPClient()
-
-    @pytest.fixture
-    def oauth_client(self, mock_http_client):
-        """Create OAuth client with mock HTTP client"""
-        return MicrosoftEmailOAuth(
-            client_id="test-client-id",
-            client_secret="test-client-secret",
-            redirect_uri="https://example.com/callback",
-            tenant_id="test-tenant",
-            http_client=mock_http_client,
-        )
-
-    def test_get_authorization_url(self, oauth_client):
-        """Test authorization URL generation"""
-        url = oauth_client.get_authorization_url()
-
-        assert "login.microsoftonline.com/test-tenant/oauth2/v2.0/authorize" in url
-        assert "client_id=test-client-id" in url
-        assert "response_type=code" in url
-        assert "redirect_uri=https%3A%2F%2Fexample.com%2Fcallback" in url
-        assert "scope=https%3A%2F%2Foutlook.office.com%2FSMTP.Send+offline_access" in url
-        assert "response_mode=query" in url
-
-    def test_get_authorization_url_with_state(self, oauth_client):
-        """Test authorization URL with state parameter"""
-        url = oauth_client.get_authorization_url(invite_token="test-state-123")
-
-        assert "state=test-state-123" in url
-
-    def test_get_access_token_success(self, oauth_client, mock_http_client):
-        """Test successful access token retrieval"""
-        # Setup mock response
-        mock_http_client.add_post_response(
-            200,
-            {
-                "access_token": "test-access-token",
-                "token_type": "Bearer",
-                "expires_in": 3600,
-                "refresh_token": "test-refresh-token",
-            },
-        )
-
-        result = oauth_client.get_access_token("test-auth-code")
-
-        # Verify result
-        assert result["access_token"] == "test-access-token"
-        assert result["token_type"] == "Bearer"
-        assert result["expires_in"] == 3600
-        assert result["refresh_token"] == "test-refresh-token"
-
-        # Verify HTTP call
-        assert len(mock_http_client.post_calls) == 1
-        call = mock_http_client.post_calls[0]
-        assert "login.microsoftonline.com/test-tenant/oauth2/v2.0/token" in call["url"]
-        assert call["data"]["grant_type"] == "authorization_code"
-        assert call["data"]["code"] == "test-auth-code"
-        assert call["data"]["client_id"] == "test-client-id"
-        assert call["data"]["client_secret"] == "test-client-secret"
-
-    def test_get_access_token_failure(self, oauth_client, mock_http_client):
-        """Test access token retrieval failure"""
-        # Setup mock error response
-        mock_http_client.add_post_response(
-            400, {"error": "invalid_grant", "error_description": "The authorization code is invalid"}
-        )
-
-        with pytest.raises(ValueError, match="Error in Microsoft OAuth"):
-            oauth_client.get_access_token("bad-auth-code")
-
-    def test_get_access_token_client_credentials_success(self, oauth_client, mock_http_client):
-        """Test successful client credentials flow"""
-        # Setup mock response
-        mock_http_client.add_post_response(
-            200, {"access_token": "service-access-token", "token_type": "Bearer", "expires_in": 3600}
-        )
-
-        result = oauth_client.get_access_token_client_credentials()
-
-        # Verify result
-        assert result["access_token"] == "service-access-token"
-        assert result["token_type"] == "Bearer"
-
-        # Verify HTTP call
-        call = mock_http_client.post_calls[0]
-        assert call["data"]["grant_type"] == "client_credentials"
-        assert call["data"]["scope"] == "https://outlook.office365.com/.default"
-
-    def test_get_access_token_client_credentials_custom_scope(self, oauth_client, mock_http_client):
-        """Test client credentials with custom scope"""
-        mock_http_client.add_post_response(200, {"access_token": "custom-scope-token", "token_type": "Bearer"})
-
-        result = oauth_client.get_access_token_client_credentials(scope="https://graph.microsoft.com/.default")
-
-        assert result["access_token"] == "custom-scope-token"
-
-        # Verify custom scope was used
-        call = mock_http_client.post_calls[0]
-        assert call["data"]["scope"] == "https://graph.microsoft.com/.default"
-
-    def test_refresh_access_token_success(self, oauth_client, mock_http_client):
-        """Test successful token refresh"""
-        # Setup mock response
-        mock_http_client.add_post_response(
-            200,
-            {
-                "access_token": "new-access-token",
-                "refresh_token": "new-refresh-token",
-                "token_type": "Bearer",
-                "expires_in": 3600,
-            },
-        )
-
-        result = oauth_client.refresh_access_token("old-refresh-token")
-
-        # Verify result
-        assert result["access_token"] == "new-access-token"
-        assert result["refresh_token"] == "new-refresh-token"
-
-        # Verify HTTP call
-        call = mock_http_client.post_calls[0]
-        assert call["data"]["grant_type"] == "refresh_token"
-        assert call["data"]["refresh_token"] == "old-refresh-token"
-
-    def test_refresh_access_token_failure(self, oauth_client, mock_http_client):
-        """Test token refresh failure"""
-        # Setup mock error response
-        mock_http_client.add_post_response(
-            400, {"error": "invalid_grant", "error_description": "The refresh token has expired"}
-        )
-
-        with pytest.raises(ValueError, match="Error refreshing Microsoft OAuth token"):
-            oauth_client.refresh_access_token("expired-refresh-token")
-
-    def test_get_raw_user_info(self, oauth_client, mock_http_client):
-        """Test getting user info from Microsoft Graph"""
-        # Setup mock response
-        mock_http_client.add_get_response(
-            {
-                "id": "12345",
-                "displayName": "Test User",
-                "mail": "test@contoso.com",
-                "userPrincipalName": "test@contoso.com",
-            }
-        )
-
-        result = oauth_client.get_raw_user_info("test-access-token")
-
-        # Verify result
-        assert result["id"] == "12345"
-        assert result["displayName"] == "Test User"
-        assert result["mail"] == "test@contoso.com"
-
-        # Verify HTTP call
-        call = mock_http_client.get_calls[0]
-        assert call["url"] == "https://graph.microsoft.com/v1.0/me"
-        assert call["headers"]["Authorization"] == "Bearer test-access-token"
-
-    def test_get_user_info_complete_flow(self, oauth_client, mock_http_client):
-        """Test complete user info retrieval flow"""
-        # Setup mock response
-        mock_http_client.add_get_response(
-            {
-                "id": "67890",
-                "displayName": "John Doe",
-                "mail": "john.doe@contoso.com",
-                "userPrincipalName": "john.doe@contoso.com",
-            }
-        )
-
-        user_info = oauth_client.get_user_info("test-access-token")
-
-        # Verify transformed user info
-        assert isinstance(user_info, OAuthUserInfo)
-        assert user_info.id == "67890"
-        assert user_info.name == "John Doe"
-        assert user_info.email == "john.doe@contoso.com"
-
-    def test_transform_user_info_with_missing_mail(self, oauth_client):
-        """Test user info transformation when mail field is missing"""
-        raw_info = {"id": "99999", "displayName": "No Mail User", "userPrincipalName": "nomail@contoso.com"}
-
-        user_info = oauth_client._transform_user_info(raw_info)
-
-        # Should fall back to userPrincipalName
-        assert user_info.email == "nomail@contoso.com"
-
-    def test_transform_user_info_with_no_display_name(self, oauth_client):
-        """Test user info transformation when displayName is missing"""
-        raw_info = {"id": "11111", "mail": "anonymous@contoso.com", "userPrincipalName": "anonymous@contoso.com"}
-
-        user_info = oauth_client._transform_user_info(raw_info)
-
-        # Should have empty name
-        assert user_info.name == ""
-        assert user_info.email == "anonymous@contoso.com"
-
-    def test_create_sasl_xoauth2_string(self):
-        """Test static SASL XOAUTH2 string creation"""
-        username = "test@contoso.com"
-        access_token = "test-token-456"
-
-        result = MicrosoftEmailOAuth.create_sasl_xoauth2_string(username, access_token)
-
-        # Decode and verify format
-        decoded = base64.b64decode(result).decode()
-        expected = f"user={username}\x01auth=Bearer {access_token}\x01\x01"
-        assert decoded == expected
-
-    def test_error_handling_with_non_json_response(self, oauth_client, mock_http_client):
-        """Test handling of non-JSON error responses"""
-        # Setup mock HTML error response
-        mock_http_client.post_responses.append(
-            {
-                "status_code": 500,
-                "json": {},
-                "text": "<html>Internal Server Error</html>",
-                "headers": {"content-type": "text/html"},
-            }
-        )
-
-        with pytest.raises(ValueError, match="Error in Microsoft OAuth"):
-            oauth_client.get_access_token("test-code")
-
-
-class TestOAuthIntegration:
-    """Integration tests for OAuth with SMTP"""
-
-    def test_oauth_token_flow_for_smtp(self):
-        """Test complete OAuth token flow for SMTP usage"""
-        # Create mock HTTP client
-        mock_http = MockHTTPClient()
-
-        # Setup mock responses for complete flow
-        mock_http.add_post_response(
-            200,
-            {
-                "access_token": "smtp-access-token",
-                "token_type": "Bearer",
-                "expires_in": 3600,
-                "refresh_token": "smtp-refresh-token",
-                "scope": "https://outlook.office.com/SMTP.Send offline_access",
-            },
-        )
-
-        # Create OAuth client
-        oauth_client = MicrosoftEmailOAuth(
-            client_id="smtp-client-id",
-            client_secret="smtp-client-secret",
-            redirect_uri="https://app.example.com/oauth/callback",
-            tenant_id="contoso.onmicrosoft.com",
-            http_client=mock_http,
-        )
-
-        # Get authorization URL
-        auth_url = oauth_client.get_authorization_url()
-        assert "scope=https%3A%2F%2Foutlook.office.com%2FSMTP.Send+offline_access" in auth_url
-
-        # Exchange code for token
-        token_response = oauth_client.get_access_token("auth-code-from-user")
-        assert token_response["access_token"] == "smtp-access-token"
-
-        # Create SASL string for SMTP
-        access_token = str(token_response["access_token"])
-        sasl_string = MicrosoftEmailOAuth.create_sasl_xoauth2_string("user@contoso.com", access_token)
-
-        # Verify SASL string is valid base64
-        try:
-            decoded = base64.b64decode(sasl_string)
-            assert b"user=user@contoso.com" in decoded
-            assert b"auth=Bearer smtp-access-token" in decoded
-        except Exception:
-            pytest.fail("SASL string is not valid base64")
-
-    def test_service_account_flow(self):
-        """Test service account (client credentials) flow"""
-        mock_http = MockHTTPClient()
-
-        # Setup mock response for client credentials
-        mock_http.add_post_response(
-            200, {"access_token": "service-smtp-token", "token_type": "Bearer", "expires_in": 3600}
-        )
-
-        oauth_client = MicrosoftEmailOAuth(
-            client_id="service-client-id",
-            client_secret="service-client-secret",
-            redirect_uri="",  # Not needed for service accounts
-            tenant_id="contoso.onmicrosoft.com",
-            http_client=mock_http,
-        )
-
-        # Get token using client credentials
-        token_response = oauth_client.get_access_token_client_credentials()
-
-        assert token_response["access_token"] == "service-smtp-token"
-
-        # Verify the request used correct grant type
-        call = mock_http.post_calls[0]
-        assert call["data"]["grant_type"] == "client_credentials"
-        assert "redirect_uri" not in call["data"]  # Should not include redirect_uri

api/tests/unit_tests/libs/mail/test_smtp.py

@@ -1,368 +0,0 @@
-"""Comprehensive tests for SMTP implementation with OAuth 2.0 support"""
-
-import base64
-import smtplib
-from unittest.mock import MagicMock, Mock
-
-import pytest
-
-from libs.mail.smtp import SMTPAuthenticator, SMTPClient, SMTPMessageBuilder
-from libs.mail.smtp_connection import SMTPConnectionFactory, SMTPConnectionProtocol
-
-
-class MockSMTPConnection:
-    """Mock SMTP connection for testing"""
-
-    def __init__(self):
-        self.ehlo_called = 0
-        self.starttls_called = False
-        self.login_called = False
-        self.docmd_called = False
-        self.sendmail_called = False
-        self.quit_called = False
-        self.last_docmd_args = None
-        self.last_login_args = None
-        self.last_sendmail_args = None
-
-    def ehlo(self, name: str = "") -> tuple:
-        self.ehlo_called += 1
-        return (250, b"OK")
-
-    def starttls(self) -> tuple:
-        self.starttls_called = True
-        return (220, b"TLS started")
-
-    def login(self, user: str, password: str) -> tuple:
-        self.login_called = True
-        self.last_login_args = (user, password)
-        return (235, b"Authentication successful")
-
-    def docmd(self, cmd: str, args: str = "") -> tuple:
-        self.docmd_called = True
-        self.last_docmd_args = (cmd, args)
-        return (235, b"Authentication successful")
-
-    def sendmail(self, from_addr: str, to_addrs: str, msg: str) -> dict:
-        self.sendmail_called = True
-        self.last_sendmail_args = (from_addr, to_addrs, msg)
-        return {}
-
-    def quit(self) -> tuple:
-        self.quit_called = True
-        return (221, b"Bye")
-
-
-class MockSMTPConnectionFactory(SMTPConnectionFactory):
-    """Mock factory for creating mock SMTP connections"""
-
-    def __init__(self, connection: MockSMTPConnection):
-        self.connection = connection
-        self.create_called = False
-
-    def create_connection(self, server: str, port: int, timeout: int = 10) -> SMTPConnectionProtocol:
-        self.create_called = True
-        self.last_create_args = (server, port, timeout)
-        return self.connection
-
-
-class TestSMTPAuthenticator:
-    """Test cases for SMTPAuthenticator"""
-
-    def test_create_sasl_xoauth2_string(self):
-        """Test SASL XOAUTH2 string creation"""
-        authenticator = SMTPAuthenticator()
-        username = "test@example.com"
-        access_token = "test_token_123"
-
-        result = authenticator.create_sasl_xoauth2_string(username, access_token)
-
-        # Decode and verify
-        decoded = base64.b64decode(result).decode()
-        expected = f"user={username}\x01auth=Bearer {access_token}\x01\x01"
-        assert decoded == expected
-
-    def test_authenticate_basic_with_valid_credentials(self):
-        """Test basic authentication with valid credentials"""
-        authenticator = SMTPAuthenticator()
-        connection = MockSMTPConnection()
-
-        authenticator.authenticate_basic(connection, "user@example.com", "password123")
-
-        assert connection.login_called
-        assert connection.last_login_args == ("user@example.com", "password123")
-
-    def test_authenticate_basic_with_empty_credentials(self):
-        """Test basic authentication skips with empty credentials"""
-        authenticator = SMTPAuthenticator()
-        connection = MockSMTPConnection()
-
-        authenticator.authenticate_basic(connection, "", "")
-
-        assert not connection.login_called
-
-    def test_authenticate_oauth2_success(self):
-        """Test successful OAuth2 authentication"""
-        authenticator = SMTPAuthenticator()
-        connection = MockSMTPConnection()
-
-        authenticator.authenticate_oauth2(connection, "user@example.com", "oauth_token_123")
-
-        assert connection.docmd_called
-        assert connection.last_docmd_args[0] == "AUTH"
-        assert connection.last_docmd_args[1].startswith("XOAUTH2 ")
-
-        # Verify the auth string
-        auth_string = connection.last_docmd_args[1].split(" ")[1]
-        decoded = base64.b64decode(auth_string).decode()
-        assert "user=user@example.com" in decoded
-        assert "auth=Bearer oauth_token_123" in decoded
-
-    def test_authenticate_oauth2_missing_credentials(self):
-        """Test OAuth2 authentication fails with missing credentials"""
-        authenticator = SMTPAuthenticator()
-        connection = MockSMTPConnection()
-
-        with pytest.raises(ValueError, match="Username and OAuth access token are required"):
-            authenticator.authenticate_oauth2(connection, "", "token")
-
-        with pytest.raises(ValueError, match="Username and OAuth access token are required"):
-            authenticator.authenticate_oauth2(connection, "user", "")
-
-    def test_authenticate_oauth2_auth_failure(self):
-        """Test OAuth2 authentication handles auth errors"""
-        authenticator = SMTPAuthenticator()
-        connection = Mock()
-        connection.docmd.side_effect = smtplib.SMTPAuthenticationError(535, b"Authentication failed")
-
-        with pytest.raises(ValueError, match="OAuth2 authentication failed"):
-            authenticator.authenticate_oauth2(connection, "user@example.com", "bad_token")
-
-
-class TestSMTPMessageBuilder:
-    """Test cases for SMTPMessageBuilder"""
-
-    def test_build_message(self):
-        """Test message building"""
-        builder = SMTPMessageBuilder()
-        mail_data = {"to": "recipient@example.com", "subject": "Test Subject", "html": "<p>Test HTML content</p>"}
-        from_addr = "sender@example.com"
-
-        msg = builder.build_message(mail_data, from_addr)
-
-        assert msg["To"] == "recipient@example.com"
-        assert msg["From"] == "sender@example.com"
-        assert msg["Subject"] == "Test Subject"
-        assert "<p>Test HTML content</p>" in msg.as_string()
-
-
-class TestSMTPClient:
-    """Test cases for SMTPClient"""
-
-    @pytest.fixture
-    def mock_connection(self):
-        """Create a mock SMTP connection"""
-        return MockSMTPConnection()
-
-    @pytest.fixture
-    def mock_factories(self, mock_connection):
-        """Create mock connection factories"""
-        return {
-            "connection_factory": MockSMTPConnectionFactory(mock_connection),
-            "ssl_connection_factory": MockSMTPConnectionFactory(mock_connection),
-        }
-
-    def test_basic_auth_send_success(self, mock_connection, mock_factories):
-        """Test successful email send with basic auth"""
-        client = SMTPClient(
-            server="smtp.example.com",
-            port=587,
-            username="user@example.com",
-            password="password123",
-            from_addr="sender@example.com",
-            use_tls=True,
-            opportunistic_tls=True,
-            auth_type="basic",
-            **mock_factories,
-        )
-
-        mail_data = {"to": "recipient@example.com", "subject": "Test Subject", "html": "<p>Test content</p>"}
-
-        client.send(mail_data)
-
-        # Verify connection sequence
-        assert mock_connection.ehlo_called == 2  # Before and after STARTTLS
-        assert mock_connection.starttls_called
-        assert mock_connection.login_called
-        assert mock_connection.last_login_args == ("user@example.com", "password123")
-        assert mock_connection.sendmail_called
-        assert mock_connection.quit_called
-
-    def test_oauth2_send_success(self, mock_connection, mock_factories):
-        """Test successful email send with OAuth2"""
-        client = SMTPClient(
-            server="smtp.office365.com",
-            port=587,
-            username="user@contoso.com",
-            password="",
-            from_addr="sender@contoso.com",
-            use_tls=True,
-            opportunistic_tls=True,
-            oauth_access_token="oauth_token_123",
-            auth_type="oauth2",
-            **mock_factories,
-        )
-
-        mail_data = {"to": "recipient@example.com", "subject": "OAuth Test", "html": "<p>OAuth test content</p>"}
-
-        client.send(mail_data)
-
-        # Verify OAuth authentication was used
-        assert mock_connection.docmd_called
-        assert not mock_connection.login_called
-        assert mock_connection.sendmail_called
-        assert mock_connection.quit_called
-
-    def test_ssl_connection_used_when_configured(self, mock_connection):
-        """Test SSL connection is used when configured"""
-        ssl_factory = MockSMTPConnectionFactory(mock_connection)
-        regular_factory = MockSMTPConnectionFactory(mock_connection)
-
-        client = SMTPClient(
-            server="smtp.example.com",
-            port=465,
-            username="user@example.com",
-            password="password123",
-            from_addr="sender@example.com",
-            use_tls=True,
-            opportunistic_tls=False,  # Use SSL, not STARTTLS
-            connection_factory=regular_factory,
-            ssl_connection_factory=ssl_factory,
-        )
-
-        mail_data = {"to": "recipient@example.com", "subject": "SSL Test", "html": "<p>SSL test content</p>"}
-
-        client.send(mail_data)
-
-        # Verify SSL factory was used
-        assert ssl_factory.create_called
-        assert not regular_factory.create_called
-        # No STARTTLS with SSL connection
-        assert not mock_connection.starttls_called
-
-    def test_connection_cleanup_on_error(self, mock_connection, mock_factories):
-        """Test connection is cleaned up even on error"""
-        # Make sendmail fail
-        mock_connection.sendmail = Mock(side_effect=smtplib.SMTPException("Send failed"))
-
-        client = SMTPClient(
-            server="smtp.example.com",
-            port=587,
-            username="user@example.com",
-            password="password123",
-            from_addr="sender@example.com",
-            **mock_factories,
-        )
-
-        mail_data = {"to": "recipient@example.com", "subject": "Test", "html": "<p>Test</p>"}
-
-        with pytest.raises(smtplib.SMTPException):
-            client.send(mail_data)
-
-        # Verify quit was still called
-        assert mock_connection.quit_called
-
-    def test_custom_authenticator_injection(self, mock_connection, mock_factories):
-        """Test custom authenticator can be injected"""
-        custom_authenticator = Mock(spec=SMTPAuthenticator)
-
-        client = SMTPClient(
-            server="smtp.example.com",
-            port=587,
-            username="user@example.com",
-            password="password123",
-            from_addr="sender@example.com",
-            authenticator=custom_authenticator,
-            **mock_factories,
-        )
-
-        mail_data = {"to": "recipient@example.com", "subject": "Test", "html": "<p>Test</p>"}
-
-        client.send(mail_data)
-
-        # Verify custom authenticator was used
-        custom_authenticator.authenticate_basic.assert_called_once()
-
-    def test_custom_message_builder_injection(self, mock_connection, mock_factories):
-        """Test custom message builder can be injected"""
-        custom_builder = Mock(spec=SMTPMessageBuilder)
-        custom_msg = MagicMock()
-        custom_msg.as_string.return_value = "custom message"
-        custom_builder.build_message.return_value = custom_msg
-
-        client = SMTPClient(
-            server="smtp.example.com",
-            port=587,
-            username="user@example.com",
-            password="password123",
-            from_addr="sender@example.com",
-            message_builder=custom_builder,
-            **mock_factories,
-        )
-
-        mail_data = {"to": "recipient@example.com", "subject": "Test", "html": "<p>Test</p>"}
-
-        client.send(mail_data)
-
-        # Verify custom builder was used
-        custom_builder.build_message.assert_called_once_with(mail_data, "sender@example.com")
-        assert mock_connection.last_sendmail_args[2] == "custom message"
-
-
-class TestIntegration:
-    """Integration tests showing how components work together"""
-
-    def test_complete_oauth_flow_without_io(self):
-        """Test complete OAuth flow without any real I/O"""
-        # Create all mocks
-        mock_connection = MockSMTPConnection()
-        connection_factory = MockSMTPConnectionFactory(mock_connection)
-
-        # Create client with OAuth
-        client = SMTPClient(
-            server="smtp.office365.com",
-            port=587,
-            username="test@contoso.com",
-            password="",
-            from_addr="test@contoso.com",
-            use_tls=True,
-            opportunistic_tls=True,
-            oauth_access_token="mock_oauth_token",
-            auth_type="oauth2",
-            connection_factory=connection_factory,
-            ssl_connection_factory=connection_factory,
-        )
-
-        # Send email
-        mail_data = {
-            "to": "recipient@example.com",
-            "subject": "OAuth Integration Test",
-            "html": "<h1>Hello OAuth!</h1>",
-        }
-
-        client.send(mail_data)
-
-        # Verify complete flow
-        assert connection_factory.create_called
-        assert mock_connection.ehlo_called == 2
-        assert mock_connection.starttls_called
-        assert mock_connection.docmd_called
-        assert "XOAUTH2" in mock_connection.last_docmd_args[1]
-        assert mock_connection.sendmail_called
-        assert mock_connection.quit_called
-
-        # Verify email data
-        from_addr, to_addr, msg_str = mock_connection.last_sendmail_args
-        assert from_addr == "test@contoso.com"
-        assert to_addr == "recipient@example.com"
-        assert "OAuth Integration Test" in msg_str
-        assert "Hello OAuth!" in msg_str

api/tests/unit_tests/libs/test_smtp_client.py

@@ -2,19 +2,19 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
-from libs.mail import SMTPClient
+from libs.smtp import SMTPClient
 
 
 def _mail() -> dict:
     return {"to": "user@example.com", "subject": "Hi", "html": "<b>Hi</b>"}
 
 
-@patch("libs.mail.smtp_connection.smtplib.SMTP")
+@patch("libs.smtp.smtplib.SMTP")
 def test_smtp_plain_success(mock_smtp_cls: MagicMock):
     mock_smtp = MagicMock()
     mock_smtp_cls.return_value = mock_smtp
 
-    client = SMTPClient(server="smtp.example.com", port=25, username="", password="", from_addr="noreply@example.com")
+    client = SMTPClient(server="smtp.example.com", port=25, username="", password="", _from="noreply@example.com")
     client.send(_mail())
 
     mock_smtp_cls.assert_called_once_with("smtp.example.com", 25, timeout=10)
@@ -22,7 +22,7 @@ def test_smtp_plain_success(mock_smtp_cls: MagicMock):
     mock_smtp.quit.assert_called_once()
 
 
-@patch("libs.mail.smtp_connection.smtplib.SMTP")
+@patch("libs.smtp.smtplib.SMTP")
 def test_smtp_tls_opportunistic_success(mock_smtp_cls: MagicMock):
     mock_smtp = MagicMock()
     mock_smtp_cls.return_value = mock_smtp
@@ -32,7 +32,7 @@ def test_smtp_tls_opportunistic_success(mock_smtp_cls: MagicMock):
         port=587,
         username="user",
         password="pass",
-        from_addr="noreply@example.com",
+        _from="noreply@example.com",
         use_tls=True,
         opportunistic_tls=True,
     )
@@ -46,7 +46,7 @@ def test_smtp_tls_opportunistic_success(mock_smtp_cls: MagicMock):
     mock_smtp.quit.assert_called_once()
 
 
-@patch("libs.mail.smtp_connection.smtplib.SMTP_SSL")
+@patch("libs.smtp.smtplib.SMTP_SSL")
 def test_smtp_tls_ssl_branch_and_timeout(mock_smtp_ssl_cls: MagicMock):
     # Cover SMTP_SSL branch and TimeoutError handling
     mock_smtp = MagicMock()
@@ -58,7 +58,7 @@ def test_smtp_tls_ssl_branch_and_timeout(mock_smtp_ssl_cls: MagicMock):
         port=465,
         username="",
         password="",
-        from_addr="noreply@example.com",
+        _from="noreply@example.com",
         use_tls=True,
         opportunistic_tls=False,
     )
@@ -67,19 +67,19 @@ def test_smtp_tls_ssl_branch_and_timeout(mock_smtp_ssl_cls: MagicMock):
     mock_smtp.quit.assert_called_once()
 
 
-@patch("libs.mail.smtp_connection.smtplib.SMTP")
+@patch("libs.smtp.smtplib.SMTP")
 def test_smtp_generic_exception_propagates(mock_smtp_cls: MagicMock):
     mock_smtp = MagicMock()
     mock_smtp.sendmail.side_effect = RuntimeError("oops")
     mock_smtp_cls.return_value = mock_smtp
 
-    client = SMTPClient(server="smtp.example.com", port=25, username="", password="", from_addr="noreply@example.com")
+    client = SMTPClient(server="smtp.example.com", port=25, username="", password="", _from="noreply@example.com")
     with pytest.raises(RuntimeError):
         client.send(_mail())
     mock_smtp.quit.assert_called_once()
 
 
-@patch("libs.mail.smtp_connection.smtplib.SMTP")
+@patch("libs.smtp.smtplib.SMTP")
 def test_smtp_smtplib_exception_in_login(mock_smtp_cls: MagicMock):
     # Ensure we hit the specific SMTPException except branch
     import smtplib
@@ -93,7 +93,7 @@ def test_smtp_smtplib_exception_in_login(mock_smtp_cls: MagicMock):
         port=25,
         username="user",  # non-empty to trigger login
         password="pass",
-        from_addr="noreply@example.com",
+        _from="noreply@example.com",
     )
     with pytest.raises(smtplib.SMTPException):
         client.send(_mail())

api/uv.lock

@@ -445,16 +445,17 @@ wheels = [
 
 [[package]]
 name = "azure-storage-blob"
-version = "12.13.0"
+version = "12.26.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "azure-core" },
     { name = "cryptography" },
-    { name = "msrest" },
+    { name = "isodate" },
+    { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/93/b13bf390e940a79a399981f75ac8d2e05a70112a95ebb7b41e9b752d2921/azure-storage-blob-12.13.0.zip", hash = "sha256:53f0d4cd32970ac9ff9b9753f83dd2fb3f9ac30e1d01e71638c436c509bfd884", size = 684838, upload-time = "2022-07-07T22:35:44.543Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/95/3e3414491ce45025a1cde107b6ae72bf72049e6021597c201cd6a3029b9a/azure_storage_blob-12.26.0.tar.gz", hash = "sha256:5dd7d7824224f7de00bfeb032753601c982655173061e242f13be6e26d78d71f", size = 583332, upload-time = "2025-07-16T21:34:07.644Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/2a/b8246df35af68d64fb7292c93dbbde63cd25036f2f669a9d9ae59e518c76/azure_storage_blob-12.13.0-py3-none-any.whl", hash = "sha256:280a6ab032845bab9627582bee78a50497ca2f14772929b5c5ee8b4605af0cb3", size = 377309, upload-time = "2022-07-07T22:35:41.905Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/64/63dbfdd83b31200ac58820a7951ddfdeed1fbee9285b0f3eae12d1357155/azure_storage_blob-12.26.0-py3-none-any.whl", hash = "sha256:8c5631b8b22b4f53ec5fff2f3bededf34cfef111e2af613ad42c9e6de00a77fe", size = 412907, upload-time = "2025-07-16T21:34:09.367Z" },
 ]
 
 [[package]]
@@ -1280,7 +1281,6 @@ version = "1.9.1"
 source = { virtual = "." }
 dependencies = [
     { name = "arize-phoenix-otel" },
-    { name = "authlib" },
     { name = "azure-identity" },
     { name = "beautifulsoup4" },
     { name = "boto3" },
@@ -1311,10 +1311,8 @@ dependencies = [
     { name = "json-repair" },
     { name = "langfuse" },
     { name = "langsmith" },
-    { name = "mailchimp-transactional" },
     { name = "markdown" },
     { name = "numpy" },
-    { name = "openai" },
     { name = "openpyxl" },
     { name = "opentelemetry-api" },
     { name = "opentelemetry-distro" },
@@ -1325,6 +1323,7 @@ dependencies = [
     { name = "opentelemetry-instrumentation" },
     { name = "opentelemetry-instrumentation-celery" },
     { name = "opentelemetry-instrumentation-flask" },
+    { name = "opentelemetry-instrumentation-httpx" },
     { name = "opentelemetry-instrumentation-redis" },
     { name = "opentelemetry-instrumentation-requests" },
     { name = "opentelemetry-instrumentation-sqlalchemy" },
@@ -1336,7 +1335,6 @@ dependencies = [
     { name = "opik" },
     { name = "packaging" },
     { name = "pandas", extra = ["excel", "output-formatting", "performance"] },
-    { name = "pandoc" },
     { name = "psycogreen" },
     { name = "psycopg2-binary" },
     { name = "pycryptodome" },
@@ -1474,7 +1472,6 @@ vdb = [
 [package.metadata]
 requires-dist = [
     { name = "arize-phoenix-otel", specifier = "~=0.9.2" },
-    { name = "authlib", specifier = "==1.6.4" },
     { name = "azure-identity", specifier = "==1.16.1" },
     { name = "beautifulsoup4", specifier = "==4.12.2" },
     { name = "boto3", specifier = "==1.35.99" },
@@ -1505,10 +1502,8 @@ requires-dist = [
     { name = "json-repair", specifier = ">=0.41.1" },
     { name = "langfuse", specifier = "~=2.51.3" },
     { name = "langsmith", specifier = "~=0.1.77" },
-    { name = "mailchimp-transactional", specifier = "~=1.0.50" },
     { name = "markdown", specifier = "~=3.5.1" },
     { name = "numpy", specifier = "~=1.26.4" },
-    { name = "openai", specifier = "~=1.61.0" },
     { name = "openpyxl", specifier = "~=3.1.5" },
     { name = "opentelemetry-api", specifier = "==1.27.0" },
     { name = "opentelemetry-distro", specifier = "==0.48b0" },
@@ -1519,6 +1514,7 @@ requires-dist = [
     { name = "opentelemetry-instrumentation", specifier = "==0.48b0" },
     { name = "opentelemetry-instrumentation-celery", specifier = "==0.48b0" },
     { name = "opentelemetry-instrumentation-flask", specifier = "==0.48b0" },
+    { name = "opentelemetry-instrumentation-httpx", specifier = "==0.48b0" },
     { name = "opentelemetry-instrumentation-redis", specifier = "==0.48b0" },
     { name = "opentelemetry-instrumentation-requests", specifier = "==0.48b0" },
     { name = "opentelemetry-instrumentation-sqlalchemy", specifier = "==0.48b0" },
@@ -1530,7 +1526,6 @@ requires-dist = [
     { name = "opik", specifier = "~=1.7.25" },
     { name = "packaging", specifier = "~=23.2" },
     { name = "pandas", extras = ["excel", "output-formatting", "performance"], specifier = "~=2.2.2" },
-    { name = "pandoc", specifier = "~=2.4" },
     { name = "psycogreen", specifier = "~=1.0.2" },
     { name = "psycopg2-binary", specifier = "~=2.9.6" },
     { name = "pycryptodome", specifier = "==3.19.1" },
@@ -1625,10 +1620,10 @@ dev = [
     { name = "types-ujson", specifier = ">=5.10.0" },
 ]
 storage = [
-    { name = "azure-storage-blob", specifier = "==12.13.0" },
+    { name = "azure-storage-blob", specifier = "==12.26.0" },
     { name = "bce-python-sdk", specifier = "~=0.9.23" },
     { name = "cos-python-sdk-v5", specifier = "==1.9.38" },
-    { name = "esdk-obs-python", specifier = "==3.24.6.1" },
+    { name = "esdk-obs-python", specifier = "==3.25.8" },
     { name = "google-cloud-storage", specifier = "==2.16.0" },
     { name = "opendal", specifier = "~=0.46.0" },
     { name = "oss2", specifier = "==2.18.5" },
@@ -1779,12 +1774,14 @@ wheels = [
 
 [[package]]
 name = "esdk-obs-python"
-version = "3.24.6.1"
+version = "3.25.8"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "crcmod" },
     { name = "pycryptodome" },
+    { name = "requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f7/af/d83276f9e288bd6a62f44d67ae1eafd401028ba1b2b643ae4014b51da5bd/esdk-obs-python-3.24.6.1.tar.gz", hash = "sha256:c45fed143e99d9256c8560c1d78f651eae0d2e809d16e962f8b286b773c33bf0", size = 85798, upload-time = "2024-07-26T13:13:22.467Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/40/99/52362d6e081a642d6de78f6ab53baa5e3f82f2386c48954e18ee7b4ab22b/esdk-obs-python-3.25.8.tar.gz", hash = "sha256:aeded00b27ecd5a25ffaec38a2cc9416b51923d48db96c663f1a735f859b5273", size = 96302, upload-time = "2025-09-01T11:35:20.432Z" }
 
 [[package]]
 name = "et-xmlfile"
@@ -3169,21 +3166,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6c/e1/0686c91738f3e6c2e1a243e0fdd4371667c4d2e5009b0a3605806c2aa020/lz4-4.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:2f4f2965c98ab254feddf6b5072854a6935adab7bc81412ec4fe238f07b85f62", size = 89736, upload-time = "2025-04-01T22:55:40.5Z" },
 ]
 
-[[package]]
-name = "mailchimp-transactional"
-version = "1.0.56"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "python-dateutil" },
-    { name = "requests" },
-    { name = "six" },
-    { name = "urllib3" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bc/cb60d02c00996839bbd87444a97d0ba5ac271b1a324001562afb8f685251/mailchimp_transactional-1.0.56-py3-none-any.whl", hash = "sha256:a76ea88b90a2d47d8b5134586aabbd3a96c459f6066d8886748ab59e50de36eb", size = 31660, upload-time = "2024-02-01T18:39:19.717Z" },
-]
-
 [[package]]
 name = "mako"
 version = "1.3.10"
@@ -3369,22 +3351,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5e/75/bd9b7bb966668920f06b200e84454c8f3566b102183bc55c5473d96cb2b9/msal_extensions-1.3.1-py3-none-any.whl", hash = "sha256:96d3de4d034504e969ac5e85bae8106c8373b5c6568e4c8fa7af2eca9dbe6bca", size = 20583, upload-time = "2025-03-14T23:51:03.016Z" },
 ]
 
-[[package]]
-name = "msrest"
-version = "0.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "certifi" },
-    { name = "isodate" },
-    { name = "requests" },
-    { name = "requests-oauthlib" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/68/77/8397c8fb8fc257d8ea0fa66f8068e073278c65f05acb17dcb22a02bfdc42/msrest-0.7.1.zip", hash = "sha256:6e7661f46f3afd88b75667b7187a92829924446c7ea1d169be8c4bb7eeb788b9", size = 175332, upload-time = "2022-06-13T22:41:25.111Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/15/cf/f2966a2638144491f8696c27320d5219f48a072715075d168b31d3237720/msrest-0.7.1-py3-none-any.whl", hash = "sha256:21120a810e1233e5e6cc7fe40b474eeb4ec6f757a15d7cf86702c369f9567c32", size = 85384, upload-time = "2022-06-13T22:41:22.42Z" },
-]
-
 [[package]]
 name = "multidict"
 version = "6.6.4"
@@ -3914,6 +3880,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/78/3d/fcde4f8f0bf9fa1ee73a12304fa538076fb83fe0a2ae966ab0f0b7da5109/opentelemetry_instrumentation_flask-0.48b0-py3-none-any.whl", hash = "sha256:26b045420b9d76e85493b1c23fcf27517972423480dc6cf78fd6924248ba5808", size = 14588, upload-time = "2024-08-28T21:26:58.504Z" },
 ]
 
+[[package]]
+name = "opentelemetry-instrumentation-httpx"
+version = "0.48b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "opentelemetry-util-http" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d3/d9/c65d818607c16d1b7ea8d2de6111c6cecadf8d2fd38c1885a72733a7c6d3/opentelemetry_instrumentation_httpx-0.48b0.tar.gz", hash = "sha256:ee977479e10398931921fb995ac27ccdeea2e14e392cb27ef012fc549089b60a", size = 16931, upload-time = "2024-08-28T21:28:03.794Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/fe/f2daa9d6d988c093b8c7b1d35df675761a8ece0b600b035dc04982746c9d/opentelemetry_instrumentation_httpx-0.48b0-py3-none-any.whl", hash = "sha256:d94f9d612c82d09fe22944d1904a30a464c19bea2ba76be656c99a28ad8be8e5", size = 13900, upload-time = "2024-08-28T21:27:01.566Z" },
+]
+
 [[package]]
 name = "opentelemetry-instrumentation-redis"
 version = "0.48b0"
@@ -4231,16 +4212,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ec/f8/46141ba8c9d7064dc5008bfb4a6ae5bd3c30e4c61c28b5c5ed485bf358ba/pandas_stubs-2.2.3.250527-py3-none-any.whl", hash = "sha256:cd0a49a95b8c5f944e605be711042a4dd8550e2c559b43d70ba2c4b524b66163", size = 159683, upload-time = "2025-05-27T15:24:28.4Z" },
 ]
 
-[[package]]
-name = "pandoc"
-version = "2.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "plumbum" },
-    { name = "ply" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/10/9a/e3186e760c57ee5f1c27ea5cea577a0ff9abfca51eefcb4d9a4cd39aff2e/pandoc-2.4.tar.gz", hash = "sha256:ecd1f8cbb7f4180c6b5db4a17a7c1a74df519995f5f186ef81ce72a9cbd0dd9a", size = 34635, upload-time = "2024-08-07T14:33:58.016Z" }
-
 [[package]]
 name = "pathspec"
 version = "0.12.1"
@@ -4347,18 +4318,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
 ]
 
-[[package]]
-name = "plumbum"
-version = "1.9.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f0/5d/49ba324ad4ae5b1a4caefafbce7a1648540129344481f2ed4ef6bb68d451/plumbum-1.9.0.tar.gz", hash = "sha256:e640062b72642c3873bd5bdc3effed75ba4d3c70ef6b6a7b907357a84d909219", size = 319083, upload-time = "2024-10-05T05:59:27.059Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4f/9d/d03542c93bb3d448406731b80f39c3d5601282f778328c22c77d270f4ed4/plumbum-1.9.0-py3-none-any.whl", hash = "sha256:9fd0d3b0e8d86e4b581af36edf3f3bbe9d1ae15b45b8caab28de1bcb27aaa7f5", size = 127970, upload-time = "2024-10-05T05:59:25.102Z" },
-]
-
 [[package]]
 name = "ply"
 version = "3.11"

docker/.env.example

@@ -836,33 +836,6 @@ SMTP_PASSWORD=
 SMTP_USE_TLS=true
 SMTP_OPPORTUNISTIC_TLS=false
 
-# SMTP authentication type: 'basic' for username/password, 'oauth2' for Microsoft OAuth 2.0
-# Use 'oauth2' for Microsoft Exchange/Outlook due to Basic Auth retirement (September 2025)
-SMTP_AUTH_TYPE=basic
-
-# Microsoft OAuth 2.0 configuration for SMTP authentication
-# Required when SMTP_AUTH_TYPE=oauth2 and SMTP_SERVER uses Microsoft Exchange/Outlook
-# 
-# Setup instructions:
-# 1. Go to Azure Portal (https://portal.azure.com) → Azure Active Directory → App registrations
-# 2. Create new application registration
-# 3. Add API permissions: Mail.Send, SMTP.Send (Application permissions)
-# 4. Grant admin consent for the permissions
-# 5. Create client secret in "Certificates & secrets"
-# 6. Use the application's Client ID, Client Secret, and your Tenant ID below
-#
-# For Microsoft Exchange Online, use:
-# SMTP_SERVER=smtp.office365.com
-# SMTP_PORT=587
-# SMTP_USE_TLS=true
-# SMTP_OPPORTUNISTIC_TLS=true
-MICROSOFT_OAUTH2_CLIENT_ID=
-MICROSOFT_OAUTH2_CLIENT_SECRET=
-# Tenant ID from Azure AD (use 'common' for multi-tenant applications)
-MICROSOFT_OAUTH2_TENANT_ID=common
-# Optional: Pre-acquired access token (leave empty to auto-acquire using client credentials)
-MICROSOFT_OAUTH2_ACCESS_TOKEN=
-
 # Sendgid configuration
 SENDGRID_API_KEY=
 
@@ -894,14 +867,14 @@ CODE_MAX_NUMBER=9223372036854775807
 CODE_MIN_NUMBER=-9223372036854775808
 CODE_MAX_DEPTH=5
 CODE_MAX_PRECISION=20
-CODE_MAX_STRING_LENGTH=80000
+CODE_MAX_STRING_LENGTH=400000
 CODE_MAX_STRING_ARRAY_LENGTH=30
 CODE_MAX_OBJECT_ARRAY_LENGTH=30
 CODE_MAX_NUMBER_ARRAY_LENGTH=1000
 CODE_EXECUTION_CONNECT_TIMEOUT=10
 CODE_EXECUTION_READ_TIMEOUT=60
 CODE_EXECUTION_WRITE_TIMEOUT=10
-TEMPLATE_TRANSFORM_MAX_LENGTH=80000
+TEMPLATE_TRANSFORM_MAX_LENGTH=400000
 
 # Workflow runtime configuration
 WORKFLOW_MAX_EXECUTION_STEPS=500

docker/docker-compose.yaml

@@ -373,11 +373,6 @@ x-shared-env: &shared-api-worker-env
   SMTP_PASSWORD: ${SMTP_PASSWORD:-}
   SMTP_USE_TLS: ${SMTP_USE_TLS:-true}
   SMTP_OPPORTUNISTIC_TLS: ${SMTP_OPPORTUNISTIC_TLS:-false}
-  SMTP_AUTH_TYPE: ${SMTP_AUTH_TYPE:-basic}
-  MICROSOFT_OAUTH2_CLIENT_ID: ${MICROSOFT_OAUTH2_CLIENT_ID:-}
-  MICROSOFT_OAUTH2_CLIENT_SECRET: ${MICROSOFT_OAUTH2_CLIENT_SECRET:-}
-  MICROSOFT_OAUTH2_TENANT_ID: ${MICROSOFT_OAUTH2_TENANT_ID:-common}
-  MICROSOFT_OAUTH2_ACCESS_TOKEN: ${MICROSOFT_OAUTH2_ACCESS_TOKEN:-}
   SENDGRID_API_KEY: ${SENDGRID_API_KEY:-}
   INDEXING_MAX_SEGMENTATION_TOKENS_LENGTH: ${INDEXING_MAX_SEGMENTATION_TOKENS_LENGTH:-4000}
   INVITE_EXPIRY_HOURS: ${INVITE_EXPIRY_HOURS:-72}
@@ -395,14 +390,14 @@ x-shared-env: &shared-api-worker-env
   CODE_MIN_NUMBER: ${CODE_MIN_NUMBER:--9223372036854775808}
   CODE_MAX_DEPTH: ${CODE_MAX_DEPTH:-5}
   CODE_MAX_PRECISION: ${CODE_MAX_PRECISION:-20}
-  CODE_MAX_STRING_LENGTH: ${CODE_MAX_STRING_LENGTH:-80000}
+  CODE_MAX_STRING_LENGTH: ${CODE_MAX_STRING_LENGTH:-400000}
   CODE_MAX_STRING_ARRAY_LENGTH: ${CODE_MAX_STRING_ARRAY_LENGTH:-30}
   CODE_MAX_OBJECT_ARRAY_LENGTH: ${CODE_MAX_OBJECT_ARRAY_LENGTH:-30}
   CODE_MAX_NUMBER_ARRAY_LENGTH: ${CODE_MAX_NUMBER_ARRAY_LENGTH:-1000}
   CODE_EXECUTION_CONNECT_TIMEOUT: ${CODE_EXECUTION_CONNECT_TIMEOUT:-10}
   CODE_EXECUTION_READ_TIMEOUT: ${CODE_EXECUTION_READ_TIMEOUT:-60}
   CODE_EXECUTION_WRITE_TIMEOUT: ${CODE_EXECUTION_WRITE_TIMEOUT:-10}
-  TEMPLATE_TRANSFORM_MAX_LENGTH: ${TEMPLATE_TRANSFORM_MAX_LENGTH:-80000}
+  TEMPLATE_TRANSFORM_MAX_LENGTH: ${TEMPLATE_TRANSFORM_MAX_LENGTH:-400000}
   WORKFLOW_MAX_EXECUTION_STEPS: ${WORKFLOW_MAX_EXECUTION_STEPS:-500}
   WORKFLOW_MAX_EXECUTION_TIME: ${WORKFLOW_MAX_EXECUTION_TIME:-1200}
   WORKFLOW_CALL_MAX_DEPTH: ${WORKFLOW_CALL_MAX_DEPTH:-5}

web/__tests__/goto-anything/command-selector.test.tsx

@@ -16,7 +16,7 @@ jest.mock('cmdk', () => ({
     Item: ({ children, onSelect, value, className }: any) => (
       <div
         className={className}
-        onClick={() => onSelect && onSelect()}
+        onClick={() => onSelect?.()}
         data-value={value}
         data-testid={`command-item-${value}`}
       >

web/app/(commonLayout)/app/(appDetailLayout)/[appId]/overview/tracing/config-button.tsx

@@ -4,6 +4,7 @@ import React, { useCallback, useRef, useState } from 'react'
 
 import type { PopupProps } from './config-popup'
 import ConfigPopup from './config-popup'
+import cn from '@/utils/classnames'
 import {
   PortalToFollowElem,
   PortalToFollowElemContent,
@@ -45,7 +46,7 @@ const ConfigBtn: FC<Props> = ({
       offset={12}
     >
       <PortalToFollowElemTrigger onClick={handleTrigger}>
-        <div className="select-none">
+        <div className={cn('select-none', className)}>
           {children}
         </div>
       </PortalToFollowElemTrigger>

web/app/components/app/annotation/batch-add-annotation-modal/csv-uploader.tsx

@@ -28,7 +28,8 @@ const CSVUploader: FC<Props> = ({
   const handleDragEnter = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target !== dragRef.current && setDragging(true)
+    if (e.target !== dragRef.current)
+      setDragging(true)
   }
   const handleDragOver = (e: DragEvent) => {
     e.preventDefault()
@@ -37,7 +38,8 @@ const CSVUploader: FC<Props> = ({
   const handleDragLeave = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target === dragRef.current && setDragging(false)
+    if (e.target === dragRef.current)
+      setDragging(false)
   }
   const handleDrop = (e: DragEvent) => {
     e.preventDefault()

web/app/components/app/app-publisher/index.tsx

@@ -348,7 +348,8 @@ const AppPublisher = ({
                     <SuggestedAction
                       className='flex-1'
                       onClick={() => {
-                        publishedAt && handleOpenInExplore()
+                        if (publishedAt)
+                          handleOpenInExplore()
                       }}
                       disabled={!publishedAt || (systemFeatures.webapp_auth.enabled && !userCanAccessApp?.result)}
                       icon={<RiPlanetLine className='h-4 w-4' />}

web/app/components/app/app-publisher/version-info-modal.tsx

@@ -40,7 +40,8 @@ const VersionInfoModal: FC<VersionInfoModalProps> = ({
       return
     }
     else {
-      titleError && setTitleError(false)
+      if (titleError)
+        setTitleError(false)
     }
 
     if (releaseNotes.length > RELEASE_NOTES_MAX_LENGTH) {
@@ -52,7 +53,8 @@ const VersionInfoModal: FC<VersionInfoModalProps> = ({
       return
     }
     else {
-      releaseNotesError && setReleaseNotesError(false)
+      if (releaseNotesError)
+        setReleaseNotesError(false)
     }
 
     onPublish({ title, releaseNotes, id: versionInfo?.id })

web/app/components/app/configuration/base/icons/citation.tsx

@@ -0,0 +1,29 @@
+import type { SVGProps } from 'react'
+
+const CitationIcon = (props: SVGProps<SVGSVGElement>) => (
+  <svg
+    viewBox="0 0 24 24"
+    fill="none"
+    xmlns="http://www.w3.org/2000/svg"
+    aria-hidden="true"
+    {...props}
+  >
+    <path
+      d="M7 6h10M7 12h6M7 18h10"
+      stroke="currentColor"
+      strokeWidth="1.5"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    />
+    <path
+      d="M5 6c0-1.105.895-2 2-2h10c1.105 0 2 .895 2 2v12c0 1.105-.895 2-2 2H9l-4 3v-3H7"
+      stroke="currentColor"
+      strokeWidth="1.5"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      fill="none"
+    />
+  </svg>
+)
+
+export default CitationIcon

web/app/components/app/configuration/config-var/config-modal/index.tsx

@@ -32,6 +32,19 @@ import { TransferMethod } from '@/types/app'
 import type { FileEntity } from '@/app/components/base/file-uploader/types'
 
 const TEXT_MAX_LENGTH = 256
+const CHECKBOX_DEFAULT_TRUE_VALUE = 'true'
+const CHECKBOX_DEFAULT_FALSE_VALUE = 'false'
+
+const getCheckboxDefaultSelectValue = (value: InputVar['default']) => {
+  if (typeof value === 'boolean')
+    return value ? CHECKBOX_DEFAULT_TRUE_VALUE : CHECKBOX_DEFAULT_FALSE_VALUE
+  if (typeof value === 'string')
+    return value.toLowerCase() === CHECKBOX_DEFAULT_TRUE_VALUE ? CHECKBOX_DEFAULT_TRUE_VALUE : CHECKBOX_DEFAULT_FALSE_VALUE
+  return CHECKBOX_DEFAULT_FALSE_VALUE
+}
+
+const parseCheckboxSelectValue = (value: string) =>
+  value === CHECKBOX_DEFAULT_TRUE_VALUE
 
 export type IConfigModalProps = {
   isCreate?: boolean
@@ -66,7 +79,7 @@ const ConfigModal: FC<IConfigModalProps> = ({
     try {
       return JSON.stringify(JSON.parse(tempPayload.json_schema).properties, null, 2)
     }
-    catch (_e) {
+    catch {
       return ''
     }
   }, [tempPayload.json_schema])
@@ -110,7 +123,7 @@ const ConfigModal: FC<IConfigModalProps> = ({
       }
       handlePayloadChange('json_schema')(JSON.stringify(res, null, 2))
     }
-    catch (_e) {
+    catch {
       return null
     }
   }, [handlePayloadChange])
@@ -198,6 +211,8 @@ const ConfigModal: FC<IConfigModalProps> = ({
     handlePayloadChange('variable')(e.target.value)
   }, [handlePayloadChange, t])
 
+  const checkboxDefaultSelectValue = useMemo(() => getCheckboxDefaultSelectValue(tempPayload.default), [tempPayload.default])
+
   const handleConfirm = () => {
     const moreInfo = tempPayload.variable === payload?.variable
       ? undefined
@@ -324,6 +339,23 @@ const ConfigModal: FC<IConfigModalProps> = ({
             </Field>
           )}
 
+          {type === InputVarType.checkbox && (
+            <Field title={t('appDebug.variableConfig.defaultValue')}>
+              <SimpleSelect
+                className="w-full"
+                optionWrapClassName="max-h-[140px] overflow-y-auto"
+                items={[
+                  { value: CHECKBOX_DEFAULT_TRUE_VALUE, name: t('appDebug.variableConfig.startChecked') },
+                  { value: CHECKBOX_DEFAULT_FALSE_VALUE, name: t('appDebug.variableConfig.noDefaultSelected') },
+                ]}
+                defaultValue={checkboxDefaultSelectValue}
+                onSelect={item => handlePayloadChange('default')(parseCheckboxSelectValue(String(item.value)))}
+                placeholder={t('appDebug.variableConfig.selectDefaultValue')}
+                allowSearch={false}
+              />
+            </Field>
+          )}
+
           {type === InputVarType.select && (
             <>
               <Field title={t('appDebug.variableConfig.options')}>

web/app/components/app/configuration/index.tsx

@@ -480,7 +480,7 @@ const Configuration: FC = () => {
         Toast.notify({ type: 'warning', message: `${t('common.modelProvider.parametersInvalidRemoved')}: ${Object.entries(removedDetails).map(([k, reason]) => `${k} (${reason})`).join(', ')}` })
       setCompletionParams(filtered)
     }
-    catch (e) {
+    catch {
       Toast.notify({ type: 'error', message: t('common.error') })
       setCompletionParams({})
     }

web/app/components/app/configuration/prompt-value-panel/index.tsx

@@ -192,7 +192,7 @@ const PromptValuePanel: FC<IPromptValuePanelProps> = ({
                 <Button
                   variant="primary"
                   disabled={canNotRun}
-                  onClick={() => onSend && onSend()}
+                  onClick={() => onSend?.()}
                   className="w-[96px]">
                   <RiPlayLargeFill className="mr-0.5 h-4 w-4 shrink-0" aria-hidden="true" />
                   {t('appDebug.inputs.run')}
@@ -203,7 +203,7 @@ const PromptValuePanel: FC<IPromptValuePanelProps> = ({
               <Button
                 variant="primary"
                 disabled={canNotRun}
-                onClick={() => onSend && onSend()}
+                onClick={() => onSend?.()}
                 className="w-[96px]">
                 <RiPlayLargeFill className="mr-0.5 h-4 w-4 shrink-0" aria-hidden="true" />
                 {t('appDebug.inputs.run')}

web/app/components/app/create-from-dsl-modal/uploader.tsx

@@ -38,7 +38,8 @@ const Uploader: FC<Props> = ({
   const handleDragEnter = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target !== dragRef.current && setDragging(true)
+    if (e.target !== dragRef.current)
+      setDragging(true)
   }
   const handleDragOver = (e: DragEvent) => {
     e.preventDefault()
@@ -47,7 +48,8 @@ const Uploader: FC<Props> = ({
   const handleDragLeave = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target === dragRef.current && setDragging(false)
+    if (e.target === dragRef.current)
+      setDragging(false)
   }
   const handleDrop = (e: DragEvent) => {
     e.preventDefault()

web/app/components/app/overview/app-chart.tsx

@@ -107,7 +107,8 @@ const Chart: React.FC<IChartProps> = ({
   const { t } = useTranslation()
   const statistics = chartData.data
   const statisticsLen = statistics.length
-  const extraDataForMarkLine = new Array(statisticsLen >= 2 ? statisticsLen - 2 : statisticsLen).fill('1')
+  const markLineLength = statisticsLen >= 2 ? statisticsLen - 2 : statisticsLen
+  const extraDataForMarkLine = Array.from({ length: markLineLength }, () => '1')
   extraDataForMarkLine.push('')
   extraDataForMarkLine.unshift('')
 

web/app/components/base/audio-btn/audio.ts

@@ -127,7 +127,7 @@ export default class AudioPlayer {
     }
     catch {
       this.isLoadData = false
-      this.callback && this.callback('error')
+      this.callback?.('error')
     }
   }
 
@@ -137,15 +137,14 @@ export default class AudioPlayer {
       if (this.audioContext.state === 'suspended') {
         this.audioContext.resume().then((_) => {
           this.audio.play()
-          this.callback && this.callback('play')
+          this.callback?.('play')
         })
       }
       else if (this.audio.ended) {
         this.audio.play()
-        this.callback && this.callback('play')
+        this.callback?.('play')
       }
-      if (this.callback)
-        this.callback('play')
+      this.callback?.('play')
     }
     else {
       this.isLoadData = true
@@ -189,24 +188,24 @@ export default class AudioPlayer {
       if (this.audio.paused) {
         this.audioContext.resume().then((_) => {
           this.audio.play()
-          this.callback && this.callback('play')
+          this.callback?.('play')
         })
       }
       else if (this.audio.ended) {
         this.audio.play()
-        this.callback && this.callback('play')
+        this.callback?.('play')
       }
       else if (this.audio.played) { /* empty */ }
 
       else {
         this.audio.play()
-        this.callback && this.callback('play')
+        this.callback?.('play')
       }
     }
   }
 
   public pauseAudio() {
-    this.callback && this.callback('paused')
+    this.callback?.('paused')
     this.audio.pause()
     this.audioContext.suspend()
   }

web/app/components/base/chat/chat-with-history/hooks.tsx

@@ -128,7 +128,7 @@ export const useChatWithHistory = (installedAppInfo?: InstalledApp) => {
         const localState = localStorage.getItem('webappSidebarCollapse')
         return localState === 'collapsed'
       }
-      catch (e) {
+      catch {
         // localStorage may be disabled in private browsing mode or by security settings
         // fallback to default value
         return false
@@ -142,7 +142,7 @@ export const useChatWithHistory = (installedAppInfo?: InstalledApp) => {
       try {
         localStorage.setItem('webappSidebarCollapse', state ? 'collapsed' : 'expanded')
       }
-      catch (e) {
+      catch {
         // localStorage may be disabled, continue without persisting state
       }
     }
@@ -235,13 +235,15 @@ export const useChatWithHistory = (installedAppInfo?: InstalledApp) => {
         }
       }
 
-      if(item.checkbox) {
+      if (item.checkbox) {
+        const preset = initInputs[item.checkbox.variable] === true
         return {
           ...item.checkbox,
-          default: false,
+          default: preset || item.default || item.checkbox.default,
           type: 'checkbox',
         }
       }
+
       if (item.select) {
         const isInputInOptions = item.select.options.includes(initInputs[item.select.variable])
         return {

web/app/components/base/chat/chat/answer/index.tsx

@@ -101,10 +101,14 @@ const Answer: FC<AnswerProps> = ({
   }, [])
 
   const handleSwitchSibling = useCallback((direction: 'prev' | 'next') => {
-    if (direction === 'prev')
-      item.prevSibling && switchSibling?.(item.prevSibling)
-    else
-      item.nextSibling && switchSibling?.(item.nextSibling)
+    if (direction === 'prev') {
+      if (item.prevSibling)
+        switchSibling?.(item.prevSibling)
+    }
+    else {
+      if (item.nextSibling)
+        switchSibling?.(item.nextSibling)
+    }
   }, [switchSibling, item.prevSibling, item.nextSibling])
 
   return (

web/app/components/base/chat/chat/question.tsx

@@ -73,10 +73,14 @@ const Question: FC<QuestionProps> = ({
   }, [content])
 
   const handleSwitchSibling = useCallback((direction: 'prev' | 'next') => {
-    if (direction === 'prev')
-      item.prevSibling && switchSibling?.(item.prevSibling)
-    else
-      item.nextSibling && switchSibling?.(item.nextSibling)
+    if (direction === 'prev') {
+      if (item.prevSibling)
+        switchSibling?.(item.prevSibling)
+    }
+    else {
+      if (item.nextSibling)
+        switchSibling?.(item.nextSibling)
+    }
   }, [switchSibling, item.prevSibling, item.nextSibling])
 
   const getContentWidth = () => {

web/app/components/base/chat/embedded-chatbot/hooks.tsx

@@ -195,13 +195,16 @@ export const useEmbeddedChatbot = () => {
           type: 'number',
         }
       }
+
       if (item.checkbox) {
+        const preset = initInputs[item.checkbox.variable] === true
         return {
           ...item.checkbox,
-          default: false,
+          default: preset || item.default || item.checkbox.default,
           type: 'checkbox',
         }
       }
+
       if (item.select) {
         const isInputInOptions = item.select.options.includes(initInputs[item.select.variable])
         return {

web/app/components/base/date-and-time-picker/utils/dayjs.ts

@@ -124,7 +124,7 @@ export const parseDateWithFormat = (dateString: string, format?: string): Dayjs
 }
 
 // Format date output with localization support
-export const formatDateForOutput = (date: Dayjs, includeTime: boolean = false, locale: string = 'en-US'): string => {
+export const formatDateForOutput = (date: Dayjs, includeTime: boolean = false, _locale: string = 'en-US'): string => {
   if (!date || !date.isValid()) return ''
 
   if (includeTime) {

web/app/components/base/drawer/index.tsx

@@ -47,7 +47,10 @@ export default function Drawer({
     <Dialog
       unmount={unmount}
       open={isOpen}
-      onClose={() => !clickOutsideNotOpen && onClose()}
+      onClose={() => {
+        if (!clickOutsideNotOpen)
+          onClose()
+      }}
       className={cn('fixed inset-0 z-[30] overflow-y-auto', dialogClassName)}
     >
       <div className={cn('flex h-screen w-screen justify-end', positionCenter && '!justify-center')}>
@@ -55,7 +58,8 @@ export default function Drawer({
         <DialogBackdrop
           className={cn('fixed inset-0 z-[40]', mask && 'bg-black/30', dialogBackdropClassName)}
           onClick={() => {
-            !clickOutsideNotOpen && onClose()
+            if (!clickOutsideNotOpen)
+              onClose()
           }}
         />
         <div className={cn('relative z-[50] flex w-full max-w-sm flex-col justify-between overflow-hidden bg-components-panel-bg p-6 text-left align-middle shadow-xl', panelClassName)}>
@@ -80,11 +84,11 @@ export default function Drawer({
               <Button
                 className='mr-2'
                 onClick={() => {
-                  onCancel && onCancel()
+                  onCancel?.()
                 }}>{t('common.operation.cancel')}</Button>
               <Button
                 onClick={() => {
-                  onOk && onOk()
+                  onOk?.()
                 }}>{t('common.operation.save')}</Button>
             </div>)}
         </div>

web/app/components/base/emoji-picker/index.tsx

@@ -45,7 +45,7 @@ const EmojiPicker: FC<IEmojiPickerProps> = ({
       <Divider className='mb-0 mt-3' />
       <div className='flex w-full items-center justify-center gap-2 p-3'>
         <Button className='w-full' onClick={() => {
-          onClose && onClose()
+          onClose?.()
         }}>
           {t('app.iconPicker.cancel')}
         </Button>
@@ -54,7 +54,7 @@ const EmojiPicker: FC<IEmojiPickerProps> = ({
           variant="primary"
           className='w-full'
           onClick={() => {
-            onSelect && onSelect(selectedEmoji, selectedBackground!)
+            onSelect?.(selectedEmoji, selectedBackground!)
           }}>
           {t('app.iconPicker.ok')}
         </Button>

web/app/components/base/form/components/field/select.tsx

@@ -33,7 +33,10 @@ const SelectField = ({
       <PureSelect
         value={field.state.value}
         options={options}
-        onChange={value => field.handleChange(value)}
+        onChange={(value) => {
+          field.handleChange(value)
+          onChange?.(value)
+        }}
         {...selectProps}
       />
     </div>

web/app/components/base/image-uploader/image-list.tsx

@@ -62,7 +62,7 @@ const ImageList: FC<ImageListProps> = ({
                 {item.progress === -1 && (
                   <RefreshCcw01
                     className="h-5 w-5 text-white"
-                    onClick={() => onReUpload && onReUpload(item._id)}
+                    onClick={() => onReUpload?.(item._id)}
                   />
                 )}
               </div>
@@ -122,7 +122,7 @@ const ImageList: FC<ImageListProps> = ({
                 'rounded-2xl shadow-lg hover:bg-state-base-hover',
                 item.progress === -1 ? 'flex' : 'hidden group-hover:flex',
               )}
-              onClick={() => onRemove && onRemove(item._id)}
+              onClick={() => onRemove?.(item._id)}
             >
               <RiCloseLine className="h-3 w-3 text-text-tertiary" />
             </button>

web/app/components/base/image-uploader/image-preview.tsx

@@ -20,7 +20,7 @@ const isBase64 = (str: string): boolean => {
   try {
     return btoa(atob(str)) === str
   }
-  catch (err) {
+  catch {
     return false
   }
 }

web/app/components/base/markdown-blocks/code-block.tsx

@@ -8,12 +8,14 @@ import {
 import ActionButton from '@/app/components/base/action-button'
 import CopyIcon from '@/app/components/base/copy-icon'
 import SVGBtn from '@/app/components/base/svg'
-import Flowchart from '@/app/components/base/mermaid'
 import { Theme } from '@/types/app'
 import useTheme from '@/hooks/use-theme'
 import SVGRenderer from '../svg-gallery' // Assumes svg-gallery.tsx is in /base directory
 import MarkdownMusic from '@/app/components/base/markdown-blocks/music'
 import ErrorBoundary from '@/app/components/base/markdown/error-boundary'
+import dynamic from 'next/dynamic'
+
+const Flowchart = dynamic(() => import('@/app/components/base/mermaid'), { ssr: false })
 
 // Available language https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_LANGUAGES_HLJS.MD
 const capitalizationLanguageNameMap: Record<string, string> = {
@@ -125,7 +127,7 @@ const CodeBlock: any = memo(({ inline, className, children = '', ...props }: any
 
   // Store event handlers in useMemo to avoid recreating them
   const echartsEvents = useMemo(() => ({
-    finished: (params: EChartsEventParams) => {
+    finished: (_params: EChartsEventParams) => {
       // Limit finished event frequency to avoid infinite loops
       finishedEventCountRef.current++
       if (finishedEventCountRef.current > 3) {

web/app/components/base/markdown/index.tsx

@@ -1,25 +1,11 @@
-import ReactMarkdown from 'react-markdown'
+import dynamic from 'next/dynamic'
 import 'katex/dist/katex.min.css'
-import RemarkMath from 'remark-math'
-import RemarkBreaks from 'remark-breaks'
-import RehypeKatex from 'rehype-katex'
-import RemarkGfm from 'remark-gfm'
-import RehypeRaw from 'rehype-raw'
 import { flow } from 'lodash-es'
 import cn from '@/utils/classnames'
-import { customUrlTransform, preprocessLaTeX, preprocessThinkTag } from './markdown-utils'
-import {
-  AudioBlock,
-  CodeBlock,
-  Img,
-  Link,
-  MarkdownButton,
-  MarkdownForm,
-  Paragraph,
-  ScriptBlock,
-  ThinkBlock,
-  VideoBlock,
-} from '@/app/components/base/markdown-blocks'
+import { preprocessLaTeX, preprocessThinkTag } from './markdown-utils'
+import type { ReactMarkdownWrapperProps } from './react-markdown-wrapper'
+
+const ReactMarkdown = dynamic(() => import('./react-markdown-wrapper').then(mod => mod.ReactMarkdownWrapper), { ssr: false })
 
 /**
  * @fileoverview Main Markdown rendering component.
@@ -31,9 +17,7 @@ import {
 export type MarkdownProps = {
   content: string
   className?: string
-  customDisallowedElements?: string[]
-  customComponents?: Record<string, React.ComponentType<any>>
-}
+} & Pick<ReactMarkdownWrapperProps, 'customComponents' | 'customDisallowedElements'>
 
 export const Markdown = (props: MarkdownProps) => {
   const { customComponents = {} } = props
@@ -44,53 +28,7 @@ export const Markdown = (props: MarkdownProps) => {
 
   return (
     <div className={cn('markdown-body', '!text-text-primary', props.className)}>
-      <ReactMarkdown
-        remarkPlugins={[
-          RemarkGfm,
-          [RemarkMath, { singleDollarTextMath: false }],
-          RemarkBreaks,
-        ]}
-        rehypePlugins={[
-          RehypeKatex,
-          RehypeRaw as any,
-          // The Rehype plug-in is used to remove the ref attribute of an element
-          () => {
-            return (tree: any) => {
-              const iterate = (node: any) => {
-                if (node.type === 'element' && node.properties?.ref)
-                  delete node.properties.ref
-
-                if (node.type === 'element' && !/^[a-z][a-z0-9]*$/i.test(node.tagName)) {
-                  node.type = 'text'
-                  node.value = `<${node.tagName}`
-                }
-
-                if (node.children)
-                  node.children.forEach(iterate)
-              }
-              tree.children.forEach(iterate)
-            }
-          },
-        ]}
-        urlTransform={customUrlTransform}
-        disallowedElements={['iframe', 'head', 'html', 'meta', 'link', 'style', 'body', ...(props.customDisallowedElements || [])]}
-        components={{
-          code: CodeBlock,
-          img: Img,
-          video: VideoBlock,
-          audio: AudioBlock,
-          a: Link,
-          p: Paragraph,
-          button: MarkdownButton,
-          form: MarkdownForm,
-          script: ScriptBlock as any,
-          details: ThinkBlock,
-          ...customComponents,
-        }}
-      >
-        {/* Markdown detect has problem. */}
-        {latexContent}
-      </ReactMarkdown>
+      <ReactMarkdown latexContent={latexContent} customComponents={customComponents} customDisallowedElements={props.customDisallowedElements} />
     </div>
   )
 }

web/app/components/base/markdown/react-markdown-wrapper.tsx

@@ -0,0 +1,82 @@
+import ReactMarkdown from 'react-markdown'
+import RemarkMath from 'remark-math'
+import RemarkBreaks from 'remark-breaks'
+import RehypeKatex from 'rehype-katex'
+import RemarkGfm from 'remark-gfm'
+import RehypeRaw from 'rehype-raw'
+import AudioBlock from '@/app/components/base/markdown-blocks/audio-block'
+import Img from '@/app/components/base/markdown-blocks/img'
+import Link from '@/app/components/base/markdown-blocks/link'
+import MarkdownButton from '@/app/components/base/markdown-blocks/button'
+import MarkdownForm from '@/app/components/base/markdown-blocks/form'
+import Paragraph from '@/app/components/base/markdown-blocks/paragraph'
+import ScriptBlock from '@/app/components/base/markdown-blocks/script-block'
+import ThinkBlock from '@/app/components/base/markdown-blocks/think-block'
+import VideoBlock from '@/app/components/base/markdown-blocks/video-block'
+import { customUrlTransform } from './markdown-utils'
+
+import type { FC } from 'react'
+
+import dynamic from 'next/dynamic'
+
+const CodeBlock = dynamic(() => import('@/app/components/base/markdown-blocks/code-block'), { ssr: false })
+
+export type ReactMarkdownWrapperProps = {
+  latexContent: any
+  customDisallowedElements?: string[]
+  customComponents?: Record<string, React.ComponentType<any>>
+}
+
+export const ReactMarkdownWrapper: FC<ReactMarkdownWrapperProps> = (props) => {
+  const { customComponents, latexContent } = props
+
+  return (
+    <ReactMarkdown
+      remarkPlugins={[
+        RemarkGfm,
+        [RemarkMath, { singleDollarTextMath: false }],
+        RemarkBreaks,
+      ]}
+      rehypePlugins={[
+        RehypeKatex,
+        RehypeRaw as any,
+          // The Rehype plug-in is used to remove the ref attribute of an element
+        () => {
+          return (tree: any) => {
+            const iterate = (node: any) => {
+              if (node.type === 'element' && node.properties?.ref)
+                delete node.properties.ref
+
+              if (node.type === 'element' && !/^[a-z][a-z0-9]*$/i.test(node.tagName)) {
+                node.type = 'text'
+                node.value = `<${node.tagName}`
+              }
+
+              if (node.children)
+                node.children.forEach(iterate)
+            }
+            tree.children.forEach(iterate)
+          }
+        },
+      ]}
+      urlTransform={customUrlTransform}
+      disallowedElements={['iframe', 'head', 'html', 'meta', 'link', 'style', 'body', ...(props.customDisallowedElements || [])]}
+      components={{
+        code: CodeBlock,
+        img: Img,
+        video: VideoBlock,
+        audio: AudioBlock,
+        a: Link,
+        p: Paragraph,
+        button: MarkdownButton,
+        form: MarkdownForm,
+        script: ScriptBlock as any,
+        details: ThinkBlock,
+        ...customComponents,
+      }}
+    >
+      {/* Markdown detect has problem. */}
+      {latexContent}
+    </ReactMarkdown>
+  )
+}

web/app/components/base/mermaid/utils.ts

@@ -60,7 +60,7 @@ export function svgToBase64(svgGraph: string): Promise<string> {
       reader.readAsDataURL(blob)
     })
   }
-  catch (error) {
+  catch {
     return Promise.resolve('')
   }
 }

web/app/components/base/pagination/hook.ts

@@ -10,9 +10,7 @@ const usePagination = ({
   edgePageCount,
   middlePagesSiblingCount,
 }: IPaginationProps): IUsePagination => {
-  const pages = new Array(totalPages)
-    .fill(0)
-    .map((_, i) => i + 1)
+  const pages = React.useMemo(() => Array.from({ length: totalPages }, (_, i) => i + 1), [totalPages])
 
   const hasPreviousPage = currentPage > 1
   const hasNextPage = currentPage < totalPages

web/app/components/base/pagination/index.tsx

@@ -57,7 +57,34 @@ const CustomizedPagination: FC<Props> = ({
     if (isNaN(Number.parseInt(value)))
       return setInputValue('')
     setInputValue(Number.parseInt(value))
-    handlePaging(value)
+  }
+
+  const handleInputConfirm = () => {
+    if (inputValue !== '' && String(inputValue) !== String(current + 1)) {
+      handlePaging(String(inputValue))
+      return
+    }
+
+    if (inputValue === '')
+      setInputValue(current + 1)
+
+    setShowInput(false)
+  }
+
+  const handleInputKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === 'Enter') {
+      e.preventDefault()
+      handleInputConfirm()
+    }
+    else if (e.key === 'Escape') {
+      e.preventDefault()
+      setInputValue(current + 1)
+      setShowInput(false)
+    }
+  }
+
+  const handleInputBlur = () => {
+    handleInputConfirm()
   }
 
   return (
@@ -105,7 +132,8 @@ const CustomizedPagination: FC<Props> = ({
             autoFocus
             value={inputValue}
             onChange={handleInputChange}
-            onBlur={() => setShowInput(false)}
+            onKeyDown={handleInputKeyDown}
+            onBlur={handleInputBlur}
           />
         )}
         <Pagination.NextButton

web/app/components/base/popover/index.tsx

@@ -37,13 +37,16 @@ export default function CustomPopover({
   const timeOutRef = useRef<number | null>(null)
 
   const onMouseEnter = (isOpen: boolean) => {
-    timeOutRef.current && window.clearTimeout(timeOutRef.current)
-    !isOpen && buttonRef.current?.click()
+    if (timeOutRef.current != null)
+      window.clearTimeout(timeOutRef.current)
+    if (!isOpen)
+      buttonRef.current?.click()
   }
 
   const onMouseLeave = (isOpen: boolean) => {
     timeOutRef.current = window.setTimeout(() => {
-      isOpen && buttonRef.current?.click()
+      if (isOpen)
+        buttonRef.current?.click()
     }, timeoutDuration)
   }
 

web/app/components/base/select/locale-signin.tsx

@@ -43,7 +43,7 @@ export default function LocaleSigninSelect({
                     className={'group flex w-full items-center rounded-lg px-3 py-2 text-sm text-text-secondary data-[active]:bg-state-base-hover'}
                     onClick={(evt) => {
                       evt.preventDefault()
-                      onChange && onChange(item.value)
+                      onChange?.(item.value)
                     }}
                   >
                     {item.name}

web/app/components/base/select/locale.tsx

@@ -43,7 +43,7 @@ export default function Select({
                     className={'group flex w-full items-center rounded-lg px-3 py-2 text-sm text-text-secondary data-[active]:bg-state-base-hover'}
                     onClick={(evt) => {
                       evt.preventDefault()
-                      onChange && onChange(item.value)
+                      onChange?.(item.value)
                     }}
                   >
                     {item.name}

web/app/components/base/tag-management/panel.tsx

@@ -97,10 +97,13 @@ const Panel = (props: PanelProps) => {
     const removeTagIDs = value.filter(v => !selectedTagIDs.includes(v))
     const selectedTags = tagList.filter(tag => selectedTagIDs.includes(tag.id))
     onCacheUpdate(selectedTags)
-    Promise.all([
-      ...(addTagIDs.length ? [bind(addTagIDs)] : []),
-      ...[removeTagIDs.length ? removeTagIDs.map(tagID => unbind(tagID)) : []],
-    ]).finally(() => {
+    const operations: Promise<unknown>[] = []
+    if (addTagIDs.length)
+      operations.push(bind(addTagIDs))
+    if (removeTagIDs.length)
+      operations.push(...removeTagIDs.map(tagID => unbind(tagID)))
+
+    Promise.all(operations).finally(() => {
       if (onChange)
         onChange()
     })

web/app/components/base/voice-input/index.tsx

@@ -81,7 +81,8 @@ const VoiceInput = ({
     setStartRecord(false)
     setStartConvert(true)
     recorder.current.stop()
-    drawRecordId.current && cancelAnimationFrame(drawRecordId.current)
+    if (drawRecordId.current)
+      cancelAnimationFrame(drawRecordId.current)
     drawRecordId.current = null
     const canvas = canvasRef.current!
     const ctx = ctxRef.current!

web/app/components/datasets/create-from-pipeline/create-options/create-from-dsl-modal/uploader.tsx

@@ -34,7 +34,8 @@ const Uploader: FC<Props> = ({
   const handleDragEnter = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target !== dragRef.current && setDragging(true)
+    if (e.target !== dragRef.current)
+      setDragging(true)
   }
   const handleDragOver = (e: DragEvent) => {
     e.preventDefault()
@@ -43,7 +44,8 @@ const Uploader: FC<Props> = ({
   const handleDragLeave = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target === dragRef.current && setDragging(false)
+    if (e.target === dragRef.current)
+      setDragging(false)
   }
   const handleDrop = (e: DragEvent) => {
     e.preventDefault()

web/app/components/datasets/create/file-uploader/index.tsx

@@ -185,7 +185,8 @@ const FileUploader = ({
   const handleDragEnter = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target !== dragRef.current && setDragging(true)
+    if (e.target !== dragRef.current)
+      setDragging(true)
   }
   const handleDragOver = (e: DragEvent) => {
     e.preventDefault()
@@ -194,7 +195,8 @@ const FileUploader = ({
   const handleDragLeave = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target === dragRef.current && setDragging(false)
+    if (e.target === dragRef.current)
+      setDragging(false)
   }
   type FileWithPath = {
     relativePath?: string

web/app/components/datasets/create/step-two/index.tsx

@@ -568,9 +568,9 @@ const StepTwo = ({
         params,
         {
           onSuccess(data) {
-            updateIndexingTypeCache && updateIndexingTypeCache(indexType as string)
-            updateResultCache && updateResultCache(data)
-            updateRetrievalMethodCache && updateRetrievalMethodCache(retrievalConfig.search_method as string)
+            updateIndexingTypeCache?.(indexType as string)
+            updateResultCache?.(data)
+            updateRetrievalMethodCache?.(retrievalConfig.search_method as string)
           },
         },
       )
@@ -578,17 +578,18 @@ const StepTwo = ({
     else {
       await createDocumentMutation.mutateAsync(params, {
         onSuccess(data) {
-          updateIndexingTypeCache && updateIndexingTypeCache(indexType as string)
-          updateResultCache && updateResultCache(data)
-          updateRetrievalMethodCache && updateRetrievalMethodCache(retrievalConfig.search_method as string)
+          updateIndexingTypeCache?.(indexType as string)
+          updateResultCache?.(data)
+          updateRetrievalMethodCache?.(retrievalConfig.search_method as string)
         },
       })
     }
     if (mutateDatasetRes)
       mutateDatasetRes()
     invalidDatasetList()
-    onStepChange && onStepChange(+1)
-    isSetting && onSave && onSave()
+    onStepChange?.(+1)
+    if (isSetting)
+      onSave?.()
   }
 
   useEffect(() => {
@@ -1026,7 +1027,7 @@ const StepTwo = ({
         {!isSetting
           ? (
             <div className='mt-8 flex items-center py-2'>
-              <Button onClick={() => onStepChange && onStepChange(-1)}>
+              <Button onClick={() => onStepChange?.(-1)}>
                 <RiArrowLeftLine className='mr-1 h-4 w-4' />
                 {t('datasetCreation.stepTwo.previousStep')}
               </Button>

web/app/components/datasets/documents/create-from-pipeline/data-source/local-file/index.tsx

@@ -7,7 +7,6 @@ import DocumentFileIcon from '@/app/components/datasets/common/document-file-ico
 import cn from '@/utils/classnames'
 import type { CustomFile as File, FileItem } from '@/models/datasets'
 import { ToastContext } from '@/app/components/base/toast'
-import SimplePieChart from '@/app/components/base/simple-pie-chart'
 import { upload } from '@/service/base'
 import I18n from '@/context/i18n'
 import { LanguagesSupported } from '@/i18n-config/language'
@@ -17,6 +16,9 @@ import useTheme from '@/hooks/use-theme'
 import { useFileUploadConfig } from '@/service/use-common'
 import { useDataSourceStore, useDataSourceStoreWithSelector } from '../store'
 import produce from 'immer'
+import dynamic from 'next/dynamic'
+
+const SimplePieChart = dynamic(() => import('@/app/components/base/simple-pie-chart'), { ssr: false })
 
 const FILES_NUMBER_LIMIT = 20
 
@@ -198,7 +200,8 @@ const LocalFile = ({
   const handleDragEnter = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target !== dragRef.current && setDragging(true)
+    if (e.target !== dragRef.current)
+      setDragging(true)
   }
   const handleDragOver = (e: DragEvent) => {
     e.preventDefault()
@@ -207,7 +210,8 @@ const LocalFile = ({
   const handleDragLeave = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target === dragRef.current && setDragging(false)
+    if (e.target === dragRef.current)
+      setDragging(false)
   }
 
   const handleDrop = useCallback((e: DragEvent) => {

web/app/components/datasets/documents/create-from-pipeline/data-source/website-crawl/base/crawled-result.tsx

@@ -45,10 +45,13 @@ const CrawledResult = ({
 
   const handleItemCheckChange = useCallback((item: CrawlResultItem) => {
     return (checked: boolean) => {
-      if (checked)
-        isMultipleChoice ? onSelectedChange([...checkedList, item]) : onSelectedChange([item])
-      else
-        onSelectedChange(checkedList.filter(checkedItem => checkedItem.source_url !== item.source_url))
+      if (checked) {
+        if (isMultipleChoice)
+          onSelectedChange([...checkedList, item])
+        else
+          onSelectedChange([item])
+      }
+      else { onSelectedChange(checkedList.filter(checkedItem => checkedItem.source_url !== item.source_url)) }
     }
   }, [checkedList, onSelectedChange, isMultipleChoice])
 

web/app/components/datasets/documents/create-from-pipeline/index.tsx

@@ -326,7 +326,10 @@ const CreateFormPipeline = () => {
   }, [])
 
   const handleSubmit = useCallback((data: Record<string, any>) => {
-    isPreview.current ? handlePreviewChunks(data) : handleProcess(data)
+    if (isPreview.current)
+      handlePreviewChunks(data)
+    else
+      handleProcess(data)
   }, [handlePreviewChunks, handleProcess])
 
   const handlePreviewFileChange = useCallback((file: DocumentItem) => {

web/app/components/datasets/documents/detail/batch-modal/csv-uploader.tsx

@@ -99,7 +99,8 @@ const CSVUploader: FC<Props> = ({
   const handleDragEnter = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target !== dragRef.current && setDragging(true)
+    if (e.target !== dragRef.current)
+      setDragging(true)
   }
   const handleDragOver = (e: DragEvent) => {
     e.preventDefault()
@@ -108,7 +109,8 @@ const CSVUploader: FC<Props> = ({
   const handleDragLeave = (e: DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
-    e.target === dragRef.current && setDragging(false)
+    if (e.target === dragRef.current)
+      setDragging(false)
   }
   const handleDrop = (e: DragEvent) => {
     e.preventDefault()

web/app/components/datasets/documents/detail/completed/index.tsx

@@ -284,7 +284,8 @@ const Completed: FC<ICompletedProps> = ({
       onSuccess: () => {
         notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
         resetList()
-        !segId && setSelectedSegmentIds([])
+        if (!segId)
+          setSelectedSegmentIds([])
       },
       onError: () => {
         notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
@@ -438,7 +439,8 @@ const Completed: FC<ICompletedProps> = ({
     }
     else {
       resetList()
-      currentPage !== totalPages && setCurrentPage(totalPages)
+      if (currentPage !== totalPages)
+        setCurrentPage(totalPages)
     }
   }, [segmentListData, limit, currentPage, resetList])
 
@@ -491,7 +493,8 @@ const Completed: FC<ICompletedProps> = ({
     }
     else {
       resetChildList()
-      currentPage !== totalPages && setCurrentPage(totalPages)
+      if (currentPage !== totalPages)
+        setCurrentPage(totalPages)
     }
   }, [childChunkListData, limit, currentPage, resetChildList])
 

web/app/components/datasets/documents/detail/metadata/index.tsx

@@ -66,7 +66,7 @@ export const FieldInfo: FC<IFieldInfoProps> = ({
           ? displayedValue
           : inputType === 'select'
             ? <SimpleSelect
-              onSelect={({ value }) => onUpdate && onUpdate(value as string)}
+              onSelect={({ value }) => onUpdate?.(value as string)}
               items={selectOptions}
               defaultValue={value}
               className={s.select}
@@ -75,7 +75,7 @@ export const FieldInfo: FC<IFieldInfoProps> = ({
             />
             : inputType === 'textarea'
               ? <AutoHeightTextarea
-                onChange={e => onUpdate && onUpdate(e.target.value)}
+                onChange={e => onUpdate?.(e.target.value)}
                 value={value}
                 className={s.textArea}
                 placeholder={`${t('datasetDocuments.metadata.placeholder.add')}${label}`}

web/app/components/datasets/documents/detail/settings/pipeline-settings/index.tsx

@@ -148,7 +148,10 @@ const PipelineSettings = ({
   }, [])
 
   const handleSubmit = useCallback((data: Record<string, any>) => {
-    isPreview.current ? handlePreviewChunks(data) : handleProcess(data)
+    if (isPreview.current)
+      handlePreviewChunks(data)
+    else
+      handleProcess(data)
   }, [handlePreviewChunks, handleProcess])
 
   if (isFetchingLastRunData) {

web/app/components/datasets/hit-testing/textarea.tsx

@@ -80,7 +80,8 @@ const TextAreaWithButton = ({
       onUpdateList?.()
     }
     setLoading(false)
-    _onSubmit && _onSubmit()
+    if (_onSubmit)
+      _onSubmit()
   }
 
   const externalRetrievalTestingOnSubmit = async () => {

web/app/components/datasets/list/dataset-card/index.tsx

@@ -157,12 +157,12 @@ const DatasetCard = ({
         data-disable-nprogress={true}
         onClick={(e) => {
           e.preventDefault()
-          isExternalProvider
-            ? push(`/datasets/${dataset.id}/hitTesting`)
-            // eslint-disable-next-line sonarjs/no-nested-conditional
-            : isPipelineUnpublished
-              ? push(`/datasets/${dataset.id}/pipeline`)
-              : push(`/datasets/${dataset.id}/documents`)
+          if (isExternalProvider)
+            push(`/datasets/${dataset.id}/hitTesting`)
+          else if (isPipelineUnpublished)
+            push(`/datasets/${dataset.id}/pipeline`)
+          else
+            push(`/datasets/${dataset.id}/documents`)
         }}
       >
         {!dataset.embedding_available && (

web/app/components/datasets/loading.tsx

@@ -0,0 +1,3 @@
+const DatasetsLoading = () => null
+
+export default DatasetsLoading

web/app/components/datasets/preview/index.tsx

@@ -0,0 +1,3 @@
+const DatasetPreview = () => null
+
+export default DatasetPreview

web/app/components/header/account-setting/collapse/index.tsx

@@ -39,7 +39,7 @@ const Collapse = ({
           <div className='mx-1 mb-1 rounded-lg border-t border-divider-subtle bg-components-panel-on-panel-item-bg py-1'>
             {
               items.map(item => (
-                <div key={item.key} onClick={() => onSelect && onSelect(item)}>
+                <div key={item.key} onClick={() => onSelect?.(item)}>
                   {renderItem(item)}
                 </div>
               ))

web/app/components/header/account-setting/model-provider-page/provider-added-card/model-load-balancing-configs.tsx

@@ -49,7 +49,7 @@ const ModelLoadBalancingConfigs = ({
   provider,
   model,
   configurationMethod,
-  currentCustomConfigurationModelFixedFields,
+  currentCustomConfigurationModelFixedFields: _currentCustomConfigurationModelFixedFields,
   withSwitch = false,
   className,
   modelCredential,

web/app/components/plugins/plugin-detail-panel/app-selector/app-picker.tsx

@@ -33,7 +33,7 @@ type Props = {
 }
 
 const AppPicker: FC<Props> = ({
-  scope,
+  scope: _scope,
   disabled,
   trigger,
   placement = 'right-start',
@@ -90,7 +90,7 @@ const AppPicker: FC<Props> = ({
     }
 
     // Set up MutationObserver to watch DOM changes
-    mutationObserver = new MutationObserver((mutations) => {
+    mutationObserver = new MutationObserver((_mutations) => {
       if (observerTarget.current) {
         setupIntersectionObserver()
         mutationObserver?.disconnect()

web/app/components/plugins/plugin-detail-panel/model-selector/index.tsx

@@ -148,7 +148,7 @@ const ModelParameterModal: FC<ModelParameterModalProps> = ({
           })
         }
       }
-      catch (e) {
+      catch {
         Toast.notify({ type: 'error', message: t('common.error') })
       }
     }

web/app/components/rag-pipeline/components/panel/input-field/field-list/hooks.ts

@@ -51,7 +51,7 @@ export const useFieldList = ({
 
   const handleListSortChange = useCallback((list: SortableItem[]) => {
     const newInputFields = list.map((item) => {
-      const { id, chosen, selected, ...filed } = item
+      const { id: _id, chosen: _chosen, selected: _selected, ...filed } = item
       return filed
     })
     handleInputFieldsChange(newInputFields)

web/app/components/rag-pipeline/components/panel/test-run/header.tsx

@@ -15,7 +15,8 @@ const Header = () => {
       isPreparingDataSource,
       setIsPreparingDataSource,
     } = workflowStore.getState()
-    isPreparingDataSource && setIsPreparingDataSource?.(false)
+    if (isPreparingDataSource)
+      setIsPreparingDataSource?.(false)
     handleCancelDebugAndPreviewPanel()
   }, [workflowStore])
 

web/app/components/rag-pipeline/hooks/use-nodes-sync-draft.ts

@@ -104,7 +104,7 @@ export const useNodesSyncDraft = () => {
         const res = await syncWorkflowDraft(postParams)
         setSyncWorkflowDraftHash(res.hash)
         setDraftUpdatedAt(res.updated_at)
-        callback?.onSuccess && callback.onSuccess()
+        callback?.onSuccess?.()
       }
       catch (error: any) {
         if (error && error.json && !error.bodyUsed) {
@@ -113,10 +113,10 @@ export const useNodesSyncDraft = () => {
               handleRefreshWorkflowDraft()
           })
         }
-        callback?.onError && callback.onError()
+        callback?.onError?.()
       }
       finally {
-        callback?.onSettled && callback.onSettled()
+        callback?.onSettled?.()
       }
     }
   }, [getPostParams, getNodesReadOnly, workflowStore, handleRefreshWorkflowDraft])

web/app/components/share/text-generation/index.tsx

@@ -363,7 +363,8 @@ const TextGeneration: FC<IMainProps> = ({
     (async () => {
       if (!appData || !appParams)
         return
-      !isWorkflow && fetchSavedMessage()
+      if (!isWorkflow)
+        fetchSavedMessage()
       const { app_id: appId, site: siteInfo, custom_config } = appData
       setAppId(appId)
       setSiteInfo(siteInfo as SiteInfo)

web/app/components/share/text-generation/result/index.tsx

@@ -126,8 +126,8 @@ const Result: FC<IResultProps> = ({
 
     let hasEmptyInput = ''
     const requiredVars = prompt_variables?.filter(({ key, name, required, type }) => {
-      if(type === 'boolean')
-        return false // boolean input is not required
+      if(type === 'boolean' || type === 'checkbox')
+        return false // boolean/checkbox input is not required
       const res = (!key || !key.trim()) || (!name || !name.trim()) || (required || required === undefined || required === null)
       return res
     }) || [] // compatible with old version

web/app/components/share/text-generation/run-once/index.tsx

@@ -51,6 +51,8 @@ const RunOnce: FC<IRunOnceProps> = ({
     promptConfig.prompt_variables.forEach((item) => {
       if (item.type === 'string' || item.type === 'paragraph')
         newInputs[item.key] = ''
+      else if (item.type === 'checkbox')
+        newInputs[item.key] = false
       else
         newInputs[item.key] = undefined
     })
@@ -77,6 +79,8 @@ const RunOnce: FC<IRunOnceProps> = ({
         newInputs[item.key] = item.default || ''
       else if (item.type === 'number')
         newInputs[item.key] = item.default
+      else if (item.type === 'checkbox')
+        newInputs[item.key] = item.default || false
       else if (item.type === 'file')
         newInputs[item.key] = item.default
       else if (item.type === 'file-list')
@@ -96,7 +100,7 @@ const RunOnce: FC<IRunOnceProps> = ({
           {(inputs === null || inputs === undefined || Object.keys(inputs).length === 0) || !isInitialized ? null
             : promptConfig.prompt_variables.map(item => (
               <div className='mt-4 w-full' key={item.key}>
-                {item.type !== 'boolean' && (
+                {item.type !== 'checkbox' && (
                   <label className='system-md-semibold flex h-6 items-center text-text-secondary'>{item.name}</label>
                 )}
                 <div className='mt-1'>
@@ -134,7 +138,7 @@ const RunOnce: FC<IRunOnceProps> = ({
                       onChange={(e: ChangeEvent<HTMLInputElement>) => { handleInputsChange({ ...inputsRef.current, [item.key]: e.target.value }) }}
                     />
                   )}
-                  {item.type === 'boolean' && (
+                  {item.type === 'checkbox' && (
                     <BoolInput
                       name={item.name || item.key}
                       value={!!inputs[item.key]}