Merge branch 'main' into copilot/refactor-unnecessary-cast-call

Co-authored-by: asukaminato0721 <30024051+asukaminato0721@users.noreply.github.com>

.devcontainer/post_create_command.sh

@@ -7,7 +7,7 @@ cd web && pnpm install
 pipx install uv
 
 echo "alias start-api=\"cd $WORKSPACE_ROOT/api && uv run python -m flask run --host 0.0.0.0 --port=5001 --debug\"" >> ~/.bashrc
-echo "alias start-worker=\"cd $WORKSPACE_ROOT/api && uv run python -m celery -A app.celery worker -P threads -c 1 --loglevel INFO -Q dataset,dataset_summary,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention\"" >> ~/.bashrc
+echo "alias start-worker=\"cd $WORKSPACE_ROOT/api && uv run python -m celery -A app.celery worker -P threads -c 1 --loglevel INFO -Q dataset,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention\"" >> ~/.bashrc
 echo "alias start-web=\"cd $WORKSPACE_ROOT/web && pnpm dev:inspect\"" >> ~/.bashrc
 echo "alias start-web-prod=\"cd $WORKSPACE_ROOT/web && pnpm build && pnpm start\"" >> ~/.bashrc
 echo "alias start-containers=\"cd $WORKSPACE_ROOT/docker && docker-compose -f docker-compose.middleware.yaml -p dify --env-file middleware.env up -d\"" >> ~/.bashrc

.github/dependabot.yml

@@ -25,10 +25,6 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 2
     groups:
-      lexical:
-        patterns:
-          - "lexical"
-          - "@lexical/*"
       storybook:
         patterns:
           - "storybook"
@@ -37,7 +33,5 @@ updates:
         patterns:
           - "*"
         exclude-patterns:
-          - "lexical"
-          - "@lexical/*"
           - "storybook"
           - "@storybook/*"

.vscode/launch.json.template

@@ -37,7 +37,7 @@
                 "-c",
                 "1",
                 "-Q",
-                "dataset,dataset_summary,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution",
+                "dataset,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution",
                 "--loglevel",
                 "INFO"
             ],

Makefile

@@ -68,9 +68,8 @@ lint:
 	@echo "✅ Linting complete"
 
 type-check:
-	@echo "📝 Running type checks (basedpyright + pyrefly + mypy)..."
+	@echo "📝 Running type checks (basedpyright + mypy)..."
 	@./dev/basedpyright-check $(PATH_TO_CHECK)
-	@./dev/pyrefly-check-local
 	@uv --directory api run mypy --exclude-gitignore --exclude 'tests/' --exclude 'migrations/' --check-untyped-defs --disable-error-code=import-untyped .
 	@echo "✅ Type checks complete"
 
@@ -132,7 +131,7 @@ help:
 	@echo "  make format         - Format code with ruff"
 	@echo "  make check          - Check code with ruff"
 	@echo "  make lint           - Format, fix, and lint code (ruff, imports, dotenv)"
-	@echo "  make type-check     - Run type checks (basedpyright, pyrefly, mypy)"
+	@echo "  make type-check     - Run type checks (basedpyright, mypy)"
 	@echo "  make test           - Run backend unit tests (or TARGET_TESTS=./api/tests/<target_tests>)"
 	@echo ""
 	@echo "Docker Build Targets:"

api/AGENTS.md

@@ -62,22 +62,6 @@ This is the default standard for backend code in this repo. Follow it for new co
 
 - Code should usually include type annotations that match the repo’s current Python version (avoid untyped public APIs and “mystery” values).
 - Prefer modern typing forms (e.g. `list[str]`, `dict[str, int]`) and avoid `Any` unless there’s a strong reason.
-- For dictionary-like data with known keys and value types, prefer `TypedDict` over `dict[...]` or `Mapping[...]`.
-- For optional keys in typed payloads, use `NotRequired[...]` (or `total=False` when most fields are optional).
-- Keep `dict[...]` / `Mapping[...]` for truly dynamic key spaces where the key set is unknown.
-
-```python
-from datetime import datetime
-from typing import NotRequired, TypedDict
-
-
-class UserProfile(TypedDict):
-    user_id: str
-    email: str
-    created_at: datetime
-    nickname: NotRequired[str]
-```
-
 - For classes, declare member variables at the top of the class body (before `__init__`) so the class shape is obvious at a glance:
 
 ```python

api/commands.py

@@ -30,7 +30,6 @@ from extensions.ext_redis import redis_client
 from extensions.ext_storage import storage
 from extensions.storage.opendal_storage import OpenDALStorage
 from extensions.storage.storage_type import StorageType
-from libs.datetime_utils import naive_utc_now
 from libs.db_migration_lock import DbMigrationAutoRenewLock
 from libs.helper import email as email_validate
 from libs.password import hash_password, password_pattern, valid_password
@@ -937,12 +936,6 @@ def clear_free_plan_tenant_expired_logs(days: int, batch: int, tenant_ids: list[
     is_flag=True,
     help="Preview cleanup results without deleting any workflow run data.",
 )
-@click.option(
-    "--task-label",
-    default="daily",
-    show_default=True,
-    help="Stable label value used to distinguish multiple cleanup CronJobs in metrics.",
-)
 def clean_workflow_runs(
     before_days: int,
     batch_size: int,
@@ -951,13 +944,10 @@ def clean_workflow_runs(
     start_from: datetime.datetime | None,
     end_before: datetime.datetime | None,
     dry_run: bool,
-    task_label: str,
 ):
     """
     Clean workflow runs and related workflow data for free tenants.
     """
-    from extensions.otel.runtime import flush_telemetry
-
     if (start_from is None) ^ (end_before is None):
         raise click.UsageError("--start-from and --end-before must be provided together.")
 
@@ -977,17 +967,13 @@ def clean_workflow_runs(
     start_time = datetime.datetime.now(datetime.UTC)
     click.echo(click.style(f"Starting workflow run cleanup at {start_time.isoformat()}.", fg="white"))
 
-    try:
-        WorkflowRunCleanup(
-            days=before_days,
-            batch_size=batch_size,
-            start_from=start_from,
-            end_before=end_before,
-            dry_run=dry_run,
-            task_label=task_label,
-        ).run()
-    finally:
-        flush_telemetry()
+    WorkflowRunCleanup(
+        days=before_days,
+        batch_size=batch_size,
+        start_from=start_from,
+        end_before=end_before,
+        dry_run=dry_run,
+    ).run()
 
     end_time = datetime.datetime.now(datetime.UTC)
     elapsed = end_time - start_time
@@ -2612,29 +2598,15 @@ def migrate_oss(
 @click.option(
     "--start-from",
     type=click.DateTime(formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"]),
-    required=False,
-    default=None,
+    required=True,
     help="Lower bound (inclusive) for created_at.",
 )
 @click.option(
     "--end-before",
     type=click.DateTime(formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"]),
-    required=False,
-    default=None,
+    required=True,
     help="Upper bound (exclusive) for created_at.",
 )
-@click.option(
-    "--from-days-ago",
-    type=int,
-    default=None,
-    help="Relative lower bound in days ago (inclusive). Must be used with --before-days.",
-)
-@click.option(
-    "--before-days",
-    type=int,
-    default=None,
-    help="Relative upper bound in days ago (exclusive). Required for relative mode.",
-)
 @click.option("--batch-size", default=1000, show_default=True, help="Batch size for selecting messages.")
 @click.option(
     "--graceful-period",
@@ -2643,99 +2615,33 @@ def migrate_oss(
     help="Graceful period in days after subscription expiration, will be ignored when billing is disabled.",
 )
 @click.option("--dry-run", is_flag=True, default=False, help="Show messages logs would be cleaned without deleting")
-@click.option(
-    "--task-label",
-    default="daily",
-    show_default=True,
-    help="Stable label value used to distinguish multiple cleanup CronJobs in metrics.",
-)
 def clean_expired_messages(
     batch_size: int,
     graceful_period: int,
-    start_from: datetime.datetime | None,
-    end_before: datetime.datetime | None,
-    from_days_ago: int | None,
-    before_days: int | None,
+    start_from: datetime.datetime,
+    end_before: datetime.datetime,
     dry_run: bool,
-    task_label: str,
 ):
     """
     Clean expired messages and related data for tenants based on clean policy.
     """
-    from extensions.otel.runtime import flush_telemetry
-
     click.echo(click.style("clean_messages: start clean messages.", fg="green"))
 
     start_at = time.perf_counter()
 
     try:
-        abs_mode = start_from is not None and end_before is not None
-        rel_mode = before_days is not None
-
-        if abs_mode and rel_mode:
-            raise click.UsageError(
-                "Options are mutually exclusive: use either (--start-from,--end-before) "
-                "or (--from-days-ago,--before-days)."
-            )
-
-        if from_days_ago is not None and before_days is None:
-            raise click.UsageError("--from-days-ago must be used together with --before-days.")
-
-        if (start_from is None) ^ (end_before is None):
-            raise click.UsageError("Both --start-from and --end-before are required when using absolute time range.")
-
-        if not abs_mode and not rel_mode:
-            raise click.UsageError(
-                "You must provide either (--start-from,--end-before) or (--before-days [--from-days-ago])."
-            )
-
-        if rel_mode:
-            assert before_days is not None
-            if before_days < 0:
-                raise click.UsageError("--before-days must be >= 0.")
-            if from_days_ago is not None:
-                if from_days_ago < 0:
-                    raise click.UsageError("--from-days-ago must be >= 0.")
-                if from_days_ago <= before_days:
-                    raise click.UsageError("--from-days-ago must be greater than --before-days.")
-
         # Create policy based on billing configuration
         # NOTE: graceful_period will be ignored when billing is disabled.
         policy = create_message_clean_policy(graceful_period_days=graceful_period)
 
         # Create and run the cleanup service
-        if abs_mode:
-            assert start_from is not None
-            assert end_before is not None
-            service = MessagesCleanService.from_time_range(
-                policy=policy,
-                start_from=start_from,
-                end_before=end_before,
-                batch_size=batch_size,
-                dry_run=dry_run,
-                task_label=task_label,
-            )
-        elif from_days_ago is None:
-            assert before_days is not None
-            service = MessagesCleanService.from_days(
-                policy=policy,
-                days=before_days,
-                batch_size=batch_size,
-                dry_run=dry_run,
-                task_label=task_label,
-            )
-        else:
-            assert before_days is not None
-            assert from_days_ago is not None
-            now = naive_utc_now()
-            service = MessagesCleanService.from_time_range(
-                policy=policy,
-                start_from=now - datetime.timedelta(days=from_days_ago),
-                end_before=now - datetime.timedelta(days=before_days),
-                batch_size=batch_size,
-                dry_run=dry_run,
-                task_label=task_label,
-            )
+        service = MessagesCleanService.from_time_range(
+            policy=policy,
+            start_from=start_from,
+            end_before=end_before,
+            batch_size=batch_size,
+            dry_run=dry_run,
+        )
         stats = service.run()
 
         end_at = time.perf_counter()
@@ -2760,81 +2666,5 @@ def clean_expired_messages(
             )
         )
         raise
-    finally:
-        flush_telemetry()
 
     click.echo(click.style("messages cleanup completed.", fg="green"))
-
-
-@click.command("export-app-messages", help="Export messages for an app to JSONL.GZ.")
-@click.option("--app-id", required=True, help="Application ID to export messages for.")
-@click.option(
-    "--start-from",
-    type=click.DateTime(formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"]),
-    default=None,
-    help="Optional lower bound (inclusive) for created_at.",
-)
-@click.option(
-    "--end-before",
-    type=click.DateTime(formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"]),
-    required=True,
-    help="Upper bound (exclusive) for created_at.",
-)
-@click.option(
-    "--filename",
-    required=True,
-    help="Base filename (relative path). Do not include suffix like .jsonl.gz.",
-)
-@click.option("--use-cloud-storage", is_flag=True, default=False, help="Upload to cloud storage instead of local file.")
-@click.option("--batch-size", default=1000, show_default=True, help="Batch size for cursor pagination.")
-@click.option("--dry-run", is_flag=True, default=False, help="Scan only, print stats without writing any file.")
-def export_app_messages(
-    app_id: str,
-    start_from: datetime.datetime | None,
-    end_before: datetime.datetime,
-    filename: str,
-    use_cloud_storage: bool,
-    batch_size: int,
-    dry_run: bool,
-):
-    if start_from and start_from >= end_before:
-        raise click.UsageError("--start-from must be before --end-before.")
-
-    from services.retention.conversation.message_export_service import AppMessageExportService
-
-    try:
-        validated_filename = AppMessageExportService.validate_export_filename(filename)
-    except ValueError as e:
-        raise click.BadParameter(str(e), param_hint="--filename") from e
-
-    click.echo(click.style(f"export_app_messages: starting export for app {app_id}.", fg="green"))
-    start_at = time.perf_counter()
-
-    try:
-        service = AppMessageExportService(
-            app_id=app_id,
-            end_before=end_before,
-            filename=validated_filename,
-            start_from=start_from,
-            batch_size=batch_size,
-            use_cloud_storage=use_cloud_storage,
-            dry_run=dry_run,
-        )
-        stats = service.run()
-
-        elapsed = time.perf_counter() - start_at
-        click.echo(
-            click.style(
-                f"export_app_messages: completed in {elapsed:.2f}s\n"
-                f"  - Batches: {stats.batches}\n"
-                f"  - Total messages: {stats.total_messages}\n"
-                f"  - Messages with feedback: {stats.messages_with_feedback}\n"
-                f"  - Total feedbacks: {stats.total_feedbacks}",
-                fg="green",
-            )
-        )
-    except Exception as e:
-        elapsed = time.perf_counter() - start_at
-        logger.exception("export_app_messages failed")
-        click.echo(click.style(f"export_app_messages: failed after {elapsed:.2f}s - {e}", fg="red"))
-        raise

api/controllers/console/explore/parameter.py

@@ -1,5 +1,3 @@
-from typing import Any, cast
-
 from controllers.common import fields
 from controllers.console import console_ns
 from controllers.console.app.error import AppUnavailableError
@@ -25,14 +23,14 @@ class AppParameterApi(InstalledAppResource):
             if workflow is None:
                 raise AppUnavailableError()
 
-            features_dict: dict[str, Any] = workflow.features_dict
+            features_dict = workflow.features_dict
             user_input_form = workflow.user_input_form(to_old_structure=True)
         else:
             app_model_config = app_model.app_model_config
             if app_model_config is None:
                 raise AppUnavailableError()
 
-            features_dict = cast(dict[str, Any], app_model_config.to_dict())
+            features_dict = app_model_config.to_dict()
 
             user_input_form = features_dict.get("user_input_form", [])
 

api/controllers/service_api/app/app.py

@@ -1,5 +1,3 @@
-from typing import Any, cast
-
 from flask_restx import Resource
 
 from controllers.common.fields import Parameters
@@ -35,14 +33,14 @@ class AppParameterApi(Resource):
             if workflow is None:
                 raise AppUnavailableError()
 
-            features_dict: dict[str, Any] = workflow.features_dict
+            features_dict = workflow.features_dict
             user_input_form = workflow.user_input_form(to_old_structure=True)
         else:
             app_model_config = app_model.app_model_config
             if app_model_config is None:
                 raise AppUnavailableError()
 
-            features_dict = cast(dict[str, Any], app_model_config.to_dict())
+            features_dict = app_model_config.to_dict()
 
             user_input_form = features_dict.get("user_input_form", [])
 

api/controllers/web/app.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Any, cast
 
 from flask import request
 from flask_restx import Resource
@@ -58,14 +57,14 @@ class AppParameterApi(WebApiResource):
             if workflow is None:
                 raise AppUnavailableError()
 
-            features_dict: dict[str, Any] = workflow.features_dict
+            features_dict = workflow.features_dict
             user_input_form = workflow.user_input_form(to_old_structure=True)
         else:
             app_model_config = app_model.app_model_config
             if app_model_config is None:
                 raise AppUnavailableError()
 
-            features_dict = cast(dict[str, Any], app_model_config.to_dict())
+            features_dict = app_model_config.to_dict()
 
             user_input_form = features_dict.get("user_input_form", [])
 

api/core/app/app_config/common/sensitive_word_avoidance/manager.py

@@ -1,13 +1,10 @@
-from collections.abc import Mapping
-from typing import Any
-
 from core.app.app_config.entities import SensitiveWordAvoidanceEntity
 from core.moderation.factory import ModerationFactory
 
 
 class SensitiveWordAvoidanceConfigManager:
     @classmethod
-    def convert(cls, config: Mapping[str, Any]) -> SensitiveWordAvoidanceEntity | None:
+    def convert(cls, config: dict) -> SensitiveWordAvoidanceEntity | None:
         sensitive_word_avoidance_dict = config.get("sensitive_word_avoidance")
         if not sensitive_word_avoidance_dict:
             return None
@@ -15,7 +12,7 @@ class SensitiveWordAvoidanceConfigManager:
         if sensitive_word_avoidance_dict.get("enabled"):
             return SensitiveWordAvoidanceEntity(
                 type=sensitive_word_avoidance_dict.get("type"),
-                config=sensitive_word_avoidance_dict.get("config", {}),
+                config=sensitive_word_avoidance_dict.get("config"),
             )
         else:
             return None

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

@@ -1,13 +1,10 @@
-from typing import Any, cast
-
 from core.agent.entities import AgentEntity, AgentPromptEntity, AgentToolEntity
 from core.agent.prompt.template import REACT_PROMPT_TEMPLATES
-from models.model import AppModelConfigDict
 
 
 class AgentConfigManager:
     @classmethod
-    def convert(cls, config: AppModelConfigDict) -> AgentEntity | None:
+    def convert(cls, config: dict) -> AgentEntity | None:
         """
         Convert model config to model config
 
@@ -31,17 +28,17 @@ class AgentConfigManager:
 
             agent_tools = []
             for tool in agent_dict.get("tools", []):
-                tool_dict = cast(dict[str, Any], tool)
-                if len(tool_dict) >= 4:
-                    if "enabled" not in tool_dict or not tool_dict["enabled"]:
+                keys = tool.keys()
+                if len(keys) >= 4:
+                    if "enabled" not in tool or not tool["enabled"]:
                         continue
 
                     agent_tool_properties = {
-                        "provider_type": tool_dict["provider_type"],
-                        "provider_id": tool_dict["provider_id"],
-                        "tool_name": tool_dict["tool_name"],
-                        "tool_parameters": tool_dict.get("tool_parameters", {}),
-                        "credential_id": tool_dict.get("credential_id", None),
+                        "provider_type": tool["provider_type"],
+                        "provider_id": tool["provider_id"],
+                        "tool_name": tool["tool_name"],
+                        "tool_parameters": tool.get("tool_parameters", {}),
+                        "credential_id": tool.get("credential_id", None),
                     }
 
                     agent_tools.append(AgentToolEntity.model_validate(agent_tool_properties))
@@ -50,8 +47,7 @@ class AgentConfigManager:
                 "react_router",
                 "router",
             }:
-                agent_prompt_raw = agent_dict.get("prompt", None)
-                agent_prompt: dict[str, Any] = agent_prompt_raw if isinstance(agent_prompt_raw, dict) else {}
+                agent_prompt = agent_dict.get("prompt", None) or {}
                 # check model mode
                 model_mode = config.get("model", {}).get("mode", "completion")
                 if model_mode == "completion":
@@ -79,7 +75,7 @@ class AgentConfigManager:
                     strategy=strategy,
                     prompt=agent_prompt_entity,
                     tools=agent_tools,
-                    max_iteration=cast(int, agent_dict.get("max_iteration", 10)),
+                    max_iteration=agent_dict.get("max_iteration", 10),
                 )
 
         return None

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

@@ -1,5 +1,5 @@
 import uuid
-from typing import Any, Literal, cast
+from typing import Literal, cast
 
 from core.app.app_config.entities import (
     DatasetEntity,
@@ -8,13 +8,13 @@ from core.app.app_config.entities import (
     ModelConfig,
 )
 from core.entities.agent_entities import PlanningStrategy
-from models.model import AppMode, AppModelConfigDict
+from models.model import AppMode
 from services.dataset_service import DatasetService
 
 
 class DatasetConfigManager:
     @classmethod
-    def convert(cls, config: AppModelConfigDict) -> DatasetEntity | None:
+    def convert(cls, config: dict) -> DatasetEntity | None:
         """
         Convert model config to model config
 
@@ -25,15 +25,11 @@ class DatasetConfigManager:
             datasets = config.get("dataset_configs", {}).get("datasets", {"strategy": "router", "datasets": []})
 
             for dataset in datasets.get("datasets", []):
-                if not isinstance(dataset, dict):
-                    continue
                 keys = list(dataset.keys())
                 if len(keys) == 0 or keys[0] != "dataset":
                     continue
 
                 dataset = dataset["dataset"]
-                if not isinstance(dataset, dict):
-                    continue
 
                 if "enabled" not in dataset or not dataset["enabled"]:
                     continue
@@ -51,14 +47,15 @@ class DatasetConfigManager:
             agent_dict = config.get("agent_mode", {})
 
             for tool in agent_dict.get("tools", []):
-                if len(tool) == 1:
+                keys = tool.keys()
+                if len(keys) == 1:
                     # old standard
                     key = list(tool.keys())[0]
 
                     if key != "dataset":
                         continue
 
-                    tool_item = cast(dict[str, Any], tool)[key]
+                    tool_item = tool[key]
 
                     if "enabled" not in tool_item or not tool_item["enabled"]:
                         continue

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

@@ -5,13 +5,12 @@ from core.app.app_config.entities import ModelConfigEntity
 from core.provider_manager import ProviderManager
 from dify_graph.model_runtime.entities.model_entities import ModelPropertyKey, ModelType
 from dify_graph.model_runtime.model_providers.model_provider_factory import ModelProviderFactory
-from models.model import AppModelConfigDict
 from models.provider_ids import ModelProviderID
 
 
 class ModelConfigManager:
     @classmethod
-    def convert(cls, config: AppModelConfigDict) -> ModelConfigEntity:
+    def convert(cls, config: dict) -> ModelConfigEntity:
         """
         Convert model config to model config
 
@@ -23,7 +22,7 @@ class ModelConfigManager:
         if not model_config:
             raise ValueError("model is required")
 
-        completion_params = model_config.get("completion_params") or {}
+        completion_params = model_config.get("completion_params")
         stop = []
         if "stop" in completion_params:
             stop = completion_params["stop"]

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

@@ -1,5 +1,3 @@
-from typing import Any
-
 from core.app.app_config.entities import (
     AdvancedChatMessageEntity,
     AdvancedChatPromptTemplateEntity,
@@ -8,12 +6,12 @@ from core.app.app_config.entities import (
 )
 from core.prompt.simple_prompt_transform import ModelMode
 from dify_graph.model_runtime.entities.message_entities import PromptMessageRole
-from models.model import AppMode, AppModelConfigDict
+from models.model import AppMode
 
 
 class PromptTemplateConfigManager:
     @classmethod
-    def convert(cls, config: AppModelConfigDict) -> PromptTemplateEntity:
+    def convert(cls, config: dict) -> PromptTemplateEntity:
         if not config.get("prompt_type"):
             raise ValueError("prompt_type is required")
 
@@ -42,15 +40,14 @@ class PromptTemplateConfigManager:
             advanced_completion_prompt_template = None
             completion_prompt_config = config.get("completion_prompt_config", {})
             if completion_prompt_config:
-                completion_prompt_template_params: dict[str, Any] = {
+                completion_prompt_template_params = {
                     "prompt": completion_prompt_config["prompt"]["text"],
                 }
 
-                conv_role = completion_prompt_config.get("conversation_histories_role")
-                if conv_role:
+                if "conversation_histories_role" in completion_prompt_config:
                     completion_prompt_template_params["role_prefix"] = {
-                        "user": conv_role["user_prefix"],
-                        "assistant": conv_role["assistant_prefix"],
+                        "user": completion_prompt_config["conversation_histories_role"]["user_prefix"],
+                        "assistant": completion_prompt_config["conversation_histories_role"]["assistant_prefix"],
                     }
 
                 advanced_completion_prompt_template = AdvancedCompletionPromptTemplateEntity(

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

@@ -1,10 +1,8 @@
 import re
-from typing import cast
 
 from core.app.app_config.entities import ExternalDataVariableEntity
 from core.external_data_tool.factory import ExternalDataToolFactory
 from dify_graph.variables.input_entities import VariableEntity, VariableEntityType
-from models.model import AppModelConfigDict
 
 _ALLOWED_VARIABLE_ENTITY_TYPE = frozenset(
     [
@@ -20,7 +18,7 @@ _ALLOWED_VARIABLE_ENTITY_TYPE = frozenset(
 
 class BasicVariablesConfigManager:
     @classmethod
-    def convert(cls, config: AppModelConfigDict) -> tuple[list[VariableEntity], list[ExternalDataVariableEntity]]:
+    def convert(cls, config: dict) -> tuple[list[VariableEntity], list[ExternalDataVariableEntity]]:
         """
         Convert model config to model config
 
@@ -53,9 +51,7 @@ class BasicVariablesConfigManager:
 
                 external_data_variables.append(
                     ExternalDataVariableEntity(
-                        variable=variable["variable"],
-                        type=variable.get("type", ""),
-                        config=variable.get("config", {}),
+                        variable=variable["variable"], type=variable["type"], config=variable["config"]
                     )
                 )
             elif variable_type in {
@@ -68,10 +64,10 @@ class BasicVariablesConfigManager:
                 variable = variables[variable_type]
                 variable_entities.append(
                     VariableEntity(
-                        type=cast(VariableEntityType, variable_type),
-                        variable=variable["variable"],
+                        type=variable_type,
+                        variable=variable.get("variable"),
                         description=variable.get("description") or "",
-                        label=variable["label"],
+                        label=variable.get("label"),
                         required=variable.get("required", False),
                         max_length=variable.get("max_length"),
                         options=variable.get("options") or [],

api/core/app/app_config/entities.py

@@ -281,7 +281,7 @@ class EasyUIBasedAppConfig(AppConfig):
 
     app_model_config_from: EasyUIBasedAppModelConfigFrom
     app_model_config_id: str
-    app_model_config_dict: dict[str, Any]
+    app_model_config_dict: dict
     model: ModelConfigEntity
     prompt_template: PromptTemplateEntity
     dataset: DatasetEntity | None = None

api/core/app/apps/advanced_chat/generate_task_pipeline.py

@@ -516,10 +516,8 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
             graph_runtime_state=validated_state,
         )
 
-        yield from self._handle_advanced_chat_message_end_event(
-            QueueAdvancedChatMessageEndEvent(), graph_runtime_state=validated_state
-        )
         yield workflow_finish_resp
+        self._base_task_pipeline.queue_manager.publish(QueueAdvancedChatMessageEndEvent(), PublishFrom.TASK_PIPELINE)
 
     def _handle_workflow_partial_success_event(
         self,
@@ -540,9 +538,6 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
             exceptions_count=event.exceptions_count,
         )
 
-        yield from self._handle_advanced_chat_message_end_event(
-            QueueAdvancedChatMessageEndEvent(), graph_runtime_state=validated_state
-        )
         yield workflow_finish_resp
 
     def _handle_workflow_paused_event(
@@ -859,14 +854,6 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
                     yield from self._handle_workflow_paused_event(event)
                     break
 
-                case QueueWorkflowSucceededEvent():
-                    yield from self._handle_workflow_succeeded_event(event, trace_manager=trace_manager)
-                    break
-
-                case QueueWorkflowPartialSuccessEvent():
-                    yield from self._handle_workflow_partial_success_event(event, trace_manager=trace_manager)
-                    break
-
                 case QueueStopEvent():
                     yield from self._handle_stop_event(event, graph_runtime_state=None, trace_manager=trace_manager)
                     break

api/core/app/apps/agent_chat/app_config_manager.py

@@ -20,7 +20,7 @@ from core.app.app_config.features.suggested_questions_after_answer.manager impor
 )
 from core.app.app_config.features.text_to_speech.manager import TextToSpeechConfigManager
 from core.entities.agent_entities import PlanningStrategy
-from models.model import App, AppMode, AppModelConfig, AppModelConfigDict, Conversation
+from models.model import App, AppMode, AppModelConfig, Conversation
 
 OLD_TOOLS = ["dataset", "google_search", "web_reader", "wikipedia", "current_datetime"]
 
@@ -40,7 +40,7 @@ class AgentChatAppConfigManager(BaseAppConfigManager):
         app_model: App,
         app_model_config: AppModelConfig,
         conversation: Conversation | None = None,
-        override_config_dict: AppModelConfigDict | None = None,
+        override_config_dict: dict | None = None,
     ) -> AgentChatAppConfig:
         """
         Convert app model config to agent chat app config
@@ -61,9 +61,7 @@ class AgentChatAppConfigManager(BaseAppConfigManager):
             app_model_config_dict = app_model_config.to_dict()
             config_dict = app_model_config_dict.copy()
         else:
-            if not override_config_dict:
-                raise Exception("override_config_dict is required when config_from is ARGS")
-            config_dict = override_config_dict
+            config_dict = override_config_dict or {}
 
         app_mode = AppMode.value_of(app_model.mode)
         app_config = AgentChatAppConfig(
@@ -72,7 +70,7 @@ class AgentChatAppConfigManager(BaseAppConfigManager):
             app_mode=app_mode,
             app_model_config_from=config_from,
             app_model_config_id=app_model_config.id,
-            app_model_config_dict=cast(dict[str, Any], config_dict),
+            app_model_config_dict=config_dict,
             model=ModelConfigManager.convert(config=config_dict),
             prompt_template=PromptTemplateConfigManager.convert(config=config_dict),
             sensitive_word_avoidance=SensitiveWordAvoidanceConfigManager.convert(config=config_dict),
@@ -88,7 +86,7 @@ class AgentChatAppConfigManager(BaseAppConfigManager):
         return app_config
 
     @classmethod
-    def config_validate(cls, tenant_id: str, config: Mapping[str, Any]) -> AppModelConfigDict:
+    def config_validate(cls, tenant_id: str, config: Mapping[str, Any]):
         """
         Validate for agent chat app model config
 
@@ -159,7 +157,7 @@ class AgentChatAppConfigManager(BaseAppConfigManager):
         # Filter out extra parameters
         filtered_config = {key: config.get(key) for key in related_config_keys}
 
-        return cast(AppModelConfigDict, filtered_config)
+        return filtered_config
 
     @classmethod
     def validate_agent_mode_and_set_defaults(

api/core/app/apps/chat/app_config_manager.py

@@ -1,5 +1,3 @@
-from typing import Any, cast
-
 from core.app.app_config.base_app_config_manager import BaseAppConfigManager
 from core.app.app_config.common.sensitive_word_avoidance.manager import SensitiveWordAvoidanceConfigManager
 from core.app.app_config.easy_ui_based_app.dataset.manager import DatasetConfigManager
@@ -15,7 +13,7 @@ from core.app.app_config.features.suggested_questions_after_answer.manager impor
     SuggestedQuestionsAfterAnswerConfigManager,
 )
 from core.app.app_config.features.text_to_speech.manager import TextToSpeechConfigManager
-from models.model import App, AppMode, AppModelConfig, AppModelConfigDict, Conversation
+from models.model import App, AppMode, AppModelConfig, Conversation
 
 
 class ChatAppConfig(EasyUIBasedAppConfig):
@@ -33,7 +31,7 @@ class ChatAppConfigManager(BaseAppConfigManager):
         app_model: App,
         app_model_config: AppModelConfig,
         conversation: Conversation | None = None,
-        override_config_dict: AppModelConfigDict | None = None,
+        override_config_dict: dict | None = None,
     ) -> ChatAppConfig:
         """
         Convert app model config to chat app config
@@ -66,7 +64,7 @@ class ChatAppConfigManager(BaseAppConfigManager):
             app_mode=app_mode,
             app_model_config_from=config_from,
             app_model_config_id=app_model_config.id,
-            app_model_config_dict=cast(dict[str, Any], config_dict),
+            app_model_config_dict=config_dict,
             model=ModelConfigManager.convert(config=config_dict),
             prompt_template=PromptTemplateConfigManager.convert(config=config_dict),
             sensitive_word_avoidance=SensitiveWordAvoidanceConfigManager.convert(config=config_dict),
@@ -81,7 +79,7 @@ class ChatAppConfigManager(BaseAppConfigManager):
         return app_config
 
     @classmethod
-    def config_validate(cls, tenant_id: str, config: dict) -> AppModelConfigDict:
+    def config_validate(cls, tenant_id: str, config: dict):
         """
         Validate for chat app model config
 
@@ -147,4 +145,4 @@ class ChatAppConfigManager(BaseAppConfigManager):
         # Filter out extra parameters
         filtered_config = {key: config.get(key) for key in related_config_keys}
 
-        return cast(AppModelConfigDict, filtered_config)
+        return filtered_config

api/core/app/apps/chat/app_runner.py

@@ -173,10 +173,8 @@ class ChatAppRunner(AppRunner):
                 memory=memory,
                 message_id=message.id,
                 inputs=inputs,
-                vision_enabled=bool(
-                    application_generate_entity.app_config.app_model_config_dict.get("file_upload", {})
-                    .get("image", {})
-                    .get("enabled", False)
+                vision_enabled=application_generate_entity.app_config.app_model_config_dict.get("file_upload", {}).get(
+                    "enabled", False
                 ),
             )
             context_files = retrieved_files or []

api/core/app/apps/completion/app_config_manager.py

@@ -1,5 +1,3 @@
-from typing import Any, cast
-
 from core.app.app_config.base_app_config_manager import BaseAppConfigManager
 from core.app.app_config.common.sensitive_word_avoidance.manager import SensitiveWordAvoidanceConfigManager
 from core.app.app_config.easy_ui_based_app.dataset.manager import DatasetConfigManager
@@ -10,7 +8,7 @@ from core.app.app_config.entities import EasyUIBasedAppConfig, EasyUIBasedAppMod
 from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
 from core.app.app_config.features.more_like_this.manager import MoreLikeThisConfigManager
 from core.app.app_config.features.text_to_speech.manager import TextToSpeechConfigManager
-from models.model import App, AppMode, AppModelConfig, AppModelConfigDict
+from models.model import App, AppMode, AppModelConfig
 
 
 class CompletionAppConfig(EasyUIBasedAppConfig):
@@ -24,7 +22,7 @@ class CompletionAppConfig(EasyUIBasedAppConfig):
 class CompletionAppConfigManager(BaseAppConfigManager):
     @classmethod
     def get_app_config(
-        cls, app_model: App, app_model_config: AppModelConfig, override_config_dict: AppModelConfigDict | None = None
+        cls, app_model: App, app_model_config: AppModelConfig, override_config_dict: dict | None = None
     ) -> CompletionAppConfig:
         """
         Convert app model config to completion app config
@@ -42,9 +40,7 @@ class CompletionAppConfigManager(BaseAppConfigManager):
             app_model_config_dict = app_model_config.to_dict()
             config_dict = app_model_config_dict.copy()
         else:
-            if not override_config_dict:
-                raise Exception("override_config_dict is required when config_from is ARGS")
-            config_dict = override_config_dict
+            config_dict = override_config_dict or {}
 
         app_mode = AppMode.value_of(app_model.mode)
         app_config = CompletionAppConfig(
@@ -53,7 +49,7 @@ class CompletionAppConfigManager(BaseAppConfigManager):
             app_mode=app_mode,
             app_model_config_from=config_from,
             app_model_config_id=app_model_config.id,
-            app_model_config_dict=cast(dict[str, Any], config_dict),
+            app_model_config_dict=config_dict,
             model=ModelConfigManager.convert(config=config_dict),
             prompt_template=PromptTemplateConfigManager.convert(config=config_dict),
             sensitive_word_avoidance=SensitiveWordAvoidanceConfigManager.convert(config=config_dict),
@@ -68,7 +64,7 @@ class CompletionAppConfigManager(BaseAppConfigManager):
         return app_config
 
     @classmethod
-    def config_validate(cls, tenant_id: str, config: dict) -> AppModelConfigDict:
+    def config_validate(cls, tenant_id: str, config: dict):
         """
         Validate for completion app model config
 
@@ -120,4 +116,4 @@ class CompletionAppConfigManager(BaseAppConfigManager):
         # Filter out extra parameters
         filtered_config = {key: config.get(key) for key in related_config_keys}
 
-        return cast(AppModelConfigDict, filtered_config)
+        return filtered_config

api/core/app/apps/completion/app_generator.py

@@ -275,7 +275,7 @@ class CompletionAppGenerator(MessageBasedAppGenerator):
             raise ValueError("Message app_model_config is None")
         override_model_config_dict = app_model_config.to_dict()
         model_dict = override_model_config_dict["model"]
-        completion_params = model_dict.get("completion_params", {})
+        completion_params = model_dict.get("completion_params")
         completion_params["temperature"] = 0.9
         model_dict["completion_params"] = completion_params
         override_model_config_dict["model"] = model_dict

api/core/app/apps/completion/app_runner.py

@@ -132,10 +132,8 @@ class CompletionAppRunner(AppRunner):
                 hit_callback=hit_callback,
                 message_id=message.id,
                 inputs=inputs,
-                vision_enabled=bool(
-                    application_generate_entity.app_config.app_model_config_dict.get("file_upload", {})
-                    .get("image", {})
-                    .get("enabled", False)
+                vision_enabled=application_generate_entity.app_config.app_model_config_dict.get("file_upload", {}).get(
+                    "enabled", False
                 ),
             )
             context_files = retrieved_files or []

api/core/app/task_pipeline/easy_ui_based_generate_task_pipeline.py

@@ -2,7 +2,7 @@ import logging
 import time
 from collections.abc import Generator
 from threading import Thread
-from typing import Any, Union, cast
+from typing import Union, cast
 
 from sqlalchemy import select
 from sqlalchemy.orm import Session
@@ -44,13 +44,14 @@ from core.app.entities.task_entities import (
 )
 from core.app.task_pipeline.based_generate_task_pipeline import BasedGenerateTaskPipeline
 from core.app.task_pipeline.message_cycle_manager import MessageCycleManager
-from core.app.task_pipeline.message_file_utils import prepare_file_dict
 from core.base.tts import AppGeneratorTTSPublisher, AudioTrunk
 from core.model_manager import ModelInstance
 from core.ops.entities.trace_entity import TraceTaskName
 from core.ops.ops_trace_manager import TraceQueueManager, TraceTask
 from core.prompt.utils.prompt_message_util import PromptMessageUtil
 from core.prompt.utils.prompt_template_parser import PromptTemplateParser
+from core.tools.signature import sign_tool_file
+from dify_graph.file import helpers as file_helpers
 from dify_graph.file.enums import FileTransferMethod
 from dify_graph.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk, LLMResultChunkDelta, LLMUsage
 from dify_graph.model_runtime.entities.message_entities import (
@@ -218,14 +219,14 @@ class EasyUIBasedGenerateTaskPipeline(BasedGenerateTaskPipeline):
         tenant_id = self._application_generate_entity.app_config.tenant_id
         task_id = self._application_generate_entity.task_id
         publisher = None
-        text_to_speech_dict = cast(dict[str, Any], self._app_config.app_model_config_dict.get("text_to_speech"))
+        text_to_speech_dict = self._app_config.app_model_config_dict.get("text_to_speech")
         if (
             text_to_speech_dict
             and text_to_speech_dict.get("autoPlay") == "enabled"
             and text_to_speech_dict.get("enabled")
         ):
             publisher = AppGeneratorTTSPublisher(
-                tenant_id, text_to_speech_dict.get("voice", ""), text_to_speech_dict.get("language", None)
+                tenant_id, text_to_speech_dict.get("voice", None), text_to_speech_dict.get("language", None)
             )
         for response in self._process_stream_response(publisher=publisher, trace_manager=trace_manager):
             while True:
@@ -459,40 +460,91 @@ class EasyUIBasedGenerateTaskPipeline(BasedGenerateTaskPipeline):
         """
         self._task_state.metadata.usage = self._task_state.llm_result.usage
         metadata_dict = self._task_state.metadata.model_dump()
-
-        # Fetch files associated with this message
-        files = None
-        with Session(db.engine, expire_on_commit=False) as session:
-            message_files = session.scalars(select(MessageFile).where(MessageFile.message_id == self._message_id)).all()
-
-            if message_files:
-                # Fetch all required UploadFile objects in a single query to avoid N+1 problem
-                upload_file_ids = list(
-                    dict.fromkeys(
-                        mf.upload_file_id
-                        for mf in message_files
-                        if mf.transfer_method == FileTransferMethod.LOCAL_FILE and mf.upload_file_id
-                    )
-                )
-                upload_files_map = {}
-                if upload_file_ids:
-                    upload_files = session.scalars(select(UploadFile).where(UploadFile.id.in_(upload_file_ids))).all()
-                    upload_files_map = {uf.id: uf for uf in upload_files}
-
-                files_list = []
-                for message_file in message_files:
-                    file_dict = prepare_file_dict(message_file, upload_files_map)
-                    files_list.append(file_dict)
-
-                files = files_list or None
-
         return MessageEndStreamResponse(
             task_id=self._application_generate_entity.task_id,
             id=self._message_id,
             metadata=metadata_dict,
-            files=files,
         )
 
+    def _record_files(self):
+        with Session(db.engine, expire_on_commit=False) as session:
+            message_files = session.scalars(select(MessageFile).where(MessageFile.message_id == self._message_id)).all()
+            if not message_files:
+                return None
+
+            files_list = []
+            upload_file_ids = [
+                mf.upload_file_id
+                for mf in message_files
+                if mf.transfer_method == FileTransferMethod.LOCAL_FILE and mf.upload_file_id
+            ]
+            upload_files_map = {}
+            if upload_file_ids:
+                upload_files = session.scalars(select(UploadFile).where(UploadFile.id.in_(upload_file_ids))).all()
+                upload_files_map = {uf.id: uf for uf in upload_files}
+
+            for message_file in message_files:
+                upload_file = None
+                if message_file.transfer_method == FileTransferMethod.LOCAL_FILE and message_file.upload_file_id:
+                    upload_file = upload_files_map.get(message_file.upload_file_id)
+
+                url = None
+                filename = "file"
+                mime_type = "application/octet-stream"
+                size = 0
+                extension = ""
+
+                if message_file.transfer_method == FileTransferMethod.REMOTE_URL:
+                    url = message_file.url
+                    if message_file.url:
+                        filename = message_file.url.split("/")[-1].split("?")[0]  # Remove query params
+                elif message_file.transfer_method == FileTransferMethod.LOCAL_FILE:
+                    if upload_file:
+                        url = file_helpers.get_signed_file_url(upload_file_id=str(upload_file.id))
+                        filename = upload_file.name
+                        mime_type = upload_file.mime_type or "application/octet-stream"
+                        size = upload_file.size or 0
+                        extension = f".{upload_file.extension}" if upload_file.extension else ""
+                    elif message_file.upload_file_id:
+                        # Fallback: generate URL even if upload_file not found
+                        url = file_helpers.get_signed_file_url(upload_file_id=str(message_file.upload_file_id))
+                elif message_file.transfer_method == FileTransferMethod.TOOL_FILE and message_file.url:
+                    # For tool files, use URL directly if it's HTTP, otherwise sign it
+                    if message_file.url.startswith("http"):
+                        url = message_file.url
+                        filename = message_file.url.split("/")[-1].split("?")[0]
+                    else:
+                        # Extract tool file id and extension from URL
+                        url_parts = message_file.url.split("/")
+                        if url_parts:
+                            file_part = url_parts[-1].split("?")[0]  # Remove query params first
+                            # Use rsplit to correctly handle filenames with multiple dots
+                            if "." in file_part:
+                                tool_file_id, ext = file_part.rsplit(".", 1)
+                                extension = f".{ext}"
+                            else:
+                                tool_file_id = file_part
+                                extension = ".bin"
+                            url = sign_tool_file(tool_file_id=tool_file_id, extension=extension)
+                            filename = file_part
+
+                transfer_method_value = message_file.transfer_method
+                remote_url = message_file.url if message_file.transfer_method == FileTransferMethod.REMOTE_URL else ""
+                file_dict = {
+                    "related_id": message_file.id,
+                    "extension": extension,
+                    "filename": filename,
+                    "size": size,
+                    "mime_type": mime_type,
+                    "transfer_method": transfer_method_value,
+                    "type": message_file.type,
+                    "url": url or "",
+                    "upload_file_id": message_file.upload_file_id or message_file.id,
+                    "remote_url": remote_url,
+                }
+                files_list.append(file_dict)
+            return files_list or None
+
     def _agent_message_to_stream_response(self, answer: str, message_id: str) -> AgentMessageStreamResponse:
         """
         Agent message to stream response.

api/core/app/task_pipeline/message_cycle_manager.py

@@ -1,6 +1,7 @@
 import hashlib
 import logging
-from threading import Thread, Timer
+import time
+from threading import Thread
 from typing import Union
 
 from flask import Flask, current_app
@@ -95,9 +96,9 @@ class MessageCycleManager:
         if auto_generate_conversation_name and is_first_message:
             # start generate thread
             # time.sleep not block other logic
-            thread = Timer(
-                1,
-                self._generate_conversation_name_worker,
+            time.sleep(1)
+            thread = Thread(
+                target=self._generate_conversation_name_worker,
                 kwargs={
                     "flask_app": current_app._get_current_object(),  # type: ignore
                     "conversation_id": conversation_id,

api/core/app/task_pipeline/message_file_utils.py

@@ -1,76 +0,0 @@
-from core.tools.signature import sign_tool_file
-from dify_graph.file import helpers as file_helpers
-from dify_graph.file.enums import FileTransferMethod
-from models.model import MessageFile, UploadFile
-
-MAX_TOOL_FILE_EXTENSION_LENGTH = 10
-
-
-def prepare_file_dict(message_file: MessageFile, upload_files_map: dict[str, UploadFile]) -> dict:
-    """
-    Prepare file dictionary for message end stream response.
-
-    :param message_file: MessageFile instance
-    :param upload_files_map: Dictionary mapping upload_file_id to UploadFile
-    :return: Dictionary containing file information
-    """
-    upload_file = None
-    if message_file.transfer_method == FileTransferMethod.LOCAL_FILE and message_file.upload_file_id:
-        upload_file = upload_files_map.get(message_file.upload_file_id)
-
-    url = None
-    filename = "file"
-    mime_type = "application/octet-stream"
-    size = 0
-    extension = ""
-
-    if message_file.transfer_method == FileTransferMethod.REMOTE_URL:
-        url = message_file.url
-        if message_file.url:
-            filename = message_file.url.split("/")[-1].split("?")[0]
-            if "." in filename:
-                extension = "." + filename.rsplit(".", 1)[1]
-    elif message_file.transfer_method == FileTransferMethod.LOCAL_FILE:
-        if upload_file:
-            url = file_helpers.get_signed_file_url(upload_file_id=str(upload_file.id))
-            filename = upload_file.name
-            mime_type = upload_file.mime_type or "application/octet-stream"
-            size = upload_file.size or 0
-            extension = f".{upload_file.extension}" if upload_file.extension else ""
-        elif message_file.upload_file_id:
-            url = file_helpers.get_signed_file_url(upload_file_id=str(message_file.upload_file_id))
-    elif message_file.transfer_method == FileTransferMethod.TOOL_FILE and message_file.url:
-        if message_file.url.startswith(("http://", "https://")):
-            url = message_file.url
-            filename = message_file.url.split("/")[-1].split("?")[0]
-            if "." in filename:
-                extension = "." + filename.rsplit(".", 1)[1]
-        else:
-            url_parts = message_file.url.split("/")
-            if url_parts:
-                file_part = url_parts[-1].split("?")[0]
-                if "." in file_part:
-                    tool_file_id, ext = file_part.rsplit(".", 1)
-                    extension = f".{ext}"
-                    if len(extension) > MAX_TOOL_FILE_EXTENSION_LENGTH:
-                        extension = ".bin"
-                else:
-                    tool_file_id = file_part
-                    extension = ".bin"
-                url = sign_tool_file(tool_file_id=tool_file_id, extension=extension)
-                filename = file_part
-
-    transfer_method_value = message_file.transfer_method.value
-    remote_url = message_file.url if message_file.transfer_method == FileTransferMethod.REMOTE_URL else ""
-    return {
-        "related_id": message_file.id,
-        "extension": extension,
-        "filename": filename,
-        "size": size,
-        "mime_type": mime_type,
-        "transfer_method": transfer_method_value,
-        "type": message_file.type,
-        "url": url or "",
-        "upload_file_id": message_file.upload_file_id or message_file.id,
-        "remote_url": remote_url,
-    }

api/core/plugin/backwards_invocation/app.py

@@ -1,6 +1,6 @@
 import uuid
 from collections.abc import Generator, Mapping
-from typing import Any, Union, cast
+from typing import Union
 
 from sqlalchemy import select
 from sqlalchemy.orm import Session
@@ -34,14 +34,14 @@ class PluginAppBackwardsInvocation(BaseBackwardsInvocation):
             if workflow is None:
                 raise ValueError("unexpected app type")
 
-            features_dict: dict[str, Any] = workflow.features_dict
+            features_dict = workflow.features_dict
             user_input_form = workflow.user_input_form(to_old_structure=True)
         else:
             app_model_config = app.app_model_config
             if app_model_config is None:
                 raise ValueError("unexpected app type")
 
-            features_dict = cast(dict[str, Any], app_model_config.to_dict())
+            features_dict = app_model_config.to_dict()
 
             user_input_form = features_dict.get("user_input_form", [])
 

api/core/rag/datasource/vdb/chroma/chroma_vector.py

@@ -65,7 +65,7 @@ class ChromaVector(BaseVector):
             self._client.get_or_create_collection(collection_name)
             redis_client.set(collection_exist_cache_key, 1, ex=3600)
 
-    def add_texts(self, documents: list[Document], embeddings: list[list[float]], **kwargs) -> list[str]:
+    def add_texts(self, documents: list[Document], embeddings: list[list[float]], **kwargs):
         uuids = self._get_uuids(documents)
         texts = [d.page_content for d in documents]
         metadatas = [d.metadata for d in documents]
@@ -73,7 +73,6 @@ class ChromaVector(BaseVector):
         collection = self._client.get_or_create_collection(self._collection_name)
         # FIXME: chromadb using numpy array, fix the type error later
         collection.upsert(ids=uuids, documents=texts, embeddings=embeddings, metadatas=metadatas)  # type: ignore
-        return uuids
 
     def delete_by_metadata_field(self, key: str, value: str):
         collection = self._client.get_or_create_collection(self._collection_name)

api/core/rag/datasource/vdb/clickzetta/clickzetta_vector.py

@@ -605,36 +605,25 @@ class ClickzettaVector(BaseVector):
                 logger.warning("Failed to create inverted index: %s", e)
                 # Continue without inverted index - full-text search will fall back to LIKE
 
-    def add_texts(self, documents: list[Document], embeddings: list[list[float]], **kwargs) -> list[str]:
+    def add_texts(self, documents: list[Document], embeddings: list[list[float]], **kwargs):
         """Add documents with embeddings to the collection."""
         if not documents:
-            return []
+            return
 
         batch_size = self._config.batch_size
         total_batches = (len(documents) + batch_size - 1) // batch_size
-        added_ids = []
 
         for i in range(0, len(documents), batch_size):
             batch_docs = documents[i : i + batch_size]
             batch_embeddings = embeddings[i : i + batch_size]
-            batch_doc_ids = []
-            for doc in batch_docs:
-                metadata = doc.metadata if isinstance(doc.metadata, dict) else {}
-                batch_doc_ids.append(self._safe_doc_id(metadata.get("doc_id", str(uuid.uuid4()))))
-            added_ids.extend(batch_doc_ids)
 
             # Execute batch insert through write queue
-            self._execute_write(
-                self._insert_batch, batch_docs, batch_embeddings, batch_doc_ids, i, batch_size, total_batches
-            )
-
-        return added_ids
+            self._execute_write(self._insert_batch, batch_docs, batch_embeddings, i, batch_size, total_batches)
 
     def _insert_batch(
         self,
         batch_docs: list[Document],
         batch_embeddings: list[list[float]],
-        batch_doc_ids: list[str],
         batch_index: int,
         batch_size: int,
         total_batches: int,
@@ -652,9 +641,14 @@ class ClickzettaVector(BaseVector):
         data_rows = []
         vector_dimension = len(batch_embeddings[0]) if batch_embeddings and batch_embeddings[0] else 768
 
-        for doc, embedding, doc_id in zip(batch_docs, batch_embeddings, batch_doc_ids):
+        for doc, embedding in zip(batch_docs, batch_embeddings):
             # Optimized: minimal checks for common case, fallback for edge cases
-            metadata = doc.metadata if isinstance(doc.metadata, dict) else {}
+            metadata = doc.metadata or {}
+
+            if not isinstance(metadata, dict):
+                metadata = {}
+
+            doc_id = self._safe_doc_id(metadata.get("doc_id", str(uuid.uuid4())))
 
             # Fast path for JSON serialization
             try:

api/core/repositories/sqlalchemy_workflow_execution_repository.py

@@ -194,13 +194,6 @@ class SQLAlchemyWorkflowExecutionRepository(WorkflowExecutionRepository):
 
         # Create a new database session
         with self._session_factory() as session:
-            existing_model = session.get(WorkflowRun, db_model.id)
-            if existing_model:
-                if existing_model.tenant_id != self._tenant_id:
-                    raise ValueError("Unauthorized access to workflow run")
-                # Preserve the original start time for pause/resume flows.
-                db_model.created_at = existing_model.created_at
-
             # SQLAlchemy merge intelligently handles both insert and update operations
             # based on the presence of the primary key
             session.merge(db_model)

api/core/tools/workflow_as_tool/provider.py

@@ -37,7 +37,6 @@ VARIABLE_TO_PARAMETER_TYPE_MAPPING = {
     VariableEntityType.CHECKBOX: ToolParameter.ToolParameterType.BOOLEAN,
     VariableEntityType.FILE: ToolParameter.ToolParameterType.FILE,
     VariableEntityType.FILE_LIST: ToolParameter.ToolParameterType.FILES,
-    VariableEntityType.JSON_OBJECT: ToolParameter.ToolParameterType.OBJECT,
 }
 
 

api/dify_graph/nodes/document_extractor/node.py

@@ -4,7 +4,6 @@ import json
 import logging
 import os
 import tempfile
-import zipfile
 from collections.abc import Mapping, Sequence
 from typing import TYPE_CHECKING, Any
 
@@ -83,18 +82,8 @@ class DocumentExtractorNode(Node[DocumentExtractorNodeData]):
 
         value = variable.value
         inputs = {"variable_selector": variable_selector}
-        if isinstance(value, list):
-            value = list(filter(lambda x: x, value))
         process_data = {"documents": value if isinstance(value, list) else [value]}
 
-        if not value:
-            return NodeRunResult(
-                status=WorkflowNodeExecutionStatus.SUCCEEDED,
-                inputs=inputs,
-                process_data=process_data,
-                outputs={"text": ArrayStringSegment(value=[])},
-            )
-
         try:
             if isinstance(value, list):
                 extracted_text_list = [
@@ -122,7 +111,6 @@ class DocumentExtractorNode(Node[DocumentExtractorNodeData]):
             else:
                 raise DocumentExtractorError(f"Unsupported variable type: {type(value)}")
         except DocumentExtractorError as e:
-            logger.warning(e, exc_info=True)
             return NodeRunResult(
                 status=WorkflowNodeExecutionStatus.FAILED,
                 error=str(e),
@@ -397,32 +385,6 @@ def parser_docx_part(block, doc: Document, content_items, i):
         content_items.append((i, "table", Table(block, doc)))
 
 
-def _normalize_docx_zip(file_content: bytes) -> bytes:
-    """
-    Some DOCX files (e.g. exported by Evernote on Windows) are malformed:
-    ZIP entry names use backslash (\\) as path separator instead of the forward
-    slash (/) required by both the ZIP spec and OOXML.  On Linux/Mac the entry
-    "word\\document.xml" is never found when python-docx looks for
-    "word/document.xml", which triggers a KeyError about a missing relationship.
-
-    This function rewrites the ZIP in-memory, normalizing all entry names to
-    use forward slashes without touching any actual document content.
-    """
-    try:
-        with zipfile.ZipFile(io.BytesIO(file_content), "r") as zin:
-            out_buf = io.BytesIO()
-            with zipfile.ZipFile(out_buf, "w", compression=zipfile.ZIP_DEFLATED) as zout:
-                for item in zin.infolist():
-                    data = zin.read(item.filename)
-                    # Normalize backslash path separators to forward slash
-                    item.filename = item.filename.replace("\\", "/")
-                    zout.writestr(item, data)
-            return out_buf.getvalue()
-    except zipfile.BadZipFile:
-        # Not a valid zip — return as-is and let python-docx report the real error
-        return file_content
-
-
 def _extract_text_from_docx(file_content: bytes) -> str:
     """
     Extract text from a DOCX file.
@@ -430,15 +392,7 @@ def _extract_text_from_docx(file_content: bytes) -> str:
     """
     try:
         doc_file = io.BytesIO(file_content)
-        try:
-            doc = docx.Document(doc_file)
-        except Exception as e:
-            logger.warning("Failed to parse DOCX, attempting to normalize ZIP entry paths: %s", e)
-            # Some DOCX files exported by tools like Evernote on Windows use
-            # backslash path separators in ZIP entries and/or single-quoted XML
-            # attributes, both of which break python-docx on Linux. Normalize and retry.
-            file_content = _normalize_docx_zip(file_content)
-            doc = docx.Document(io.BytesIO(file_content))
+        doc = docx.Document(doc_file)
         text = []
 
         # Keep track of paragraph and table positions

api/dify_graph/nodes/knowledge_retrieval/knowledge_retrieval_node.py

@@ -23,11 +23,7 @@ from dify_graph.variables import (
 )
 from dify_graph.variables.segments import ArrayObjectSegment
 
-from .entities import (
-    Condition,
-    KnowledgeRetrievalNodeData,
-    MetadataFilteringCondition,
-)
+from .entities import KnowledgeRetrievalNodeData
 from .exc import (
     KnowledgeRetrievalNodeError,
     RateLimitExceededError,
@@ -120,7 +116,7 @@ class KnowledgeRetrievalNode(LLMUsageTrackingMixin, Node[KnowledgeRetrievalNodeD
 
         try:
             results, usage = self._fetch_dataset_retriever(node_data=self._node_data, variables=variables)
-            outputs = {"result": ArrayObjectSegment(value=[item.model_dump(by_alias=True) for item in results])}
+            outputs = {"result": ArrayObjectSegment(value=[item.model_dump() for item in results])}
             return NodeRunResult(
                 status=WorkflowNodeExecutionStatus.SUCCEEDED,
                 inputs=variables,
@@ -175,12 +171,6 @@ class KnowledgeRetrievalNode(LLMUsageTrackingMixin, Node[KnowledgeRetrievalNodeD
         if node_data.metadata_filtering_mode is not None:
             metadata_filtering_mode = node_data.metadata_filtering_mode
 
-        resolved_metadata_conditions = (
-            self._resolve_metadata_filtering_conditions(node_data.metadata_filtering_conditions)
-            if node_data.metadata_filtering_conditions
-            else None
-        )
-
         if str(node_data.retrieval_mode) == DatasetRetrieveConfigEntity.RetrieveStrategy.SINGLE and query:
             # fetch model config
             if node_data.single_retrieval_config is None:
@@ -199,7 +189,7 @@ class KnowledgeRetrievalNode(LLMUsageTrackingMixin, Node[KnowledgeRetrievalNodeD
                     model_mode=model.mode,
                     model_name=model.name,
                     metadata_model_config=node_data.metadata_model_config,
-                    metadata_filtering_conditions=resolved_metadata_conditions,
+                    metadata_filtering_conditions=node_data.metadata_filtering_conditions,
                     metadata_filtering_mode=metadata_filtering_mode,
                     query=query,
                 )
@@ -257,7 +247,7 @@ class KnowledgeRetrievalNode(LLMUsageTrackingMixin, Node[KnowledgeRetrievalNodeD
                     weights=weights,
                     reranking_enable=node_data.multiple_retrieval_config.reranking_enable,
                     metadata_model_config=node_data.metadata_model_config,
-                    metadata_filtering_conditions=resolved_metadata_conditions,
+                    metadata_filtering_conditions=node_data.metadata_filtering_conditions,
                     metadata_filtering_mode=metadata_filtering_mode,
                     attachment_ids=[attachment.related_id for attachment in attachments] if attachments else None,
                 )
@@ -266,48 +256,6 @@ class KnowledgeRetrievalNode(LLMUsageTrackingMixin, Node[KnowledgeRetrievalNodeD
         usage = self._rag_retrieval.llm_usage
         return retrieval_resource_list, usage
 
-    def _resolve_metadata_filtering_conditions(
-        self, conditions: MetadataFilteringCondition
-    ) -> MetadataFilteringCondition:
-        if conditions.conditions is None:
-            return MetadataFilteringCondition(
-                logical_operator=conditions.logical_operator,
-                conditions=None,
-            )
-
-        variable_pool = self.graph_runtime_state.variable_pool
-        resolved_conditions: list[Condition] = []
-        for cond in conditions.conditions or []:
-            value = cond.value
-            if isinstance(value, str):
-                segment_group = variable_pool.convert_template(value)
-                if len(segment_group.value) == 1:
-                    resolved_value = segment_group.value[0].to_object()
-                else:
-                    resolved_value = segment_group.text
-            elif isinstance(value, Sequence) and all(isinstance(v, str) for v in value):
-                resolved_values = []
-                for v in value:  # type: ignore
-                    segment_group = variable_pool.convert_template(v)
-                    if len(segment_group.value) == 1:
-                        resolved_values.append(segment_group.value[0].to_object())
-                    else:
-                        resolved_values.append(segment_group.text)
-                resolved_value = resolved_values
-            else:
-                resolved_value = value
-            resolved_conditions.append(
-                Condition(
-                    name=cond.name,
-                    comparison_operator=cond.comparison_operator,
-                    value=resolved_value,
-                )
-            )
-        return MetadataFilteringCondition(
-            logical_operator=conditions.logical_operator or "and",
-            conditions=resolved_conditions,
-        )
-
     @classmethod
     def _extract_variable_selector_to_variable_mapping(
         cls,

api/dify_graph/runtime/variable_pool.py

@@ -65,15 +65,9 @@ class VariablePool(BaseModel):
         # Add environment variables to the variable pool
         for var in self.environment_variables:
             self.add((ENVIRONMENT_VARIABLE_NODE_ID, var.name), var)
-        # Add conversation variables to the variable pool. When restoring from a serialized
-        # snapshot, `variable_dictionary` already carries the latest runtime values.
-        # In that case, keep existing entries instead of overwriting them with the
-        # bootstrap list.
+        # Add conversation variables to the variable pool
         for var in self.conversation_variables:
-            selector = (CONVERSATION_VARIABLE_NODE_ID, var.name)
-            if self._has(selector):
-                continue
-            self.add(selector, var)
+            self.add((CONVERSATION_VARIABLE_NODE_ID, var.name), var)
         # Add rag pipeline variables to the variable pool
         if self.rag_pipeline_variables:
             rag_pipeline_variables_map: defaultdict[Any, dict[Any, Any]] = defaultdict(dict)

api/docker/entrypoint.sh

@@ -35,10 +35,10 @@ if [[ "${MODE}" == "worker" ]]; then
   if [[ -z "${CELERY_QUEUES}" ]]; then
     if [[ "${EDITION}" == "CLOUD" ]]; then
       # Cloud edition: separate queues for dataset and trigger tasks
-      DEFAULT_QUEUES="api_token,dataset,dataset_summary,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow_professional,workflow_team,workflow_sandbox,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution"
+      DEFAULT_QUEUES="api_token,dataset,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow_professional,workflow_team,workflow_sandbox,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution"
     else
       # Community edition (SELF_HOSTED): dataset, pipeline and workflow have separate queues
-      DEFAULT_QUEUES="api_token,dataset,dataset_summary,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution"
+      DEFAULT_QUEUES="api_token,dataset,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution"
     fi
   else
     DEFAULT_QUEUES="${CELERY_QUEUES}"

api/events/event_handlers/update_app_dataset_join_when_app_model_config_updated.py

@@ -1,5 +1,3 @@
-from typing import Any, cast
-
 from sqlalchemy import select
 
 from events.app_event import app_model_config_was_updated
@@ -56,11 +54,9 @@ def get_dataset_ids_from_model_config(app_model_config: AppModelConfig) -> set[s
             continue
 
         tool_type = list(tool.keys())[0]
-        tool_config = cast(dict[str, Any], list(tool.values())[0])
+        tool_config = list(tool.values())[0]
         if tool_type == "dataset":
-            dataset_id = tool_config.get("id")
-            if isinstance(dataset_id, str):
-                dataset_ids.add(dataset_id)
+            dataset_ids.add(tool_config.get("id"))
 
     # get dataset from dataset_configs
     dataset_configs = app_model_config.dataset_configs_dict

api/extensions/ext_commands.py

@@ -13,7 +13,6 @@ def init_app(app: DifyApp):
         convert_to_agent_apps,
         create_tenant,
         delete_archived_workflow_runs,
-        export_app_messages,
         extract_plugins,
         extract_unique_plugins,
         file_usage,
@@ -67,7 +66,6 @@ def init_app(app: DifyApp):
         restore_workflow_runs,
         clean_workflow_runs,
         clean_expired_messages,
-        export_app_messages,
     ]
     for cmd in cmds_to_register:
         app.cli.add_command(cmd)

api/extensions/otel/runtime.py

@@ -5,7 +5,7 @@ from typing import Union
 
 from celery.signals import worker_init
 from flask_login import user_loaded_from_request, user_logged_in
-from opentelemetry import metrics, trace
+from opentelemetry import trace
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.propagators.b3 import B3Format
 from opentelemetry.propagators.composite import CompositePropagator
@@ -31,29 +31,9 @@ def setup_context_propagation() -> None:
 
 
 def shutdown_tracer() -> None:
-    flush_telemetry()
-
-
-def flush_telemetry() -> None:
-    """
-    Best-effort flush for telemetry providers.
-
-    This is mainly used by short-lived command processes (e.g. Kubernetes CronJob)
-    so counters/histograms are exported before the process exits.
-    """
     provider = trace.get_tracer_provider()
     if hasattr(provider, "force_flush"):
-        try:
-            provider.force_flush()
-        except Exception:
-            logger.exception("otel: failed to flush trace provider")
-
-    metric_provider = metrics.get_meter_provider()
-    if hasattr(metric_provider, "force_flush"):
-        try:
-            metric_provider.force_flush()
-        except Exception:
-            logger.exception("otel: failed to flush metric provider")
+        provider.force_flush()
 
 
 def is_celery_worker():

api/migrations/env.py

@@ -66,7 +66,6 @@ def run_migrations_offline():
     context.configure(
         url=url, target_metadata=get_metadata(), literal_binds=True
     )
-    logger.info("Generating offline migration SQL with url: %s", url)
 
     with context.begin_transaction():
         context.run_migrations()

api/models/model.py

@@ -7,7 +7,7 @@ from collections.abc import Mapping, Sequence
 from datetime import datetime
 from decimal import Decimal
 from enum import StrEnum, auto
-from typing import TYPE_CHECKING, Any, Literal, NotRequired, cast
+from typing import TYPE_CHECKING, Any, Literal, cast
 from uuid import uuid4
 
 import sqlalchemy as sa
@@ -15,7 +15,6 @@ from flask import request
 from flask_login import UserMixin  # type: ignore[import-untyped]
 from sqlalchemy import BigInteger, Float, Index, PrimaryKeyConstraint, String, exists, func, select, text
 from sqlalchemy.orm import Mapped, Session, mapped_column
-from typing_extensions import TypedDict
 
 from configs import dify_config
 from constants import DEFAULT_FILE_NUMBER_LIMITS
@@ -37,259 +36,6 @@ if TYPE_CHECKING:
     from .workflow import Workflow
 
 
-# --- TypedDict definitions for structured dict return types ---
-
-
-class EnabledConfig(TypedDict):
-    enabled: bool
-
-
-class EmbeddingModelInfo(TypedDict):
-    embedding_provider_name: str
-    embedding_model_name: str
-
-
-class AnnotationReplyDisabledConfig(TypedDict):
-    enabled: Literal[False]
-
-
-class AnnotationReplyEnabledConfig(TypedDict):
-    id: str
-    enabled: Literal[True]
-    score_threshold: float
-    embedding_model: EmbeddingModelInfo
-
-
-AnnotationReplyConfig = AnnotationReplyEnabledConfig | AnnotationReplyDisabledConfig
-
-
-class SensitiveWordAvoidanceConfig(TypedDict):
-    enabled: bool
-    type: str
-    config: dict[str, Any]
-
-
-class AgentToolConfig(TypedDict):
-    provider_type: str
-    provider_id: str
-    tool_name: str
-    tool_parameters: dict[str, Any]
-    plugin_unique_identifier: NotRequired[str | None]
-    credential_id: NotRequired[str | None]
-
-
-class AgentModeConfig(TypedDict):
-    enabled: bool
-    strategy: str | None
-    tools: list[AgentToolConfig | dict[str, Any]]
-    prompt: str | None
-
-
-class ImageUploadConfig(TypedDict):
-    enabled: bool
-    number_limits: int
-    detail: str
-    transfer_methods: list[str]
-
-
-class FileUploadConfig(TypedDict):
-    image: ImageUploadConfig
-
-
-class DeletedToolInfo(TypedDict):
-    type: str
-    tool_name: str
-    provider_id: str
-
-
-class ExternalDataToolConfig(TypedDict):
-    enabled: bool
-    variable: str
-    type: str
-    config: dict[str, Any]
-
-
-class UserInputFormItemConfig(TypedDict):
-    variable: str
-    label: str
-    description: NotRequired[str]
-    required: NotRequired[bool]
-    max_length: NotRequired[int]
-    options: NotRequired[list[str]]
-    default: NotRequired[str]
-    type: NotRequired[str]
-    config: NotRequired[dict[str, Any]]
-
-
-# Each item is a single-key dict, e.g. {"text-input": UserInputFormItemConfig}
-UserInputFormItem = dict[str, UserInputFormItemConfig]
-
-
-class DatasetConfigs(TypedDict):
-    retrieval_model: str
-    datasets: NotRequired[dict[str, Any]]
-    top_k: NotRequired[int]
-    score_threshold: NotRequired[float]
-    score_threshold_enabled: NotRequired[bool]
-    reranking_model: NotRequired[dict[str, Any] | None]
-    weights: NotRequired[dict[str, Any] | None]
-    reranking_enabled: NotRequired[bool]
-    reranking_mode: NotRequired[str]
-    metadata_filtering_mode: NotRequired[str]
-    metadata_model_config: NotRequired[dict[str, Any] | None]
-    metadata_filtering_conditions: NotRequired[dict[str, Any] | None]
-
-
-class ChatPromptMessage(TypedDict):
-    text: str
-    role: str
-
-
-class ChatPromptConfig(TypedDict, total=False):
-    prompt: list[ChatPromptMessage]
-
-
-class CompletionPromptText(TypedDict):
-    text: str
-
-
-class ConversationHistoriesRole(TypedDict):
-    user_prefix: str
-    assistant_prefix: str
-
-
-class CompletionPromptConfig(TypedDict):
-    prompt: CompletionPromptText
-    conversation_histories_role: NotRequired[ConversationHistoriesRole]
-
-
-class ModelConfig(TypedDict):
-    provider: str
-    name: str
-    mode: str
-    completion_params: NotRequired[dict[str, Any]]
-
-
-class AppModelConfigDict(TypedDict):
-    opening_statement: str | None
-    suggested_questions: list[str]
-    suggested_questions_after_answer: EnabledConfig
-    speech_to_text: EnabledConfig
-    text_to_speech: EnabledConfig
-    retriever_resource: EnabledConfig
-    annotation_reply: AnnotationReplyConfig
-    more_like_this: EnabledConfig
-    sensitive_word_avoidance: SensitiveWordAvoidanceConfig
-    external_data_tools: list[ExternalDataToolConfig]
-    model: ModelConfig
-    user_input_form: list[UserInputFormItem]
-    dataset_query_variable: str | None
-    pre_prompt: str | None
-    agent_mode: AgentModeConfig
-    prompt_type: str
-    chat_prompt_config: ChatPromptConfig
-    completion_prompt_config: CompletionPromptConfig
-    dataset_configs: DatasetConfigs
-    file_upload: FileUploadConfig
-    # Added dynamically in Conversation.model_config
-    model_id: NotRequired[str | None]
-    provider: NotRequired[str | None]
-
-
-class ConversationDict(TypedDict):
-    id: str
-    app_id: str
-    app_model_config_id: str | None
-    model_provider: str | None
-    override_model_configs: str | None
-    model_id: str | None
-    mode: str
-    name: str
-    summary: str | None
-    inputs: dict[str, Any]
-    introduction: str | None
-    system_instruction: str | None
-    system_instruction_tokens: int
-    status: str
-    invoke_from: str | None
-    from_source: str
-    from_end_user_id: str | None
-    from_account_id: str | None
-    read_at: datetime | None
-    read_account_id: str | None
-    dialogue_count: int
-    created_at: datetime
-    updated_at: datetime
-
-
-class MessageDict(TypedDict):
-    id: str
-    app_id: str
-    conversation_id: str
-    model_id: str | None
-    inputs: dict[str, Any]
-    query: str
-    total_price: Decimal | None
-    message: dict[str, Any]
-    answer: str
-    status: str
-    error: str | None
-    message_metadata: dict[str, Any]
-    from_source: str
-    from_end_user_id: str | None
-    from_account_id: str | None
-    created_at: str
-    updated_at: str
-    agent_based: bool
-    workflow_run_id: str | None
-
-
-class MessageFeedbackDict(TypedDict):
-    id: str
-    app_id: str
-    conversation_id: str
-    message_id: str
-    rating: str
-    content: str | None
-    from_source: str
-    from_end_user_id: str | None
-    from_account_id: str | None
-    created_at: str
-    updated_at: str
-
-
-class MessageFileInfo(TypedDict, total=False):
-    belongs_to: str | None
-    upload_file_id: str | None
-    id: str
-    tenant_id: str
-    type: str
-    transfer_method: str
-    remote_url: str | None
-    related_id: str | None
-    filename: str | None
-    extension: str | None
-    mime_type: str | None
-    size: int
-    dify_model_identity: str
-    url: str | None
-
-
-class ExtraContentDict(TypedDict, total=False):
-    type: str
-    workflow_run_id: str
-
-
-class TraceAppConfigDict(TypedDict):
-    id: str
-    app_id: str
-    tracing_provider: str | None
-    tracing_config: dict[str, Any]
-    is_active: bool
-    created_at: str | None
-    updated_at: str | None
-
-
 class DifySetup(TypeBase):
     __tablename__ = "dify_setups"
     __table_args__ = (sa.PrimaryKeyConstraint("version", name="dify_setup_pkey"),)
@@ -430,7 +176,7 @@ class App(Base):
         return str(self.mode)
 
     @property
-    def deleted_tools(self) -> list[DeletedToolInfo]:
+    def deleted_tools(self) -> list[dict[str, str]]:
         from core.tools.tool_manager import ToolManager, ToolProviderType
         from services.plugin.plugin_service import PluginService
 
@@ -511,7 +257,7 @@ class App(Base):
             provider_id.provider_name: existence[i] for i, provider_id in enumerate(builtin_provider_ids)
         }
 
-        deleted_tools: list[DeletedToolInfo] = []
+        deleted_tools: list[dict[str, str]] = []
 
         for tool in tools:
             keys = list(tool.keys())
@@ -618,38 +364,35 @@ class AppModelConfig(TypeBase):
         return app
 
     @property
-    def model_dict(self) -> ModelConfig:
-        return cast(ModelConfig, json.loads(self.model) if self.model else {})
+    def model_dict(self) -> dict[str, Any]:
+        return json.loads(self.model) if self.model else {}
 
     @property
     def suggested_questions_list(self) -> list[str]:
         return json.loads(self.suggested_questions) if self.suggested_questions else []
 
     @property
-    def suggested_questions_after_answer_dict(self) -> EnabledConfig:
-        return cast(
-            EnabledConfig,
+    def suggested_questions_after_answer_dict(self) -> dict[str, Any]:
+        return (
             json.loads(self.suggested_questions_after_answer)
             if self.suggested_questions_after_answer
-            else {"enabled": False},
+            else {"enabled": False}
         )
 
     @property
-    def speech_to_text_dict(self) -> EnabledConfig:
-        return cast(EnabledConfig, json.loads(self.speech_to_text) if self.speech_to_text else {"enabled": False})
+    def speech_to_text_dict(self) -> dict[str, Any]:
+        return json.loads(self.speech_to_text) if self.speech_to_text else {"enabled": False}
 
     @property
-    def text_to_speech_dict(self) -> EnabledConfig:
-        return cast(EnabledConfig, json.loads(self.text_to_speech) if self.text_to_speech else {"enabled": False})
+    def text_to_speech_dict(self) -> dict[str, Any]:
+        return json.loads(self.text_to_speech) if self.text_to_speech else {"enabled": False}
 
     @property
-    def retriever_resource_dict(self) -> EnabledConfig:
-        return cast(
-            EnabledConfig, json.loads(self.retriever_resource) if self.retriever_resource else {"enabled": True}
-        )
+    def retriever_resource_dict(self) -> dict[str, Any]:
+        return json.loads(self.retriever_resource) if self.retriever_resource else {"enabled": True}
 
     @property
-    def annotation_reply_dict(self) -> AnnotationReplyConfig:
+    def annotation_reply_dict(self) -> dict[str, Any]:
         annotation_setting = (
             db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == self.app_id).first()
         )
@@ -672,62 +415,56 @@ class AppModelConfig(TypeBase):
             return {"enabled": False}
 
     @property
-    def more_like_this_dict(self) -> EnabledConfig:
-        return cast(EnabledConfig, json.loads(self.more_like_this) if self.more_like_this else {"enabled": False})
+    def more_like_this_dict(self) -> dict[str, Any]:
+        return json.loads(self.more_like_this) if self.more_like_this else {"enabled": False}
 
     @property
-    def sensitive_word_avoidance_dict(self) -> SensitiveWordAvoidanceConfig:
-        return cast(
-            SensitiveWordAvoidanceConfig,
+    def sensitive_word_avoidance_dict(self) -> dict[str, Any]:
+        return (
             json.loads(self.sensitive_word_avoidance)
             if self.sensitive_word_avoidance
-            else {"enabled": False, "type": "", "config": {}},
+            else {"enabled": False, "type": "", "configs": []}
         )
 
     @property
-    def external_data_tools_list(self) -> list[ExternalDataToolConfig]:
+    def external_data_tools_list(self) -> list[dict[str, Any]]:
         return json.loads(self.external_data_tools) if self.external_data_tools else []
 
     @property
-    def user_input_form_list(self) -> list[UserInputFormItem]:
+    def user_input_form_list(self) -> list[dict[str, Any]]:
         return json.loads(self.user_input_form) if self.user_input_form else []
 
     @property
-    def agent_mode_dict(self) -> AgentModeConfig:
-        return cast(
-            AgentModeConfig,
+    def agent_mode_dict(self) -> dict[str, Any]:
+        return (
             json.loads(self.agent_mode)
             if self.agent_mode
-            else {"enabled": False, "strategy": None, "tools": [], "prompt": None},
+            else {"enabled": False, "strategy": None, "tools": [], "prompt": None}
         )
 
     @property
-    def chat_prompt_config_dict(self) -> ChatPromptConfig:
-        return cast(ChatPromptConfig, json.loads(self.chat_prompt_config) if self.chat_prompt_config else {})
+    def chat_prompt_config_dict(self) -> dict[str, Any]:
+        return json.loads(self.chat_prompt_config) if self.chat_prompt_config else {}
 
     @property
-    def completion_prompt_config_dict(self) -> CompletionPromptConfig:
-        return cast(
-            CompletionPromptConfig,
-            json.loads(self.completion_prompt_config) if self.completion_prompt_config else {},
-        )
+    def completion_prompt_config_dict(self) -> dict[str, Any]:
+        return json.loads(self.completion_prompt_config) if self.completion_prompt_config else {}
 
     @property
-    def dataset_configs_dict(self) -> DatasetConfigs:
+    def dataset_configs_dict(self) -> dict[str, Any]:
         if self.dataset_configs:
-            dataset_configs = json.loads(self.dataset_configs)
+            dataset_configs: dict[str, Any] = json.loads(self.dataset_configs)
             if "retrieval_model" not in dataset_configs:
                 return {"retrieval_model": "single"}
             else:
-                return cast(DatasetConfigs, dataset_configs)
+                return dataset_configs
         return {
             "retrieval_model": "multiple",
         }
 
     @property
-    def file_upload_dict(self) -> FileUploadConfig:
-        return cast(
-            FileUploadConfig,
+    def file_upload_dict(self) -> dict[str, Any]:
+        return (
             json.loads(self.file_upload)
             if self.file_upload
             else {
@@ -737,10 +474,10 @@ class AppModelConfig(TypeBase):
                     "detail": "high",
                     "transfer_methods": ["remote_url", "local_file"],
                 }
-            },
+            }
         )
 
-    def to_dict(self) -> AppModelConfigDict:
+    def to_dict(self) -> dict[str, Any]:
         return {
             "opening_statement": self.opening_statement,
             "suggested_questions": self.suggested_questions_list,
@@ -764,42 +501,36 @@ class AppModelConfig(TypeBase):
             "file_upload": self.file_upload_dict,
         }
 
-    def from_model_config_dict(self, model_config: AppModelConfigDict):
+    def from_model_config_dict(self, model_config: Mapping[str, Any]):
         self.opening_statement = model_config.get("opening_statement")
         self.suggested_questions = (
-            json.dumps(model_config.get("suggested_questions")) if model_config.get("suggested_questions") else None
+            json.dumps(model_config["suggested_questions"]) if model_config.get("suggested_questions") else None
         )
         self.suggested_questions_after_answer = (
-            json.dumps(model_config.get("suggested_questions_after_answer"))
+            json.dumps(model_config["suggested_questions_after_answer"])
             if model_config.get("suggested_questions_after_answer")
             else None
         )
-        self.speech_to_text = (
-            json.dumps(model_config.get("speech_to_text")) if model_config.get("speech_to_text") else None
-        )
-        self.text_to_speech = (
-            json.dumps(model_config.get("text_to_speech")) if model_config.get("text_to_speech") else None
-        )
-        self.more_like_this = (
-            json.dumps(model_config.get("more_like_this")) if model_config.get("more_like_this") else None
-        )
+        self.speech_to_text = json.dumps(model_config["speech_to_text"]) if model_config.get("speech_to_text") else None
+        self.text_to_speech = json.dumps(model_config["text_to_speech"]) if model_config.get("text_to_speech") else None
+        self.more_like_this = json.dumps(model_config["more_like_this"]) if model_config.get("more_like_this") else None
         self.sensitive_word_avoidance = (
-            json.dumps(model_config.get("sensitive_word_avoidance"))
+            json.dumps(model_config["sensitive_word_avoidance"])
             if model_config.get("sensitive_word_avoidance")
             else None
         )
         self.external_data_tools = (
-            json.dumps(model_config.get("external_data_tools")) if model_config.get("external_data_tools") else None
+            json.dumps(model_config["external_data_tools"]) if model_config.get("external_data_tools") else None
         )
-        self.model = json.dumps(model_config.get("model")) if model_config.get("model") else None
+        self.model = json.dumps(model_config["model"]) if model_config.get("model") else None
         self.user_input_form = (
-            json.dumps(model_config.get("user_input_form")) if model_config.get("user_input_form") else None
+            json.dumps(model_config["user_input_form"]) if model_config.get("user_input_form") else None
         )
         self.dataset_query_variable = model_config.get("dataset_query_variable")
-        self.pre_prompt = model_config.get("pre_prompt")
-        self.agent_mode = json.dumps(model_config.get("agent_mode")) if model_config.get("agent_mode") else None
+        self.pre_prompt = model_config["pre_prompt"]
+        self.agent_mode = json.dumps(model_config["agent_mode"]) if model_config.get("agent_mode") else None
         self.retriever_resource = (
-            json.dumps(model_config.get("retriever_resource")) if model_config.get("retriever_resource") else None
+            json.dumps(model_config["retriever_resource"]) if model_config.get("retriever_resource") else None
         )
         self.prompt_type = model_config.get("prompt_type", "simple")
         self.chat_prompt_config = (
@@ -1092,26 +823,24 @@ class Conversation(Base):
         self._inputs = inputs
 
     @property
-    def model_config(self) -> AppModelConfigDict:
-        model_config = cast(AppModelConfigDict, {})
+    def model_config(self):
+        model_config = {}
         app_model_config: AppModelConfig | None = None
 
         if self.mode == AppMode.ADVANCED_CHAT:
             if self.override_model_configs:
                 override_model_configs = json.loads(self.override_model_configs)
-                model_config = cast(AppModelConfigDict, override_model_configs)
+                model_config = override_model_configs
         else:
             if self.override_model_configs:
                 override_model_configs = json.loads(self.override_model_configs)
 
                 if "model" in override_model_configs:
                     # where is app_id?
-                    app_model_config = AppModelConfig(app_id=self.app_id).from_model_config_dict(
-                        cast(AppModelConfigDict, override_model_configs)
-                    )
+                    app_model_config = AppModelConfig(app_id=self.app_id).from_model_config_dict(override_model_configs)
                     model_config = app_model_config.to_dict()
                 else:
-                    model_config["configs"] = override_model_configs  # type: ignore[typeddict-unknown-key]
+                    model_config["configs"] = override_model_configs
             else:
                 app_model_config = (
                     db.session.query(AppModelConfig).where(AppModelConfig.id == self.app_model_config_id).first()
@@ -1286,7 +1015,7 @@ class Conversation(Base):
     def in_debug_mode(self) -> bool:
         return self.override_model_configs is not None
 
-    def to_dict(self) -> ConversationDict:
+    def to_dict(self) -> dict[str, Any]:
         return {
             "id": self.id,
             "app_id": self.app_id,
@@ -1566,7 +1295,7 @@ class Message(Base):
         return self.message_metadata_dict.get("retriever_resources") if self.message_metadata else []
 
     @property
-    def message_files(self) -> list[MessageFileInfo]:
+    def message_files(self) -> list[dict[str, Any]]:
         from factories import file_factory
 
         message_files = db.session.scalars(select(MessageFile).where(MessageFile.message_id == self.id)).all()
@@ -1621,13 +1350,10 @@ class Message(Base):
                 )
             files.append(file)
 
-        result = cast(
-            list[MessageFileInfo],
-            [
-                {"belongs_to": message_file.belongs_to, "upload_file_id": message_file.upload_file_id, **file.to_dict()}
-                for (file, message_file) in zip(files, message_files)
-            ],
-        )
+        result: list[dict[str, Any]] = [
+            {"belongs_to": message_file.belongs_to, "upload_file_id": message_file.upload_file_id, **file.to_dict()}
+            for (file, message_file) in zip(files, message_files)
+        ]
 
         db.session.commit()
         return result
@@ -1637,7 +1363,7 @@ class Message(Base):
         self._extra_contents = list(contents)
 
     @property
-    def extra_contents(self) -> list[ExtraContentDict]:
+    def extra_contents(self) -> list[dict[str, Any]]:
         return getattr(self, "_extra_contents", [])
 
     @property
@@ -1653,7 +1379,7 @@ class Message(Base):
 
         return None
 
-    def to_dict(self) -> MessageDict:
+    def to_dict(self) -> dict[str, Any]:
         return {
             "id": self.id,
             "app_id": self.app_id,
@@ -1677,7 +1403,7 @@ class Message(Base):
         }
 
     @classmethod
-    def from_dict(cls, data: MessageDict) -> Message:
+    def from_dict(cls, data: dict[str, Any]) -> Message:
         return cls(
             id=data["id"],
             app_id=data["app_id"],
@@ -1737,7 +1463,7 @@ class MessageFeedback(TypeBase):
         account = db.session.query(Account).where(Account.id == self.from_account_id).first()
         return account
 
-    def to_dict(self) -> MessageFeedbackDict:
+    def to_dict(self) -> dict[str, Any]:
         return {
             "id": str(self.id),
             "app_id": str(self.app_id),
@@ -2000,8 +1726,8 @@ class AppMCPServer(TypeBase):
             return result
 
     @property
-    def parameters_dict(self) -> dict[str, str]:
-        return cast(dict[str, str], json.loads(self.parameters))
+    def parameters_dict(self) -> dict[str, Any]:
+        return cast(dict[str, Any], json.loads(self.parameters))
 
 
 class Site(Base):
@@ -2441,7 +2167,7 @@ class TraceAppConfig(TypeBase):
     def tracing_config_str(self) -> str:
         return json.dumps(self.tracing_config_dict)
 
-    def to_dict(self) -> TraceAppConfigDict:
+    def to_dict(self) -> dict[str, Any]:
         return {
             "id": self.id,
             "app_id": self.app_id,

api/pyproject.toml

@@ -35,7 +35,7 @@ dependencies = [
     "jsonschema>=4.25.1",
     "langfuse~=2.51.3",
     "langsmith~=0.1.77",
-    "markdown~=3.8.1",
+    "markdown~=3.5.1",
     "mlflow-skinny>=3.0.0",
     "numpy~=1.26.4",
     "openpyxl~=3.1.5",
@@ -247,13 +247,3 @@ module = [
     "extensions.logstore.repositories.logstore_api_workflow_run_repository",
 ]
 ignore_errors = true
-
-[tool.pyrefly]
-project-includes = ["."]
-project-excludes = [
-    ".venv",
-    "migrations/",
-]
-python-platform = "linux"
-python-version = "3.11.0"
-infer-with-first-use = false

api/pyrefly-local-excludes.txt

@@ -1,200 +0,0 @@
-configs/middleware/cache/redis_pubsub_config.py
-controllers/console/app/annotation.py
-controllers/console/app/app.py
-controllers/console/app/app_import.py
-controllers/console/app/mcp_server.py
-controllers/console/app/site.py
-controllers/console/auth/email_register.py
-controllers/console/human_input_form.py
-controllers/console/init_validate.py
-controllers/console/ping.py
-controllers/console/setup.py
-controllers/console/version.py
-controllers/console/workspace/trigger_providers.py
-controllers/service_api/app/annotation.py
-controllers/web/workflow_events.py
-core/agent/fc_agent_runner.py
-core/app/apps/advanced_chat/app_generator.py
-core/app/apps/advanced_chat/app_runner.py
-core/app/apps/advanced_chat/generate_task_pipeline.py
-core/app/apps/agent_chat/app_generator.py
-core/app/apps/base_app_generate_response_converter.py
-core/app/apps/base_app_generator.py
-core/app/apps/chat/app_generator.py
-core/app/apps/common/workflow_response_converter.py
-core/app/apps/completion/app_generator.py
-core/app/apps/pipeline/pipeline_generator.py
-core/app/apps/pipeline/pipeline_runner.py
-core/app/apps/workflow/app_generator.py
-core/app/apps/workflow/app_runner.py
-core/app/apps/workflow/generate_task_pipeline.py
-core/app/apps/workflow_app_runner.py
-core/app/task_pipeline/easy_ui_based_generate_task_pipeline.py
-core/datasource/datasource_manager.py
-core/external_data_tool/api/api.py
-core/llm_generator/llm_generator.py
-core/llm_generator/output_parser/structured_output.py
-core/mcp/mcp_client.py
-core/ops/aliyun_trace/data_exporter/traceclient.py
-core/ops/arize_phoenix_trace/arize_phoenix_trace.py
-core/ops/mlflow_trace/mlflow_trace.py
-core/ops/ops_trace_manager.py
-core/ops/tencent_trace/client.py
-core/ops/tencent_trace/utils.py
-core/plugin/backwards_invocation/base.py
-core/plugin/backwards_invocation/model.py
-core/prompt/utils/extract_thread_messages.py
-core/rag/datasource/keyword/jieba/jieba.py
-core/rag/datasource/keyword/jieba/jieba_keyword_table_handler.py
-core/rag/datasource/vdb/analyticdb/analyticdb_vector.py
-core/rag/datasource/vdb/analyticdb/analyticdb_vector_openapi.py
-core/rag/datasource/vdb/baidu/baidu_vector.py
-core/rag/datasource/vdb/chroma/chroma_vector.py
-core/rag/datasource/vdb/clickzetta/clickzetta_vector.py
-core/rag/datasource/vdb/couchbase/couchbase_vector.py
-core/rag/datasource/vdb/elasticsearch/elasticsearch_vector.py
-core/rag/datasource/vdb/huawei/huawei_cloud_vector.py
-core/rag/datasource/vdb/lindorm/lindorm_vector.py
-core/rag/datasource/vdb/matrixone/matrixone_vector.py
-core/rag/datasource/vdb/milvus/milvus_vector.py
-core/rag/datasource/vdb/myscale/myscale_vector.py
-core/rag/datasource/vdb/oceanbase/oceanbase_vector.py
-core/rag/datasource/vdb/opensearch/opensearch_vector.py
-core/rag/datasource/vdb/oracle/oraclevector.py
-core/rag/datasource/vdb/pgvecto_rs/pgvecto_rs.py
-core/rag/datasource/vdb/relyt/relyt_vector.py
-core/rag/datasource/vdb/tablestore/tablestore_vector.py
-core/rag/datasource/vdb/tencent/tencent_vector.py
-core/rag/datasource/vdb/tidb_on_qdrant/tidb_on_qdrant_vector.py
-core/rag/datasource/vdb/tidb_on_qdrant/tidb_service.py
-core/rag/datasource/vdb/tidb_vector/tidb_vector.py
-core/rag/datasource/vdb/upstash/upstash_vector.py
-core/rag/datasource/vdb/vikingdb/vikingdb_vector.py
-core/rag/datasource/vdb/weaviate/weaviate_vector.py
-core/rag/extractor/csv_extractor.py
-core/rag/extractor/excel_extractor.py
-core/rag/extractor/firecrawl/firecrawl_app.py
-core/rag/extractor/firecrawl/firecrawl_web_extractor.py
-core/rag/extractor/html_extractor.py
-core/rag/extractor/jina_reader_extractor.py
-core/rag/extractor/markdown_extractor.py
-core/rag/extractor/notion_extractor.py
-core/rag/extractor/pdf_extractor.py
-core/rag/extractor/text_extractor.py
-core/rag/extractor/unstructured/unstructured_doc_extractor.py
-core/rag/extractor/unstructured/unstructured_eml_extractor.py
-core/rag/extractor/unstructured/unstructured_epub_extractor.py
-core/rag/extractor/unstructured/unstructured_markdown_extractor.py
-core/rag/extractor/unstructured/unstructured_msg_extractor.py
-core/rag/extractor/unstructured/unstructured_ppt_extractor.py
-core/rag/extractor/unstructured/unstructured_pptx_extractor.py
-core/rag/extractor/unstructured/unstructured_xml_extractor.py
-core/rag/extractor/watercrawl/client.py
-core/rag/extractor/watercrawl/extractor.py
-core/rag/extractor/watercrawl/provider.py
-core/rag/extractor/word_extractor.py
-core/rag/index_processor/processor/paragraph_index_processor.py
-core/rag/index_processor/processor/parent_child_index_processor.py
-core/rag/index_processor/processor/qa_index_processor.py
-core/rag/retrieval/router/multi_dataset_function_call_router.py
-core/rag/summary_index/summary_index.py
-core/repositories/sqlalchemy_workflow_execution_repository.py
-core/repositories/sqlalchemy_workflow_node_execution_repository.py
-core/tools/__base/tool.py
-core/tools/mcp_tool/provider.py
-core/tools/plugin_tool/provider.py
-core/tools/utils/message_transformer.py
-core/tools/utils/web_reader_tool.py
-core/tools/workflow_as_tool/provider.py
-core/trigger/debug/event_selectors.py
-core/trigger/entities/entities.py
-core/trigger/provider.py
-core/workflow/workflow_entry.py
-dify_graph/entities/workflow_execution.py
-dify_graph/file/file_manager.py
-dify_graph/graph_engine/error_handler.py
-dify_graph/graph_engine/layers/execution_limits.py
-dify_graph/nodes/agent/agent_node.py
-dify_graph/nodes/base/node.py
-dify_graph/nodes/code/code_node.py
-dify_graph/nodes/datasource/datasource_node.py
-dify_graph/nodes/document_extractor/node.py
-dify_graph/nodes/human_input/human_input_node.py
-dify_graph/nodes/if_else/if_else_node.py
-dify_graph/nodes/iteration/iteration_node.py
-dify_graph/nodes/knowledge_index/knowledge_index_node.py
-dify_graph/nodes/knowledge_retrieval/knowledge_retrieval_node.py
-dify_graph/nodes/list_operator/node.py
-dify_graph/nodes/llm/node.py
-dify_graph/nodes/loop/loop_node.py
-dify_graph/nodes/parameter_extractor/parameter_extractor_node.py
-dify_graph/nodes/question_classifier/question_classifier_node.py
-dify_graph/nodes/start/start_node.py
-dify_graph/nodes/template_transform/template_transform_node.py
-dify_graph/nodes/tool/tool_node.py
-dify_graph/nodes/trigger_plugin/trigger_event_node.py
-dify_graph/nodes/trigger_schedule/trigger_schedule_node.py
-dify_graph/nodes/trigger_webhook/node.py
-dify_graph/nodes/variable_aggregator/variable_aggregator_node.py
-dify_graph/nodes/variable_assigner/v1/node.py
-dify_graph/nodes/variable_assigner/v2/node.py
-dify_graph/variables/types.py
-extensions/ext_fastopenapi.py
-extensions/logstore/repositories/logstore_api_workflow_run_repository.py
-extensions/otel/instrumentation.py
-extensions/otel/runtime.py
-extensions/storage/aliyun_oss_storage.py
-extensions/storage/aws_s3_storage.py
-extensions/storage/azure_blob_storage.py
-extensions/storage/baidu_obs_storage.py
-extensions/storage/clickzetta_volume/clickzetta_volume_storage.py
-extensions/storage/clickzetta_volume/file_lifecycle.py
-extensions/storage/google_cloud_storage.py
-extensions/storage/huawei_obs_storage.py
-extensions/storage/opendal_storage.py
-extensions/storage/oracle_oci_storage.py
-extensions/storage/supabase_storage.py
-extensions/storage/tencent_cos_storage.py
-extensions/storage/volcengine_tos_storage.py
-factories/variable_factory.py
-libs/external_api.py
-libs/gmpy2_pkcs10aep_cipher.py
-libs/helper.py
-libs/login.py
-libs/module_loading.py
-libs/oauth.py
-libs/oauth_data_source.py
-models/trigger.py
-models/workflow.py
-repositories/sqlalchemy_api_workflow_node_execution_repository.py
-repositories/sqlalchemy_api_workflow_run_repository.py
-repositories/sqlalchemy_execution_extra_content_repository.py
-schedule/queue_monitor_task.py
-services/account_service.py
-services/audio_service.py
-services/auth/firecrawl/firecrawl.py
-services/auth/jina.py
-services/auth/jina/jina.py
-services/auth/watercrawl/watercrawl.py
-services/conversation_service.py
-services/dataset_service.py
-services/document_indexing_proxy/document_indexing_task_proxy.py
-services/document_indexing_proxy/duplicate_document_indexing_task_proxy.py
-services/external_knowledge_service.py
-services/plugin/plugin_migration.py
-services/recommend_app/buildin/buildin_retrieval.py
-services/recommend_app/database/database_retrieval.py
-services/recommend_app/remote/remote_retrieval.py
-services/summary_index_service.py
-services/tools/tools_transform_service.py
-services/trigger/trigger_provider_service.py
-services/trigger/trigger_subscription_builder_service.py
-services/trigger/webhook_service.py
-services/workflow_draft_variable_service.py
-services/workflow_event_snapshot_service.py
-services/workflow_service.py
-tasks/app_generate/workflow_execute_task.py
-tasks/regenerate_summary_index_task.py
-tasks/trigger_processing_tasks.py
-tasks/workflow_cfs_scheduler/cfs_scheduler.py
-tasks/workflow_execution_tasks.py

api/pyrefly.toml

@@ -0,0 +1,8 @@
+project-includes = ["."]
+project-excludes = [
+    ".venv",
+    "migrations/",
+]
+python-platform = "linux"
+python-version = "3.11.0"
+infer-with-first-use = false

api/pytest.ini

@@ -1,6 +1,5 @@
 [pytest]
-pythonpath = .
-addopts = --cov=./api --cov-report=json --import-mode=importlib
+addopts = --cov=./api --cov-report=json
 env =
     ANTHROPIC_API_KEY = sk-ant-api11-IamNotARealKeyJustForMockTestKawaiiiiiiiiii-NotBaka-ASkksz
     AZURE_OPENAI_API_BASE = https://difyai-openai.openai.azure.com
@@ -20,7 +19,7 @@ env =
     GOOGLE_API_KEY = abcdefghijklmnopqrstuvwxyz
     HUGGINGFACE_API_KEY = hf-awuwuwuwuwuwuwuwuwuwuwuwuwuwuwuwuwu
     HUGGINGFACE_EMBEDDINGS_ENDPOINT_URL = c
-    HUGGINGFACE_TEXT2TEXT_GEN_ENDPOINT_URL =    b
+    HUGGINGFACE_TEXT2TEXT_GEN_ENDPOINT_URL = b
     HUGGINGFACE_TEXT_GEN_ENDPOINT_URL = a
     MIXEDBREAD_API_KEY = mk-aaaaaaaaaaaaaaaaaaaa
     MOCK_SWITCH = true

api/services/app_dsl_service.py

@@ -4,7 +4,6 @@ import logging
 import uuid
 from collections.abc import Mapping
 from enum import StrEnum
-from typing import cast
 from urllib.parse import urlparse
 from uuid import uuid4
 
@@ -33,7 +32,7 @@ from extensions.ext_redis import redis_client
 from factories import variable_factory
 from libs.datetime_utils import naive_utc_now
 from models import Account, App, AppMode
-from models.model import AppModelConfig, AppModelConfigDict, IconType
+from models.model import AppModelConfig, IconType
 from models.workflow import Workflow
 from services.plugin.dependencies_analysis import DependenciesAnalysisService
 from services.workflow_draft_variable_service import WorkflowDraftVariableService
@@ -524,7 +523,7 @@ class AppDslService:
             if not app.app_model_config:
                 app_model_config = AppModelConfig(
                     app_id=app.id, created_by=account.id, updated_by=account.id
-                ).from_model_config_dict(cast(AppModelConfigDict, model_config))
+                ).from_model_config_dict(model_config)
                 app_model_config.id = str(uuid4())
                 app.app_model_config_id = app_model_config.id
 

api/services/app_model_config_service.py

@@ -1,12 +1,12 @@
 from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfigManager
 from core.app.apps.chat.app_config_manager import ChatAppConfigManager
 from core.app.apps.completion.app_config_manager import CompletionAppConfigManager
-from models.model import AppMode, AppModelConfigDict
+from models.model import AppMode
 
 
 class AppModelConfigService:
     @classmethod
-    def validate_configuration(cls, tenant_id: str, config: dict, app_mode: AppMode) -> AppModelConfigDict:
+    def validate_configuration(cls, tenant_id: str, config: dict, app_mode: AppMode):
         if app_mode == AppMode.CHAT:
             return ChatAppConfigManager.config_validate(tenant_id, config)
         elif app_mode == AppMode.AGENT_CHAT:

api/services/app_service.py

@@ -1,6 +1,6 @@
 import json
 import logging
-from typing import Any, TypedDict, cast
+from typing import TypedDict, cast
 
 import sqlalchemy as sa
 from flask_sqlalchemy.pagination import Pagination
@@ -187,7 +187,7 @@ class AppService:
             for tool in agent_mode.get("tools") or []:
                 if not isinstance(tool, dict) or len(tool.keys()) <= 3:
                     continue
-                agent_tool_entity = AgentToolEntity(**cast(dict[str, Any], tool))
+                agent_tool_entity = AgentToolEntity(**tool)
                 # get tool
                 try:
                     tool_runtime = ToolManager.get_agent_tool_runtime(
@@ -388,7 +388,7 @@ class AppService:
             agent_config = app_model_config.agent_mode_dict
 
             # get all tools
-            tools = cast(list[dict[str, Any]], agent_config.get("tools", []))
+            tools = agent_config.get("tools", [])
 
         url_prefix = dify_config.CONSOLE_API_URL + "/console/api/workspaces/current/tool-provider/builtin/"
 

api/services/audio_service.py

@@ -2,7 +2,6 @@ import io
 import logging
 import uuid
 from collections.abc import Generator
-from typing import cast
 
 from flask import Response, stream_with_context
 from werkzeug.datastructures import FileStorage
@@ -107,7 +106,7 @@ class AudioService:
                         if not text_to_speech_dict.get("enabled"):
                             raise ValueError("TTS is not enabled")
 
-                        voice = cast(str | None, text_to_speech_dict.get("voice"))
+                        voice = text_to_speech_dict.get("voice")
 
             model_manager = ModelManager()
             model_instance = model_manager.get_default_model_instance(

api/services/rag_pipeline/rag_pipeline_transform_service.py

@@ -63,12 +63,7 @@ class RagPipelineTransformService:
             ):
                 node = self._deal_file_extensions(node)
             if node.get("data", {}).get("type") == "knowledge-index":
-                knowledge_configuration = KnowledgeConfiguration.model_validate(node.get("data", {}))
-                if dataset.tenant_id != current_user.current_tenant_id:
-                    raise ValueError("Unauthorized")
-                node = self._deal_knowledge_index(
-                    knowledge_configuration, dataset, indexing_technique, retrieval_model, node
-                )
+                node = self._deal_knowledge_index(dataset, doc_form, indexing_technique, retrieval_model, node)
             new_nodes.append(node)
         if new_nodes:
             graph["nodes"] = new_nodes
@@ -160,13 +155,14 @@ class RagPipelineTransformService:
 
     def _deal_knowledge_index(
         self,
-        knowledge_configuration: KnowledgeConfiguration,
         dataset: Dataset,
+        doc_form: str,
         indexing_technique: str | None,
         retrieval_model: RetrievalSetting | None,
         node: dict,
     ):
         knowledge_configuration_dict = node.get("data", {})
+        knowledge_configuration = KnowledgeConfiguration.model_validate(knowledge_configuration_dict)
 
         if indexing_technique == "high_quality":
             knowledge_configuration.embedding_model = dataset.embedding_model

api/services/retention/conversation/message_export_service.py

@@ -1,304 +0,0 @@
-"""
-Export app messages to JSONL.GZ format.
-
-Outputs: conversation_id, message_id, query, answer, inputs (raw JSON),
-retriever_resources (from message_metadata), feedback (user feedbacks array).
-
-Uses (created_at, id) cursor pagination and batch-loads feedbacks to avoid N+1.
-Does NOT touch Message.inputs / Message.user_feedback properties.
-"""
-
-import datetime
-import gzip
-import json
-import logging
-import tempfile
-from collections import defaultdict
-from collections.abc import Generator, Iterable
-from pathlib import Path, PurePosixPath
-from typing import Any, BinaryIO, cast
-
-import orjson
-import sqlalchemy as sa
-from pydantic import BaseModel, ConfigDict, Field
-from sqlalchemy import select, tuple_
-from sqlalchemy.orm import Session
-
-from extensions.ext_database import db
-from extensions.ext_storage import storage
-from models.model import Message, MessageFeedback
-
-logger = logging.getLogger(__name__)
-
-MAX_FILENAME_BASE_LENGTH = 1024
-FORBIDDEN_FILENAME_SUFFIXES = (".jsonl.gz", ".jsonl", ".gz")
-
-
-class AppMessageExportFeedback(BaseModel):
-    id: str
-    app_id: str
-    conversation_id: str
-    message_id: str
-    rating: str
-    content: str | None = None
-    from_source: str
-    from_end_user_id: str | None = None
-    from_account_id: str | None = None
-    created_at: str
-    updated_at: str
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AppMessageExportRecord(BaseModel):
-    conversation_id: str
-    message_id: str
-    query: str
-    answer: str
-    inputs: dict[str, Any]
-    retriever_resources: list[Any] = Field(default_factory=list)
-    feedback: list[AppMessageExportFeedback] = Field(default_factory=list)
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AppMessageExportStats(BaseModel):
-    batches: int = 0
-    total_messages: int = 0
-    messages_with_feedback: int = 0
-    total_feedbacks: int = 0
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class AppMessageExportService:
-    @staticmethod
-    def validate_export_filename(filename: str) -> str:
-        normalized = filename.strip()
-        if not normalized:
-            raise ValueError("--filename must not be empty.")
-
-        normalized_lower = normalized.lower()
-        if normalized_lower.endswith(FORBIDDEN_FILENAME_SUFFIXES):
-            raise ValueError("--filename must not include .jsonl.gz/.jsonl/.gz suffix; pass base filename only.")
-
-        if normalized.startswith("/"):
-            raise ValueError("--filename must be a relative path; absolute paths are not allowed.")
-
-        if "\\" in normalized:
-            raise ValueError("--filename must use '/' as path separator; '\\' is not allowed.")
-
-        if "//" in normalized:
-            raise ValueError("--filename must not contain empty path segments ('//').")
-
-        if len(normalized) > MAX_FILENAME_BASE_LENGTH:
-            raise ValueError(f"--filename is too long; max length is {MAX_FILENAME_BASE_LENGTH}.")
-
-        for ch in normalized:
-            if ch == "\x00" or ord(ch) < 32 or ord(ch) == 127:
-                raise ValueError("--filename must not contain control characters or NUL.")
-
-        parts = PurePosixPath(normalized).parts
-        if not parts:
-            raise ValueError("--filename must include a file name.")
-
-        if any(part in (".", "..") for part in parts):
-            raise ValueError("--filename must not contain '.' or '..' path segments.")
-
-        return normalized
-
-    @property
-    def output_gz_name(self) -> str:
-        return f"{self._filename_base}.jsonl.gz"
-
-    @property
-    def output_jsonl_name(self) -> str:
-        return f"{self._filename_base}.jsonl"
-
-    def __init__(
-        self,
-        app_id: str,
-        end_before: datetime.datetime,
-        filename: str,
-        *,
-        start_from: datetime.datetime | None = None,
-        batch_size: int = 1000,
-        use_cloud_storage: bool = False,
-        dry_run: bool = False,
-    ) -> None:
-        if start_from and start_from >= end_before:
-            raise ValueError(f"start_from ({start_from}) must be before end_before ({end_before})")
-
-        self._app_id = app_id
-        self._end_before = end_before
-        self._start_from = start_from
-        self._filename_base = self.validate_export_filename(filename)
-        self._batch_size = batch_size
-        self._use_cloud_storage = use_cloud_storage
-        self._dry_run = dry_run
-
-    def run(self) -> AppMessageExportStats:
-        stats = AppMessageExportStats()
-
-        logger.info(
-            "export_app_messages: app_id=%s, start_from=%s, end_before=%s, dry_run=%s, cloud=%s, output_gz=%s",
-            self._app_id,
-            self._start_from,
-            self._end_before,
-            self._dry_run,
-            self._use_cloud_storage,
-            self.output_gz_name,
-        )
-
-        if self._dry_run:
-            for _ in self._iter_records_with_stats(stats):
-                pass
-            self._finalize_stats(stats)
-            return stats
-
-        if self._use_cloud_storage:
-            self._export_to_cloud(stats)
-        else:
-            self._export_to_local(stats)
-
-        self._finalize_stats(stats)
-        return stats
-
-    def iter_records(self) -> Generator[AppMessageExportRecord, None, None]:
-        for batch in self._iter_record_batches():
-            yield from batch
-
-    @staticmethod
-    def write_jsonl_gz(records: Iterable[AppMessageExportRecord], fileobj: BinaryIO) -> None:
-        with gzip.GzipFile(fileobj=fileobj, mode="wb") as gz:
-            for record in records:
-                gz.write(orjson.dumps(record.model_dump(mode="json")) + b"\n")
-
-    def _export_to_local(self, stats: AppMessageExportStats) -> None:
-        output_path = Path.cwd() / self.output_gz_name
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        with output_path.open("wb") as output_file:
-            self.write_jsonl_gz(self._iter_records_with_stats(stats), output_file)
-
-    def _export_to_cloud(self, stats: AppMessageExportStats) -> None:
-        with tempfile.SpooledTemporaryFile(max_size=64 * 1024 * 1024) as tmp:
-            self.write_jsonl_gz(self._iter_records_with_stats(stats), cast(BinaryIO, tmp))
-            tmp.seek(0)
-            data = tmp.read()
-
-        storage.save(self.output_gz_name, data)
-        logger.info("export_app_messages: uploaded %d bytes to cloud key=%s", len(data), self.output_gz_name)
-
-    def _iter_records_with_stats(self, stats: AppMessageExportStats) -> Generator[AppMessageExportRecord, None, None]:
-        for record in self.iter_records():
-            self._update_stats(stats, record)
-            yield record
-
-    @staticmethod
-    def _update_stats(stats: AppMessageExportStats, record: AppMessageExportRecord) -> None:
-        stats.total_messages += 1
-        if record.feedback:
-            stats.messages_with_feedback += 1
-            stats.total_feedbacks += len(record.feedback)
-
-    def _finalize_stats(self, stats: AppMessageExportStats) -> None:
-        if stats.total_messages == 0:
-            stats.batches = 0
-            return
-        stats.batches = (stats.total_messages + self._batch_size - 1) // self._batch_size
-
-    def _iter_record_batches(self) -> Generator[list[AppMessageExportRecord], None, None]:
-        cursor: tuple[datetime.datetime, str] | None = None
-        while True:
-            rows, cursor = self._fetch_batch(cursor)
-            if not rows:
-                break
-
-            message_ids = [str(row.id) for row in rows]
-            feedbacks_map = self._fetch_feedbacks(message_ids)
-            yield [self._build_record(row, feedbacks_map) for row in rows]
-
-    def _fetch_batch(
-        self, cursor: tuple[datetime.datetime, str] | None
-    ) -> tuple[list[Any], tuple[datetime.datetime, str] | None]:
-        with Session(db.engine, expire_on_commit=False) as session:
-            stmt = (
-                select(
-                    Message.id,
-                    Message.conversation_id,
-                    Message.query,
-                    Message.answer,
-                    Message._inputs,  # pyright: ignore[reportPrivateUsage]
-                    Message.message_metadata,
-                    Message.created_at,
-                )
-                .where(
-                    Message.app_id == self._app_id,
-                    Message.created_at < self._end_before,
-                )
-                .order_by(Message.created_at, Message.id)
-                .limit(self._batch_size)
-            )
-
-            if self._start_from:
-                stmt = stmt.where(Message.created_at >= self._start_from)
-
-            if cursor:
-                stmt = stmt.where(
-                    tuple_(Message.created_at, Message.id)
-                    > tuple_(
-                        sa.literal(cursor[0], type_=sa.DateTime()),
-                        sa.literal(cursor[1], type_=Message.id.type),
-                    )
-                )
-
-            rows = list(session.execute(stmt).all())
-
-        if not rows:
-            return [], cursor
-
-        last = rows[-1]
-        return rows, (last.created_at, last.id)
-
-    def _fetch_feedbacks(self, message_ids: list[str]) -> dict[str, list[AppMessageExportFeedback]]:
-        if not message_ids:
-            return {}
-
-        with Session(db.engine, expire_on_commit=False) as session:
-            stmt = (
-                select(MessageFeedback)
-                .where(
-                    MessageFeedback.message_id.in_(message_ids),
-                    MessageFeedback.from_source == "user",
-                )
-                .order_by(MessageFeedback.message_id, MessageFeedback.created_at)
-            )
-            feedbacks = list(session.scalars(stmt).all())
-
-        result: dict[str, list[AppMessageExportFeedback]] = defaultdict(list)
-        for feedback in feedbacks:
-            result[str(feedback.message_id)].append(AppMessageExportFeedback.model_validate(feedback.to_dict()))
-        return result
-
-    @staticmethod
-    def _build_record(row: Any, feedbacks_map: dict[str, list[AppMessageExportFeedback]]) -> AppMessageExportRecord:
-        retriever_resources: list[Any] = []
-        if row.message_metadata:
-            try:
-                metadata = json.loads(row.message_metadata)
-                value = metadata.get("retriever_resources", [])
-                if isinstance(value, list):
-                    retriever_resources = value
-            except (json.JSONDecodeError, TypeError):
-                pass
-
-        message_id = str(row.id)
-        return AppMessageExportRecord(
-            conversation_id=str(row.conversation_id),
-            message_id=message_id,
-            query=row.query,
-            answer=row.answer,
-            inputs=row._inputs if isinstance(row._inputs, dict) else {},
-            retriever_resources=retriever_resources,
-            feedback=feedbacks_map.get(message_id, []),
-        )

api/services/retention/conversation/messages_clean_service.py

@@ -1,18 +1,17 @@
 import datetime
 import logging
+import os
 import random
 import time
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, cast
+from typing import cast
 
 import sqlalchemy as sa
 from sqlalchemy import delete, select, tuple_
 from sqlalchemy.engine import CursorResult
 from sqlalchemy.orm import Session
 
-from configs import dify_config
 from extensions.ext_database import db
-from libs.datetime_utils import naive_utc_now
 from models.model import (
     App,
     AppAnnotationHitHistory,
@@ -33,128 +32,6 @@ from services.retention.conversation.messages_clean_policy import (
 logger = logging.getLogger(__name__)
 
 
-if TYPE_CHECKING:
-    from opentelemetry.metrics import Counter, Histogram
-
-
-class MessagesCleanupMetrics:
-    """
-    Records low-cardinality OpenTelemetry metrics for expired message cleanup jobs.
-
-    We keep labels stable (dry_run/window_mode/task_label/status) so these metrics remain
-    dashboard-friendly for long-running CronJob executions.
-    """
-
-    _job_runs_total: "Counter | None"
-    _batches_total: "Counter | None"
-    _messages_scanned_total: "Counter | None"
-    _messages_filtered_total: "Counter | None"
-    _messages_deleted_total: "Counter | None"
-    _job_duration_seconds: "Histogram | None"
-    _batch_duration_seconds: "Histogram | None"
-    _base_attributes: dict[str, str]
-
-    def __init__(self, *, dry_run: bool, has_window: bool, task_label: str) -> None:
-        self._job_runs_total = None
-        self._batches_total = None
-        self._messages_scanned_total = None
-        self._messages_filtered_total = None
-        self._messages_deleted_total = None
-        self._job_duration_seconds = None
-        self._batch_duration_seconds = None
-        self._base_attributes = {
-            "job_name": "messages_cleanup",
-            "dry_run": str(dry_run).lower(),
-            "window_mode": "between" if has_window else "before_cutoff",
-            "task_label": task_label,
-        }
-        self._init_instruments()
-
-    def _init_instruments(self) -> None:
-        try:
-            from opentelemetry.metrics import get_meter
-
-            meter = get_meter("messages_cleanup", version=dify_config.project.version)
-            self._job_runs_total = meter.create_counter(
-                "messages_cleanup_jobs_total",
-                description="Total number of expired message cleanup jobs by status.",
-                unit="{job}",
-            )
-            self._batches_total = meter.create_counter(
-                "messages_cleanup_batches_total",
-                description="Total number of message cleanup batches processed.",
-                unit="{batch}",
-            )
-            self._messages_scanned_total = meter.create_counter(
-                "messages_cleanup_scanned_messages_total",
-                description="Total messages scanned by cleanup jobs.",
-                unit="{message}",
-            )
-            self._messages_filtered_total = meter.create_counter(
-                "messages_cleanup_filtered_messages_total",
-                description="Total messages selected by cleanup policy.",
-                unit="{message}",
-            )
-            self._messages_deleted_total = meter.create_counter(
-                "messages_cleanup_deleted_messages_total",
-                description="Total messages deleted by cleanup jobs.",
-                unit="{message}",
-            )
-            self._job_duration_seconds = meter.create_histogram(
-                "messages_cleanup_job_duration_seconds",
-                description="Duration of expired message cleanup jobs in seconds.",
-                unit="s",
-            )
-            self._batch_duration_seconds = meter.create_histogram(
-                "messages_cleanup_batch_duration_seconds",
-                description="Duration of expired message cleanup batch processing in seconds.",
-                unit="s",
-            )
-        except Exception:
-            logger.exception("messages_cleanup_metrics: failed to initialize instruments")
-
-    def _attrs(self, **extra: str) -> dict[str, str]:
-        return {**self._base_attributes, **extra}
-
-    @staticmethod
-    def _add(counter: "Counter | None", value: int, attributes: dict[str, str]) -> None:
-        if not counter or value <= 0:
-            return
-        try:
-            counter.add(value, attributes)
-        except Exception:
-            logger.exception("messages_cleanup_metrics: failed to add counter value")
-
-    @staticmethod
-    def _record(histogram: "Histogram | None", value: float, attributes: dict[str, str]) -> None:
-        if not histogram:
-            return
-        try:
-            histogram.record(value, attributes)
-        except Exception:
-            logger.exception("messages_cleanup_metrics: failed to record histogram value")
-
-    def record_batch(
-        self,
-        *,
-        scanned_messages: int,
-        filtered_messages: int,
-        deleted_messages: int,
-        batch_duration_seconds: float,
-    ) -> None:
-        attributes = self._attrs()
-        self._add(self._batches_total, 1, attributes)
-        self._add(self._messages_scanned_total, scanned_messages, attributes)
-        self._add(self._messages_filtered_total, filtered_messages, attributes)
-        self._add(self._messages_deleted_total, deleted_messages, attributes)
-        self._record(self._batch_duration_seconds, batch_duration_seconds, attributes)
-
-    def record_completion(self, *, status: str, job_duration_seconds: float) -> None:
-        attributes = self._attrs(status=status)
-        self._add(self._job_runs_total, 1, attributes)
-        self._record(self._job_duration_seconds, job_duration_seconds, attributes)
-
-
 class MessagesCleanService:
     """
     Service for cleaning expired messages based on retention policies.
@@ -170,7 +47,6 @@ class MessagesCleanService:
         start_from: datetime.datetime | None = None,
         batch_size: int = 1000,
         dry_run: bool = False,
-        task_label: str = "daily",
     ) -> None:
         """
         Initialize the service with cleanup parameters.
@@ -181,20 +57,12 @@ class MessagesCleanService:
             start_from: Optional start time (inclusive) of the range
             batch_size: Number of messages to process per batch
             dry_run: Whether to perform a dry run (no actual deletion)
-            task_label: Stable task label to distinguish multiple cleanup CronJobs
         """
         self._policy = policy
         self._end_before = end_before
         self._start_from = start_from
         self._batch_size = batch_size
         self._dry_run = dry_run
-        normalized_task_label = task_label.strip()
-        self._task_label = normalized_task_label or "daily"
-        self._metrics = MessagesCleanupMetrics(
-            dry_run=dry_run,
-            has_window=bool(start_from),
-            task_label=self._task_label,
-        )
 
     @classmethod
     def from_time_range(
@@ -204,7 +72,6 @@ class MessagesCleanService:
         end_before: datetime.datetime,
         batch_size: int = 1000,
         dry_run: bool = False,
-        task_label: str = "daily",
     ) -> "MessagesCleanService":
         """
         Create a service instance for cleaning messages within a specific time range.
@@ -217,7 +84,6 @@ class MessagesCleanService:
             end_before: End time (exclusive) of the range
             batch_size: Number of messages to process per batch
             dry_run: Whether to perform a dry run (no actual deletion)
-            task_label: Stable task label to distinguish multiple cleanup CronJobs
 
         Returns:
             MessagesCleanService instance
@@ -245,7 +111,6 @@ class MessagesCleanService:
             start_from=start_from,
             batch_size=batch_size,
             dry_run=dry_run,
-            task_label=task_label,
         )
 
     @classmethod
@@ -255,7 +120,6 @@ class MessagesCleanService:
         days: int = 30,
         batch_size: int = 1000,
         dry_run: bool = False,
-        task_label: str = "daily",
     ) -> "MessagesCleanService":
         """
         Create a service instance for cleaning messages older than specified days.
@@ -265,7 +129,6 @@ class MessagesCleanService:
             days: Number of days to look back from now
             batch_size: Number of messages to process per batch
             dry_run: Whether to perform a dry run (no actual deletion)
-            task_label: Stable task label to distinguish multiple cleanup CronJobs
 
         Returns:
             MessagesCleanService instance
@@ -279,7 +142,7 @@ class MessagesCleanService:
         if batch_size <= 0:
             raise ValueError(f"batch_size ({batch_size}) must be greater than 0")
 
-        end_before = naive_utc_now() - datetime.timedelta(days=days)
+        end_before = datetime.datetime.now() - datetime.timedelta(days=days)
 
         logger.info(
             "clean_messages: days=%s, end_before=%s, batch_size=%s, policy=%s",
@@ -289,14 +152,7 @@ class MessagesCleanService:
             policy.__class__.__name__,
         )
 
-        return cls(
-            policy=policy,
-            end_before=end_before,
-            start_from=None,
-            batch_size=batch_size,
-            dry_run=dry_run,
-            task_label=task_label,
-        )
+        return cls(policy=policy, end_before=end_before, start_from=None, batch_size=batch_size, dry_run=dry_run)
 
     def run(self) -> dict[str, int]:
         """
@@ -305,18 +161,7 @@ class MessagesCleanService:
         Returns:
             Dict with statistics: batches, filtered_messages, total_deleted
         """
-        status = "success"
-        run_start = time.monotonic()
-        try:
-            return self._clean_messages_by_time_range()
-        except Exception:
-            status = "failed"
-            raise
-        finally:
-            self._metrics.record_completion(
-                status=status,
-                job_duration_seconds=time.monotonic() - run_start,
-            )
+        return self._clean_messages_by_time_range()
 
     def _clean_messages_by_time_range(self) -> dict[str, int]:
         """
@@ -351,14 +196,11 @@ class MessagesCleanService:
             self._end_before,
         )
 
-        max_batch_interval_ms = dify_config.SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL
+        max_batch_interval_ms = int(os.environ.get("SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL", 200))
 
         while True:
             stats["batches"] += 1
             batch_start = time.monotonic()
-            batch_scanned_messages = 0
-            batch_filtered_messages = 0
-            batch_deleted_messages = 0
 
             # Step 1: Fetch a batch of messages using cursor
             with Session(db.engine, expire_on_commit=False) as session:
@@ -397,16 +239,9 @@ class MessagesCleanService:
 
                 # Track total messages fetched across all batches
                 stats["total_messages"] += len(messages)
-                batch_scanned_messages = len(messages)
 
                 if not messages:
                     logger.info("clean_messages (batch %s): no more messages to process", stats["batches"])
-                    self._metrics.record_batch(
-                        scanned_messages=batch_scanned_messages,
-                        filtered_messages=batch_filtered_messages,
-                        deleted_messages=batch_deleted_messages,
-                        batch_duration_seconds=time.monotonic() - batch_start,
-                    )
                     break
 
                 # Update cursor to the last message's (created_at, id)
@@ -432,12 +267,6 @@ class MessagesCleanService:
 
             if not apps:
                 logger.info("clean_messages (batch %s): no apps found, skip", stats["batches"])
-                self._metrics.record_batch(
-                    scanned_messages=batch_scanned_messages,
-                    filtered_messages=batch_filtered_messages,
-                    deleted_messages=batch_deleted_messages,
-                    batch_duration_seconds=time.monotonic() - batch_start,
-                )
                 continue
 
             # Build app_id -> tenant_id mapping
@@ -456,16 +285,9 @@ class MessagesCleanService:
 
             if not message_ids_to_delete:
                 logger.info("clean_messages (batch %s): no messages to delete, skip", stats["batches"])
-                self._metrics.record_batch(
-                    scanned_messages=batch_scanned_messages,
-                    filtered_messages=batch_filtered_messages,
-                    deleted_messages=batch_deleted_messages,
-                    batch_duration_seconds=time.monotonic() - batch_start,
-                )
                 continue
 
             stats["filtered_messages"] += len(message_ids_to_delete)
-            batch_filtered_messages = len(message_ids_to_delete)
 
             # Step 4: Batch delete messages and their relations
             if not self._dry_run:
@@ -486,7 +308,6 @@ class MessagesCleanService:
                     commit_ms = int((time.monotonic() - commit_start) * 1000)
 
                     stats["total_deleted"] += messages_deleted
-                    batch_deleted_messages = messages_deleted
 
                     logger.info(
                         "clean_messages (batch %s): processed %s messages, deleted %s messages",
@@ -521,13 +342,6 @@ class MessagesCleanService:
                 for msg_id in sampled_ids:
                     logger.info("clean_messages (batch %s, dry_run) sample: message_id=%s", stats["batches"], msg_id)
 
-            self._metrics.record_batch(
-                scanned_messages=batch_scanned_messages,
-                filtered_messages=batch_filtered_messages,
-                deleted_messages=batch_deleted_messages,
-                batch_duration_seconds=time.monotonic() - batch_start,
-            )
-
         logger.info(
             "clean_messages completed: total batches: %s, total messages: %s, filtered messages: %s, total deleted: %s",
             stats["batches"],

api/services/retention/workflow_run/clear_free_plan_expired_workflow_run_logs.py

@@ -1,9 +1,9 @@
 import datetime
 import logging
+import os
 import random
 import time
 from collections.abc import Iterable, Sequence
-from typing import TYPE_CHECKING
 
 import click
 from sqlalchemy.orm import Session, sessionmaker
@@ -20,156 +20,6 @@ from services.billing_service import BillingService, SubscriptionPlan
 logger = logging.getLogger(__name__)
 
 
-if TYPE_CHECKING:
-    from opentelemetry.metrics import Counter, Histogram
-
-
-class WorkflowRunCleanupMetrics:
-    """
-    Records low-cardinality OpenTelemetry metrics for workflow run cleanup jobs.
-
-    Metrics are emitted with stable labels only (dry_run/window_mode/task_label/status)
-    to keep dashboard and alert cardinality predictable in production clusters.
-    """
-
-    _job_runs_total: "Counter | None"
-    _batches_total: "Counter | None"
-    _runs_scanned_total: "Counter | None"
-    _runs_targeted_total: "Counter | None"
-    _runs_deleted_total: "Counter | None"
-    _runs_skipped_total: "Counter | None"
-    _related_records_total: "Counter | None"
-    _job_duration_seconds: "Histogram | None"
-    _batch_duration_seconds: "Histogram | None"
-    _base_attributes: dict[str, str]
-
-    def __init__(self, *, dry_run: bool, has_window: bool, task_label: str) -> None:
-        self._job_runs_total = None
-        self._batches_total = None
-        self._runs_scanned_total = None
-        self._runs_targeted_total = None
-        self._runs_deleted_total = None
-        self._runs_skipped_total = None
-        self._related_records_total = None
-        self._job_duration_seconds = None
-        self._batch_duration_seconds = None
-        self._base_attributes = {
-            "job_name": "workflow_run_cleanup",
-            "dry_run": str(dry_run).lower(),
-            "window_mode": "between" if has_window else "before_cutoff",
-            "task_label": task_label,
-        }
-        self._init_instruments()
-
-    def _init_instruments(self) -> None:
-        try:
-            from opentelemetry.metrics import get_meter
-
-            meter = get_meter("workflow_run_cleanup", version=dify_config.project.version)
-            self._job_runs_total = meter.create_counter(
-                "workflow_run_cleanup_jobs_total",
-                description="Total number of workflow run cleanup jobs by status.",
-                unit="{job}",
-            )
-            self._batches_total = meter.create_counter(
-                "workflow_run_cleanup_batches_total",
-                description="Total number of processed cleanup batches.",
-                unit="{batch}",
-            )
-            self._runs_scanned_total = meter.create_counter(
-                "workflow_run_cleanup_scanned_runs_total",
-                description="Total workflow runs scanned by cleanup jobs.",
-                unit="{run}",
-            )
-            self._runs_targeted_total = meter.create_counter(
-                "workflow_run_cleanup_targeted_runs_total",
-                description="Total workflow runs targeted by cleanup policy.",
-                unit="{run}",
-            )
-            self._runs_deleted_total = meter.create_counter(
-                "workflow_run_cleanup_deleted_runs_total",
-                description="Total workflow runs deleted by cleanup jobs.",
-                unit="{run}",
-            )
-            self._runs_skipped_total = meter.create_counter(
-                "workflow_run_cleanup_skipped_runs_total",
-                description="Total workflow runs skipped because tenant is paid/unknown.",
-                unit="{run}",
-            )
-            self._related_records_total = meter.create_counter(
-                "workflow_run_cleanup_related_records_total",
-                description="Total related records processed by cleanup jobs.",
-                unit="{record}",
-            )
-            self._job_duration_seconds = meter.create_histogram(
-                "workflow_run_cleanup_job_duration_seconds",
-                description="Duration of workflow run cleanup jobs in seconds.",
-                unit="s",
-            )
-            self._batch_duration_seconds = meter.create_histogram(
-                "workflow_run_cleanup_batch_duration_seconds",
-                description="Duration of workflow run cleanup batch processing in seconds.",
-                unit="s",
-            )
-        except Exception:
-            logger.exception("workflow_run_cleanup_metrics: failed to initialize instruments")
-
-    def _attrs(self, **extra: str) -> dict[str, str]:
-        return {**self._base_attributes, **extra}
-
-    @staticmethod
-    def _add(counter: "Counter | None", value: int, attributes: dict[str, str]) -> None:
-        if not counter or value <= 0:
-            return
-        try:
-            counter.add(value, attributes)
-        except Exception:
-            logger.exception("workflow_run_cleanup_metrics: failed to add counter value")
-
-    @staticmethod
-    def _record(histogram: "Histogram | None", value: float, attributes: dict[str, str]) -> None:
-        if not histogram:
-            return
-        try:
-            histogram.record(value, attributes)
-        except Exception:
-            logger.exception("workflow_run_cleanup_metrics: failed to record histogram value")
-
-    def record_batch(
-        self,
-        *,
-        batch_rows: int,
-        targeted_runs: int,
-        skipped_runs: int,
-        deleted_runs: int,
-        related_counts: dict[str, int] | None,
-        related_action: str | None,
-        batch_duration_seconds: float,
-    ) -> None:
-        attributes = self._attrs()
-        self._add(self._batches_total, 1, attributes)
-        self._add(self._runs_scanned_total, batch_rows, attributes)
-        self._add(self._runs_targeted_total, targeted_runs, attributes)
-        self._add(self._runs_skipped_total, skipped_runs, attributes)
-        self._add(self._runs_deleted_total, deleted_runs, attributes)
-        self._record(self._batch_duration_seconds, batch_duration_seconds, attributes)
-
-        if not related_counts or not related_action:
-            return
-
-        for record_type, count in related_counts.items():
-            self._add(
-                self._related_records_total,
-                count,
-                self._attrs(action=related_action, record_type=record_type),
-            )
-
-    def record_completion(self, *, status: str, job_duration_seconds: float) -> None:
-        attributes = self._attrs(status=status)
-        self._add(self._job_runs_total, 1, attributes)
-        self._record(self._job_duration_seconds, job_duration_seconds, attributes)
-
-
 class WorkflowRunCleanup:
     def __init__(
         self,
@@ -179,7 +29,6 @@ class WorkflowRunCleanup:
         end_before: datetime.datetime | None = None,
         workflow_run_repo: APIWorkflowRunRepository | None = None,
         dry_run: bool = False,
-        task_label: str = "daily",
     ):
         if (start_from is None) ^ (end_before is None):
             raise ValueError("start_from and end_before must be both set or both omitted.")
@@ -197,13 +46,6 @@ class WorkflowRunCleanup:
         self.batch_size = batch_size
         self._cleanup_whitelist: set[str] | None = None
         self.dry_run = dry_run
-        normalized_task_label = task_label.strip()
-        self.task_label = normalized_task_label or "daily"
-        self._metrics = WorkflowRunCleanupMetrics(
-            dry_run=dry_run,
-            has_window=bool(start_from),
-            task_label=self.task_label,
-        )
         self.free_plan_grace_period_days = dify_config.SANDBOX_EXPIRED_RECORDS_CLEAN_GRACEFUL_PERIOD
         self.workflow_run_repo: APIWorkflowRunRepository
         if workflow_run_repo:
@@ -232,193 +74,153 @@ class WorkflowRunCleanup:
         related_totals = self._empty_related_counts() if self.dry_run else None
         batch_index = 0
         last_seen: tuple[datetime.datetime, str] | None = None
-        status = "success"
-        run_start = time.monotonic()
-        max_batch_interval_ms = dify_config.SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL
 
-        try:
-            while True:
-                batch_start = time.monotonic()
+        max_batch_interval_ms = int(os.environ.get("SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL", 200))
 
-                fetch_start = time.monotonic()
-                run_rows = self.workflow_run_repo.get_runs_batch_by_time_range(
-                    start_from=self.window_start,
-                    end_before=self.window_end,
-                    last_seen=last_seen,
-                    batch_size=self.batch_size,
+        while True:
+            batch_start = time.monotonic()
+
+            fetch_start = time.monotonic()
+            run_rows = self.workflow_run_repo.get_runs_batch_by_time_range(
+                start_from=self.window_start,
+                end_before=self.window_end,
+                last_seen=last_seen,
+                batch_size=self.batch_size,
+            )
+            if not run_rows:
+                logger.info("workflow_run_cleanup (batch #%s): no more rows to process", batch_index + 1)
+                break
+
+            batch_index += 1
+            last_seen = (run_rows[-1].created_at, run_rows[-1].id)
+            logger.info(
+                "workflow_run_cleanup (batch #%s): fetched %s rows in %sms",
+                batch_index,
+                len(run_rows),
+                int((time.monotonic() - fetch_start) * 1000),
+            )
+
+            tenant_ids = {row.tenant_id for row in run_rows}
+
+            filter_start = time.monotonic()
+            free_tenants = self._filter_free_tenants(tenant_ids)
+            logger.info(
+                "workflow_run_cleanup (batch #%s): filtered %s free tenants from %s tenants in %sms",
+                batch_index,
+                len(free_tenants),
+                len(tenant_ids),
+                int((time.monotonic() - filter_start) * 1000),
+            )
+
+            free_runs = [row for row in run_rows if row.tenant_id in free_tenants]
+            paid_or_skipped = len(run_rows) - len(free_runs)
+
+            if not free_runs:
+                skipped_message = (
+                    f"[batch #{batch_index}] skipped (no sandbox runs in batch, {paid_or_skipped} paid/unknown)"
                 )
-                if not run_rows:
-                    logger.info("workflow_run_cleanup (batch #%s): no more rows to process", batch_index + 1)
-                    break
-
-                batch_index += 1
-                last_seen = (run_rows[-1].created_at, run_rows[-1].id)
-                logger.info(
-                    "workflow_run_cleanup (batch #%s): fetched %s rows in %sms",
-                    batch_index,
-                    len(run_rows),
-                    int((time.monotonic() - fetch_start) * 1000),
-                )
-
-                tenant_ids = {row.tenant_id for row in run_rows}
-
-                filter_start = time.monotonic()
-                free_tenants = self._filter_free_tenants(tenant_ids)
-                logger.info(
-                    "workflow_run_cleanup (batch #%s): filtered %s free tenants from %s tenants in %sms",
-                    batch_index,
-                    len(free_tenants),
-                    len(tenant_ids),
-                    int((time.monotonic() - filter_start) * 1000),
-                )
-
-                free_runs = [row for row in run_rows if row.tenant_id in free_tenants]
-                paid_or_skipped = len(run_rows) - len(free_runs)
-
-                if not free_runs:
-                    skipped_message = (
-                        f"[batch #{batch_index}] skipped (no sandbox runs in batch, {paid_or_skipped} paid/unknown)"
-                    )
-                    click.echo(
-                        click.style(
-                            skipped_message,
-                            fg="yellow",
-                        )
-                    )
-                    self._metrics.record_batch(
-                        batch_rows=len(run_rows),
-                        targeted_runs=0,
-                        skipped_runs=paid_or_skipped,
-                        deleted_runs=0,
-                        related_counts=None,
-                        related_action=None,
-                        batch_duration_seconds=time.monotonic() - batch_start,
-                    )
-                    continue
-
-                total_runs_targeted += len(free_runs)
-
-                if self.dry_run:
-                    count_start = time.monotonic()
-                    batch_counts = self.workflow_run_repo.count_runs_with_related(
-                        free_runs,
-                        count_node_executions=self._count_node_executions,
-                        count_trigger_logs=self._count_trigger_logs,
-                    )
-                    logger.info(
-                        "workflow_run_cleanup (batch #%s, dry_run): counted related records in %sms",
-                        batch_index,
-                        int((time.monotonic() - count_start) * 1000),
-                    )
-                    if related_totals is not None:
-                        for key in related_totals:
-                            related_totals[key] += batch_counts.get(key, 0)
-                    sample_ids = ", ".join(run.id for run in free_runs[:5])
-                    click.echo(
-                        click.style(
-                            f"[batch #{batch_index}] would delete {len(free_runs)} runs "
-                            f"(sample ids: {sample_ids}) and skip {paid_or_skipped} paid/unknown",
-                            fg="yellow",
-                        )
-                    )
-                    logger.info(
-                        "workflow_run_cleanup (batch #%s, dry_run): batch total %sms",
-                        batch_index,
-                        int((time.monotonic() - batch_start) * 1000),
-                    )
-                    self._metrics.record_batch(
-                        batch_rows=len(run_rows),
-                        targeted_runs=len(free_runs),
-                        skipped_runs=paid_or_skipped,
-                        deleted_runs=0,
-                        related_counts={key: batch_counts.get(key, 0) for key in self._empty_related_counts()},
-                        related_action="would_delete",
-                        batch_duration_seconds=time.monotonic() - batch_start,
-                    )
-                    continue
-
-                try:
-                    delete_start = time.monotonic()
-                    counts = self.workflow_run_repo.delete_runs_with_related(
-                        free_runs,
-                        delete_node_executions=self._delete_node_executions,
-                        delete_trigger_logs=self._delete_trigger_logs,
-                    )
-                    delete_ms = int((time.monotonic() - delete_start) * 1000)
-                except Exception:
-                    logger.exception("Failed to delete workflow runs batch ending at %s", last_seen[0])
-                    raise
-
-                total_runs_deleted += counts["runs"]
                 click.echo(
                     click.style(
-                        f"[batch #{batch_index}] deleted runs: {counts['runs']} "
-                        f"(nodes {counts['node_executions']}, offloads {counts['offloads']}, "
-                        f"app_logs {counts['app_logs']}, trigger_logs {counts['trigger_logs']}, "
-                        f"pauses {counts['pauses']}, pause_reasons {counts['pause_reasons']}); "
-                        f"skipped {paid_or_skipped} paid/unknown",
-                        fg="green",
+                        skipped_message,
+                        fg="yellow",
+                    )
+                )
+                continue
+
+            total_runs_targeted += len(free_runs)
+
+            if self.dry_run:
+                count_start = time.monotonic()
+                batch_counts = self.workflow_run_repo.count_runs_with_related(
+                    free_runs,
+                    count_node_executions=self._count_node_executions,
+                    count_trigger_logs=self._count_trigger_logs,
+                )
+                logger.info(
+                    "workflow_run_cleanup (batch #%s, dry_run): counted related records in %sms",
+                    batch_index,
+                    int((time.monotonic() - count_start) * 1000),
+                )
+                if related_totals is not None:
+                    for key in related_totals:
+                        related_totals[key] += batch_counts.get(key, 0)
+                sample_ids = ", ".join(run.id for run in free_runs[:5])
+                click.echo(
+                    click.style(
+                        f"[batch #{batch_index}] would delete {len(free_runs)} runs "
+                        f"(sample ids: {sample_ids}) and skip {paid_or_skipped} paid/unknown",
+                        fg="yellow",
                     )
                 )
                 logger.info(
-                    "workflow_run_cleanup (batch #%s): delete %sms, batch total %sms",
+                    "workflow_run_cleanup (batch #%s, dry_run): batch total %sms",
                     batch_index,
-                    delete_ms,
                     int((time.monotonic() - batch_start) * 1000),
                 )
-                self._metrics.record_batch(
-                    batch_rows=len(run_rows),
-                    targeted_runs=len(free_runs),
-                    skipped_runs=paid_or_skipped,
-                    deleted_runs=counts["runs"],
-                    related_counts={key: counts.get(key, 0) for key in self._empty_related_counts()},
-                    related_action="deleted",
-                    batch_duration_seconds=time.monotonic() - batch_start,
+                continue
+
+            try:
+                delete_start = time.monotonic()
+                counts = self.workflow_run_repo.delete_runs_with_related(
+                    free_runs,
+                    delete_node_executions=self._delete_node_executions,
+                    delete_trigger_logs=self._delete_trigger_logs,
                 )
+                delete_ms = int((time.monotonic() - delete_start) * 1000)
+            except Exception:
+                logger.exception("Failed to delete workflow runs batch ending at %s", last_seen[0])
+                raise
 
-                # Random sleep between batches to avoid overwhelming the database
-                sleep_ms = random.uniform(0, max_batch_interval_ms)  # noqa: S311
-                logger.info("workflow_run_cleanup (batch #%s): sleeping for %.2fms", batch_index, sleep_ms)
-                time.sleep(sleep_ms / 1000)
-
-            if self.dry_run:
-                if self.window_start:
-                    summary_message = (
-                        f"Dry run complete. Would delete {total_runs_targeted} workflow runs "
-                        f"between {self.window_start.isoformat()} and {self.window_end.isoformat()}"
-                    )
-                else:
-                    summary_message = (
-                        f"Dry run complete. Would delete {total_runs_targeted} workflow runs "
-                        f"before {self.window_end.isoformat()}"
-                    )
-                if related_totals is not None:
-                    summary_message = (
-                        f"{summary_message}; related records: {self._format_related_counts(related_totals)}"
-                    )
-                summary_color = "yellow"
-            else:
-                if self.window_start:
-                    summary_message = (
-                        f"Cleanup complete. Deleted {total_runs_deleted} workflow runs "
-                        f"between {self.window_start.isoformat()} and {self.window_end.isoformat()}"
-                    )
-                else:
-                    summary_message = (
-                        f"Cleanup complete. Deleted {total_runs_deleted} workflow runs "
-                        f"before {self.window_end.isoformat()}"
-                    )
-                summary_color = "white"
-
-            click.echo(click.style(summary_message, fg=summary_color))
-        except Exception:
-            status = "failed"
-            raise
-        finally:
-            self._metrics.record_completion(
-                status=status,
-                job_duration_seconds=time.monotonic() - run_start,
+            total_runs_deleted += counts["runs"]
+            click.echo(
+                click.style(
+                    f"[batch #{batch_index}] deleted runs: {counts['runs']} "
+                    f"(nodes {counts['node_executions']}, offloads {counts['offloads']}, "
+                    f"app_logs {counts['app_logs']}, trigger_logs {counts['trigger_logs']}, "
+                    f"pauses {counts['pauses']}, pause_reasons {counts['pause_reasons']}); "
+                    f"skipped {paid_or_skipped} paid/unknown",
+                    fg="green",
+                )
             )
+            logger.info(
+                "workflow_run_cleanup (batch #%s): delete %sms, batch total %sms",
+                batch_index,
+                delete_ms,
+                int((time.monotonic() - batch_start) * 1000),
+            )
+
+            # Random sleep between batches to avoid overwhelming the database
+            sleep_ms = random.uniform(0, max_batch_interval_ms)  # noqa: S311
+            logger.info("workflow_run_cleanup (batch #%s): sleeping for %.2fms", batch_index, sleep_ms)
+            time.sleep(sleep_ms / 1000)
+
+        if self.dry_run:
+            if self.window_start:
+                summary_message = (
+                    f"Dry run complete. Would delete {total_runs_targeted} workflow runs "
+                    f"between {self.window_start.isoformat()} and {self.window_end.isoformat()}"
+                )
+            else:
+                summary_message = (
+                    f"Dry run complete. Would delete {total_runs_targeted} workflow runs "
+                    f"before {self.window_end.isoformat()}"
+                )
+            if related_totals is not None:
+                summary_message = f"{summary_message}; related records: {self._format_related_counts(related_totals)}"
+            summary_color = "yellow"
+        else:
+            if self.window_start:
+                summary_message = (
+                    f"Cleanup complete. Deleted {total_runs_deleted} workflow runs "
+                    f"between {self.window_start.isoformat()} and {self.window_end.isoformat()}"
+                )
+            else:
+                summary_message = (
+                    f"Cleanup complete. Deleted {total_runs_deleted} workflow runs before {self.window_end.isoformat()}"
+                )
+            summary_color = "white"
+
+        click.echo(click.style(summary_message, fg=summary_color))
 
     def _filter_free_tenants(self, tenant_ids: Iterable[str]) -> set[str]:
         tenant_id_list = list(tenant_ids)

api/tasks/generate_summary_index_task.py

@@ -14,7 +14,7 @@ from services.summary_index_service import SummaryIndexService
 logger = logging.getLogger(__name__)
 
 
-@shared_task(queue="dataset_summary")
+@shared_task(queue="dataset")
 def generate_summary_index_task(dataset_id: str, document_id: str, segment_ids: list[str] | None = None):
     """
     Async generate summary index for document segments.

api/tasks/process_tenant_plugin_autoupgrade_check_task.py

@@ -6,6 +6,7 @@ import typing
 import click
 from celery import shared_task
 
+from core.helper.marketplace import record_install_plugin_event
 from core.plugin.entities.marketplace import MarketplacePluginSnapshot
 from core.plugin.entities.plugin import PluginInstallationSource
 from core.plugin.impl.plugin import PluginInstaller
@@ -165,6 +166,7 @@ def process_tenant_plugin_autoupgrade_check_task(
                         # execute upgrade
                         new_unique_identifier = manifest.latest_package_identifier
 
+                        record_install_plugin_event(new_unique_identifier)
                         click.echo(
                             click.style(
                                 f"Upgrade plugin: {original_unique_identifier} -> {new_unique_identifier}",

api/tasks/regenerate_summary_index_task.py

@@ -16,7 +16,7 @@ from services.summary_index_service import SummaryIndexService
 logger = logging.getLogger(__name__)
 
 
-@shared_task(queue="dataset_summary")
+@shared_task(queue="dataset")
 def regenerate_summary_index_task(
     dataset_id: str,
     regenerate_reason: str = "summary_model_changed",

api/tests/integration_tests/controllers/console/app/test_description_validation.py

@@ -5,10 +5,14 @@ This test module validates the 400-character limit enforcement
 for App descriptions across all creation and editing endpoints.
 """
 
+import os
 import sys
 
 import pytest
 
+# Add the API root to Python path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))
+
 
 class TestAppDescriptionValidationUnit:
     """Unit tests for description validation function"""

api/tests/test_containers_integration_tests/conftest.py

@@ -10,11 +10,8 @@ more reliable and realistic test scenarios.
 import logging
 import os
 from collections.abc import Generator
-from contextlib import contextmanager
 from pathlib import Path
-from typing import Protocol, TypeVar
 
-import psycopg2
 import pytest
 from flask import Flask
 from flask.testing import FlaskClient
@@ -34,25 +31,6 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(level
 logger = logging.getLogger(__name__)
 
 
-class _CloserProtocol(Protocol):
-    """_Closer is any type which implement the close() method."""
-
-    def close(self):
-        """close the current object, release any external resouece (file, transaction, connection etc.)
-        associated with it.
-        """
-        pass
-
-
-_Closer = TypeVar("_Closer", bound=_CloserProtocol)
-
-
-@contextmanager
-def _auto_close(closer: _Closer) -> Generator[_Closer, None, None]:
-    yield closer
-    closer.close()
-
-
 class DifyTestContainers:
     """
     Manages all test containers required for Dify integration tests.
@@ -119,28 +97,45 @@ class DifyTestContainers:
         wait_for_logs(self.postgres, "is ready to accept connections", timeout=30)
         logger.info("PostgreSQL container is ready and accepting connections")
 
-        conn = psycopg2.connect(
-            host=db_host,
-            port=db_port,
-            user=self.postgres.username,
-            password=self.postgres.password,
-            database=self.postgres.dbname,
-        )
-        conn.autocommit = True
-        with _auto_close(conn):
-            with conn.cursor() as cursor:
-                # Install uuid-ossp extension for UUID generation
-                logger.info("Installing uuid-ossp extension...")
-                cursor.execute('CREATE EXTENSION IF NOT EXISTS "uuid-ossp";')
-            logger.info("uuid-ossp extension installed successfully")
+        # Install uuid-ossp extension for UUID generation
+        logger.info("Installing uuid-ossp extension...")
+        try:
+            import psycopg2
 
-            # NOTE: We cannot use `with conn.cursor() as cursor:` as it will wrap the statement
-            # inside a transaction. However, the `CREATE DATABASE` statement cannot run inside a transaction block.
-            with _auto_close(conn.cursor()) as cursor:
-                # Create plugin database for dify-plugin-daemon
-                logger.info("Creating plugin database...")
-                cursor.execute("CREATE DATABASE dify_plugin;")
+            conn = psycopg2.connect(
+                host=db_host,
+                port=db_port,
+                user=self.postgres.username,
+                password=self.postgres.password,
+                database=self.postgres.dbname,
+            )
+            conn.autocommit = True
+            cursor = conn.cursor()
+            cursor.execute('CREATE EXTENSION IF NOT EXISTS "uuid-ossp";')
+            cursor.close()
+            conn.close()
+            logger.info("uuid-ossp extension installed successfully")
+        except Exception as e:
+            logger.warning("Failed to install uuid-ossp extension: %s", e)
+
+        # Create plugin database for dify-plugin-daemon
+        logger.info("Creating plugin database...")
+        try:
+            conn = psycopg2.connect(
+                host=db_host,
+                port=db_port,
+                user=self.postgres.username,
+                password=self.postgres.password,
+                database=self.postgres.dbname,
+            )
+            conn.autocommit = True
+            cursor = conn.cursor()
+            cursor.execute("CREATE DATABASE dify_plugin;")
+            cursor.close()
+            conn.close()
             logger.info("Plugin database created successfully")
+        except Exception as e:
+            logger.warning("Failed to create plugin database: %s", e)
 
         # Set up storage environment variables
         os.environ.setdefault("STORAGE_TYPE", "opendal")
@@ -263,16 +258,23 @@ class DifyTestContainers:
         containers = [self.redis, self.postgres, self.dify_sandbox, self.dify_plugin_daemon]
         for container in containers:
             if container:
-                container_name = container.image
-                logger.info("Stopping container: %s", container_name)
-                container.stop()
-                logger.info("Successfully stopped container: %s", container_name)
+                try:
+                    container_name = container.image
+                    logger.info("Stopping container: %s", container_name)
+                    container.stop()
+                    logger.info("Successfully stopped container: %s", container_name)
+                except Exception as e:
+                    # Log error but don't fail the test cleanup
+                    logger.warning("Failed to stop container %s: %s", container, e)
 
         # Stop and remove the network
         if self.network:
-            logger.info("Removing Docker network...")
-            self.network.remove()
-            logger.info("Successfully removed Docker network")
+            try:
+                logger.info("Removing Docker network...")
+                self.network.remove()
+                logger.info("Successfully removed Docker network")
+            except Exception as e:
+                logger.warning("Failed to remove Docker network: %s", e)
 
         self._containers_started = False
         logger.info("All test containers stopped and cleaned up successfully")

api/tests/test_containers_integration_tests/services/test_dataset_permission_service.py

@@ -1,497 +0,0 @@
-"""
-Container-backed integration tests for dataset permission services on the real SQL path.
-
-This module exercises persisted DatasetPermission rows and dataset permission
-checks with testcontainers-backed infrastructure instead of database-chain mocks.
-"""
-
-from uuid import uuid4
-
-import pytest
-
-from extensions.ext_database import db
-from models import Account, Tenant, TenantAccountJoin, TenantAccountRole
-from models.dataset import (
-    Dataset,
-    DatasetPermission,
-    DatasetPermissionEnum,
-)
-from services.dataset_service import DatasetPermissionService, DatasetService
-from services.errors.account import NoPermissionError
-
-
-class DatasetPermissionTestDataFactory:
-    """Create persisted entities and request payloads for dataset permission integration tests."""
-
-    @staticmethod
-    def create_account_with_tenant(
-        role: TenantAccountRole = TenantAccountRole.NORMAL,
-        tenant: Tenant | None = None,
-    ) -> tuple[Account, Tenant]:
-        """Create a real account and tenant with specified role."""
-        account = Account(
-            email=f"{uuid4()}@example.com",
-            name=f"user-{uuid4()}",
-            interface_language="en-US",
-            status="active",
-        )
-        if tenant is None:
-            tenant = Tenant(name=f"tenant-{uuid4()}", status="normal")
-            db.session.add_all([account, tenant])
-        else:
-            db.session.add(account)
-
-        db.session.flush()
-
-        join = TenantAccountJoin(
-            tenant_id=tenant.id,
-            account_id=account.id,
-            role=role,
-            current=True,
-        )
-        db.session.add(join)
-        db.session.commit()
-
-        account.current_tenant = tenant
-        return account, tenant
-
-    @staticmethod
-    def create_dataset(
-        tenant_id: str,
-        created_by: str,
-        permission: DatasetPermissionEnum = DatasetPermissionEnum.ONLY_ME,
-        name: str = "Test Dataset",
-    ) -> Dataset:
-        """Create a real dataset with specified attributes."""
-        dataset = Dataset(
-            tenant_id=tenant_id,
-            name=name,
-            description="desc",
-            data_source_type="upload_file",
-            indexing_technique="high_quality",
-            created_by=created_by,
-            permission=permission,
-            provider="vendor",
-            retrieval_model={"top_k": 2},
-        )
-        db.session.add(dataset)
-        db.session.commit()
-        return dataset
-
-    @staticmethod
-    def create_dataset_permission(
-        dataset_id: str,
-        account_id: str,
-        tenant_id: str,
-        has_permission: bool = True,
-    ) -> DatasetPermission:
-        """Create a real DatasetPermission instance."""
-        permission = DatasetPermission(
-            dataset_id=dataset_id,
-            account_id=account_id,
-            tenant_id=tenant_id,
-            has_permission=has_permission,
-        )
-        db.session.add(permission)
-        db.session.commit()
-        return permission
-
-    @staticmethod
-    def build_user_list_payload(user_ids: list[str]) -> list[dict[str, str]]:
-        """Build the request payload shape used by partial-member list updates."""
-        return [{"user_id": user_id} for user_id in user_ids]
-
-
-class TestDatasetPermissionServiceGetPartialMemberList:
-    """Verify partial-member list reads against persisted DatasetPermission rows."""
-
-    def test_get_dataset_partial_member_list_with_members(self, db_session_with_containers):
-        """
-        Test retrieving partial member list with multiple members.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        user_1, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        user_2, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        user_3, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        dataset = DatasetPermissionTestDataFactory.create_dataset(tenant.id, owner.id)
-
-        expected_account_ids = [user_1.id, user_2.id, user_3.id]
-        for account_id in expected_account_ids:
-            DatasetPermissionTestDataFactory.create_dataset_permission(dataset.id, account_id, tenant.id)
-
-        # Act
-        result = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-
-        # Assert
-        assert set(result) == set(expected_account_ids)
-        assert len(result) == 3
-
-    def test_get_dataset_partial_member_list_with_single_member(self, db_session_with_containers):
-        """
-        Test retrieving partial member list with single member.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        user, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        dataset = DatasetPermissionTestDataFactory.create_dataset(tenant.id, owner.id)
-
-        expected_account_ids = [user.id]
-        DatasetPermissionTestDataFactory.create_dataset_permission(dataset.id, user.id, tenant.id)
-
-        # Act
-        result = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-
-        # Assert
-        assert set(result) == set(expected_account_ids)
-        assert len(result) == 1
-
-    def test_get_dataset_partial_member_list_empty(self, db_session_with_containers):
-        """
-        Test retrieving partial member list when no members exist.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        dataset = DatasetPermissionTestDataFactory.create_dataset(tenant.id, owner.id)
-
-        # Act
-        result = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-
-        # Assert
-        assert result == []
-        assert len(result) == 0
-
-
-class TestDatasetPermissionServiceUpdatePartialMemberList:
-    """Verify partial-member list updates against persisted DatasetPermission rows."""
-
-    def test_update_partial_member_list_add_new_members(self, db_session_with_containers):
-        """
-        Test adding new partial members to a dataset.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        member_1, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        member_2, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        dataset = DatasetPermissionTestDataFactory.create_dataset(tenant.id, owner.id)
-        user_list = DatasetPermissionTestDataFactory.build_user_list_payload([member_1.id, member_2.id])
-
-        # Act
-        DatasetPermissionService.update_partial_member_list(tenant.id, dataset.id, user_list)
-
-        # Assert
-        result = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-        assert set(result) == {member_1.id, member_2.id}
-
-    def test_update_partial_member_list_replace_existing(self, db_session_with_containers):
-        """
-        Test replacing existing partial members with new ones.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        old_member_1, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        old_member_2, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        new_member_1, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        new_member_2, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        dataset = DatasetPermissionTestDataFactory.create_dataset(tenant.id, owner.id)
-
-        old_users = DatasetPermissionTestDataFactory.build_user_list_payload([old_member_1.id, old_member_2.id])
-        DatasetPermissionService.update_partial_member_list(tenant.id, dataset.id, old_users)
-
-        new_users = DatasetPermissionTestDataFactory.build_user_list_payload([new_member_1.id, new_member_2.id])
-
-        # Act
-        DatasetPermissionService.update_partial_member_list(tenant.id, dataset.id, new_users)
-
-        # Assert
-        result = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-        assert set(result) == {new_member_1.id, new_member_2.id}
-
-    def test_update_partial_member_list_empty_list(self, db_session_with_containers):
-        """
-        Test updating with empty member list (clearing all members).
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        member_1, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        member_2, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        dataset = DatasetPermissionTestDataFactory.create_dataset(tenant.id, owner.id)
-        users = DatasetPermissionTestDataFactory.build_user_list_payload([member_1.id, member_2.id])
-        DatasetPermissionService.update_partial_member_list(tenant.id, dataset.id, users)
-
-        # Act
-        DatasetPermissionService.update_partial_member_list(tenant.id, dataset.id, [])
-
-        # Assert
-        result = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-        assert result == []
-
-    def test_update_partial_member_list_database_error_rollback(self, db_session_with_containers):
-        """
-        Test error handling and rollback on database error.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        existing_member, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        replacement_member, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        dataset = DatasetPermissionTestDataFactory.create_dataset(tenant.id, owner.id)
-        DatasetPermissionService.update_partial_member_list(
-            tenant.id,
-            dataset.id,
-            DatasetPermissionTestDataFactory.build_user_list_payload([existing_member.id]),
-        )
-        user_list = DatasetPermissionTestDataFactory.build_user_list_payload([replacement_member.id])
-        rollback_called = {"count": 0}
-        original_rollback = db.session.rollback
-
-        # Act / Assert
-        with pytest.MonkeyPatch.context() as mp:
-
-            def _raise_commit():
-                raise Exception("Database connection error")
-
-            def _rollback_and_mark():
-                rollback_called["count"] += 1
-                original_rollback()
-
-            mp.setattr("services.dataset_service.db.session.commit", _raise_commit)
-            mp.setattr("services.dataset_service.db.session.rollback", _rollback_and_mark)
-            with pytest.raises(Exception, match="Database connection error"):
-                DatasetPermissionService.update_partial_member_list(tenant.id, dataset.id, user_list)
-
-        # Assert
-        result = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-        assert rollback_called["count"] == 1
-        assert result == [existing_member.id]
-        assert db_session_with_containers.query(DatasetPermission).filter_by(dataset_id=dataset.id).count() == 1
-
-
-class TestDatasetPermissionServiceClearPartialMemberList:
-    """Verify partial-member clearing against persisted DatasetPermission rows."""
-
-    def test_clear_partial_member_list_success(self, db_session_with_containers):
-        """
-        Test successful clearing of partial member list.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        member_1, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        member_2, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        dataset = DatasetPermissionTestDataFactory.create_dataset(tenant.id, owner.id)
-        users = DatasetPermissionTestDataFactory.build_user_list_payload([member_1.id, member_2.id])
-        DatasetPermissionService.update_partial_member_list(tenant.id, dataset.id, users)
-
-        # Act
-        DatasetPermissionService.clear_partial_member_list(dataset.id)
-
-        # Assert
-        result = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-        assert result == []
-
-    def test_clear_partial_member_list_empty_list(self, db_session_with_containers):
-        """
-        Test clearing partial member list when no members exist.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        dataset = DatasetPermissionTestDataFactory.create_dataset(tenant.id, owner.id)
-
-        # Act
-        DatasetPermissionService.clear_partial_member_list(dataset.id)
-
-        # Assert
-        result = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-        assert result == []
-
-    def test_clear_partial_member_list_database_error_rollback(self, db_session_with_containers):
-        """
-        Test error handling and rollback on database error.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        member_1, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        member_2, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-        dataset = DatasetPermissionTestDataFactory.create_dataset(tenant.id, owner.id)
-        users = DatasetPermissionTestDataFactory.build_user_list_payload([member_1.id, member_2.id])
-        DatasetPermissionService.update_partial_member_list(tenant.id, dataset.id, users)
-        rollback_called = {"count": 0}
-        original_rollback = db.session.rollback
-
-        # Act / Assert
-        with pytest.MonkeyPatch.context() as mp:
-
-            def _raise_commit():
-                raise Exception("Database connection error")
-
-            def _rollback_and_mark():
-                rollback_called["count"] += 1
-                original_rollback()
-
-            mp.setattr("services.dataset_service.db.session.commit", _raise_commit)
-            mp.setattr("services.dataset_service.db.session.rollback", _rollback_and_mark)
-            with pytest.raises(Exception, match="Database connection error"):
-                DatasetPermissionService.clear_partial_member_list(dataset.id)
-
-        # Assert
-        result = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-        assert rollback_called["count"] == 1
-        assert set(result) == {member_1.id, member_2.id}
-        assert db_session_with_containers.query(DatasetPermission).filter_by(dataset_id=dataset.id).count() == 2
-
-
-class TestDatasetServiceCheckDatasetPermission:
-    """Verify dataset access checks against persisted partial-member permissions."""
-
-    def test_check_dataset_permission_partial_members_with_permission_success(self, db_session_with_containers):
-        """
-        Test that user with explicit permission can access partial_members dataset.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        user, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-
-        dataset = DatasetPermissionTestDataFactory.create_dataset(
-            tenant.id,
-            owner.id,
-            permission=DatasetPermissionEnum.PARTIAL_TEAM,
-        )
-        DatasetPermissionTestDataFactory.create_dataset_permission(dataset.id, user.id, tenant.id)
-
-        # Act (should not raise)
-        DatasetService.check_dataset_permission(dataset, user)
-
-        # Assert
-        permissions = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-        assert user.id in permissions
-
-    def test_check_dataset_permission_partial_members_without_permission_error(self, db_session_with_containers):
-        """
-        Test error when user without permission tries to access partial_members dataset.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        user, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-
-        dataset = DatasetPermissionTestDataFactory.create_dataset(
-            tenant.id,
-            owner.id,
-            permission=DatasetPermissionEnum.PARTIAL_TEAM,
-        )
-
-        # Act & Assert
-        with pytest.raises(NoPermissionError, match="You do not have permission to access this dataset"):
-            DatasetService.check_dataset_permission(dataset, user)
-
-
-class TestDatasetServiceCheckDatasetOperatorPermission:
-    """Verify operator permission checks against persisted partial-member permissions."""
-
-    def test_check_dataset_operator_permission_partial_members_with_permission_success(
-        self, db_session_with_containers
-    ):
-        """
-        Test that user with explicit permission can access partial_members dataset.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        user, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-
-        dataset = DatasetPermissionTestDataFactory.create_dataset(
-            tenant.id,
-            owner.id,
-            permission=DatasetPermissionEnum.PARTIAL_TEAM,
-        )
-        DatasetPermissionTestDataFactory.create_dataset_permission(dataset.id, user.id, tenant.id)
-
-        # Act (should not raise)
-        DatasetService.check_dataset_operator_permission(user=user, dataset=dataset)
-
-        # Assert
-        permissions = DatasetPermissionService.get_dataset_partial_member_list(dataset.id)
-        assert user.id in permissions
-
-    def test_check_dataset_operator_permission_partial_members_without_permission_error(
-        self, db_session_with_containers
-    ):
-        """
-        Test error when user without permission tries to access partial_members dataset.
-        """
-        # Arrange
-        owner, tenant = DatasetPermissionTestDataFactory.create_account_with_tenant(role=TenantAccountRole.OWNER)
-        user, _ = DatasetPermissionTestDataFactory.create_account_with_tenant(
-            role=TenantAccountRole.NORMAL,
-            tenant=tenant,
-        )
-
-        dataset = DatasetPermissionTestDataFactory.create_dataset(
-            tenant.id,
-            owner.id,
-            permission=DatasetPermissionEnum.PARTIAL_TEAM,
-        )
-
-        # Act & Assert
-        with pytest.raises(NoPermissionError, match="You do not have permission to access this dataset"):
-            DatasetService.check_dataset_operator_permission(user=user, dataset=dataset)

api/tests/test_containers_integration_tests/services/test_message_export_service.py

@@ -1,233 +0,0 @@
-import datetime
-import json
-import uuid
-from decimal import Decimal
-
-import pytest
-from sqlalchemy.orm import Session
-
-from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole
-from models.model import (
-    App,
-    AppAnnotationHitHistory,
-    Conversation,
-    DatasetRetrieverResource,
-    Message,
-    MessageAgentThought,
-    MessageAnnotation,
-    MessageChain,
-    MessageFeedback,
-    MessageFile,
-)
-from models.web import SavedMessage
-from services.retention.conversation.message_export_service import AppMessageExportService, AppMessageExportStats
-
-
-class TestAppMessageExportServiceIntegration:
-    @pytest.fixture(autouse=True)
-    def cleanup_database(self, db_session_with_containers: Session):
-        yield
-        db_session_with_containers.query(DatasetRetrieverResource).delete()
-        db_session_with_containers.query(AppAnnotationHitHistory).delete()
-        db_session_with_containers.query(SavedMessage).delete()
-        db_session_with_containers.query(MessageFile).delete()
-        db_session_with_containers.query(MessageAgentThought).delete()
-        db_session_with_containers.query(MessageChain).delete()
-        db_session_with_containers.query(MessageAnnotation).delete()
-        db_session_with_containers.query(MessageFeedback).delete()
-        db_session_with_containers.query(Message).delete()
-        db_session_with_containers.query(Conversation).delete()
-        db_session_with_containers.query(App).delete()
-        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()
-
-    @staticmethod
-    def _create_app_context(session: Session) -> tuple[App, Conversation]:
-        account = Account(
-            email=f"test-{uuid.uuid4()}@example.com",
-            name="tester",
-            interface_language="en-US",
-            status="active",
-        )
-        session.add(account)
-        session.flush()
-
-        tenant = Tenant(name=f"tenant-{uuid.uuid4()}", status="normal")
-        session.add(tenant)
-        session.flush()
-
-        join = TenantAccountJoin(
-            tenant_id=tenant.id,
-            account_id=account.id,
-            role=TenantAccountRole.OWNER,
-            current=True,
-        )
-        session.add(join)
-        session.flush()
-
-        app = App(
-            tenant_id=tenant.id,
-            name="export-app",
-            description="integration test app",
-            mode="chat",
-            enable_site=True,
-            enable_api=True,
-            api_rpm=60,
-            api_rph=3600,
-            is_demo=False,
-            is_public=False,
-            created_by=account.id,
-            updated_by=account.id,
-        )
-        session.add(app)
-        session.flush()
-
-        conversation = Conversation(
-            app_id=app.id,
-            app_model_config_id=str(uuid.uuid4()),
-            model_provider="openai",
-            model_id="gpt-4o-mini",
-            mode="chat",
-            name="conv",
-            inputs={"seed": 1},
-            status="normal",
-            from_source="api",
-            from_end_user_id=str(uuid.uuid4()),
-        )
-        session.add(conversation)
-        session.commit()
-        return app, conversation
-
-    @staticmethod
-    def _create_message(
-        session: Session,
-        app: App,
-        conversation: Conversation,
-        created_at: datetime.datetime,
-        *,
-        query: str,
-        answer: str,
-        inputs: dict,
-        message_metadata: str | None,
-    ) -> Message:
-        message = Message(
-            app_id=app.id,
-            conversation_id=conversation.id,
-            model_provider="openai",
-            model_id="gpt-4o-mini",
-            inputs=inputs,
-            query=query,
-            answer=answer,
-            message=[{"role": "assistant", "content": answer}],
-            message_tokens=10,
-            message_unit_price=Decimal("0.001"),
-            answer_tokens=20,
-            answer_unit_price=Decimal("0.002"),
-            total_price=Decimal("0.003"),
-            currency="USD",
-            message_metadata=message_metadata,
-            from_source="api",
-            from_end_user_id=conversation.from_end_user_id,
-            created_at=created_at,
-        )
-        session.add(message)
-        session.flush()
-        return message
-
-    def test_iter_records_with_stats(self, db_session_with_containers: Session):
-        app, conversation = self._create_app_context(db_session_with_containers)
-
-        first_inputs = {
-            "plain": "v1",
-            "nested": {"a": 1, "b": [1, {"x": True}]},
-            "list": ["x", 2, {"y": "z"}],
-        }
-        second_inputs = {"other": "value", "items": [1, 2, 3]}
-
-        base_time = datetime.datetime(2026, 2, 25, 10, 0, 0)
-        first_message = self._create_message(
-            db_session_with_containers,
-            app,
-            conversation,
-            created_at=base_time,
-            query="q1",
-            answer="a1",
-            inputs=first_inputs,
-            message_metadata=json.dumps({"retriever_resources": [{"dataset_id": "ds-1"}]}),
-        )
-        second_message = self._create_message(
-            db_session_with_containers,
-            app,
-            conversation,
-            created_at=base_time + datetime.timedelta(minutes=1),
-            query="q2",
-            answer="a2",
-            inputs=second_inputs,
-            message_metadata=None,
-        )
-
-        user_feedback_1 = MessageFeedback(
-            app_id=app.id,
-            conversation_id=conversation.id,
-            message_id=first_message.id,
-            rating="like",
-            from_source="user",
-            content="first",
-            from_end_user_id=conversation.from_end_user_id,
-        )
-        user_feedback_2 = MessageFeedback(
-            app_id=app.id,
-            conversation_id=conversation.id,
-            message_id=first_message.id,
-            rating="dislike",
-            from_source="user",
-            content="second",
-            from_end_user_id=conversation.from_end_user_id,
-        )
-        admin_feedback = MessageFeedback(
-            app_id=app.id,
-            conversation_id=conversation.id,
-            message_id=first_message.id,
-            rating="like",
-            from_source="admin",
-            content="should-be-filtered",
-            from_account_id=str(uuid.uuid4()),
-        )
-        db_session_with_containers.add_all([user_feedback_1, user_feedback_2, admin_feedback])
-        user_feedback_1.created_at = base_time + datetime.timedelta(minutes=2)
-        user_feedback_2.created_at = base_time + datetime.timedelta(minutes=3)
-        admin_feedback.created_at = base_time + datetime.timedelta(minutes=4)
-        db_session_with_containers.commit()
-
-        service = AppMessageExportService(
-            app_id=app.id,
-            start_from=base_time - datetime.timedelta(minutes=1),
-            end_before=base_time + datetime.timedelta(minutes=10),
-            filename="unused",
-            batch_size=1,
-            dry_run=True,
-        )
-        stats = AppMessageExportStats()
-        records = list(service._iter_records_with_stats(stats))
-        service._finalize_stats(stats)
-
-        assert len(records) == 2
-        assert records[0].message_id == first_message.id
-        assert records[1].message_id == second_message.id
-
-        assert records[0].inputs == first_inputs
-        assert records[1].inputs == second_inputs
-
-        assert records[0].retriever_resources == [{"dataset_id": "ds-1"}]
-        assert records[1].retriever_resources == []
-
-        assert [feedback.rating for feedback in records[0].feedback] == ["like", "dislike"]
-        assert [feedback.content for feedback in records[0].feedback] == ["first", "second"]
-        assert records[1].feedback == []
-
-        assert stats.batches == 2
-        assert stats.total_messages == 2
-        assert stats.messages_with_feedback == 1
-        assert stats.total_feedbacks == 2

api/tests/unit_tests/commands/test_clean_expired_messages.py

@@ -1,188 +0,0 @@
-import datetime
-import re
-from unittest.mock import MagicMock, patch
-
-import click
-import pytest
-
-from commands import clean_expired_messages
-
-
-def _mock_service() -> MagicMock:
-    service = MagicMock()
-    service.run.return_value = {
-        "batches": 1,
-        "total_messages": 10,
-        "filtered_messages": 5,
-        "total_deleted": 5,
-    }
-    return service
-
-
-def test_absolute_mode_calls_from_time_range():
-    policy = object()
-    service = _mock_service()
-    start_from = datetime.datetime(2024, 1, 1, 0, 0, 0)
-    end_before = datetime.datetime(2024, 2, 1, 0, 0, 0)
-
-    with (
-        patch("commands.create_message_clean_policy", return_value=policy),
-        patch("commands.MessagesCleanService.from_time_range", return_value=service) as mock_from_time_range,
-        patch("commands.MessagesCleanService.from_days") as mock_from_days,
-    ):
-        clean_expired_messages.callback(
-            batch_size=200,
-            graceful_period=21,
-            start_from=start_from,
-            end_before=end_before,
-            from_days_ago=None,
-            before_days=None,
-            dry_run=True,
-            task_label="daily",
-        )
-
-    mock_from_time_range.assert_called_once_with(
-        policy=policy,
-        start_from=start_from,
-        end_before=end_before,
-        batch_size=200,
-        dry_run=True,
-        task_label="daily",
-    )
-    mock_from_days.assert_not_called()
-
-
-def test_relative_mode_before_days_only_calls_from_days():
-    policy = object()
-    service = _mock_service()
-
-    with (
-        patch("commands.create_message_clean_policy", return_value=policy),
-        patch("commands.MessagesCleanService.from_days", return_value=service) as mock_from_days,
-        patch("commands.MessagesCleanService.from_time_range") as mock_from_time_range,
-    ):
-        clean_expired_messages.callback(
-            batch_size=500,
-            graceful_period=14,
-            start_from=None,
-            end_before=None,
-            from_days_ago=None,
-            before_days=30,
-            dry_run=False,
-            task_label="daily",
-        )
-
-    mock_from_days.assert_called_once_with(
-        policy=policy,
-        days=30,
-        batch_size=500,
-        dry_run=False,
-        task_label="daily",
-    )
-    mock_from_time_range.assert_not_called()
-
-
-def test_relative_mode_with_from_days_ago_calls_from_time_range():
-    policy = object()
-    service = _mock_service()
-    fixed_now = datetime.datetime(2024, 8, 20, 12, 0, 0)
-
-    with (
-        patch("commands.create_message_clean_policy", return_value=policy),
-        patch("commands.MessagesCleanService.from_time_range", return_value=service) as mock_from_time_range,
-        patch("commands.MessagesCleanService.from_days") as mock_from_days,
-        patch("commands.naive_utc_now", return_value=fixed_now),
-    ):
-        clean_expired_messages.callback(
-            batch_size=1000,
-            graceful_period=21,
-            start_from=None,
-            end_before=None,
-            from_days_ago=60,
-            before_days=30,
-            dry_run=False,
-            task_label="daily",
-        )
-
-    mock_from_time_range.assert_called_once_with(
-        policy=policy,
-        start_from=fixed_now - datetime.timedelta(days=60),
-        end_before=fixed_now - datetime.timedelta(days=30),
-        batch_size=1000,
-        dry_run=False,
-        task_label="daily",
-    )
-    mock_from_days.assert_not_called()
-
-
-@pytest.mark.parametrize(
-    ("kwargs", "message"),
-    [
-        (
-            {
-                "start_from": datetime.datetime(2024, 1, 1),
-                "end_before": datetime.datetime(2024, 2, 1),
-                "from_days_ago": None,
-                "before_days": 30,
-            },
-            "mutually exclusive",
-        ),
-        (
-            {
-                "start_from": datetime.datetime(2024, 1, 1),
-                "end_before": None,
-                "from_days_ago": None,
-                "before_days": None,
-            },
-            "Both --start-from and --end-before are required",
-        ),
-        (
-            {
-                "start_from": None,
-                "end_before": None,
-                "from_days_ago": 10,
-                "before_days": None,
-            },
-            "--from-days-ago must be used together with --before-days",
-        ),
-        (
-            {
-                "start_from": None,
-                "end_before": None,
-                "from_days_ago": None,
-                "before_days": -1,
-            },
-            "--before-days must be >= 0",
-        ),
-        (
-            {
-                "start_from": None,
-                "end_before": None,
-                "from_days_ago": 30,
-                "before_days": 30,
-            },
-            "--from-days-ago must be greater than --before-days",
-        ),
-        (
-            {
-                "start_from": None,
-                "end_before": None,
-                "from_days_ago": None,
-                "before_days": None,
-            },
-            "You must provide either (--start-from,--end-before) or (--before-days [--from-days-ago])",
-        ),
-    ],
-)
-def test_invalid_inputs_raise_usage_error(kwargs: dict, message: str):
-    with pytest.raises(click.UsageError, match=re.escape(message)):
-        clean_expired_messages.callback(
-            batch_size=1000,
-            graceful_period=21,
-            start_from=kwargs["start_from"],
-            end_before=kwargs["end_before"],
-            from_days_ago=kwargs["from_days_ago"],
-            before_days=kwargs["before_days"],
-            dry_run=False,
-            task_label="daily",
-        )

api/tests/unit_tests/conftest.py

@@ -32,6 +32,11 @@ os.environ.setdefault("OPENDAL_SCHEME", "fs")
 os.environ.setdefault("OPENDAL_FS_ROOT", "/tmp/dify-storage")
 os.environ.setdefault("STORAGE_TYPE", "opendal")
 
+# Add the API directory to Python path to ensure proper imports
+import sys
+
+sys.path.insert(0, PROJECT_DIR)
+
 from core.db.session_factory import configure_session_factory, session_factory
 from extensions import ext_redis
 

api/tests/unit_tests/controllers/common/test_errors.py

@@ -1,70 +0,0 @@
-from controllers.common.errors import (
-    BlockedFileExtensionError,
-    FilenameNotExistsError,
-    FileTooLargeError,
-    NoFileUploadedError,
-    RemoteFileUploadError,
-    TooManyFilesError,
-    UnsupportedFileTypeError,
-)
-
-
-class TestFilenameNotExistsError:
-    def test_defaults(self):
-        error = FilenameNotExistsError()
-
-        assert error.code == 400
-        assert error.description == "The specified filename does not exist."
-
-
-class TestRemoteFileUploadError:
-    def test_defaults(self):
-        error = RemoteFileUploadError()
-
-        assert error.code == 400
-        assert error.description == "Error uploading remote file."
-
-
-class TestFileTooLargeError:
-    def test_defaults(self):
-        error = FileTooLargeError()
-
-        assert error.code == 413
-        assert error.error_code == "file_too_large"
-        assert error.description == "File size exceeded. {message}"
-
-
-class TestUnsupportedFileTypeError:
-    def test_defaults(self):
-        error = UnsupportedFileTypeError()
-
-        assert error.code == 415
-        assert error.error_code == "unsupported_file_type"
-        assert error.description == "File type not allowed."
-
-
-class TestBlockedFileExtensionError:
-    def test_defaults(self):
-        error = BlockedFileExtensionError()
-
-        assert error.code == 400
-        assert error.error_code == "file_extension_blocked"
-        assert error.description == "The file extension is blocked for security reasons."
-
-
-class TestTooManyFilesError:
-    def test_defaults(self):
-        error = TooManyFilesError()
-
-        assert error.code == 400
-        assert error.error_code == "too_many_files"
-        assert error.description == "Only one file is allowed."
-
-
-class TestNoFileUploadedError:
-    def test_defaults(self):
-        error = NoFileUploadedError()
-
-        assert error.code == 400
-        assert error.error_code == "no_file_uploaded"
-        assert error.description == "Please upload your file."

api/tests/unit_tests/controllers/common/test_file_response.py

@@ -1,95 +1,22 @@
 from flask import Response
 
-from controllers.common.file_response import (
-    _normalize_mime_type,
-    enforce_download_for_html,
-    is_html_content,
-)
+from controllers.common.file_response import enforce_download_for_html, is_html_content
 
 
-class TestNormalizeMimeType:
-    def test_returns_empty_string_for_none(self):
-        assert _normalize_mime_type(None) == ""
-
-    def test_returns_empty_string_for_empty_string(self):
-        assert _normalize_mime_type("") == ""
-
-    def test_normalizes_mime_type(self):
-        assert _normalize_mime_type("Text/HTML; Charset=UTF-8") == "text/html"
-
-
-class TestIsHtmlContent:
-    def test_detects_html_via_mime_type(self):
+class TestFileResponseHelpers:
+    def test_is_html_content_detects_mime_type(self):
         mime_type = "text/html; charset=UTF-8"
 
-        result = is_html_content(
-            mime_type=mime_type,
-            filename="file.txt",
-            extension="txt",
-        )
+        result = is_html_content(mime_type, filename="file.txt", extension="txt")
 
         assert result is True
 
-    def test_detects_html_via_extension_argument(self):
-        result = is_html_content(
-            mime_type="text/plain",
-            filename=None,
-            extension="html",
-        )
+    def test_is_html_content_detects_extension(self):
+        result = is_html_content("text/plain", filename="report.html", extension=None)
 
         assert result is True
 
-    def test_detects_html_via_filename_extension(self):
-        result = is_html_content(
-            mime_type="text/plain",
-            filename="report.html",
-            extension=None,
-        )
-
-        assert result is True
-
-    def test_returns_false_when_no_html_detected_anywhere(self):
-        """
-        Missing negative test:
-        - MIME type is not HTML
-        - filename has no HTML extension
-        - extension argument is not HTML
-        """
-        result = is_html_content(
-            mime_type="application/json",
-            filename="data.json",
-            extension="json",
-        )
-
-        assert result is False
-
-    def test_returns_false_when_all_inputs_are_none(self):
-        result = is_html_content(
-            mime_type=None,
-            filename=None,
-            extension=None,
-        )
-
-        assert result is False
-
-
-class TestEnforceDownloadForHtml:
-    def test_sets_attachment_when_filename_missing(self):
-        response = Response("payload", mimetype="text/html")
-
-        updated = enforce_download_for_html(
-            response,
-            mime_type="text/html",
-            filename=None,
-            extension="html",
-        )
-
-        assert updated is True
-        assert response.headers["Content-Disposition"] == "attachment"
-        assert response.headers["Content-Type"] == "application/octet-stream"
-        assert response.headers["X-Content-Type-Options"] == "nosniff"
-
-    def test_sets_headers_when_filename_present(self):
+    def test_enforce_download_for_html_sets_headers(self):
         response = Response("payload", mimetype="text/html")
 
         updated = enforce_download_for_html(
@@ -100,12 +27,11 @@ class TestEnforceDownloadForHtml:
         )
 
         assert updated is True
-        assert response.headers["Content-Disposition"].startswith("attachment")
-        assert "unsafe.html" in response.headers["Content-Disposition"]
+        assert "attachment" in response.headers["Content-Disposition"]
         assert response.headers["Content-Type"] == "application/octet-stream"
         assert response.headers["X-Content-Type-Options"] == "nosniff"
 
-    def test_does_not_modify_response_for_non_html_content(self):
+    def test_enforce_download_for_html_no_change_for_non_html(self):
         response = Response("payload", mimetype="text/plain")
 
         updated = enforce_download_for_html(

api/tests/unit_tests/controllers/common/test_helpers.py

@@ -1,188 +0,0 @@
-from uuid import UUID
-
-import httpx
-import pytest
-
-from controllers.common import helpers
-from controllers.common.helpers import FileInfo, guess_file_info_from_response
-
-
-def make_response(
-    url="https://example.com/file.txt",
-    headers=None,
-    content=None,
-):
-    return httpx.Response(
-        200,
-        request=httpx.Request("GET", url),
-        headers=headers or {},
-        content=content or b"",
-    )
-
-
-class TestGuessFileInfoFromResponse:
-    def test_filename_from_url(self):
-        response = make_response(
-            url="https://example.com/test.pdf",
-            content=b"Hello World",
-        )
-
-        info = guess_file_info_from_response(response)
-
-        assert info.filename == "test.pdf"
-        assert info.extension == ".pdf"
-        assert info.mimetype == "application/pdf"
-
-    def test_filename_from_content_disposition(self):
-        headers = {
-            "Content-Disposition": "attachment; filename=myfile.csv",
-            "Content-Type": "text/csv",
-        }
-        response = make_response(
-            url="https://example.com/",
-            headers=headers,
-            content=b"Hello World",
-        )
-
-        info = guess_file_info_from_response(response)
-
-        assert info.filename == "myfile.csv"
-        assert info.extension == ".csv"
-        assert info.mimetype == "text/csv"
-
-    @pytest.mark.parametrize(
-        ("magic_available", "expected_ext"),
-        [
-            (True, "txt"),
-            (False, "bin"),
-        ],
-    )
-    def test_generated_filename_when_missing(self, monkeypatch, magic_available, expected_ext):
-        if magic_available:
-            if helpers.magic is None:
-                pytest.skip("python-magic is not installed, cannot run 'magic_available=True' test variant")
-        else:
-            monkeypatch.setattr(helpers, "magic", None)
-
-        response = make_response(
-            url="https://example.com/",
-            content=b"Hello World",
-        )
-
-        info = guess_file_info_from_response(response)
-
-        name, ext = info.filename.split(".")
-        UUID(name)
-        assert ext == expected_ext
-
-    def test_mimetype_from_header_when_unknown(self):
-        headers = {"Content-Type": "application/json"}
-        response = make_response(
-            url="https://example.com/file.unknown",
-            headers=headers,
-            content=b'{"a": 1}',
-        )
-
-        info = guess_file_info_from_response(response)
-
-        assert info.mimetype == "application/json"
-
-    def test_extension_added_when_missing(self):
-        headers = {"Content-Type": "image/png"}
-        response = make_response(
-            url="https://example.com/image",
-            headers=headers,
-            content=b"fakepngdata",
-        )
-
-        info = guess_file_info_from_response(response)
-
-        assert info.extension == ".png"
-        assert info.filename.endswith(".png")
-
-    def test_content_length_used_as_size(self):
-        headers = {
-            "Content-Length": "1234",
-            "Content-Type": "text/plain",
-        }
-        response = make_response(
-            url="https://example.com/a.txt",
-            headers=headers,
-            content=b"a" * 1234,
-        )
-
-        info = guess_file_info_from_response(response)
-
-        assert info.size == 1234
-
-    def test_size_minus_one_when_header_missing(self):
-        response = make_response(url="https://example.com/a.txt")
-
-        info = guess_file_info_from_response(response)
-
-        assert info.size == -1
-
-    def test_fallback_to_bin_extension(self):
-        headers = {"Content-Type": "application/octet-stream"}
-        response = make_response(
-            url="https://example.com/download",
-            headers=headers,
-            content=b"\x00\x01\x02\x03",
-        )
-
-        info = guess_file_info_from_response(response)
-
-        assert info.extension == ".bin"
-        assert info.filename.endswith(".bin")
-
-    def test_return_type(self):
-        response = make_response()
-
-        info = guess_file_info_from_response(response)
-
-        assert isinstance(info, FileInfo)
-
-
-class TestMagicImportWarnings:
-    @pytest.mark.parametrize(
-        ("platform_name", "expected_message"),
-        [
-            ("Windows", "pip install python-magic-bin"),
-            ("Darwin", "brew install libmagic"),
-            ("Linux", "sudo apt-get install libmagic1"),
-            ("Other", "install `libmagic`"),
-        ],
-    )
-    def test_magic_import_warning_per_platform(
-        self,
-        monkeypatch,
-        platform_name,
-        expected_message,
-    ):
-        import builtins
-        import importlib
-
-        # Force ImportError when "magic" is imported
-        real_import = builtins.__import__
-
-        def fake_import(name, *args, **kwargs):
-            if name == "magic":
-                raise ImportError("No module named magic")
-            return real_import(name, *args, **kwargs)
-
-        monkeypatch.setattr(builtins, "__import__", fake_import)
-        monkeypatch.setattr("platform.system", lambda: platform_name)
-
-        # Remove helpers so it imports fresh
-        import sys
-
-        original_helpers = sys.modules.get(helpers.__name__)
-        sys.modules.pop(helpers.__name__, None)
-
-        try:
-            with pytest.warns(UserWarning, match="To use python-magic") as warning:
-                imported_helpers = importlib.import_module(helpers.__name__)
-            assert expected_message in str(warning[0].message)
-        finally:
-            if original_helpers is not None:
-                sys.modules[helpers.__name__] = original_helpers

api/tests/unit_tests/controllers/common/test_schema.py

@@ -1,189 +0,0 @@
-import sys
-from enum import StrEnum
-from unittest.mock import MagicMock, patch
-
-import pytest
-from flask_restx import Namespace
-from pydantic import BaseModel
-
-
-class UserModel(BaseModel):
-    id: int
-    name: str
-
-
-class ProductModel(BaseModel):
-    id: int
-    price: float
-
-
-@pytest.fixture(autouse=True)
-def mock_console_ns():
-    """Mock the console_ns to avoid circular imports during test collection."""
-    mock_ns = MagicMock(spec=Namespace)
-    mock_ns.models = {}
-
-    # Inject mock before importing schema module
-    with patch.dict(sys.modules, {"controllers.console": MagicMock(console_ns=mock_ns)}):
-        yield mock_ns
-
-
-def test_default_ref_template_value():
-    from controllers.common.schema import DEFAULT_REF_TEMPLATE_SWAGGER_2_0
-
-    assert DEFAULT_REF_TEMPLATE_SWAGGER_2_0 == "#/definitions/{model}"
-
-
-def test_register_schema_model_calls_namespace_schema_model():
-    from controllers.common.schema import register_schema_model
-
-    namespace = MagicMock(spec=Namespace)
-
-    register_schema_model(namespace, UserModel)
-
-    namespace.schema_model.assert_called_once()
-
-    model_name, schema = namespace.schema_model.call_args.args
-
-    assert model_name == "UserModel"
-    assert isinstance(schema, dict)
-    assert "properties" in schema
-
-
-def test_register_schema_model_passes_schema_from_pydantic():
-    from controllers.common.schema import DEFAULT_REF_TEMPLATE_SWAGGER_2_0, register_schema_model
-
-    namespace = MagicMock(spec=Namespace)
-
-    register_schema_model(namespace, UserModel)
-
-    schema = namespace.schema_model.call_args.args[1]
-
-    expected_schema = UserModel.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
-
-    assert schema == expected_schema
-
-
-def test_register_schema_models_registers_multiple_models():
-    from controllers.common.schema import register_schema_models
-
-    namespace = MagicMock(spec=Namespace)
-
-    register_schema_models(namespace, UserModel, ProductModel)
-
-    assert namespace.schema_model.call_count == 2
-
-    called_names = [call.args[0] for call in namespace.schema_model.call_args_list]
-    assert called_names == ["UserModel", "ProductModel"]
-
-
-def test_register_schema_models_calls_register_schema_model(monkeypatch):
-    from controllers.common.schema import register_schema_models
-
-    namespace = MagicMock(spec=Namespace)
-
-    calls = []
-
-    def fake_register(ns, model):
-        calls.append((ns, model))
-
-    monkeypatch.setattr(
-        "controllers.common.schema.register_schema_model",
-        fake_register,
-    )
-
-    register_schema_models(namespace, UserModel, ProductModel)
-
-    assert calls == [
-        (namespace, UserModel),
-        (namespace, ProductModel),
-    ]
-
-
-class StatusEnum(StrEnum):
-    ACTIVE = "active"
-    INACTIVE = "inactive"
-
-
-class PriorityEnum(StrEnum):
-    HIGH = "high"
-    LOW = "low"
-
-
-def test_get_or_create_model_returns_existing_model(mock_console_ns):
-    from controllers.common.schema import get_or_create_model
-
-    existing_model = MagicMock()
-    mock_console_ns.models = {"TestModel": existing_model}
-
-    result = get_or_create_model("TestModel", {"key": "value"})
-
-    assert result == existing_model
-    mock_console_ns.model.assert_not_called()
-
-
-def test_get_or_create_model_creates_new_model_when_not_exists(mock_console_ns):
-    from controllers.common.schema import get_or_create_model
-
-    mock_console_ns.models = {}
-    new_model = MagicMock()
-    mock_console_ns.model.return_value = new_model
-    field_def = {"name": {"type": "string"}}
-
-    result = get_or_create_model("NewModel", field_def)
-
-    assert result == new_model
-    mock_console_ns.model.assert_called_once_with("NewModel", field_def)
-
-
-def test_get_or_create_model_does_not_call_model_if_exists(mock_console_ns):
-    from controllers.common.schema import get_or_create_model
-
-    existing_model = MagicMock()
-    mock_console_ns.models = {"ExistingModel": existing_model}
-
-    result = get_or_create_model("ExistingModel", {"key": "value"})
-
-    assert result == existing_model
-    mock_console_ns.model.assert_not_called()
-
-
-def test_register_enum_models_registers_single_enum():
-    from controllers.common.schema import register_enum_models
-
-    namespace = MagicMock(spec=Namespace)
-
-    register_enum_models(namespace, StatusEnum)
-
-    namespace.schema_model.assert_called_once()
-
-    model_name, schema = namespace.schema_model.call_args.args
-
-    assert model_name == "StatusEnum"
-    assert isinstance(schema, dict)
-
-
-def test_register_enum_models_registers_multiple_enums():
-    from controllers.common.schema import register_enum_models
-
-    namespace = MagicMock(spec=Namespace)
-
-    register_enum_models(namespace, StatusEnum, PriorityEnum)
-
-    assert namespace.schema_model.call_count == 2
-
-    called_names = [call.args[0] for call in namespace.schema_model.call_args_list]
-    assert called_names == ["StatusEnum", "PriorityEnum"]
-
-
-def test_register_enum_models_uses_correct_ref_template():
-    from controllers.common.schema import register_enum_models
-
-    namespace = MagicMock(spec=Namespace)
-
-    register_enum_models(namespace, StatusEnum)
-
-    schema = namespace.schema_model.call_args.args[1]
-
-    # Verify the schema contains enum values
-    assert "enum" in schema or "anyOf" in schema

api/tests/unit_tests/core/app/apps/advanced_chat/test_generate_task_pipeline_extra_contents.py

@@ -9,16 +9,8 @@ import pytest
 
 from core.app.apps.advanced_chat import generate_task_pipeline as pipeline_module
 from core.app.entities.app_invoke_entities import InvokeFrom
-from core.app.entities.queue_entities import (
-    QueuePingEvent,
-    QueueTextChunkEvent,
-    QueueWorkflowPartialSuccessEvent,
-    QueueWorkflowPausedEvent,
-    QueueWorkflowSucceededEvent,
-)
-from core.app.entities.task_entities import StreamEvent
+from core.app.entities.queue_entities import QueueTextChunkEvent, QueueWorkflowPausedEvent
 from dify_graph.entities.pause_reason import HumanInputRequired
-from dify_graph.enums import WorkflowExecutionStatus
 from models.enums import MessageStatus
 from models.execution_extra_content import HumanInputContent
 from models.model import EndUser
@@ -193,97 +185,3 @@ def test_resume_appends_chunks_to_paused_answer() -> None:
 
     assert message.answer == "beforeafter"
     assert message.status == MessageStatus.NORMAL
-
-
-def test_workflow_succeeded_emits_message_end_before_workflow_finished() -> None:
-    pipeline = _build_pipeline()
-    pipeline._application_generate_entity = SimpleNamespace(task_id="task-1")
-    pipeline._workflow_id = "workflow-1"
-    pipeline._ensure_workflow_initialized = mock.Mock()
-    runtime_state = SimpleNamespace()
-    pipeline._ensure_graph_runtime_initialized = mock.Mock(return_value=runtime_state)
-    pipeline._handle_advanced_chat_message_end_event = mock.Mock(
-        return_value=iter([SimpleNamespace(event=StreamEvent.MESSAGE_END)])
-    )
-    pipeline._workflow_response_converter = mock.Mock()
-    pipeline._workflow_response_converter.workflow_finish_to_stream_response.return_value = SimpleNamespace(
-        event=StreamEvent.WORKFLOW_FINISHED,
-        data=SimpleNamespace(status=WorkflowExecutionStatus.SUCCEEDED),
-    )
-
-    event = QueueWorkflowSucceededEvent(outputs={})
-    responses = list(pipeline._handle_workflow_succeeded_event(event))
-
-    assert [resp.event for resp in responses] == [StreamEvent.MESSAGE_END, StreamEvent.WORKFLOW_FINISHED]
-
-
-def test_workflow_partial_success_emits_message_end_before_workflow_finished() -> None:
-    pipeline = _build_pipeline()
-    pipeline._application_generate_entity = SimpleNamespace(task_id="task-1")
-    pipeline._workflow_id = "workflow-1"
-    pipeline._ensure_workflow_initialized = mock.Mock()
-    runtime_state = SimpleNamespace()
-    pipeline._ensure_graph_runtime_initialized = mock.Mock(return_value=runtime_state)
-    pipeline._handle_advanced_chat_message_end_event = mock.Mock(
-        return_value=iter([SimpleNamespace(event=StreamEvent.MESSAGE_END)])
-    )
-    pipeline._workflow_response_converter = mock.Mock()
-    pipeline._workflow_response_converter.workflow_finish_to_stream_response.return_value = SimpleNamespace(
-        event=StreamEvent.WORKFLOW_FINISHED,
-        data=SimpleNamespace(status=WorkflowExecutionStatus.PARTIAL_SUCCEEDED),
-    )
-
-    event = QueueWorkflowPartialSuccessEvent(exceptions_count=1, outputs={})
-    responses = list(pipeline._handle_workflow_partial_success_event(event))
-
-    assert [resp.event for resp in responses] == [StreamEvent.MESSAGE_END, StreamEvent.WORKFLOW_FINISHED]
-
-
-def test_process_stream_response_breaks_after_workflow_succeeded() -> None:
-    pipeline = _build_pipeline()
-    succeeded_event = QueueWorkflowSucceededEvent(outputs={})
-    ping_event = QueuePingEvent()
-    queue_messages = [
-        SimpleNamespace(event=succeeded_event),
-        SimpleNamespace(event=ping_event),
-    ]
-
-    pipeline._conversation_name_generate_thread = None
-    pipeline._base_task_pipeline = mock.Mock()
-    pipeline._base_task_pipeline.queue_manager = mock.Mock()
-    pipeline._base_task_pipeline.queue_manager.listen.return_value = iter(queue_messages)
-    pipeline._base_task_pipeline.ping_stream_response = mock.Mock(return_value=SimpleNamespace(event=StreamEvent.PING))
-    pipeline._handle_workflow_succeeded_event = mock.Mock(
-        return_value=iter([SimpleNamespace(event=StreamEvent.WORKFLOW_FINISHED)])
-    )
-
-    responses = list(pipeline._process_stream_response())
-
-    assert [resp.event for resp in responses] == [StreamEvent.WORKFLOW_FINISHED]
-    pipeline._handle_workflow_succeeded_event.assert_called_once_with(succeeded_event, trace_manager=None)
-    pipeline._base_task_pipeline.ping_stream_response.assert_not_called()
-
-
-def test_process_stream_response_breaks_after_workflow_partial_success() -> None:
-    pipeline = _build_pipeline()
-    partial_event = QueueWorkflowPartialSuccessEvent(exceptions_count=1, outputs={})
-    ping_event = QueuePingEvent()
-    queue_messages = [
-        SimpleNamespace(event=partial_event),
-        SimpleNamespace(event=ping_event),
-    ]
-
-    pipeline._conversation_name_generate_thread = None
-    pipeline._base_task_pipeline = mock.Mock()
-    pipeline._base_task_pipeline.queue_manager = mock.Mock()
-    pipeline._base_task_pipeline.queue_manager.listen.return_value = iter(queue_messages)
-    pipeline._base_task_pipeline.ping_stream_response = mock.Mock(return_value=SimpleNamespace(event=StreamEvent.PING))
-    pipeline._handle_workflow_partial_success_event = mock.Mock(
-        return_value=iter([SimpleNamespace(event=StreamEvent.WORKFLOW_FINISHED)])
-    )
-
-    responses = list(pipeline._process_stream_response())
-
-    assert [resp.event for resp in responses] == [StreamEvent.WORKFLOW_FINISHED]
-    pipeline._handle_workflow_partial_success_event.assert_called_once_with(partial_event, trace_manager=None)
-    pipeline._base_task_pipeline.ping_stream_response.assert_not_called()

api/tests/unit_tests/core/app/apps/test_advanced_chat_app_generator.py

@@ -124,12 +124,12 @@ def test_message_cycle_manager_uses_new_conversation_flag(monkeypatch):
         def start(self):
             self.started = True
 
-    def fake_thread(*args, **kwargs):
+    def fake_thread(**kwargs):
         thread = DummyThread(**kwargs)
         captured["thread"] = thread
         return thread
 
-    monkeypatch.setattr(message_cycle_manager, "Timer", fake_thread)
+    monkeypatch.setattr(message_cycle_manager, "Thread", fake_thread)
 
     manager = MessageCycleManager(application_generate_entity=entity, task_state=MagicMock())
     thread = manager.generate_conversation_name(conversation_id="existing-conversation-id", query="hello")

api/tests/unit_tests/core/app/apps/test_pause_resume.py

@@ -1,8 +1,13 @@
 import sys
 import time
+from pathlib import Path
 from types import ModuleType, SimpleNamespace
 from typing import Any
 
+API_DIR = str(Path(__file__).resolve().parents[5])
+if API_DIR not in sys.path:
+    sys.path.insert(0, API_DIR)
+
 import dify_graph.nodes.human_input.entities  # noqa: F401
 from core.app.apps.advanced_chat import app_generator as adv_app_gen_module
 from core.app.apps.workflow import app_generator as wf_app_gen_module

api/tests/unit_tests/core/app/task_pipeline/test_easy_ui_message_end_files.py

@@ -1,425 +0,0 @@
-"""
-Unit tests for EasyUIBasedGenerateTaskPipeline._message_end_to_stream_response method.
-
-This test suite ensures that the files array is correctly populated in the message_end
-SSE event, which is critical for vision/image chat responses to render correctly.
-
-Test Coverage:
-- Files array populated when MessageFile records exist
-- Files array is None when no MessageFile records exist
-- Correct signed URL generation for LOCAL_FILE transfer method
-- Correct URL handling for REMOTE_URL transfer method
-- Correct URL handling for TOOL_FILE transfer method
-- Proper file metadata formatting (filename, mime_type, size, extension)
-"""
-
-import uuid
-from unittest.mock import MagicMock, Mock, patch
-
-import pytest
-from sqlalchemy.orm import Session
-
-from core.app.entities.task_entities import MessageEndStreamResponse
-from core.app.task_pipeline.easy_ui_based_generate_task_pipeline import EasyUIBasedGenerateTaskPipeline
-from dify_graph.file.enums import FileTransferMethod
-from models.model import MessageFile, UploadFile
-
-
-class TestMessageEndStreamResponseFiles:
-    """Test suite for files array population in message_end SSE event."""
-
-    @pytest.fixture
-    def mock_pipeline(self):
-        """Create a mock EasyUIBasedGenerateTaskPipeline instance."""
-        pipeline = Mock(spec=EasyUIBasedGenerateTaskPipeline)
-        pipeline._message_id = str(uuid.uuid4())
-        pipeline._task_state = Mock()
-        pipeline._task_state.metadata = Mock()
-        pipeline._task_state.metadata.model_dump = Mock(return_value={"test": "metadata"})
-        pipeline._task_state.llm_result = Mock()
-        pipeline._task_state.llm_result.usage = Mock()
-        pipeline._application_generate_entity = Mock()
-        pipeline._application_generate_entity.task_id = str(uuid.uuid4())
-        return pipeline
-
-    @pytest.fixture
-    def mock_message_file_local(self):
-        """Create a mock MessageFile with LOCAL_FILE transfer method."""
-        message_file = Mock(spec=MessageFile)
-        message_file.id = str(uuid.uuid4())
-        message_file.message_id = str(uuid.uuid4())
-        message_file.transfer_method = FileTransferMethod.LOCAL_FILE
-        message_file.upload_file_id = str(uuid.uuid4())
-        message_file.url = None
-        message_file.type = "image"
-        return message_file
-
-    @pytest.fixture
-    def mock_message_file_remote(self):
-        """Create a mock MessageFile with REMOTE_URL transfer method."""
-        message_file = Mock(spec=MessageFile)
-        message_file.id = str(uuid.uuid4())
-        message_file.message_id = str(uuid.uuid4())
-        message_file.transfer_method = FileTransferMethod.REMOTE_URL
-        message_file.upload_file_id = None
-        message_file.url = "https://example.com/image.jpg"
-        message_file.type = "image"
-        return message_file
-
-    @pytest.fixture
-    def mock_message_file_tool(self):
-        """Create a mock MessageFile with TOOL_FILE transfer method."""
-        message_file = Mock(spec=MessageFile)
-        message_file.id = str(uuid.uuid4())
-        message_file.message_id = str(uuid.uuid4())
-        message_file.transfer_method = FileTransferMethod.TOOL_FILE
-        message_file.upload_file_id = None
-        message_file.url = "tool_file_123.png"
-        message_file.type = "image"
-        return message_file
-
-    @pytest.fixture
-    def mock_upload_file(self, mock_message_file_local):
-        """Create a mock UploadFile."""
-        upload_file = Mock(spec=UploadFile)
-        upload_file.id = mock_message_file_local.upload_file_id
-        upload_file.name = "test_image.png"
-        upload_file.mime_type = "image/png"
-        upload_file.size = 1024
-        upload_file.extension = "png"
-        return upload_file
-
-    def test_message_end_with_no_files(self, mock_pipeline):
-        """Test that files array is None when no MessageFile records exist."""
-        # Arrange
-        with (
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.db") as mock_db,
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.Session") as mock_session_class,
-        ):
-            mock_engine = MagicMock()
-            mock_db.engine = mock_engine
-
-            mock_session = MagicMock(spec=Session)
-            mock_session_class.return_value.__enter__.return_value = mock_session
-            mock_session.scalars.return_value.all.return_value = []
-
-            # Act
-            result = EasyUIBasedGenerateTaskPipeline._message_end_to_stream_response(mock_pipeline)
-
-            # Assert
-            assert isinstance(result, MessageEndStreamResponse)
-            assert result.files is None
-            assert result.id == mock_pipeline._message_id
-            assert result.metadata == {"test": "metadata"}
-
-    def test_message_end_with_local_file(self, mock_pipeline, mock_message_file_local, mock_upload_file):
-        """Test that files array is populated correctly for LOCAL_FILE transfer method."""
-        # Arrange
-        mock_message_file_local.message_id = mock_pipeline._message_id
-
-        with (
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.db") as mock_db,
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.Session") as mock_session_class,
-            patch("core.app.task_pipeline.message_file_utils.file_helpers.get_signed_file_url") as mock_get_url,
-        ):
-            mock_engine = MagicMock()
-            mock_db.engine = mock_engine
-
-            mock_session = MagicMock(spec=Session)
-            mock_session_class.return_value.__enter__.return_value = mock_session
-
-            # Mock database queries
-            # First query: MessageFile
-            mock_message_files_result = Mock()
-            mock_message_files_result.all.return_value = [mock_message_file_local]
-
-            # Second query: UploadFile (batch query to avoid N+1)
-            mock_upload_files_result = Mock()
-            mock_upload_files_result.all.return_value = [mock_upload_file]
-
-            # Setup scalars to return different results for different queries
-            call_count = [0]  # Use list to allow modification in nested function
-
-            def scalars_side_effect(query):
-                call_count[0] += 1
-                # First call is for MessageFile, second call is for UploadFile
-                if call_count[0] == 1:
-                    return mock_message_files_result
-                else:
-                    return mock_upload_files_result
-
-            mock_session.scalars.side_effect = scalars_side_effect
-            mock_get_url.return_value = "https://example.com/signed-url?signature=abc123"
-
-            # Act
-            result = EasyUIBasedGenerateTaskPipeline._message_end_to_stream_response(mock_pipeline)
-
-            # Assert
-            assert isinstance(result, MessageEndStreamResponse)
-            assert result.files is not None
-            assert len(result.files) == 1
-
-            file_dict = result.files[0]
-            assert file_dict["related_id"] == mock_message_file_local.id
-            assert file_dict["filename"] == "test_image.png"
-            assert file_dict["mime_type"] == "image/png"
-            assert file_dict["size"] == 1024
-            assert file_dict["extension"] == ".png"
-            assert file_dict["type"] == "image"
-            assert file_dict["transfer_method"] == FileTransferMethod.LOCAL_FILE.value
-            assert "https://example.com/signed-url" in file_dict["url"]
-            assert file_dict["upload_file_id"] == mock_message_file_local.upload_file_id
-            assert file_dict["remote_url"] == ""
-
-            # Verify database queries
-            # Should be called twice: once for MessageFile, once for UploadFile
-            assert mock_session.scalars.call_count == 2
-            mock_get_url.assert_called_once_with(upload_file_id=str(mock_upload_file.id))
-
-    def test_message_end_with_remote_url(self, mock_pipeline, mock_message_file_remote):
-        """Test that files array is populated correctly for REMOTE_URL transfer method."""
-        # Arrange
-        mock_message_file_remote.message_id = mock_pipeline._message_id
-
-        with (
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.db") as mock_db,
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.Session") as mock_session_class,
-        ):
-            mock_engine = MagicMock()
-            mock_db.engine = mock_engine
-            mock_session = MagicMock(spec=Session)
-            mock_session_class.return_value.__enter__.return_value = mock_session
-
-            # Mock database queries
-            mock_scalars_result = Mock()
-            mock_scalars_result.all.return_value = [mock_message_file_remote]
-            mock_session.scalars.return_value = mock_scalars_result
-
-            # Act
-            result = EasyUIBasedGenerateTaskPipeline._message_end_to_stream_response(mock_pipeline)
-
-            # Assert
-            assert isinstance(result, MessageEndStreamResponse)
-            assert result.files is not None
-            assert len(result.files) == 1
-
-            file_dict = result.files[0]
-            assert file_dict["related_id"] == mock_message_file_remote.id
-            assert file_dict["filename"] == "image.jpg"
-            assert file_dict["url"] == "https://example.com/image.jpg"
-            assert file_dict["extension"] == ".jpg"
-            assert file_dict["type"] == "image"
-            assert file_dict["transfer_method"] == FileTransferMethod.REMOTE_URL.value
-            assert file_dict["remote_url"] == "https://example.com/image.jpg"
-            assert file_dict["upload_file_id"] == mock_message_file_remote.id
-
-            # Verify only one query for message_files is made
-            mock_session.scalars.assert_called_once()
-
-    def test_message_end_with_tool_file_http(self, mock_pipeline, mock_message_file_tool):
-        """Test that files array is populated correctly for TOOL_FILE with HTTP URL."""
-        # Arrange
-        mock_message_file_tool.message_id = mock_pipeline._message_id
-        mock_message_file_tool.url = "https://example.com/tool_file.png"
-
-        with (
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.db") as mock_db,
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.Session") as mock_session_class,
-        ):
-            mock_engine = MagicMock()
-            mock_db.engine = mock_engine
-            mock_session = MagicMock(spec=Session)
-            mock_session_class.return_value.__enter__.return_value = mock_session
-
-            # Mock database queries
-            mock_scalars_result = Mock()
-            mock_scalars_result.all.return_value = [mock_message_file_tool]
-            mock_session.scalars.return_value = mock_scalars_result
-
-            # Act
-            result = EasyUIBasedGenerateTaskPipeline._message_end_to_stream_response(mock_pipeline)
-
-            # Assert
-            assert isinstance(result, MessageEndStreamResponse)
-            assert result.files is not None
-            assert len(result.files) == 1
-
-            file_dict = result.files[0]
-            assert file_dict["url"] == "https://example.com/tool_file.png"
-            assert file_dict["filename"] == "tool_file.png"
-            assert file_dict["extension"] == ".png"
-            assert file_dict["transfer_method"] == FileTransferMethod.TOOL_FILE.value
-
-    def test_message_end_with_tool_file_local(self, mock_pipeline, mock_message_file_tool):
-        """Test that files array is populated correctly for TOOL_FILE with local path."""
-        # Arrange
-        mock_message_file_tool.message_id = mock_pipeline._message_id
-        mock_message_file_tool.url = "tool_file_123.png"
-
-        with (
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.db") as mock_db,
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.Session") as mock_session_class,
-            patch("core.app.task_pipeline.message_file_utils.sign_tool_file") as mock_sign_tool,
-        ):
-            mock_engine = MagicMock()
-            mock_db.engine = mock_engine
-
-            mock_session = MagicMock(spec=Session)
-            mock_session_class.return_value.__enter__.return_value = mock_session
-
-            # Mock database queries
-            mock_scalars_result = Mock()
-            mock_scalars_result.all.return_value = [mock_message_file_tool]
-            mock_session.scalars.return_value = mock_scalars_result
-
-            mock_sign_tool.return_value = "https://example.com/signed-tool-file.png?signature=xyz"
-
-            # Act
-            result = EasyUIBasedGenerateTaskPipeline._message_end_to_stream_response(mock_pipeline)
-
-            # Assert
-            assert isinstance(result, MessageEndStreamResponse)
-            assert result.files is not None
-            assert len(result.files) == 1
-
-            file_dict = result.files[0]
-            assert "https://example.com/signed-tool-file.png" in file_dict["url"]
-            assert file_dict["filename"] == "tool_file_123.png"
-            assert file_dict["extension"] == ".png"
-            assert file_dict["transfer_method"] == FileTransferMethod.TOOL_FILE.value
-
-            # Verify tool file signing was called
-            mock_sign_tool.assert_called_once_with(tool_file_id="tool_file_123", extension=".png")
-
-    def test_message_end_with_tool_file_long_extension(self, mock_pipeline, mock_message_file_tool):
-        """Test that TOOL_FILE extensions longer than MAX_TOOL_FILE_EXTENSION_LENGTH fall back to .bin."""
-        mock_message_file_tool.message_id = mock_pipeline._message_id
-        mock_message_file_tool.url = "tool_file_abc.verylongextension"
-
-        with (
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.db") as mock_db,
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.Session") as mock_session_class,
-            patch("core.app.task_pipeline.message_file_utils.sign_tool_file") as mock_sign_tool,
-        ):
-            mock_engine = MagicMock()
-            mock_db.engine = mock_engine
-            mock_session = MagicMock(spec=Session)
-            mock_session_class.return_value.__enter__.return_value = mock_session
-            mock_scalars_result = Mock()
-            mock_scalars_result.all.return_value = [mock_message_file_tool]
-            mock_session.scalars.return_value = mock_scalars_result
-            mock_sign_tool.return_value = "https://example.com/signed.bin"
-
-            result = EasyUIBasedGenerateTaskPipeline._message_end_to_stream_response(mock_pipeline)
-
-            assert result.files is not None
-            file_dict = result.files[0]
-            assert file_dict["extension"] == ".bin"
-            mock_sign_tool.assert_called_once_with(tool_file_id="tool_file_abc", extension=".bin")
-
-    def test_message_end_with_multiple_files(
-        self, mock_pipeline, mock_message_file_local, mock_message_file_remote, mock_upload_file
-    ):
-        """Test that files array contains all MessageFile records when multiple exist."""
-        # Arrange
-        mock_message_file_local.message_id = mock_pipeline._message_id
-        mock_message_file_remote.message_id = mock_pipeline._message_id
-
-        with (
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.db") as mock_db,
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.Session") as mock_session_class,
-            patch("core.app.task_pipeline.message_file_utils.file_helpers.get_signed_file_url") as mock_get_url,
-        ):
-            mock_engine = MagicMock()
-            mock_db.engine = mock_engine
-
-            mock_session = MagicMock(spec=Session)
-            mock_session_class.return_value.__enter__.return_value = mock_session
-
-            # Mock database queries
-            # First query: MessageFile
-            mock_message_files_result = Mock()
-            mock_message_files_result.all.return_value = [mock_message_file_local, mock_message_file_remote]
-
-            # Second query: UploadFile (batch query to avoid N+1)
-            mock_upload_files_result = Mock()
-            mock_upload_files_result.all.return_value = [mock_upload_file]
-
-            # Setup scalars to return different results for different queries
-            call_count = [0]  # Use list to allow modification in nested function
-
-            def scalars_side_effect(query):
-                call_count[0] += 1
-                # First call is for MessageFile, second call is for UploadFile
-                if call_count[0] == 1:
-                    return mock_message_files_result
-                else:
-                    return mock_upload_files_result
-
-            mock_session.scalars.side_effect = scalars_side_effect
-            mock_get_url.return_value = "https://example.com/signed-url?signature=abc123"
-
-            # Act
-            result = EasyUIBasedGenerateTaskPipeline._message_end_to_stream_response(mock_pipeline)
-
-            # Assert
-            assert isinstance(result, MessageEndStreamResponse)
-            assert result.files is not None
-            assert len(result.files) == 2
-
-            # Verify both files are present
-            file_ids = [f["related_id"] for f in result.files]
-            assert mock_message_file_local.id in file_ids
-            assert mock_message_file_remote.id in file_ids
-
-    def test_message_end_with_local_file_no_upload_file(self, mock_pipeline, mock_message_file_local):
-        """Test fallback when UploadFile is not found for LOCAL_FILE."""
-        # Arrange
-        mock_message_file_local.message_id = mock_pipeline._message_id
-
-        with (
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.db") as mock_db,
-            patch("core.app.task_pipeline.easy_ui_based_generate_task_pipeline.Session") as mock_session_class,
-            patch("core.app.task_pipeline.message_file_utils.file_helpers.get_signed_file_url") as mock_get_url,
-        ):
-            mock_engine = MagicMock()
-            mock_db.engine = mock_engine
-
-            mock_session = MagicMock(spec=Session)
-            mock_session_class.return_value.__enter__.return_value = mock_session
-
-            # Mock database queries
-            # First query: MessageFile
-            mock_message_files_result = Mock()
-            mock_message_files_result.all.return_value = [mock_message_file_local]
-
-            # Second query: UploadFile (batch query) - returns empty list (not found)
-            mock_upload_files_result = Mock()
-            mock_upload_files_result.all.return_value = []  # UploadFile not found
-
-            # Setup scalars to return different results for different queries
-            call_count = [0]  # Use list to allow modification in nested function
-
-            def scalars_side_effect(query):
-                call_count[0] += 1
-                # First call is for MessageFile, second call is for UploadFile
-                if call_count[0] == 1:
-                    return mock_message_files_result
-                else:
-                    return mock_upload_files_result
-
-            mock_session.scalars.side_effect = scalars_side_effect
-            mock_get_url.return_value = "https://example.com/fallback-url?signature=def456"
-
-            # Act
-            result = EasyUIBasedGenerateTaskPipeline._message_end_to_stream_response(mock_pipeline)
-
-            # Assert
-            assert isinstance(result, MessageEndStreamResponse)
-            assert result.files is not None
-            assert len(result.files) == 1
-
-            file_dict = result.files[0]
-            assert "https://example.com/fallback-url" in file_dict["url"]
-            # Verify fallback URL was generated using upload_file_id from message_file
-            mock_get_url.assert_called_with(upload_file_id=str(mock_message_file_local.upload_file_id))

api/tests/unit_tests/core/repositories/test_sqlalchemy_workflow_execution_repository.py

@@ -1,84 +0,0 @@
-from datetime import datetime
-from unittest.mock import MagicMock
-from uuid import uuid4
-
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-
-from core.repositories.sqlalchemy_workflow_execution_repository import SQLAlchemyWorkflowExecutionRepository
-from dify_graph.entities.workflow_execution import WorkflowExecution, WorkflowType
-from models import Account, WorkflowRun
-from models.enums import WorkflowRunTriggeredFrom
-
-
-def _build_repository_with_mocked_session(session: MagicMock) -> SQLAlchemyWorkflowExecutionRepository:
-    engine = create_engine("sqlite:///:memory:")
-    real_session_factory = sessionmaker(bind=engine, expire_on_commit=False)
-
-    user = MagicMock(spec=Account)
-    user.id = str(uuid4())
-    user.current_tenant_id = str(uuid4())
-
-    repository = SQLAlchemyWorkflowExecutionRepository(
-        session_factory=real_session_factory,
-        user=user,
-        app_id="app-id",
-        triggered_from=WorkflowRunTriggeredFrom.APP_RUN,
-    )
-
-    session_context = MagicMock()
-    session_context.__enter__.return_value = session
-    session_context.__exit__.return_value = False
-    repository._session_factory = MagicMock(return_value=session_context)
-    return repository
-
-
-def _build_execution(*, execution_id: str, started_at: datetime) -> WorkflowExecution:
-    return WorkflowExecution.new(
-        id_=execution_id,
-        workflow_id="workflow-id",
-        workflow_type=WorkflowType.WORKFLOW,
-        workflow_version="1.0.0",
-        graph={"nodes": [], "edges": []},
-        inputs={"query": "hello"},
-        started_at=started_at,
-    )
-
-
-def test_save_uses_execution_started_at_when_record_does_not_exist():
-    session = MagicMock()
-    session.get.return_value = None
-    repository = _build_repository_with_mocked_session(session)
-
-    started_at = datetime(2026, 1, 1, 12, 0, 0)
-    execution = _build_execution(execution_id=str(uuid4()), started_at=started_at)
-
-    repository.save(execution)
-
-    saved_model = session.merge.call_args.args[0]
-    assert saved_model.created_at == started_at
-    session.commit.assert_called_once()
-
-
-def test_save_preserves_existing_created_at_when_record_already_exists():
-    session = MagicMock()
-    repository = _build_repository_with_mocked_session(session)
-
-    execution_id = str(uuid4())
-    existing_created_at = datetime(2026, 1, 1, 12, 0, 0)
-    existing_run = WorkflowRun()
-    existing_run.id = execution_id
-    existing_run.tenant_id = repository._tenant_id
-    existing_run.created_at = existing_created_at
-    session.get.return_value = existing_run
-
-    execution = _build_execution(
-        execution_id=execution_id,
-        started_at=datetime(2026, 1, 1, 12, 30, 0),
-    )
-
-    repository.save(execution)
-
-    saved_model = session.merge.call_args.args[0]
-    assert saved_model.created_at == existing_created_at
-    session.commit.assert_called_once()

api/tests/unit_tests/core/workflow/entities/test_graph_runtime_state.py

@@ -4,10 +4,8 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
-from dify_graph.constants import CONVERSATION_VARIABLE_NODE_ID
 from dify_graph.model_runtime.entities.llm_entities import LLMUsage
 from dify_graph.runtime import GraphRuntimeState, ReadOnlyGraphRuntimeStateWrapper, VariablePool
-from dify_graph.variables.variables import StringVariable
 
 
 class StubCoordinator:
@@ -280,17 +278,3 @@ class TestGraphRuntimeState:
         assert restored_execution.started is True
 
         assert new_stub.state == "configured"
-
-    def test_snapshot_restore_preserves_updated_conversation_variable(self):
-        variable_pool = VariablePool(
-            conversation_variables=[StringVariable(name="session_name", value="before")],
-        )
-        variable_pool.add((CONVERSATION_VARIABLE_NODE_ID, "session_name"), "after")
-
-        state = GraphRuntimeState(variable_pool=variable_pool, start_at=time())
-        snapshot = state.dumps()
-        restored = GraphRuntimeState.from_snapshot(snapshot)
-
-        restored_value = restored.variable_pool.get((CONVERSATION_VARIABLE_NODE_ID, "session_name"))
-        assert restored_value is not None
-        assert restored_value.value == "after"

api/tests/unit_tests/core/workflow/graph_engine/test_mock_iteration_simple.py

@@ -2,7 +2,15 @@
 Simple test to verify MockNodeFactory works with iteration nodes.
 """
 
+import sys
+from pathlib import Path
+
 from dify_graph.entities.graph_init_params import DIFY_RUN_CONTEXT_KEY
+
+# Add api directory to path
+api_dir = Path(__file__).parent.parent.parent.parent.parent.parent
+sys.path.insert(0, str(api_dir))
+
 from dify_graph.enums import NodeType
 from tests.unit_tests.core.workflow.graph_engine.test_mock_config import MockConfigBuilder
 from tests.unit_tests.core.workflow.graph_engine.test_mock_factory import MockNodeFactory

api/tests/unit_tests/core/workflow/graph_engine/test_mock_simple.py

@@ -3,8 +3,14 @@ Simple test to validate the auto-mock system without external dependencies.
 """
 
 import sys
+from pathlib import Path
 
 from dify_graph.entities.graph_init_params import DIFY_RUN_CONTEXT_KEY
+
+# Add api directory to path
+api_dir = Path(__file__).parent.parent.parent.parent.parent.parent
+sys.path.insert(0, str(api_dir))
+
 from dify_graph.enums import NodeType
 from tests.unit_tests.core.workflow.graph_engine.test_mock_config import MockConfig, MockConfigBuilder, NodeMockConfig
 from tests.unit_tests.core.workflow.graph_engine.test_mock_factory import MockNodeFactory

api/tests/unit_tests/core/workflow/nodes/knowledge_retrieval/test_knowledge_retrieval_node.py

@@ -8,9 +8,7 @@ from core.app.entities.app_invoke_entities import InvokeFrom, UserFrom
 from dify_graph.enums import WorkflowNodeExecutionStatus
 from dify_graph.model_runtime.entities.llm_entities import LLMUsage
 from dify_graph.nodes.knowledge_retrieval.entities import (
-    Condition,
     KnowledgeRetrievalNodeData,
-    MetadataFilteringCondition,
     MultipleRetrievalConfig,
     RerankingModelConfig,
     SingleRetrievalConfig,
@@ -207,7 +205,6 @@ class TestKnowledgeRetrievalNode:
         assert result.status == WorkflowNodeExecutionStatus.SUCCEEDED
         assert "result" in result.outputs
         assert mock_rag_retrieval.knowledge_retrieval.called
-        mock_source.model_dump.assert_called_once_with(by_alias=True)
 
     def test_run_with_query_variable_multiple_mode(
         self,
@@ -595,106 +592,3 @@ class TestFetchDatasetRetriever:
 
         # Assert
         assert version == "1"
-
-    def test_resolve_metadata_filtering_conditions_templates(
-        self,
-        mock_graph_init_params,
-        mock_graph_runtime_state,
-        mock_rag_retrieval,
-    ):
-        """_resolve_metadata_filtering_conditions should expand {{#...#}} and keep numbers/None unchanged."""
-        # Arrange
-        node_id = str(uuid.uuid4())
-        config = {
-            "id": node_id,
-            "data": {
-                "title": "Knowledge Retrieval",
-                "type": "knowledge-retrieval",
-                "dataset_ids": [str(uuid.uuid4())],
-                "retrieval_mode": "multiple",
-            },
-        }
-        # Variable in pool used by template
-        mock_graph_runtime_state.variable_pool.add(["start", "query"], StringSegment(value="readme"))
-
-        node = KnowledgeRetrievalNode(
-            id=node_id,
-            config=config,
-            graph_init_params=mock_graph_init_params,
-            graph_runtime_state=mock_graph_runtime_state,
-            rag_retrieval=mock_rag_retrieval,
-        )
-
-        conditions = MetadataFilteringCondition(
-            logical_operator="and",
-            conditions=[
-                Condition(name="document_name", comparison_operator="is", value="{{#start.query#}}"),
-                Condition(name="tags", comparison_operator="in", value=["x", "{{#start.query#}}"]),
-                Condition(name="year", comparison_operator="=", value=2025),
-            ],
-        )
-
-        # Act
-        resolved = node._resolve_metadata_filtering_conditions(conditions)
-
-        # Assert
-        assert resolved.logical_operator == "and"
-        assert resolved.conditions[0].value == "readme"
-        assert isinstance(resolved.conditions[1].value, list)
-        assert resolved.conditions[1].value[1] == "readme"
-        assert resolved.conditions[2].value == 2025
-
-    def test_fetch_passes_resolved_metadata_conditions(
-        self,
-        mock_graph_init_params,
-        mock_graph_runtime_state,
-        mock_rag_retrieval,
-    ):
-        """_fetch_dataset_retriever should pass resolved metadata conditions into request."""
-        # Arrange
-        query = "hi"
-        variables = {"query": query}
-        mock_graph_runtime_state.variable_pool.add(["start", "q"], StringSegment(value="readme"))
-
-        node_data = KnowledgeRetrievalNodeData(
-            title="Knowledge Retrieval",
-            type="knowledge-retrieval",
-            dataset_ids=[str(uuid.uuid4())],
-            retrieval_mode="multiple",
-            multiple_retrieval_config=MultipleRetrievalConfig(
-                top_k=4,
-                score_threshold=0.0,
-                reranking_mode="reranking_model",
-                reranking_enable=True,
-                reranking_model=RerankingModelConfig(provider="cohere", model="rerank-v2"),
-            ),
-            metadata_filtering_mode="manual",
-            metadata_filtering_conditions=MetadataFilteringCondition(
-                logical_operator="and",
-                conditions=[
-                    Condition(name="document_name", comparison_operator="is", value="{{#start.q#}}"),
-                ],
-            ),
-        )
-
-        node_id = str(uuid.uuid4())
-        config = {"id": node_id, "data": node_data.model_dump()}
-        node = KnowledgeRetrievalNode(
-            id=node_id,
-            config=config,
-            graph_init_params=mock_graph_init_params,
-            graph_runtime_state=mock_graph_runtime_state,
-            rag_retrieval=mock_rag_retrieval,
-        )
-
-        mock_rag_retrieval.knowledge_retrieval.return_value = []
-        mock_rag_retrieval.llm_usage = LLMUsage.empty_usage()
-
-        # Act
-        node._fetch_dataset_retriever(node_data=node_data, variables=variables)
-
-        # Assert the passed request has resolved value
-        call_args = mock_rag_retrieval.knowledge_retrieval.call_args
-        request = call_args[1]["request"]
-        assert request.metadata_filtering_conditions is not None
-        assert request.metadata_filtering_conditions.conditions[0].value == "readme"

api/tests/unit_tests/core/workflow/nodes/test_document_extractor_node.py

@@ -16,7 +16,6 @@ from dify_graph.nodes.document_extractor.node import (
     _extract_text_from_excel,
     _extract_text_from_pdf,
     _extract_text_from_plain_text,
-    _normalize_docx_zip,
 )
 from dify_graph.variables import ArrayFileSegment
 from dify_graph.variables.segments import ArrayStringSegment
@@ -87,38 +86,6 @@ def test_run_invalid_variable_type(document_extractor_node, mock_graph_runtime_s
     assert "is not an ArrayFileSegment" in result.error
 
 
-def test_run_empty_file_list_returns_succeeded(document_extractor_node, mock_graph_runtime_state):
-    """Empty file list should return SUCCEEDED with empty documents and ArrayStringSegment([])."""
-    document_extractor_node.graph_runtime_state = mock_graph_runtime_state
-
-    # Provide an actual ArrayFileSegment with an empty list
-    mock_graph_runtime_state.variable_pool.get.return_value = ArrayFileSegment(value=[])
-
-    result = document_extractor_node._run()
-
-    assert isinstance(result, NodeRunResult)
-    assert result.status == WorkflowNodeExecutionStatus.SUCCEEDED, result.error
-    assert result.process_data.get("documents") == []
-    assert result.outputs["text"] == ArrayStringSegment(value=[])
-
-
-def test_run_none_only_file_list_returns_succeeded(document_extractor_node, mock_graph_runtime_state):
-    """A file list containing only None (e.g., [None]) should be filtered to [] and succeed."""
-    document_extractor_node.graph_runtime_state = mock_graph_runtime_state
-
-    # Use a Mock to bypass type validation for None entries in the list
-    afs = Mock(spec=ArrayFileSegment)
-    afs.value = [None]
-    mock_graph_runtime_state.variable_pool.get.return_value = afs
-
-    result = document_extractor_node._run()
-
-    assert isinstance(result, NodeRunResult)
-    assert result.status == WorkflowNodeExecutionStatus.SUCCEEDED, result.error
-    assert result.process_data.get("documents") == []
-    assert result.outputs["text"] == ArrayStringSegment(value=[])
-
-
 @pytest.mark.parametrize(
     ("mime_type", "file_content", "expected_text", "transfer_method", "extension"),
     [
@@ -418,58 +385,3 @@ def test_extract_text_from_excel_numeric_type_column(mock_excel_file):
     expected_manual = "| 1.0 | 1.1 |\n| --- | --- |\n| Test | Test |\n\n"
 
     assert expected_manual == result
-
-
-def _make_docx_zip(use_backslash: bool) -> bytes:
-    """Helper to build a minimal in-memory DOCX zip.
-
-    When use_backslash=True the ZIP entry names use backslash separators
-    (as produced by Evernote on Windows), otherwise forward slashes are used.
-    """
-    import zipfile
-
-    sep = "\\" if use_backslash else "/"
-    buf = io.BytesIO()
-    with zipfile.ZipFile(buf, "w", compression=zipfile.ZIP_DEFLATED) as zf:
-        zf.writestr("[Content_Types].xml", b"<Types/>")
-        zf.writestr(f"_rels{sep}.rels", b"<Relationships/>")
-        zf.writestr(f"word{sep}document.xml", b"<w:document/>")
-        zf.writestr(f"word{sep}_rels{sep}document.xml.rels", b"<Relationships/>")
-    return buf.getvalue()
-
-
-def test_normalize_docx_zip_replaces_backslashes():
-    """ZIP entries with backslash separators must be rewritten to forward slashes."""
-    import zipfile
-
-    malformed = _make_docx_zip(use_backslash=True)
-    fixed = _normalize_docx_zip(malformed)
-
-    with zipfile.ZipFile(io.BytesIO(fixed)) as zf:
-        names = zf.namelist()
-
-    assert "word/document.xml" in names
-    assert "word/_rels/document.xml.rels" in names
-    # No entry should contain a backslash after normalization
-    assert all("\\" not in name for name in names)
-
-
-def test_normalize_docx_zip_leaves_forward_slash_unchanged():
-    """ZIP entries that already use forward slashes must not be modified."""
-    import zipfile
-
-    normal = _make_docx_zip(use_backslash=False)
-    fixed = _normalize_docx_zip(normal)
-
-    with zipfile.ZipFile(io.BytesIO(fixed)) as zf:
-        names = zf.namelist()
-
-    assert "word/document.xml" in names
-    assert "word/_rels/document.xml.rels" in names
-
-
-def test_normalize_docx_zip_returns_original_on_bad_zip():
-    """Non-zip bytes must be returned as-is without raising."""
-    garbage = b"not a zip file at all"
-    result = _normalize_docx_zip(garbage)
-    assert result == garbage

api/tests/unit_tests/services/dataset_permission_service.py

@@ -258,6 +258,323 @@ class DatasetPermissionTestDataFactory:
         return [{"user_id": user_id} for user_id in user_ids]
 
 
+# ============================================================================
+# Tests for get_dataset_partial_member_list
+# ============================================================================
+
+
+class TestDatasetPermissionServiceGetPartialMemberList:
+    """
+    Comprehensive unit tests for DatasetPermissionService.get_dataset_partial_member_list method.
+
+    This test class covers the retrieval of partial member lists for datasets,
+    which returns a list of account IDs that have explicit permissions for
+    a given dataset.
+
+    The get_dataset_partial_member_list method:
+    1. Queries DatasetPermission table for the dataset ID
+    2. Selects account_id values
+    3. Returns list of account IDs
+
+    Test scenarios include:
+    - Retrieving list with multiple members
+    - Retrieving list with single member
+    - Retrieving empty list (no partial members)
+    - Database query validation
+    """
+
+    @pytest.fixture
+    def mock_db_session(self):
+        """
+        Mock database session for testing.
+
+        Provides a mocked database session that can be used to verify
+        query construction and execution.
+        """
+        with patch("services.dataset_service.db.session") as mock_db:
+            yield mock_db
+
+    def test_get_dataset_partial_member_list_with_members(self, mock_db_session):
+        """
+        Test retrieving partial member list with multiple members.
+
+        Verifies that when a dataset has multiple partial members, all
+        account IDs are returned correctly.
+
+        This test ensures:
+        - Query is constructed correctly
+        - All account IDs are returned
+        - Database query is executed
+        """
+        # Arrange
+        dataset_id = "dataset-123"
+        expected_account_ids = ["user-456", "user-789", "user-012"]
+
+        # Mock the scalars query to return account IDs
+        mock_scalars_result = Mock()
+        mock_scalars_result.all.return_value = expected_account_ids
+        mock_db_session.scalars.return_value = mock_scalars_result
+
+        # Act
+        result = DatasetPermissionService.get_dataset_partial_member_list(dataset_id)
+
+        # Assert
+        assert result == expected_account_ids
+        assert len(result) == 3
+
+        # Verify query was executed
+        mock_db_session.scalars.assert_called_once()
+
+    def test_get_dataset_partial_member_list_with_single_member(self, mock_db_session):
+        """
+        Test retrieving partial member list with single member.
+
+        Verifies that when a dataset has only one partial member, the
+        single account ID is returned correctly.
+
+        This test ensures:
+        - Query works correctly for single member
+        - Result is a list with one element
+        - Database query is executed
+        """
+        # Arrange
+        dataset_id = "dataset-123"
+        expected_account_ids = ["user-456"]
+
+        # Mock the scalars query to return single account ID
+        mock_scalars_result = Mock()
+        mock_scalars_result.all.return_value = expected_account_ids
+        mock_db_session.scalars.return_value = mock_scalars_result
+
+        # Act
+        result = DatasetPermissionService.get_dataset_partial_member_list(dataset_id)
+
+        # Assert
+        assert result == expected_account_ids
+        assert len(result) == 1
+
+        # Verify query was executed
+        mock_db_session.scalars.assert_called_once()
+
+    def test_get_dataset_partial_member_list_empty(self, mock_db_session):
+        """
+        Test retrieving partial member list when no members exist.
+
+        Verifies that when a dataset has no partial members, an empty
+        list is returned.
+
+        This test ensures:
+        - Empty list is returned correctly
+        - Query is executed even when no results
+        - No errors are raised
+        """
+        # Arrange
+        dataset_id = "dataset-123"
+
+        # Mock the scalars query to return empty list
+        mock_scalars_result = Mock()
+        mock_scalars_result.all.return_value = []
+        mock_db_session.scalars.return_value = mock_scalars_result
+
+        # Act
+        result = DatasetPermissionService.get_dataset_partial_member_list(dataset_id)
+
+        # Assert
+        assert result == []
+        assert len(result) == 0
+
+        # Verify query was executed
+        mock_db_session.scalars.assert_called_once()
+
+
+# ============================================================================
+# Tests for update_partial_member_list
+# ============================================================================
+
+
+class TestDatasetPermissionServiceUpdatePartialMemberList:
+    """
+    Comprehensive unit tests for DatasetPermissionService.update_partial_member_list method.
+
+    This test class covers the update of partial member lists for datasets,
+    which replaces the existing partial member list with a new one.
+
+    The update_partial_member_list method:
+    1. Deletes all existing DatasetPermission records for the dataset
+    2. Creates new DatasetPermission records for each user in the list
+    3. Adds all new permissions to the session
+    4. Commits the transaction
+    5. Rolls back on error
+
+    Test scenarios include:
+    - Adding new partial members
+    - Updating existing partial members
+    - Replacing entire member list
+    - Handling empty member list
+    - Database transaction handling
+    - Error handling and rollback
+    """
+
+    @pytest.fixture
+    def mock_db_session(self):
+        """
+        Mock database session for testing.
+
+        Provides a mocked database session that can be used to verify
+        database operations including queries, adds, commits, and rollbacks.
+        """
+        with patch("services.dataset_service.db.session") as mock_db:
+            yield mock_db
+
+    def test_update_partial_member_list_add_new_members(self, mock_db_session):
+        """
+        Test adding new partial members to a dataset.
+
+        Verifies that when updating with new members, the old members
+        are deleted and new members are added correctly.
+
+        This test ensures:
+        - Old permissions are deleted
+        - New permissions are created
+        - All permissions are added to session
+        - Transaction is committed
+        """
+        # Arrange
+        tenant_id = "tenant-123"
+        dataset_id = "dataset-123"
+        user_list = DatasetPermissionTestDataFactory.create_user_list_mock(["user-456", "user-789"])
+
+        # Mock the query delete operation
+        mock_query = Mock()
+        mock_query.where.return_value = mock_query
+        mock_query.delete.return_value = None
+        mock_db_session.query.return_value = mock_query
+
+        # Act
+        DatasetPermissionService.update_partial_member_list(tenant_id, dataset_id, user_list)
+
+        # Assert
+        # Verify old permissions were deleted
+        mock_db_session.query.assert_called()
+        mock_query.where.assert_called()
+
+        # Verify new permissions were added
+        mock_db_session.add_all.assert_called_once()
+
+        # Verify transaction was committed
+        mock_db_session.commit.assert_called_once()
+
+        # Verify no rollback occurred
+        mock_db_session.rollback.assert_not_called()
+
+    def test_update_partial_member_list_replace_existing(self, mock_db_session):
+        """
+        Test replacing existing partial members with new ones.
+
+        Verifies that when updating with a different member list, the
+        old members are removed and new members are added.
+
+        This test ensures:
+        - Old permissions are deleted
+        - New permissions replace old ones
+        - Transaction is committed successfully
+        """
+        # Arrange
+        tenant_id = "tenant-123"
+        dataset_id = "dataset-123"
+        user_list = DatasetPermissionTestDataFactory.create_user_list_mock(["user-999", "user-888"])
+
+        # Mock the query delete operation
+        mock_query = Mock()
+        mock_query.where.return_value = mock_query
+        mock_query.delete.return_value = None
+        mock_db_session.query.return_value = mock_query
+
+        # Act
+        DatasetPermissionService.update_partial_member_list(tenant_id, dataset_id, user_list)
+
+        # Assert
+        # Verify old permissions were deleted
+        mock_db_session.query.assert_called()
+
+        # Verify new permissions were added
+        mock_db_session.add_all.assert_called_once()
+
+        # Verify transaction was committed
+        mock_db_session.commit.assert_called_once()
+
+    def test_update_partial_member_list_empty_list(self, mock_db_session):
+        """
+        Test updating with empty member list (clearing all members).
+
+        Verifies that when updating with an empty list, all existing
+        permissions are deleted and no new permissions are added.
+
+        This test ensures:
+        - Old permissions are deleted
+        - No new permissions are added
+        - Transaction is committed
+        """
+        # Arrange
+        tenant_id = "tenant-123"
+        dataset_id = "dataset-123"
+        user_list = []
+
+        # Mock the query delete operation
+        mock_query = Mock()
+        mock_query.where.return_value = mock_query
+        mock_query.delete.return_value = None
+        mock_db_session.query.return_value = mock_query
+
+        # Act
+        DatasetPermissionService.update_partial_member_list(tenant_id, dataset_id, user_list)
+
+        # Assert
+        # Verify old permissions were deleted
+        mock_db_session.query.assert_called()
+
+        # Verify add_all was called with empty list
+        mock_db_session.add_all.assert_called_once_with([])
+
+        # Verify transaction was committed
+        mock_db_session.commit.assert_called_once()
+
+    def test_update_partial_member_list_database_error_rollback(self, mock_db_session):
+        """
+        Test error handling and rollback on database error.
+
+        Verifies that when a database error occurs during the update,
+        the transaction is rolled back and the error is re-raised.
+
+        This test ensures:
+        - Error is caught and handled
+        - Transaction is rolled back
+        - Error is re-raised
+        - No commit occurs after error
+        """
+        # Arrange
+        tenant_id = "tenant-123"
+        dataset_id = "dataset-123"
+        user_list = DatasetPermissionTestDataFactory.create_user_list_mock(["user-456"])
+
+        # Mock the query delete operation
+        mock_query = Mock()
+        mock_query.where.return_value = mock_query
+        mock_query.delete.return_value = None
+        mock_db_session.query.return_value = mock_query
+
+        # Mock commit to raise an error
+        database_error = Exception("Database connection error")
+        mock_db_session.commit.side_effect = database_error
+
+        # Act & Assert
+        with pytest.raises(Exception, match="Database connection error"):
+            DatasetPermissionService.update_partial_member_list(tenant_id, dataset_id, user_list)
+
+        # Verify rollback was called
+        mock_db_session.rollback.assert_called_once()
+
+
 # ============================================================================
 # Tests for check_permission
 # ============================================================================
@@ -459,6 +776,144 @@ class TestDatasetPermissionServiceCheckPermission:
         mock_get_partial_member_list.assert_called_once_with(dataset.id)
 
 
+# ============================================================================
+# Tests for clear_partial_member_list
+# ============================================================================
+
+
+class TestDatasetPermissionServiceClearPartialMemberList:
+    """
+    Comprehensive unit tests for DatasetPermissionService.clear_partial_member_list method.
+
+    This test class covers the clearing of partial member lists, which removes
+    all DatasetPermission records for a given dataset.
+
+    The clear_partial_member_list method:
+    1. Deletes all DatasetPermission records for the dataset
+    2. Commits the transaction
+    3. Rolls back on error
+
+    Test scenarios include:
+    - Clearing list with existing members
+    - Clearing empty list (no members)
+    - Database transaction handling
+    - Error handling and rollback
+    """
+
+    @pytest.fixture
+    def mock_db_session(self):
+        """
+        Mock database session for testing.
+
+        Provides a mocked database session that can be used to verify
+        database operations including queries, deletes, commits, and rollbacks.
+        """
+        with patch("services.dataset_service.db.session") as mock_db:
+            yield mock_db
+
+    def test_clear_partial_member_list_success(self, mock_db_session):
+        """
+        Test successful clearing of partial member list.
+
+        Verifies that when clearing a partial member list, all permissions
+        are deleted and the transaction is committed.
+
+        This test ensures:
+        - All permissions are deleted
+        - Transaction is committed
+        - No errors are raised
+        """
+        # Arrange
+        dataset_id = "dataset-123"
+
+        # Mock the query delete operation
+        mock_query = Mock()
+        mock_query.where.return_value = mock_query
+        mock_query.delete.return_value = None
+        mock_db_session.query.return_value = mock_query
+
+        # Act
+        DatasetPermissionService.clear_partial_member_list(dataset_id)
+
+        # Assert
+        # Verify query was executed
+        mock_db_session.query.assert_called()
+
+        # Verify delete was called
+        mock_query.where.assert_called()
+        mock_query.delete.assert_called_once()
+
+        # Verify transaction was committed
+        mock_db_session.commit.assert_called_once()
+
+        # Verify no rollback occurred
+        mock_db_session.rollback.assert_not_called()
+
+    def test_clear_partial_member_list_empty_list(self, mock_db_session):
+        """
+        Test clearing partial member list when no members exist.
+
+        Verifies that when clearing an already empty list, the operation
+        completes successfully without errors.
+
+        This test ensures:
+        - Operation works correctly for empty lists
+        - Transaction is committed
+        - No errors are raised
+        """
+        # Arrange
+        dataset_id = "dataset-123"
+
+        # Mock the query delete operation
+        mock_query = Mock()
+        mock_query.where.return_value = mock_query
+        mock_query.delete.return_value = None
+        mock_db_session.query.return_value = mock_query
+
+        # Act
+        DatasetPermissionService.clear_partial_member_list(dataset_id)
+
+        # Assert
+        # Verify query was executed
+        mock_db_session.query.assert_called()
+
+        # Verify transaction was committed
+        mock_db_session.commit.assert_called_once()
+
+    def test_clear_partial_member_list_database_error_rollback(self, mock_db_session):
+        """
+        Test error handling and rollback on database error.
+
+        Verifies that when a database error occurs during clearing,
+        the transaction is rolled back and the error is re-raised.
+
+        This test ensures:
+        - Error is caught and handled
+        - Transaction is rolled back
+        - Error is re-raised
+        - No commit occurs after error
+        """
+        # Arrange
+        dataset_id = "dataset-123"
+
+        # Mock the query delete operation
+        mock_query = Mock()
+        mock_query.where.return_value = mock_query
+        mock_query.delete.return_value = None
+        mock_db_session.query.return_value = mock_query
+
+        # Mock commit to raise an error
+        database_error = Exception("Database connection error")
+        mock_db_session.commit.side_effect = database_error
+
+        # Act & Assert
+        with pytest.raises(Exception, match="Database connection error"):
+            DatasetPermissionService.clear_partial_member_list(dataset_id)
+
+        # Verify rollback was called
+        mock_db_session.rollback.assert_called_once()
+
+
 # ============================================================================
 # Tests for DatasetService.check_dataset_permission
 # ============================================================================
@@ -592,6 +1047,72 @@ class TestDatasetServiceCheckDatasetPermission:
         with pytest.raises(NoPermissionError, match="You do not have permission to access this dataset"):
             DatasetService.check_dataset_permission(dataset, user)
 
+    def test_check_dataset_permission_partial_members_with_permission_success(self, mock_db_session):
+        """
+        Test that user with explicit permission can access partial_members dataset.
+
+        Verifies that when a user has an explicit DatasetPermission record
+        for a partial_members dataset, they can access it successfully.
+
+        This test ensures:
+        - Explicit permissions are checked correctly
+        - Users with permissions can access
+        - Database query is executed
+        """
+        # Arrange
+        user = DatasetPermissionTestDataFactory.create_user_mock(user_id="user-123", role=TenantAccountRole.NORMAL)
+        dataset = DatasetPermissionTestDataFactory.create_dataset_mock(
+            tenant_id="tenant-123",
+            permission=DatasetPermissionEnum.PARTIAL_TEAM,
+            created_by="other-user-456",  # Not the creator
+        )
+
+        # Mock permission query to return permission record
+        mock_permission = DatasetPermissionTestDataFactory.create_dataset_permission_mock(
+            dataset_id=dataset.id, account_id=user.id
+        )
+        mock_query = Mock()
+        mock_query.filter_by.return_value = mock_query
+        mock_query.first.return_value = mock_permission
+        mock_db_session.query.return_value = mock_query
+
+        # Act (should not raise)
+        DatasetService.check_dataset_permission(dataset, user)
+
+        # Assert
+        # Verify permission query was executed
+        mock_db_session.query.assert_called()
+
+    def test_check_dataset_permission_partial_members_without_permission_error(self, mock_db_session):
+        """
+        Test error when user without permission tries to access partial_members dataset.
+
+        Verifies that when a user does not have an explicit DatasetPermission
+        record for a partial_members dataset, a NoPermissionError is raised.
+
+        This test ensures:
+        - Missing permissions are detected
+        - Error message is clear
+        - Error type is correct
+        """
+        # Arrange
+        user = DatasetPermissionTestDataFactory.create_user_mock(user_id="user-123", role=TenantAccountRole.NORMAL)
+        dataset = DatasetPermissionTestDataFactory.create_dataset_mock(
+            tenant_id="tenant-123",
+            permission=DatasetPermissionEnum.PARTIAL_TEAM,
+            created_by="other-user-456",  # Not the creator
+        )
+
+        # Mock permission query to return None (no permission)
+        mock_query = Mock()
+        mock_query.filter_by.return_value = mock_query
+        mock_query.first.return_value = None  # No permission found
+        mock_db_session.query.return_value = mock_query
+
+        # Act & Assert
+        with pytest.raises(NoPermissionError, match="You do not have permission to access this dataset"):
+            DatasetService.check_dataset_permission(dataset, user)
+
     def test_check_dataset_permission_partial_members_creator_success(self, mock_db_session):
         """
         Test that creator can access partial_members dataset without explicit permission.
@@ -790,6 +1311,72 @@ class TestDatasetServiceCheckDatasetOperatorPermission:
         with pytest.raises(NoPermissionError, match="You do not have permission to access this dataset"):
             DatasetService.check_dataset_operator_permission(user=user, dataset=dataset)
 
+    def test_check_dataset_operator_permission_partial_members_with_permission_success(self, mock_db_session):
+        """
+        Test that user with explicit permission can access partial_members dataset.
+
+        Verifies that when a user has an explicit DatasetPermission record
+        for a partial_members dataset, they can access it successfully.
+
+        This test ensures:
+        - Explicit permissions are checked correctly
+        - Users with permissions can access
+        - Database query is executed
+        """
+        # Arrange
+        user = DatasetPermissionTestDataFactory.create_user_mock(user_id="user-123", role=TenantAccountRole.NORMAL)
+        dataset = DatasetPermissionTestDataFactory.create_dataset_mock(
+            tenant_id="tenant-123",
+            permission=DatasetPermissionEnum.PARTIAL_TEAM,
+            created_by="other-user-456",  # Not the creator
+        )
+
+        # Mock permission query to return permission records
+        mock_permission = DatasetPermissionTestDataFactory.create_dataset_permission_mock(
+            dataset_id=dataset.id, account_id=user.id
+        )
+        mock_query = Mock()
+        mock_query.filter_by.return_value = mock_query
+        mock_query.all.return_value = [mock_permission]  # User has permission
+        mock_db_session.query.return_value = mock_query
+
+        # Act (should not raise)
+        DatasetService.check_dataset_operator_permission(user=user, dataset=dataset)
+
+        # Assert
+        # Verify permission query was executed
+        mock_db_session.query.assert_called()
+
+    def test_check_dataset_operator_permission_partial_members_without_permission_error(self, mock_db_session):
+        """
+        Test error when user without permission tries to access partial_members dataset.
+
+        Verifies that when a user does not have an explicit DatasetPermission
+        record for a partial_members dataset, a NoPermissionError is raised.
+
+        This test ensures:
+        - Missing permissions are detected
+        - Error message is clear
+        - Error type is correct
+        """
+        # Arrange
+        user = DatasetPermissionTestDataFactory.create_user_mock(user_id="user-123", role=TenantAccountRole.NORMAL)
+        dataset = DatasetPermissionTestDataFactory.create_dataset_mock(
+            tenant_id="tenant-123",
+            permission=DatasetPermissionEnum.PARTIAL_TEAM,
+            created_by="other-user-456",  # Not the creator
+        )
+
+        # Mock permission query to return empty list (no permission)
+        mock_query = Mock()
+        mock_query.filter_by.return_value = mock_query
+        mock_query.all.return_value = []  # No permissions found
+        mock_db_session.query.return_value = mock_query
+
+        # Act & Assert
+        with pytest.raises(NoPermissionError, match="You do not have permission to access this dataset"):
+            DatasetService.check_dataset_operator_permission(user=user, dataset=dataset)
+
 
 # ============================================================================
 # Additional Documentation and Notes

api/tests/unit_tests/services/test_clear_free_plan_expired_workflow_run_logs.py

@@ -265,61 +265,6 @@ def test_run_exits_on_empty_batch(monkeypatch: pytest.MonkeyPatch) -> None:
     cleanup.run()
 
 
-def test_run_records_metrics_on_success(monkeypatch: pytest.MonkeyPatch) -> None:
-    cutoff = datetime.datetime.now()
-    repo = FakeRepo(
-        batches=[[FakeRun("run-free", "t_free", cutoff)]],
-        delete_result={
-            "runs": 0,
-            "node_executions": 2,
-            "offloads": 1,
-            "app_logs": 3,
-            "trigger_logs": 4,
-            "pauses": 5,
-            "pause_reasons": 6,
-        },
-    )
-    cleanup = create_cleanup(monkeypatch, repo=repo, days=30, batch_size=10)
-    monkeypatch.setattr(cleanup_module.dify_config, "BILLING_ENABLED", False)
-
-    batch_calls: list[dict[str, object]] = []
-    completion_calls: list[dict[str, object]] = []
-    monkeypatch.setattr(cleanup._metrics, "record_batch", lambda **kwargs: batch_calls.append(kwargs))
-    monkeypatch.setattr(cleanup._metrics, "record_completion", lambda **kwargs: completion_calls.append(kwargs))
-
-    cleanup.run()
-
-    assert len(batch_calls) == 1
-    assert batch_calls[0]["batch_rows"] == 1
-    assert batch_calls[0]["targeted_runs"] == 1
-    assert batch_calls[0]["deleted_runs"] == 1
-    assert batch_calls[0]["related_action"] == "deleted"
-    assert len(completion_calls) == 1
-    assert completion_calls[0]["status"] == "success"
-
-
-def test_run_records_failed_metrics(monkeypatch: pytest.MonkeyPatch) -> None:
-    class FailingRepo(FakeRepo):
-        def delete_runs_with_related(
-            self, runs: list[FakeRun], delete_node_executions=None, delete_trigger_logs=None
-        ) -> dict[str, int]:
-            raise RuntimeError("delete failed")
-
-    cutoff = datetime.datetime.now()
-    repo = FailingRepo(batches=[[FakeRun("run-free", "t_free", cutoff)]])
-    cleanup = create_cleanup(monkeypatch, repo=repo, days=30, batch_size=10)
-    monkeypatch.setattr(cleanup_module.dify_config, "BILLING_ENABLED", False)
-
-    completion_calls: list[dict[str, object]] = []
-    monkeypatch.setattr(cleanup._metrics, "record_completion", lambda **kwargs: completion_calls.append(kwargs))
-
-    with pytest.raises(RuntimeError, match="delete failed"):
-        cleanup.run()
-
-    assert len(completion_calls) == 1
-    assert completion_calls[0]["status"] == "failed"
-
-
 def test_run_dry_run_skips_deletions(monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
     cutoff = datetime.datetime.now()
     repo = FakeRepo(

api/tests/unit_tests/services/test_export_app_messages.py

@@ -1,43 +0,0 @@
-import datetime
-
-import pytest
-
-from services.retention.conversation.message_export_service import AppMessageExportService
-
-
-def test_validate_export_filename_accepts_relative_path():
-    assert AppMessageExportService.validate_export_filename("exports/2026/test01") == "exports/2026/test01"
-
-
-@pytest.mark.parametrize(
-    "filename",
-    [
-        "test01.jsonl.gz",
-        "test01.jsonl",
-        "test01.gz",
-        "/tmp/test01",
-        "exports/../test01",
-        "bad\x00name",
-        "bad\tname",
-        "a" * 1025,
-    ],
-)
-def test_validate_export_filename_rejects_invalid_values(filename: str):
-    with pytest.raises(ValueError):
-        AppMessageExportService.validate_export_filename(filename)
-
-
-def test_service_derives_output_names_from_filename_base():
-    service = AppMessageExportService(
-        app_id="736b9b03-20f2-4697-91da-8d00f6325900",
-        start_from=None,
-        end_before=datetime.datetime(2026, 3, 1),
-        filename="exports/2026/test01",
-        batch_size=1000,
-        use_cloud_storage=True,
-        dry_run=True,
-    )
-
-    assert service._filename_base == "exports/2026/test01"
-    assert service.output_gz_name == "exports/2026/test01.jsonl.gz"
-    assert service.output_jsonl_name == "exports/2026/test01.jsonl"

api/tests/unit_tests/services/test_messages_clean_service.py

@@ -554,9 +554,11 @@ class TestMessagesCleanServiceFromDays:
             MessagesCleanService.from_days(policy=policy, days=-1)
 
         # Act
-        with patch("services.retention.conversation.messages_clean_service.naive_utc_now") as mock_now:
+        with patch("services.retention.conversation.messages_clean_service.datetime", autospec=True) as mock_datetime:
             fixed_now = datetime.datetime(2024, 6, 15, 14, 0, 0)
-            mock_now.return_value = fixed_now
+            mock_datetime.datetime.now.return_value = fixed_now
+            mock_datetime.timedelta = datetime.timedelta
+
             service = MessagesCleanService.from_days(policy=policy, days=0)
 
         # Assert
@@ -584,9 +586,11 @@ class TestMessagesCleanServiceFromDays:
         dry_run = True
 
         # Act
-        with patch("services.retention.conversation.messages_clean_service.naive_utc_now") as mock_now:
+        with patch("services.retention.conversation.messages_clean_service.datetime", autospec=True) as mock_datetime:
             fixed_now = datetime.datetime(2024, 6, 15, 10, 30, 0)
-            mock_now.return_value = fixed_now
+            mock_datetime.datetime.now.return_value = fixed_now
+            mock_datetime.timedelta = datetime.timedelta
+
             service = MessagesCleanService.from_days(
                 policy=policy,
                 days=days,
@@ -609,9 +613,11 @@ class TestMessagesCleanServiceFromDays:
         policy = BillingDisabledPolicy()
 
         # Act
-        with patch("services.retention.conversation.messages_clean_service.naive_utc_now") as mock_now:
+        with patch("services.retention.conversation.messages_clean_service.datetime", autospec=True) as mock_datetime:
             fixed_now = datetime.datetime(2024, 6, 15, 10, 30, 0)
-            mock_now.return_value = fixed_now
+            mock_datetime.datetime.now.return_value = fixed_now
+            mock_datetime.timedelta = datetime.timedelta
+
             service = MessagesCleanService.from_days(policy=policy)
 
         # Assert
@@ -619,53 +625,3 @@ class TestMessagesCleanServiceFromDays:
         assert service._end_before == expected_end_before
         assert service._batch_size == 1000  # default
         assert service._dry_run is False  # default
-
-
-class TestMessagesCleanServiceRun:
-    """Unit tests for MessagesCleanService.run instrumentation behavior."""
-
-    def test_run_records_completion_metrics_on_success(self):
-        # Arrange
-        service = MessagesCleanService(
-            policy=BillingDisabledPolicy(),
-            start_from=datetime.datetime(2024, 1, 1),
-            end_before=datetime.datetime(2024, 1, 2),
-            batch_size=100,
-            dry_run=False,
-        )
-        expected_stats = {
-            "batches": 1,
-            "total_messages": 10,
-            "filtered_messages": 5,
-            "total_deleted": 5,
-        }
-        service._clean_messages_by_time_range = MagicMock(return_value=expected_stats)  # type: ignore[method-assign]
-        completion_calls: list[dict[str, object]] = []
-        service._metrics.record_completion = lambda **kwargs: completion_calls.append(kwargs)  # type: ignore[method-assign]
-
-        # Act
-        result = service.run()
-
-        # Assert
-        assert result == expected_stats
-        assert len(completion_calls) == 1
-        assert completion_calls[0]["status"] == "success"
-
-    def test_run_records_completion_metrics_on_failure(self):
-        # Arrange
-        service = MessagesCleanService(
-            policy=BillingDisabledPolicy(),
-            start_from=datetime.datetime(2024, 1, 1),
-            end_before=datetime.datetime(2024, 1, 2),
-            batch_size=100,
-            dry_run=False,
-        )
-        service._clean_messages_by_time_range = MagicMock(side_effect=RuntimeError("clean failed"))  # type: ignore[method-assign]
-        completion_calls: list[dict[str, object]] = []
-        service._metrics.record_completion = lambda **kwargs: completion_calls.append(kwargs)  # type: ignore[method-assign]
-
-        # Act & Assert
-        with pytest.raises(RuntimeError, match="clean failed"):
-            service.run()
-        assert len(completion_calls) == 1
-        assert completion_calls[0]["status"] == "failed"

api/tests/unit_tests/tasks/test_summary_queue_isolation.py

@@ -1,40 +0,0 @@
-"""
-Unit tests for summary index task queue isolation.
-
-These tasks must NOT run on the shared 'dataset' queue because they invoke LLMs
-for each document segment and can occupy all worker slots for hours, blocking
-document indexing tasks.
-"""
-
-import pytest
-
-from tasks.generate_summary_index_task import generate_summary_index_task
-from tasks.regenerate_summary_index_task import regenerate_summary_index_task
-
-SUMMARY_QUEUE = "dataset_summary"
-INDEXING_QUEUE = "dataset"
-
-
-def _task_queue(task) -> str | None:
-    # Celery's @shared_task(queue=...) stores the routing key on the task instance
-    # at runtime, but type stubs don't declare it; use getattr to stay type-clean.
-    return getattr(task, "queue", None)
-
-
-@pytest.mark.parametrize(
-    ("task", "task_name"),
-    [
-        (generate_summary_index_task, "generate_summary_index_task"),
-        (regenerate_summary_index_task, "regenerate_summary_index_task"),
-    ],
-)
-def test_summary_task_uses_dedicated_queue(task, task_name):
-    """Summary tasks must use the dataset_summary queue, not the shared dataset queue.
-
-    Summary generation is LLM-heavy and will block document indexing if placed
-    on the shared queue.
-    """
-    assert _task_queue(task) == SUMMARY_QUEUE, (
-        f"{task_name} must run on '{SUMMARY_QUEUE}' queue (not '{INDEXING_QUEUE}'). "
-        "Summary generation is LLM-heavy and will block document indexing if placed on the shared queue."
-    )

api/uv.lock

@@ -1606,7 +1606,7 @@ requires-dist = [
     { name = "langfuse", specifier = "~=2.51.3" },
     { name = "langsmith", specifier = "~=0.1.77" },
     { name = "litellm", specifier = "==1.77.1" },
-    { name = "markdown", specifier = "~=3.8.1" },
+    { name = "markdown", specifier = "~=3.5.1" },
     { name = "mlflow-skinny", specifier = ">=3.0.0" },
     { name = "numpy", specifier = "~=1.26.4" },
     { name = "openpyxl", specifier = "~=3.1.5" },
@@ -3437,11 +3437,11 @@ wheels = [
 
 [[package]]
 name = "markdown"
-version = "3.8.1"
+version = "3.5.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/db/7c/0738e5ff0adccd0b4e02c66d0446c03a3c557e02bb49b7c263d7ab56c57d/markdown-3.8.1.tar.gz", hash = "sha256:a2e2f01cead4828ee74ecca9623045f62216aef2212a7685d6eb9163f590b8c1", size = 361280, upload-time = "2025-06-18T14:50:49.618Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/11/28/c5441a6642681d92de56063fa7984df56f783d3f1eba518dc3e7a253b606/Markdown-3.5.2.tar.gz", hash = "sha256:e1ac7b3dc550ee80e602e71c1d168002f062e49f1b11e26a36264dafd4df2ef8", size = 349398, upload-time = "2024-01-10T15:19:38.261Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/50/34/3d1ff0cb4843a33817d06800e9383a2b2a2df4d508e37f53a40e829905d9/markdown-3.8.1-py3-none-any.whl", hash = "sha256:46cc0c0f1e5211ab2e9d453582f0b28a1bfaf058a9f7d5c50386b99b588d8811", size = 106642, upload-time = "2025-06-18T14:50:48.52Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f4/f0031854de10a0bc7821ef9fca0b92ca0d7aa6fbfbf504c5473ba825e49c/Markdown-3.5.2-py3-none-any.whl", hash = "sha256:d43323865d89fc0cb9b20c75fc8ad313af307cc087e84b657d9eec768eddeadd", size = 103870, upload-time = "2024-01-10T15:19:36.071Z" },
 ]
 
 [[package]]

dev/pyrefly-check-local

@@ -1,34 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-SCRIPT_DIR="$(dirname "$(realpath "$0")")"
-REPO_ROOT="$SCRIPT_DIR/.."
-cd "$REPO_ROOT"
-
-EXCLUDES_FILE="api/pyrefly-local-excludes.txt"
-
-pyrefly_args=(
-  "--summary=none"
-  "--project-excludes=.venv"
-  "--project-excludes=migrations/"
-  "--project-excludes=tests/"
-)
-
-if [[ -f "$EXCLUDES_FILE" ]]; then
-  while IFS= read -r exclude; do
-    [[ -z "$exclude" || "${exclude:0:1}" == "#" ]] && continue
-    pyrefly_args+=("--project-excludes=$exclude")
-  done < "$EXCLUDES_FILE"
-fi
-
-tmp_output="$(mktemp)"
-set +e
-uv run --directory api --dev pyrefly check "${pyrefly_args[@]}" >"$tmp_output" 2>&1
-pyrefly_status=$?
-set -e
-
-uv run --directory api python libs/pyrefly_diagnostics.py < "$tmp_output"
-rm -f "$tmp_output"
-
-exit "$pyrefly_status"

dev/start-worker

@@ -21,7 +21,6 @@ show_help() {
   echo ""
   echo "Available queues:"
   echo "  dataset                - RAG indexing and document processing"
-  echo "  dataset_summary        - LLM-heavy summary index generation (isolated from indexing)"
   echo "  workflow               - Workflow triggers (community edition)"
   echo "  workflow_professional  - Professional tier workflows (cloud edition)"
   echo "  workflow_team         - Team tier workflows (cloud edition)"
@@ -107,10 +106,10 @@ if [[ -z "${QUEUES}" ]]; then
   # Configure queues based on edition
   if [[ "${EDITION}" == "CLOUD" ]]; then
     # Cloud edition: separate queues for dataset and trigger tasks
-    QUEUES="dataset,dataset_summary,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow_professional,workflow_team,workflow_sandbox,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution"
+    QUEUES="dataset,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow_professional,workflow_team,workflow_sandbox,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution"
   else
     # Community edition (SELF_HOSTED): dataset and workflow have separate queues
-    QUEUES="dataset,dataset_summary,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution"
+    QUEUES="dataset,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution"
   fi
 
   echo "No queues specified, using edition-based defaults: ${QUEUES}"

scripts/stress-test/common/config_helper.py

@@ -6,13 +6,6 @@ from typing import Any
 
 
 class ConfigHelper:
-    _LEGACY_SECTION_MAP = {
-        "admin_config": "admin",
-        "token_config": "auth",
-        "app_config": "app",
-        "api_key_config": "api_key",
-    }
-
     """Helper class for reading and writing configuration files."""
 
     def __init__(self, base_dir: Path | None = None):
@@ -57,8 +50,14 @@ class ConfigHelper:
             Dictionary containing config data, or None if file doesn't exist
         """
         # Provide backward compatibility for old config names
-        if filename in self._LEGACY_SECTION_MAP:
-            return self.get_state_section(self._LEGACY_SECTION_MAP[filename])
+        if filename in ["admin_config", "token_config", "app_config", "api_key_config"]:
+            section_map = {
+                "admin_config": "admin",
+                "token_config": "auth",
+                "app_config": "app",
+                "api_key_config": "api_key",
+            }
+            return self.get_state_section(section_map[filename])
 
         config_path = self.get_config_path(filename)
 
@@ -86,11 +85,14 @@ class ConfigHelper:
             True if successful, False otherwise
         """
         # Provide backward compatibility for old config names
-        if filename in self._LEGACY_SECTION_MAP:
-            return self.update_state_section(
-                self._LEGACY_SECTION_MAP[filename],
-                data,
-            )
+        if filename in ["admin_config", "token_config", "app_config", "api_key_config"]:
+            section_map = {
+                "admin_config": "admin",
+                "token_config": "auth",
+                "app_config": "app",
+                "api_key_config": "api_key",
+            }
+            return self.update_state_section(section_map[filename], data)
 
         self.ensure_config_dir()
         config_path = self.get_config_path(filename)

web/AGENTS.md

@@ -2,12 +2,6 @@
 
 - Refer to the `./docs/test.md` and `./docs/lint.md` for detailed frontend workflow instructions.
 
-## Overlay Components (Mandatory)
-
-- `./docs/overlay-migration.md` is the source of truth for overlay-related work.
-- In new or modified code, use only overlay primitives from `@/app/components/base/ui/*`.
-- Do not introduce deprecated overlay imports from `@/app/components/base/*`; when touching legacy callers, prefer migrating them and keep the allowlist shrinking (never expanding).
-
 ## Automated Test Generation
 
 - Use `./docs/test.md` as the canonical instruction set for generating frontend automated tests.

web/app/components/base/amplitude/AmplitudeProvider.spec.tsx

@@ -1,139 +0,0 @@
-import * as amplitude from '@amplitude/analytics-browser'
-import { sessionReplayPlugin } from '@amplitude/plugin-session-replay-browser'
-import { render } from '@testing-library/react'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import AmplitudeProvider, { isAmplitudeEnabled } from './AmplitudeProvider'
-
-const mockConfig = vi.hoisted(() => ({
-  AMPLITUDE_API_KEY: 'test-api-key',
-  IS_CLOUD_EDITION: true,
-}))
-
-vi.mock('@/config', () => mockConfig)
-
-vi.mock('@amplitude/analytics-browser', () => ({
-  init: vi.fn(),
-  add: vi.fn(),
-}))
-
-vi.mock('@amplitude/plugin-session-replay-browser', () => ({
-  sessionReplayPlugin: vi.fn(() => ({ name: 'session-replay' })),
-}))
-
-describe('AmplitudeProvider', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mockConfig.AMPLITUDE_API_KEY = 'test-api-key'
-    mockConfig.IS_CLOUD_EDITION = true
-  })
-
-  describe('isAmplitudeEnabled', () => {
-    it('returns true when cloud edition and api key present', () => {
-      expect(isAmplitudeEnabled()).toBe(true)
-    })
-
-    it('returns false when cloud edition but no api key', () => {
-      mockConfig.AMPLITUDE_API_KEY = ''
-      expect(isAmplitudeEnabled()).toBe(false)
-    })
-
-    it('returns false when not cloud edition', () => {
-      mockConfig.IS_CLOUD_EDITION = false
-      expect(isAmplitudeEnabled()).toBe(false)
-    })
-  })
-
-  describe('Component', () => {
-    it('initializes amplitude when enabled', () => {
-      render(<AmplitudeProvider sessionReplaySampleRate={0.8} />)
-
-      expect(amplitude.init).toHaveBeenCalledWith('test-api-key', expect.any(Object))
-      expect(sessionReplayPlugin).toHaveBeenCalledWith({ sampleRate: 0.8 })
-      expect(amplitude.add).toHaveBeenCalledTimes(2)
-    })
-
-    it('does not initialize amplitude when disabled', () => {
-      mockConfig.AMPLITUDE_API_KEY = ''
-      render(<AmplitudeProvider />)
-
-      expect(amplitude.init).not.toHaveBeenCalled()
-      expect(amplitude.add).not.toHaveBeenCalled()
-    })
-
-    it('pageNameEnrichmentPlugin logic works as expected', async () => {
-      render(<AmplitudeProvider />)
-      const plugin = vi.mocked(amplitude.add).mock.calls[0]?.[0] as amplitude.Types.EnrichmentPlugin | undefined
-      expect(plugin).toBeDefined()
-      if (!plugin?.execute || !plugin.setup)
-        throw new Error('Expected page-name-enrichment plugin with setup/execute')
-
-      expect(plugin.name).toBe('page-name-enrichment')
-
-      const execute = plugin.execute
-      const setup = plugin.setup
-      type SetupFn = NonNullable<amplitude.Types.EnrichmentPlugin['setup']>
-      const getPageTitle = (evt: amplitude.Types.Event | null | undefined) =>
-        (evt?.event_properties as Record<string, unknown> | undefined)?.['[Amplitude] Page Title']
-
-      await setup(
-        {} as Parameters<SetupFn>[0],
-        {} as Parameters<SetupFn>[1],
-      )
-
-      const originalWindowLocation = window.location
-      try {
-        Object.defineProperty(window, 'location', {
-          value: { pathname: '/datasets' },
-          writable: true,
-        })
-        const event: amplitude.Types.Event = {
-          event_type: '[Amplitude] Page Viewed',
-          event_properties: {},
-        }
-        const result = await execute(event)
-        expect(getPageTitle(result)).toBe('Knowledge')
-        window.location.pathname = '/'
-        await execute(event)
-        expect(getPageTitle(event)).toBe('Home')
-        window.location.pathname = '/apps'
-        await execute(event)
-        expect(getPageTitle(event)).toBe('Studio')
-        window.location.pathname = '/explore'
-        await execute(event)
-        expect(getPageTitle(event)).toBe('Explore')
-        window.location.pathname = '/tools'
-        await execute(event)
-        expect(getPageTitle(event)).toBe('Tools')
-        window.location.pathname = '/account'
-        await execute(event)
-        expect(getPageTitle(event)).toBe('Account')
-        window.location.pathname = '/signin'
-        await execute(event)
-        expect(getPageTitle(event)).toBe('Sign In')
-        window.location.pathname = '/signup'
-        await execute(event)
-        expect(getPageTitle(event)).toBe('Sign Up')
-        window.location.pathname = '/unknown'
-        await execute(event)
-        expect(getPageTitle(event)).toBe('Unknown')
-        const otherEvent = {
-          event_type: 'Button Clicked',
-          event_properties: {},
-        } as amplitude.Types.Event
-        const otherResult = await execute(otherEvent)
-        expect(getPageTitle(otherResult)).toBeUndefined()
-        const noPropsEvent = {
-          event_type: '[Amplitude] Page Viewed',
-        } as amplitude.Types.Event
-        const noPropsResult = await execute(noPropsEvent)
-        expect(noPropsResult?.event_properties).toBeUndefined()
-      }
-      finally {
-        Object.defineProperty(window, 'location', {
-          value: originalWindowLocation,
-          writable: true,
-        })
-      }
-    })
-  })
-})

web/app/components/base/amplitude/index.spec.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import AmplitudeProvider, { isAmplitudeEnabled } from './AmplitudeProvider'
-import indexDefault, {
-  isAmplitudeEnabled as indexIsAmplitudeEnabled,
-  resetUser,
-  setUserId,
-  setUserProperties,
-  trackEvent,
-} from './index'
-import {
-  resetUser as utilsResetUser,
-  setUserId as utilsSetUserId,
-  setUserProperties as utilsSetUserProperties,
-  trackEvent as utilsTrackEvent,
-} from './utils'
-
-describe('Amplitude index exports', () => {
-  it('exports AmplitudeProvider as default', () => {
-    expect(indexDefault).toBe(AmplitudeProvider)
-  })
-
-  it('exports isAmplitudeEnabled', () => {
-    expect(indexIsAmplitudeEnabled).toBe(isAmplitudeEnabled)
-  })
-
-  it('exports utils', () => {
-    expect(resetUser).toBe(utilsResetUser)
-    expect(setUserId).toBe(utilsSetUserId)
-    expect(setUserProperties).toBe(utilsSetUserProperties)
-    expect(trackEvent).toBe(utilsTrackEvent)
-  })
-})

web/app/components/base/amplitude/utils.spec.ts

@@ -1,119 +0,0 @@
-import { resetUser, setUserId, setUserProperties, trackEvent } from './utils'
-
-const mockState = vi.hoisted(() => ({
-  enabled: true,
-}))
-
-const mockTrack = vi.hoisted(() => vi.fn())
-const mockSetUserId = vi.hoisted(() => vi.fn())
-const mockIdentify = vi.hoisted(() => vi.fn())
-const mockReset = vi.hoisted(() => vi.fn())
-
-const MockIdentify = vi.hoisted(() =>
-  class {
-    setCalls: Array<[string, unknown]> = []
-
-    set(key: string, value: unknown) {
-      this.setCalls.push([key, value])
-      return this
-    }
-  },
-)
-
-vi.mock('./AmplitudeProvider', () => ({
-  isAmplitudeEnabled: () => mockState.enabled,
-}))
-
-vi.mock('@amplitude/analytics-browser', () => ({
-  track: (...args: unknown[]) => mockTrack(...args),
-  setUserId: (...args: unknown[]) => mockSetUserId(...args),
-  identify: (...args: unknown[]) => mockIdentify(...args),
-  reset: (...args: unknown[]) => mockReset(...args),
-  Identify: MockIdentify,
-}))
-
-describe('amplitude utils', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mockState.enabled = true
-  })
-
-  describe('trackEvent', () => {
-    it('should call amplitude.track when amplitude is enabled', () => {
-      trackEvent('dataset_created', { source: 'wizard' })
-
-      expect(mockTrack).toHaveBeenCalledTimes(1)
-      expect(mockTrack).toHaveBeenCalledWith('dataset_created', { source: 'wizard' })
-    })
-
-    it('should not call amplitude.track when amplitude is disabled', () => {
-      mockState.enabled = false
-
-      trackEvent('dataset_created', { source: 'wizard' })
-
-      expect(mockTrack).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('setUserId', () => {
-    it('should call amplitude.setUserId when amplitude is enabled', () => {
-      setUserId('user-123')
-
-      expect(mockSetUserId).toHaveBeenCalledTimes(1)
-      expect(mockSetUserId).toHaveBeenCalledWith('user-123')
-    })
-
-    it('should not call amplitude.setUserId when amplitude is disabled', () => {
-      mockState.enabled = false
-
-      setUserId('user-123')
-
-      expect(mockSetUserId).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('setUserProperties', () => {
-    it('should build identify event and call amplitude.identify when amplitude is enabled', () => {
-      const properties: Record<string, unknown> = {
-        role: 'owner',
-        seats: 3,
-        verified: true,
-      }
-
-      setUserProperties(properties)
-
-      expect(mockIdentify).toHaveBeenCalledTimes(1)
-      const identifyArg = mockIdentify.mock.calls[0][0] as InstanceType<typeof MockIdentify>
-      expect(identifyArg).toBeInstanceOf(MockIdentify)
-      expect(identifyArg.setCalls).toEqual([
-        ['role', 'owner'],
-        ['seats', 3],
-        ['verified', true],
-      ])
-    })
-
-    it('should not call amplitude.identify when amplitude is disabled', () => {
-      mockState.enabled = false
-
-      setUserProperties({ role: 'owner' })
-
-      expect(mockIdentify).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('resetUser', () => {
-    it('should call amplitude.reset when amplitude is enabled', () => {
-      resetUser()
-
-      expect(mockReset).toHaveBeenCalledTimes(1)
-    })
-
-    it('should not call amplitude.reset when amplitude is disabled', () => {
-      mockState.enabled = false
-
-      resetUser()
-
-      expect(mockReset).not.toHaveBeenCalled()
-    })
-  })
-})

web/app/components/base/audio-btn/__tests__/audio.player.manager.spec.ts

@@ -1,148 +0,0 @@
-import { AudioPlayerManager } from '../audio.player.manager'
-
-type AudioCallback = ((event: string) => void) | null
-type AudioPlayerCtorArgs = [
-  string,
-  boolean,
-  string | undefined,
-  string | null | undefined,
-  string | undefined,
-  AudioCallback,
-]
-
-type MockAudioPlayerInstance = {
-  setCallback: ReturnType<typeof vi.fn>
-  pauseAudio: ReturnType<typeof vi.fn>
-  resetMsgId: ReturnType<typeof vi.fn>
-  cacheBuffers: Array<ArrayBuffer>
-  sourceBuffer: {
-    abort: ReturnType<typeof vi.fn>
-  } | undefined
-}
-
-const mockState = vi.hoisted(() => ({
-  instances: [] as MockAudioPlayerInstance[],
-}))
-
-const mockAudioPlayerConstructor = vi.hoisted(() => vi.fn())
-
-const MockAudioPlayer = vi.hoisted(() => {
-  return class MockAudioPlayerClass {
-    setCallback = vi.fn()
-    pauseAudio = vi.fn()
-    resetMsgId = vi.fn()
-    cacheBuffers = [new ArrayBuffer(1)]
-    sourceBuffer = { abort: vi.fn() }
-
-    constructor(...args: AudioPlayerCtorArgs) {
-      mockAudioPlayerConstructor(...args)
-      mockState.instances.push(this as unknown as MockAudioPlayerInstance)
-    }
-  }
-})
-
-vi.mock('@/app/components/base/audio-btn/audio', () => ({
-  default: MockAudioPlayer,
-}))
-
-describe('AudioPlayerManager', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mockState.instances = []
-    Reflect.set(AudioPlayerManager, 'instance', undefined)
-  })
-
-  describe('getInstance', () => {
-    it('should return the same singleton instance across calls', () => {
-      const first = AudioPlayerManager.getInstance()
-      const second = AudioPlayerManager.getInstance()
-
-      expect(first).toBe(second)
-    })
-  })
-
-  describe('getAudioPlayer', () => {
-    it('should create a new audio player when no existing player is cached', () => {
-      const manager = AudioPlayerManager.getInstance()
-      const callback = vi.fn()
-
-      const result = manager.getAudioPlayer('/text-to-audio', false, 'msg-1', 'hello', 'en-US', callback)
-
-      expect(mockAudioPlayerConstructor).toHaveBeenCalledTimes(1)
-      expect(mockAudioPlayerConstructor).toHaveBeenCalledWith(
-        '/text-to-audio',
-        false,
-        'msg-1',
-        'hello',
-        'en-US',
-        callback,
-      )
-      expect(result).toBe(mockState.instances[0])
-    })
-
-    it('should reuse existing player and update callback when msg id is unchanged', () => {
-      const manager = AudioPlayerManager.getInstance()
-      const firstCallback = vi.fn()
-      const secondCallback = vi.fn()
-
-      const first = manager.getAudioPlayer('/text-to-audio', false, 'msg-1', 'hello', 'en-US', firstCallback)
-      const second = manager.getAudioPlayer('/ignored', true, 'msg-1', 'ignored', 'fr-FR', secondCallback)
-
-      expect(mockAudioPlayerConstructor).toHaveBeenCalledTimes(1)
-      expect(first).toBe(second)
-      expect(mockState.instances[0].setCallback).toHaveBeenCalledTimes(1)
-      expect(mockState.instances[0].setCallback).toHaveBeenCalledWith(secondCallback)
-    })
-
-    it('should cleanup existing player and create a new one when msg id changes', () => {
-      const manager = AudioPlayerManager.getInstance()
-      const callback = vi.fn()
-      manager.getAudioPlayer('/text-to-audio', false, 'msg-1', 'hello', 'en-US', callback)
-      const previous = mockState.instances[0]
-
-      const next = manager.getAudioPlayer('/apps/1/text-to-audio', false, 'msg-2', 'world', 'en-US', callback)
-
-      expect(previous.pauseAudio).toHaveBeenCalledTimes(1)
-      expect(previous.cacheBuffers).toEqual([])
-      expect(previous.sourceBuffer?.abort).toHaveBeenCalledTimes(1)
-      expect(mockAudioPlayerConstructor).toHaveBeenCalledTimes(2)
-      expect(next).toBe(mockState.instances[1])
-    })
-
-    it('should swallow cleanup errors and still create a new player', () => {
-      const manager = AudioPlayerManager.getInstance()
-      const callback = vi.fn()
-      manager.getAudioPlayer('/text-to-audio', false, 'msg-1', 'hello', 'en-US', callback)
-      const previous = mockState.instances[0]
-      previous.pauseAudio.mockImplementation(() => {
-        throw new Error('cleanup failure')
-      })
-
-      expect(() => {
-        manager.getAudioPlayer('/apps/1/text-to-audio', false, 'msg-2', 'world', 'en-US', callback)
-      }).not.toThrow()
-
-      expect(previous.pauseAudio).toHaveBeenCalledTimes(1)
-      expect(mockAudioPlayerConstructor).toHaveBeenCalledTimes(2)
-    })
-  })
-
-  describe('resetMsgId', () => {
-    it('should forward reset message id to the cached audio player when present', () => {
-      const manager = AudioPlayerManager.getInstance()
-      const callback = vi.fn()
-      manager.getAudioPlayer('/text-to-audio', false, 'msg-1', 'hello', 'en-US', callback)
-
-      manager.resetMsgId('msg-updated')
-
-      expect(mockState.instances[0].resetMsgId).toHaveBeenCalledTimes(1)
-      expect(mockState.instances[0].resetMsgId).toHaveBeenCalledWith('msg-updated')
-    })
-
-    it('should not throw when resetting message id without an audio player', () => {
-      const manager = AudioPlayerManager.getInstance()
-
-      expect(() => manager.resetMsgId('msg-updated')).not.toThrow()
-    })
-  })
-})

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

@@ -1,610 +0,0 @@
-import { Buffer } from 'node:buffer'
-import { waitFor } from '@testing-library/react'
-import { AppSourceType } from '@/service/share'
-import AudioPlayer from '../audio'
-
-const mockToastNotify = vi.hoisted(() => vi.fn())
-const mockTextToAudioStream = vi.hoisted(() => vi.fn())
-
-vi.mock('@/app/components/base/toast', () => ({
-  default: {
-    notify: (...args: unknown[]) => mockToastNotify(...args),
-  },
-}))
-
-vi.mock('@/service/share', () => ({
-  AppSourceType: {
-    webApp: 'webApp',
-    installedApp: 'installedApp',
-  },
-  textToAudioStream: (...args: unknown[]) => mockTextToAudioStream(...args),
-}))
-
-type AudioEventName = 'ended' | 'paused' | 'loaded' | 'play' | 'timeupdate' | 'loadeddate' | 'canplay' | 'error' | 'sourceopen'
-
-type AudioEventListener = () => void
-
-type ReaderResult = {
-  value: Uint8Array | undefined
-  done: boolean
-}
-
-type Reader = {
-  read: () => Promise<ReaderResult>
-}
-
-type AudioResponse = {
-  status: number
-  body: {
-    getReader: () => Reader
-  }
-}
-
-class MockSourceBuffer {
-  updating = false
-  appendBuffer = vi.fn((_buffer: ArrayBuffer) => undefined)
-  abort = vi.fn(() => undefined)
-}
-
-class MockMediaSource {
-  readyState: 'open' | 'closed' = 'open'
-  sourceBuffer = new MockSourceBuffer()
-  private listeners: Partial<Record<AudioEventName, AudioEventListener[]>> = {}
-
-  addEventListener = vi.fn((event: AudioEventName, listener: AudioEventListener) => {
-    const listeners = this.listeners[event] || []
-    listeners.push(listener)
-    this.listeners[event] = listeners
-  })
-
-  addSourceBuffer = vi.fn((_contentType: string) => this.sourceBuffer)
-  endOfStream = vi.fn(() => undefined)
-
-  emit(event: AudioEventName) {
-    const listeners = this.listeners[event] || []
-    listeners.forEach((listener) => {
-      listener()
-    })
-  }
-}
-
-class MockAudio {
-  src = ''
-  autoplay = false
-  disableRemotePlayback = false
-  controls = false
-  paused = true
-  ended = false
-  played: unknown = null
-  private listeners: Partial<Record<AudioEventName, AudioEventListener[]>> = {}
-
-  addEventListener = vi.fn((event: AudioEventName, listener: AudioEventListener) => {
-    const listeners = this.listeners[event] || []
-    listeners.push(listener)
-    this.listeners[event] = listeners
-  })
-
-  play = vi.fn(async () => {
-    this.paused = false
-  })
-
-  pause = vi.fn(() => {
-    this.paused = true
-  })
-
-  emit(event: AudioEventName) {
-    const listeners = this.listeners[event] || []
-    listeners.forEach((listener) => {
-      listener()
-    })
-  }
-}
-
-class MockAudioContext {
-  state: 'running' | 'suspended' = 'running'
-  destination = {}
-  connect = vi.fn(() => undefined)
-  createMediaElementSource = vi.fn((_audio: MockAudio) => ({
-    connect: this.connect,
-  }))
-
-  resume = vi.fn(async () => {
-    this.state = 'running'
-  })
-
-  suspend = vi.fn(() => {
-    this.state = 'suspended'
-  })
-}
-
-const testState = {
-  mediaSources: [] as MockMediaSource[],
-  audios: [] as MockAudio[],
-  audioContexts: [] as MockAudioContext[],
-}
-
-class MockMediaSourceCtor extends MockMediaSource {
-  constructor() {
-    super()
-    testState.mediaSources.push(this)
-  }
-}
-
-class MockAudioCtor extends MockAudio {
-  constructor() {
-    super()
-    testState.audios.push(this)
-  }
-}
-
-class MockAudioContextCtor extends MockAudioContext {
-  constructor() {
-    super()
-    testState.audioContexts.push(this)
-  }
-}
-
-const originalAudio = globalThis.Audio
-const originalAudioContext = globalThis.AudioContext
-const originalCreateObjectURL = globalThis.URL.createObjectURL
-const originalMediaSource = window.MediaSource
-const originalManagedMediaSource = window.ManagedMediaSource
-
-const setMediaSourceSupport = (options: { mediaSource: boolean, managedMediaSource: boolean }) => {
-  Object.defineProperty(window, 'MediaSource', {
-    configurable: true,
-    writable: true,
-    value: options.mediaSource ? MockMediaSourceCtor : undefined,
-  })
-  Object.defineProperty(window, 'ManagedMediaSource', {
-    configurable: true,
-    writable: true,
-    value: options.managedMediaSource ? MockMediaSourceCtor : undefined,
-  })
-}
-
-const makeAudioResponse = (status: number, reads: ReaderResult[]): AudioResponse => {
-  const read = vi.fn<() => Promise<ReaderResult>>()
-  reads.forEach((result) => {
-    read.mockResolvedValueOnce(result)
-  })
-
-  return {
-    status,
-    body: {
-      getReader: () => ({ read }),
-    },
-  }
-}
-
-describe('AudioPlayer', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    testState.mediaSources = []
-    testState.audios = []
-    testState.audioContexts = []
-
-    Object.defineProperty(globalThis, 'Audio', {
-      configurable: true,
-      writable: true,
-      value: MockAudioCtor,
-    })
-    Object.defineProperty(globalThis, 'AudioContext', {
-      configurable: true,
-      writable: true,
-      value: MockAudioContextCtor,
-    })
-    Object.defineProperty(globalThis.URL, 'createObjectURL', {
-      configurable: true,
-      writable: true,
-      value: vi.fn(() => 'blob:mock-url'),
-    })
-
-    setMediaSourceSupport({ mediaSource: true, managedMediaSource: false })
-  })
-
-  afterAll(() => {
-    Object.defineProperty(globalThis, 'Audio', {
-      configurable: true,
-      writable: true,
-      value: originalAudio,
-    })
-    Object.defineProperty(globalThis, 'AudioContext', {
-      configurable: true,
-      writable: true,
-      value: originalAudioContext,
-    })
-    Object.defineProperty(globalThis.URL, 'createObjectURL', {
-      configurable: true,
-      writable: true,
-      value: originalCreateObjectURL,
-    })
-    Object.defineProperty(window, 'MediaSource', {
-      configurable: true,
-      writable: true,
-      value: originalMediaSource,
-    })
-    Object.defineProperty(window, 'ManagedMediaSource', {
-      configurable: true,
-      writable: true,
-      value: originalManagedMediaSource,
-    })
-  })
-
-  describe('constructor behavior', () => {
-    it('should initialize media source, audio, and media element source when MediaSource exists', () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', callback)
-      const audio = testState.audios[0]
-      const audioContext = testState.audioContexts[0]
-      const mediaSource = testState.mediaSources[0]
-
-      expect(player.mediaSource).toBe(mediaSource as unknown as MediaSource)
-      expect(globalThis.URL.createObjectURL).toHaveBeenCalledTimes(1)
-      expect(audio.src).toBe('blob:mock-url')
-      expect(audio.autoplay).toBe(true)
-      expect(audioContext.createMediaElementSource).toHaveBeenCalledWith(audio)
-      expect(audioContext.connect).toHaveBeenCalledTimes(1)
-    })
-
-    it('should notify unsupported browser when no MediaSource implementation exists', () => {
-      setMediaSourceSupport({ mediaSource: false, managedMediaSource: false })
-
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', null)
-      const audio = testState.audios[0]
-
-      expect(player.mediaSource).toBeNull()
-      expect(audio.src).toBe('')
-      expect(mockToastNotify).toHaveBeenCalledTimes(1)
-      expect(mockToastNotify).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'error',
-        }),
-      )
-    })
-
-    it('should configure fallback audio controls when ManagedMediaSource is used', () => {
-      setMediaSourceSupport({ mediaSource: false, managedMediaSource: true })
-
-      // Create with callback to ensure constructor path completes with fallback source.
-      const player = new AudioPlayer('/text-to-audio', false, 'msg-1', 'hello', undefined, vi.fn())
-      const audio = testState.audios[0]
-
-      expect(player.mediaSource).not.toBeNull()
-      expect(audio.disableRemotePlayback).toBe(true)
-      expect(audio.controls).toBe(true)
-    })
-  })
-
-  describe('event wiring', () => {
-    it('should forward registered audio events to callback', () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', callback)
-      const audio = testState.audios[0]
-
-      audio.emit('play')
-      audio.emit('ended')
-      audio.emit('error')
-      audio.emit('paused')
-      audio.emit('loaded')
-      audio.emit('timeupdate')
-      audio.emit('loadeddate')
-      audio.emit('canplay')
-
-      expect(player.callback).toBe(callback)
-      expect(callback).toHaveBeenCalledWith('play')
-      expect(callback).toHaveBeenCalledWith('ended')
-      expect(callback).toHaveBeenCalledWith('error')
-      expect(callback).toHaveBeenCalledWith('paused')
-      expect(callback).toHaveBeenCalledWith('loaded')
-      expect(callback).toHaveBeenCalledWith('timeupdate')
-      expect(callback).toHaveBeenCalledWith('loadeddate')
-      expect(callback).toHaveBeenCalledWith('canplay')
-    })
-
-    it('should initialize source buffer only once when sourceopen fires multiple times', () => {
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', vi.fn())
-      const mediaSource = testState.mediaSources[0]
-
-      mediaSource.emit('sourceopen')
-      mediaSource.emit('sourceopen')
-
-      expect(mediaSource.addSourceBuffer).toHaveBeenCalledTimes(1)
-      expect(player.sourceBuffer).toBe(mediaSource.sourceBuffer)
-    })
-  })
-
-  describe('playback control', () => {
-    it('should request streaming audio when playAudio is called before loading', async () => {
-      mockTextToAudioStream.mockResolvedValue(
-        makeAudioResponse(200, [
-          { value: new Uint8Array([4, 5]), done: false },
-          { value: new Uint8Array([1, 2, 3]), done: true },
-        ]),
-      )
-
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', vi.fn())
-      player.playAudio()
-
-      await waitFor(() => {
-        expect(mockTextToAudioStream).toHaveBeenCalledTimes(1)
-      })
-
-      expect(mockTextToAudioStream).toHaveBeenCalledWith(
-        '/text-to-audio',
-        AppSourceType.webApp,
-        { content_type: 'audio/mpeg' },
-        {
-          message_id: 'msg-1',
-          streaming: true,
-          voice: 'en-US',
-          text: 'hello',
-        },
-      )
-      expect(player.isLoadData).toBe(true)
-    })
-
-    it('should emit error callback and reset load flag when stream response status is not 200', async () => {
-      const callback = vi.fn()
-      mockTextToAudioStream.mockResolvedValue(
-        makeAudioResponse(500, [{ value: new Uint8Array([1]), done: true }]),
-      )
-
-      const player = new AudioPlayer('/text-to-audio', false, 'msg-2', 'world', undefined, callback)
-      player.playAudio()
-
-      await waitFor(() => {
-        expect(callback).toHaveBeenCalledWith('error')
-      })
-      expect(player.isLoadData).toBe(false)
-    })
-
-    it('should resume and play immediately when playAudio is called in suspended loaded state', async () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', false, 'msg-1', 'hello', undefined, callback)
-      const audio = testState.audios[0]
-      const audioContext = testState.audioContexts[0]
-
-      player.isLoadData = true
-      audioContext.state = 'suspended'
-      player.playAudio()
-      await Promise.resolve()
-
-      expect(audioContext.resume).toHaveBeenCalledTimes(1)
-      expect(audio.play).toHaveBeenCalledTimes(1)
-      expect(callback).toHaveBeenCalledWith('play')
-    })
-
-    it('should play ended audio when data is already loaded', () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', false, 'msg-1', 'hello', undefined, callback)
-      const audio = testState.audios[0]
-      const audioContext = testState.audioContexts[0]
-
-      player.isLoadData = true
-      audioContext.state = 'running'
-      audio.ended = true
-      player.playAudio()
-
-      expect(audio.play).toHaveBeenCalledTimes(1)
-      expect(callback).toHaveBeenCalledWith('play')
-    })
-
-    it('should only emit play callback without replaying when loaded audio is already playing', () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', false, 'msg-1', 'hello', undefined, callback)
-      const audio = testState.audios[0]
-      const audioContext = testState.audioContexts[0]
-
-      player.isLoadData = true
-      audioContext.state = 'running'
-      audio.ended = false
-      player.playAudio()
-
-      expect(audio.play).not.toHaveBeenCalled()
-      expect(callback).toHaveBeenCalledWith('play')
-    })
-
-    it('should emit error callback when stream request throws', async () => {
-      const callback = vi.fn()
-      mockTextToAudioStream.mockRejectedValue(new Error('network failed'))
-      const player = new AudioPlayer('/text-to-audio', false, 'msg-2', 'world', undefined, callback)
-
-      player.playAudio()
-
-      await waitFor(() => {
-        expect(callback).toHaveBeenCalledWith('error')
-      })
-      expect(player.isLoadData).toBe(false)
-    })
-
-    it('should call pause flow and notify paused event when pauseAudio is invoked', () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', callback)
-      const audio = testState.audios[0]
-      const audioContext = testState.audioContexts[0]
-
-      player.pauseAudio()
-
-      expect(callback).toHaveBeenCalledWith('paused')
-      expect(audio.pause).toHaveBeenCalledTimes(1)
-      expect(audioContext.suspend).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('message and direct-audio helpers', () => {
-    it('should update message id through resetMsgId', () => {
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', null)
-
-      player.resetMsgId('msg-2')
-
-      expect(player.msgId).toBe('msg-2')
-    })
-
-    it('should end stream without playback when playAudioWithAudio receives empty content', async () => {
-      vi.useFakeTimers()
-      try {
-        const callback = vi.fn()
-        const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', callback)
-        const mediaSource = testState.mediaSources[0]
-
-        await player.playAudioWithAudio('', true)
-        await vi.advanceTimersByTimeAsync(40)
-
-        expect(player.isLoadData).toBe(false)
-        expect(player.cacheBuffers).toHaveLength(0)
-        expect(mediaSource.endOfStream).toHaveBeenCalledTimes(1)
-        expect(callback).not.toHaveBeenCalledWith('play')
-      }
-      finally {
-        vi.useRealTimers()
-      }
-    })
-
-    it('should decode base64 and start playback when playAudioWithAudio is called with playable content', async () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', callback)
-      const audio = testState.audios[0]
-      const audioContext = testState.audioContexts[0]
-      const mediaSource = testState.mediaSources[0]
-      const audioBase64 = Buffer.from('hello').toString('base64')
-
-      mediaSource.emit('sourceopen')
-      audio.paused = true
-      await player.playAudioWithAudio(audioBase64, true)
-      await Promise.resolve()
-
-      expect(player.isLoadData).toBe(true)
-      expect(player.cacheBuffers).toHaveLength(0)
-      expect(mediaSource.sourceBuffer.appendBuffer).toHaveBeenCalledTimes(1)
-      const appendedAudioData = mediaSource.sourceBuffer.appendBuffer.mock.calls[0][0]
-      expect(appendedAudioData).toBeInstanceOf(ArrayBuffer)
-      expect(appendedAudioData.byteLength).toBeGreaterThan(0)
-      expect(audioContext.resume).toHaveBeenCalledTimes(1)
-      expect(audio.play).toHaveBeenCalledTimes(1)
-      expect(callback).toHaveBeenCalledWith('play')
-    })
-
-    it('should skip playback when playAudioWithAudio is called with play=false', async () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', callback)
-      const audio = testState.audios[0]
-      const audioContext = testState.audioContexts[0]
-
-      await player.playAudioWithAudio(Buffer.from('hello').toString('base64'), false)
-
-      expect(player.isLoadData).toBe(false)
-      expect(audioContext.resume).not.toHaveBeenCalled()
-      expect(audio.play).not.toHaveBeenCalled()
-      expect(callback).not.toHaveBeenCalledWith('play')
-    })
-
-    it('should play immediately for ended audio in playAudioWithAudio', async () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', callback)
-      const audio = testState.audios[0]
-
-      audio.paused = false
-      audio.ended = true
-      await player.playAudioWithAudio(Buffer.from('hello').toString('base64'), true)
-
-      expect(audio.play).toHaveBeenCalledTimes(1)
-      expect(callback).toHaveBeenCalledWith('play')
-    })
-
-    it('should not replay when played list exists in playAudioWithAudio', async () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', callback)
-      const audio = testState.audios[0]
-
-      audio.paused = false
-      audio.ended = false
-      audio.played = {}
-      await player.playAudioWithAudio(Buffer.from('hello').toString('base64'), true)
-
-      expect(audio.play).not.toHaveBeenCalled()
-      expect(callback).not.toHaveBeenCalledWith('play')
-    })
-
-    it('should replay when paused is false and played list is empty in playAudioWithAudio', async () => {
-      const callback = vi.fn()
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', callback)
-      const audio = testState.audios[0]
-
-      audio.paused = false
-      audio.ended = false
-      audio.played = null
-      await player.playAudioWithAudio(Buffer.from('hello').toString('base64'), true)
-
-      expect(audio.play).toHaveBeenCalledTimes(1)
-      expect(callback).toHaveBeenCalledWith('play')
-    })
-  })
-
-  describe('buffering internals', () => {
-    it('should finish stream when receiveAudioData gets an undefined chunk', () => {
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', null)
-      const finishStream = vi
-        .spyOn(player as unknown as { finishStream: () => void }, 'finishStream')
-        .mockImplementation(() => { })
-
-        ; (player as unknown as { receiveAudioData: (data: Uint8Array | undefined) => void }).receiveAudioData(undefined)
-
-      expect(finishStream).toHaveBeenCalledTimes(1)
-    })
-
-    it('should finish stream when receiveAudioData gets empty bytes while source is open', () => {
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', null)
-      const finishStream = vi
-        .spyOn(player as unknown as { finishStream: () => void }, 'finishStream')
-        .mockImplementation(() => { })
-
-        ; (player as unknown as { receiveAudioData: (data: Uint8Array) => void }).receiveAudioData(new Uint8Array(0))
-
-      expect(finishStream).toHaveBeenCalledTimes(1)
-    })
-
-    it('should queue incoming buffer when source buffer is updating', () => {
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', null)
-      const mediaSource = testState.mediaSources[0]
-      mediaSource.emit('sourceopen')
-      mediaSource.sourceBuffer.updating = true
-
-      ; (player as unknown as { receiveAudioData: (data: Uint8Array) => void }).receiveAudioData(new Uint8Array([1, 2, 3]))
-
-      expect(player.cacheBuffers.length).toBe(1)
-    })
-
-    it('should append previously queued buffer before new one when source buffer is idle', () => {
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', null)
-      const mediaSource = testState.mediaSources[0]
-      mediaSource.emit('sourceopen')
-
-      const existingBuffer = new ArrayBuffer(2)
-      player.cacheBuffers = [existingBuffer]
-      mediaSource.sourceBuffer.updating = false
-
-      ; (player as unknown as { receiveAudioData: (data: Uint8Array) => void }).receiveAudioData(new Uint8Array([9]))
-
-      expect(mediaSource.sourceBuffer.appendBuffer).toHaveBeenCalledTimes(1)
-      expect(mediaSource.sourceBuffer.appendBuffer).toHaveBeenCalledWith(existingBuffer)
-      expect(player.cacheBuffers.length).toBe(1)
-    })
-
-    it('should append cache chunks and end stream when finishStream drains buffers', () => {
-      vi.useFakeTimers()
-      const player = new AudioPlayer('/text-to-audio', true, 'msg-1', 'hello', 'en-US', null)
-      const mediaSource = testState.mediaSources[0]
-      mediaSource.emit('sourceopen')
-      mediaSource.sourceBuffer.updating = false
-      player.cacheBuffers = [new ArrayBuffer(3)]
-
-      ; (player as unknown as { finishStream: () => void }).finishStream()
-      vi.advanceTimersByTime(50)
-
-      expect(mediaSource.sourceBuffer.appendBuffer).toHaveBeenCalledTimes(1)
-      expect(mediaSource.endOfStream).toHaveBeenCalledTimes(1)
-      vi.useRealTimers()
-    })
-  })
-})

web/app/components/base/audio-gallery/AudioPlayer.tsx

@@ -26,7 +26,6 @@ const AudioPlayer: React.FC<AudioPlayerProps> = ({ src, srcs }) => {
 
   useEffect(() => {
     const audio = audioRef.current
-    /* v8 ignore next 2 - @preserve */
     if (!audio)
       return
 
@@ -218,7 +217,6 @@ const AudioPlayer: React.FC<AudioPlayerProps> = ({ src, srcs }) => {
 
   const drawWaveform = useCallback(() => {
     const canvas = canvasRef.current
-    /* v8 ignore next 2 - @preserve */
     if (!canvas)
       return
 
@@ -270,20 +268,14 @@ const AudioPlayer: React.FC<AudioPlayerProps> = ({ src, srcs }) => {
     drawWaveform()
   }, [drawWaveform, bufferedTime, hasStartedPlaying])
 
-  const handleMouseMove = useCallback((e: React.MouseEvent<HTMLCanvasElement> | React.TouchEvent<HTMLCanvasElement>) => {
+  const handleMouseMove = useCallback((e: React.MouseEvent) => {
     const canvas = canvasRef.current
     const audio = audioRef.current
     if (!canvas || !audio)
       return
 
-    const clientX = 'touches' in e
-      ? e.touches[0]?.clientX ?? e.changedTouches[0]?.clientX
-      : e.clientX
-    if (clientX === undefined)
-      return
-
     const rect = canvas.getBoundingClientRect()
-    const percent = Math.min(Math.max(0, clientX - rect.left), rect.width) / rect.width
+    const percent = Math.min(Math.max(0, e.clientX - rect.left), rect.width) / rect.width
     const time = percent * duration
 
     // Check if the hovered position is within a buffered range before updating hoverTime
@@ -297,7 +289,7 @@ const AudioPlayer: React.FC<AudioPlayerProps> = ({ src, srcs }) => {
 
   return (
     <div className="flex h-9 min-w-[240px] max-w-[420px] items-center gap-2 rounded-[10px] border border-components-panel-border-subtle bg-components-chat-input-audio-bg-alt p-2 shadow-xs backdrop-blur-sm">
-      <audio ref={audioRef} src={src} preload="auto" data-testid="audio-player">
+      <audio ref={audioRef} src={src} preload="auto">
         {/* If srcs array is provided, render multiple source elements */}
         {srcs && srcs.map((srcUrl, index) => (
           <source key={index} src={srcUrl} />
@@ -305,8 +297,12 @@ const AudioPlayer: React.FC<AudioPlayerProps> = ({ src, srcs }) => {
       </audio>
       <button type="button" data-testid="play-pause-btn" className="inline-flex shrink-0 cursor-pointer items-center justify-center border-none text-text-accent transition-all hover:text-text-accent-secondary disabled:text-components-button-primary-bg-disabled" onClick={togglePlay} disabled={!isAudioAvailable}>
         {isPlaying
-          ? (<div className="i-ri-pause-circle-fill h-5 w-5" />)
-          : (<div className="i-ri-play-large-fill h-5 w-5" />)}
+          ? (
+              <div className="i-ri-pause-circle-fill h-5 w-5" />
+            )
+          : (
+              <div className="i-ri-play-large-fill h-5 w-5" />
+            )}
       </button>
       <div className={cn(isAudioAvailable && 'grow')} hidden={!isAudioAvailable}>
         <div className="flex h-8 items-center justify-center">
@@ -317,8 +313,6 @@ const AudioPlayer: React.FC<AudioPlayerProps> = ({ src, srcs }) => {
             onClick={handleCanvasInteraction}
             onMouseMove={handleMouseMove}
             onMouseDown={handleCanvasInteraction}
-            onTouchMove={handleMouseMove}
-            onTouchStart={handleCanvasInteraction}
           />
           <div className="inline-flex min-w-[50px] items-center justify-center text-text-accent-secondary system-xs-medium">
             <span className="rounded-[10px] px-0.5 py-1">{formatTime(duration)}</span>

web/app/components/base/audio-gallery/__tests__/AudioPlayer.spec.tsx

@@ -1,7 +1,8 @@
-import type { ToastHandle } from '@/app/components/base/toast'
 import { act, fireEvent, render, screen } from '@testing-library/react'
-import Toast from '@/app/components/base/toast'
+import * as React from 'react'
+import { vi } from 'vitest'
 import useThemeMock from '@/hooks/use-theme'
+
 import { Theme } from '@/types/app'
 import AudioPlayer from '../AudioPlayer'
 
@@ -44,13 +45,6 @@ async function advanceWaveformTimer() {
   })
 }
 
-// eslint-disable-next-line ts/no-explicit-any
-type ReactEventHandler = ((...args: any[]) => void) | undefined
-function getReactProps<T extends Element>(el: T): Record<string, ReactEventHandler> {
-  const key = Object.keys(el).find(k => k.startsWith('__reactProps$'))
-  return key ? (el as unknown as Record<string, Record<string, ReactEventHandler>>)[key] : {}
-}
-
 // ─── Setup / teardown ─────────────────────────────────────────────────────────
 
 beforeEach(() => {
@@ -62,12 +56,8 @@ beforeEach(() => {
   HTMLMediaElement.prototype.load = vi.fn()
 })
 
-afterEach(async () => {
-  await act(async () => {
-    vi.runOnlyPendingTimers()
-    await Promise.resolve()
-    await Promise.resolve()
-  })
+afterEach(() => {
+  vi.runOnlyPendingTimers()
   vi.useRealTimers()
   vi.unstubAllGlobals()
 })
@@ -310,47 +300,36 @@ describe('AudioPlayer — waveform generation', () => {
 
     expect(screen.getByTestId('waveform-canvas')).toBeInTheDocument()
   })
-
-  it('should use webkitAudioContext when AudioContext is unavailable', async () => {
-    vi.stubGlobal('AudioContext', undefined)
-    vi.stubGlobal('webkitAudioContext', buildAudioContext(320))
-    stubFetchOk(256)
-
-    render(<AudioPlayer src="https://cdn.example/audio.mp3" />)
-    await advanceWaveformTimer()
-
-    expect(screen.getByTestId('waveform-canvas')).toBeInTheDocument()
-  })
 })
 
 // ─── Canvas interactions ──────────────────────────────────────────────────────
 
-async function renderWithDuration(src = 'https://example.com/audio.mp3', durationVal = 120) {
-  vi.stubGlobal('AudioContext', buildAudioContext(300))
-  stubFetchOk(128)
-
-  render(<AudioPlayer src={src} />)
-
-  const audio = document.querySelector('audio') as HTMLAudioElement
-  Object.defineProperty(audio, 'duration', { value: durationVal, configurable: true })
-  Object.defineProperty(audio, 'buffered', {
-    value: { length: 1, start: () => 0, end: () => durationVal },
-    configurable: true,
-  })
-
-  await act(async () => {
-    audio.dispatchEvent(new Event('loadedmetadata'))
-  })
-  await advanceWaveformTimer()
-
-  const canvas = screen.getByTestId('waveform-canvas') as HTMLCanvasElement
-  canvas.getBoundingClientRect = () =>
-    ({ left: 0, width: 200, top: 0, height: 10, right: 200, bottom: 10 }) as DOMRect
-
-  return { audio, canvas }
-}
-
 describe('AudioPlayer — canvas seek interactions', () => {
+  async function renderWithDuration(src = 'https://example.com/audio.mp3', durationVal = 120) {
+    vi.stubGlobal('AudioContext', buildAudioContext(300))
+    stubFetchOk(128)
+
+    render(<AudioPlayer src={src} />)
+
+    const audio = document.querySelector('audio') as HTMLAudioElement
+    Object.defineProperty(audio, 'duration', { value: durationVal, configurable: true })
+    Object.defineProperty(audio, 'buffered', {
+      value: { length: 1, start: () => 0, end: () => durationVal },
+      configurable: true,
+    })
+
+    await act(async () => {
+      audio.dispatchEvent(new Event('loadedmetadata'))
+    })
+    await advanceWaveformTimer()
+
+    const canvas = screen.getByTestId('waveform-canvas') as HTMLCanvasElement
+    canvas.getBoundingClientRect = () =>
+      ({ left: 0, width: 200, top: 0, height: 10, right: 200, bottom: 10 }) as DOMRect
+
+    return { audio, canvas }
+  }
+
   it('should seek to clicked position and start playback', async () => {
     const { audio, canvas } = await renderWithDuration()
 
@@ -413,309 +392,3 @@ describe('AudioPlayer — canvas seek interactions', () => {
     })
   })
 })
-
-// ─── Missing coverage tests ───────────────────────────────────────────────────
-
-describe('AudioPlayer — missing coverage', () => {
-  it('should handle unmounting without crashing (clears timeout)', () => {
-    const { unmount } = render(<AudioPlayer src="https://example.com/a.mp3" />)
-    unmount()
-    // Timer is cleared, no state update should happen after unmount
-  })
-
-  it('should handle getContext returning null safely', () => {
-    const originalGetContext = HTMLCanvasElement.prototype.getContext
-    HTMLCanvasElement.prototype.getContext = vi.fn().mockReturnValue(null)
-
-    render(<AudioPlayer src="https://example.com/audio.mp3" />)
-    expect(screen.getByTestId('waveform-canvas')).toBeInTheDocument()
-
-    HTMLCanvasElement.prototype.getContext = originalGetContext
-  })
-
-  it('should fallback to fillRect when roundRect is missing in drawWaveform', async () => {
-    // Note: React 18 / testing-library wraps updates automatically, but we still wait for advanceWaveformTimer
-    const originalGetContext = HTMLCanvasElement.prototype.getContext
-    let fillRectCalled = false
-    HTMLCanvasElement.prototype.getContext = function (this: HTMLCanvasElement, ...args: Parameters<typeof HTMLCanvasElement.prototype.getContext>) {
-      const ctx = originalGetContext.apply(this, args) as CanvasRenderingContext2D | null
-      if (ctx) {
-        Object.defineProperty(ctx, 'roundRect', { value: undefined, configurable: true })
-        const origFillRect = ctx.fillRect
-        ctx.fillRect = function (...fArgs: Parameters<CanvasRenderingContext2D['fillRect']>) {
-          fillRectCalled = true
-          return origFillRect.apply(this, fArgs)
-        }
-      }
-      return ctx as CanvasRenderingContext2D
-    } as typeof HTMLCanvasElement.prototype.getContext
-
-    vi.stubGlobal('AudioContext', buildAudioContext(300))
-    stubFetchOk(128)
-
-    render(<AudioPlayer src="https://example.com/audio.mp3" />)
-    await advanceWaveformTimer()
-
-    expect(fillRectCalled).toBe(true)
-    HTMLCanvasElement.prototype.getContext = originalGetContext
-  })
-
-  it('should handle play error gracefully when togglePlay is clicked', async () => {
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { })
-    vi.spyOn(HTMLMediaElement.prototype, 'play').mockRejectedValue(new Error('play failed'))
-
-    render(<AudioPlayer src="https://example.com/audio.mp3" />)
-    const btn = screen.getByTestId('play-pause-btn')
-
-    await act(async () => {
-      fireEvent.click(btn)
-    })
-
-    expect(errorSpy).toHaveBeenCalled()
-    errorSpy.mockRestore()
-  })
-
-  it('should notify error when audio.play() fails during canvas seek', async () => {
-    vi.stubGlobal('AudioContext', buildAudioContext(300))
-    stubFetchOk(128)
-
-    render(<AudioPlayer src="https://example.com/audio.mp3" />)
-    await advanceWaveformTimer()
-
-    const canvas = screen.getByTestId('waveform-canvas') as HTMLCanvasElement
-    const audio = document.querySelector('audio') as HTMLAudioElement
-    Object.defineProperty(audio, 'duration', { value: 120, configurable: true })
-    canvas.getBoundingClientRect = () => ({ left: 0, width: 200, top: 0, height: 10, right: 200, bottom: 10 }) as DOMRect
-
-    vi.spyOn(HTMLMediaElement.prototype, 'play').mockRejectedValue(new Error('play failed'))
-
-    await act(async () => {
-      fireEvent.click(canvas, { clientX: 100 })
-    })
-
-    // We can observe the error by checking document body for toast if Toast acts synchronously
-    // Or we just ensure the execution branched into catch naturally.
-    expect(HTMLMediaElement.prototype.play).toHaveBeenCalled()
-  })
-
-  it('should support touch events on canvas', async () => {
-    vi.stubGlobal('AudioContext', buildAudioContext(300))
-    stubFetchOk(128)
-
-    render(<AudioPlayer src="https://example.com/audio.mp3" />)
-    await advanceWaveformTimer()
-
-    const canvas = screen.getByTestId('waveform-canvas') as HTMLCanvasElement
-    const audio = document.querySelector('audio') as HTMLAudioElement
-    Object.defineProperty(audio, 'duration', { value: 120, configurable: true })
-    canvas.getBoundingClientRect = () => ({ left: 0, width: 200, top: 0, height: 10, right: 200, bottom: 10 }) as DOMRect
-
-    await act(async () => {
-      // Use touch events
-      fireEvent.touchStart(canvas, {
-        touches: [{ clientX: 50 }],
-      })
-    })
-
-    expect(HTMLMediaElement.prototype.play).toHaveBeenCalled()
-  })
-
-  it('should gracefully handle interaction when canvas/audio refs are null', async () => {
-    const { unmount } = render(<AudioPlayer src="https://example.com/audio.mp3" />)
-    const canvas = screen.getByTestId('waveform-canvas')
-    unmount()
-    expect(canvas).toBeTruthy()
-  })
-
-  it('should keep play button disabled when source is unavailable', async () => {
-    vi.stubGlobal('AudioContext', buildAudioContext(300))
-    const toastSpy = vi.spyOn(Toast, 'notify').mockImplementation(() => ({} as unknown as ToastHandle))
-    render(<AudioPlayer src="blob:https://example.com" />)
-    await advanceWaveformTimer() // sets isAudioAvailable to false (invalid protocol)
-
-    const btn = screen.getByTestId('play-pause-btn')
-    await act(async () => {
-      fireEvent.click(btn)
-    })
-
-    expect(btn).toBeDisabled()
-    expect(HTMLMediaElement.prototype.play).not.toHaveBeenCalled()
-    expect(toastSpy).not.toHaveBeenCalled()
-    toastSpy.mockRestore()
-  })
-
-  it('should notify when toggle is invoked while audio is unavailable', async () => {
-    const toastSpy = vi.spyOn(Toast, 'notify').mockImplementation(() => ({} as unknown as ToastHandle))
-    render(<AudioPlayer src="https://example.com/a.mp3" />)
-    const audio = document.querySelector('audio') as HTMLAudioElement
-    await act(async () => {
-      audio.dispatchEvent(new Event('error'))
-    })
-
-    const btn = screen.getByTestId('play-pause-btn')
-    const props = getReactProps(btn)
-
-    await act(async () => {
-      props.onClick?.()
-    })
-
-    expect(toastSpy).toHaveBeenCalledWith(expect.objectContaining({
-      type: 'error',
-      message: 'Audio element not found',
-    }))
-    toastSpy.mockRestore()
-  })
-})
-
-describe('AudioPlayer — additional branch coverage', () => {
-  it('should render multiple source elements when srcs is provided', () => {
-    render(<AudioPlayer srcs={['a.mp3', 'b.ogg']} />)
-    const audio = screen.getByTestId('audio-player')
-    const sources = audio.querySelectorAll('source')
-    expect(sources).toHaveLength(2)
-  })
-
-  it('should handle handleMouseMove with empty touch list', async () => {
-    vi.stubGlobal('AudioContext', buildAudioContext(300))
-    stubFetchOk(128)
-    render(<AudioPlayer src="https://example.com/a.mp3" />)
-    await advanceWaveformTimer()
-    const canvas = screen.getByTestId('waveform-canvas')
-
-    await act(async () => {
-      fireEvent.touchMove(canvas, {
-        touches: [],
-        changedTouches: [{ clientX: 50 }],
-      })
-    })
-  })
-
-  it('should handle handleMouseMove with missing clientX', async () => {
-    vi.stubGlobal('AudioContext', buildAudioContext(300))
-    stubFetchOk(128)
-    render(<AudioPlayer src="https://example.com/a.mp3" />)
-    await advanceWaveformTimer()
-    const canvas = screen.getByTestId('waveform-canvas')
-
-    await act(async () => {
-      fireEvent.touchMove(canvas, {
-        touches: [{}] as unknown as TouchList,
-      })
-    })
-  })
-
-  it('should render "Audio source unavailable" when isAudioAvailable is false', async () => {
-    render(<AudioPlayer src="https://example.com/a.mp3" />)
-    const audio = document.querySelector('audio') as HTMLAudioElement
-
-    await act(async () => {
-      audio.dispatchEvent(new Event('error'))
-    })
-
-    expect(screen.queryByTestId('play-pause-btn')).toBeDisabled()
-  })
-
-  it('should update current time on timeupdate event', async () => {
-    render(<AudioPlayer src="https://example.com/a.mp3" />)
-    const audio = document.querySelector('audio') as HTMLAudioElement
-    Object.defineProperty(audio, 'currentTime', { value: 10, configurable: true })
-
-    await act(async () => {
-      audio.dispatchEvent(new Event('timeupdate'))
-    })
-  })
-
-  it('should ignore toggle click after audio error marks source unavailable', async () => {
-    const toastSpy = vi.spyOn(Toast, 'notify').mockImplementation(() => ({} as unknown as ToastHandle))
-    render(<AudioPlayer src="https://example.com/a.mp3" />)
-    const audio = document.querySelector('audio') as HTMLAudioElement
-    await act(async () => {
-      audio.dispatchEvent(new Event('error'))
-    })
-
-    const btn = screen.getByTestId('play-pause-btn')
-    await act(async () => {
-      fireEvent.click(btn)
-    })
-
-    expect(btn).toBeDisabled()
-    expect(HTMLMediaElement.prototype.play).not.toHaveBeenCalled()
-    expect(toastSpy).not.toHaveBeenCalled()
-    toastSpy.mockRestore()
-  })
-
-  it('should cover Dark theme waveform states', async () => {
-    ; (useThemeMock as ReturnType<typeof vi.fn>).mockReturnValue({ theme: Theme.dark })
-    vi.stubGlobal('AudioContext', buildAudioContext(300))
-    stubFetchOk(128)
-
-    render(<AudioPlayer src="https://example.com/audio.mp3" />)
-    const audio = document.querySelector('audio') as HTMLAudioElement
-    Object.defineProperty(audio, 'duration', { value: 100, configurable: true })
-    Object.defineProperty(audio, 'currentTime', { value: 50, configurable: true })
-
-    await act(async () => {
-      audio.dispatchEvent(new Event('loadedmetadata'))
-      audio.dispatchEvent(new Event('timeupdate'))
-    })
-    await advanceWaveformTimer()
-
-    expect(screen.getByTestId('waveform-canvas')).toBeInTheDocument()
-  })
-
-  it('should handle missing canvas/audio in handleCanvasInteraction/handleMouseMove', async () => {
-    const { unmount } = render(<AudioPlayer src="https://example.com/a.mp3" />)
-    const canvas = screen.getByTestId('waveform-canvas')
-
-    unmount()
-    fireEvent.click(canvas)
-    fireEvent.mouseMove(canvas)
-  })
-
-  it('should cover waveform branches for hover and played states', async () => {
-    const { audio, canvas } = await renderWithDuration('https://example.com/a.mp3', 100)
-
-    // Set some progress
-    Object.defineProperty(audio, 'currentTime', { value: 20, configurable: true })
-
-    // Trigger hover on a buffered range
-    Object.defineProperty(audio, 'buffered', {
-      value: { length: 1, start: () => 0, end: () => 100 },
-      configurable: true,
-    })
-
-    await act(async () => {
-      fireEvent.mouseMove(canvas, { clientX: 50 }) // 50s hover
-      audio.dispatchEvent(new Event('timeupdate'))
-    })
-
-    expect(canvas).toBeInTheDocument()
-  })
-
-  it('should hit null-ref guards in canvas handlers after unmount', async () => {
-    const { unmount } = render(<AudioPlayer src="https://example.com/a.mp3" />)
-    const canvas = screen.getByTestId('waveform-canvas')
-    const props = getReactProps(canvas)
-    unmount()
-
-    await act(async () => {
-      props.onClick?.({ preventDefault: vi.fn(), clientX: 10 })
-      props.onMouseMove?.({ clientX: 10 })
-    })
-  })
-
-  it('should execute non-matching buffered branch in hover loop', async () => {
-    const { audio, canvas } = await renderWithDuration('https://example.com/a.mp3', 100)
-
-    Object.defineProperty(audio, 'buffered', {
-      value: { length: 1, start: () => 0, end: () => 10 },
-      configurable: true,
-    })
-
-    await act(async () => {
-      fireEvent.mouseMove(canvas, { clientX: 180 }) // time near 90, outside 0-10
-    })
-
-    expect(canvas).toBeInTheDocument()
-  })
-})

web/app/components/base/audio-gallery/__tests__/index.spec.tsx

@@ -1,9 +1,24 @@
 import { render, screen } from '@testing-library/react'
+import * as React from 'react'
+// AudioGallery.spec.tsx
+import { describe, expect, it, vi } from 'vitest'
+
 import AudioGallery from '../index'
 
+// Mock AudioPlayer so we only assert prop forwarding
+const audioPlayerMock = vi.fn()
+
+vi.mock('../AudioPlayer', () => ({
+  default: (props: { srcs: string[] }) => {
+    audioPlayerMock(props)
+    return <div data-testid="audio-player" />
+  },
+}))
+
 describe('AudioGallery', () => {
-  beforeEach(() => {
-    vi.spyOn(HTMLMediaElement.prototype, 'load').mockImplementation(() => { })
+  afterEach(() => {
+    audioPlayerMock.mockClear()
+    vi.resetModules()
   })
 
   it('returns null when srcs array is empty', () => {
@@ -18,15 +33,11 @@ describe('AudioGallery', () => {
     expect(screen.queryByTestId('audio-player')).toBeNull()
   })
 
-  it('filters out falsy srcs and renders only valid sources in AudioPlayer', () => {
+  it('filters out falsy srcs and passes valid srcs to AudioPlayer', () => {
     render(<AudioGallery srcs={['a.mp3', '', 'b.mp3']} />)
-    const audio = screen.getByTestId('audio-player')
-    const sources = audio.querySelectorAll('source')
-
-    expect(audio).toBeInTheDocument()
-    expect(sources).toHaveLength(2)
-    expect(sources[0]?.getAttribute('src')).toBe('a.mp3')
-    expect(sources[1]?.getAttribute('src')).toBe('b.mp3')
+    expect(screen.getByTestId('audio-player')).toBeInTheDocument()
+    expect(audioPlayerMock).toHaveBeenCalledTimes(1)
+    expect(audioPlayerMock).toHaveBeenCalledWith({ srcs: ['a.mp3', 'b.mp3'] })
   })
 
   it('wraps AudioPlayer inside container with expected class', () => {
@@ -34,6 +45,5 @@ describe('AudioGallery', () => {
     const root = container.firstChild as HTMLElement
     expect(root).toBeTruthy()
     expect(root.className).toContain('my-3')
-    expect(screen.getByTestId('audio-player')).toBeInTheDocument()
   })
 })

web/app/components/base/chat/__tests__/utils.spec.ts

@@ -1,18 +1,6 @@
-import type { IChatItem } from '../chat/type'
-import type { ChatItem, ChatItemInTree } from '../types'
+import type { ChatItemInTree } from '../types'
 import { get } from 'es-toolkit/compat'
-import { UUID_NIL } from '../constants'
-import {
-  buildChatItemTree,
-  getLastAnswer,
-  getProcessedInputsFromUrlParams,
-  getProcessedSystemVariablesFromUrlParams,
-  getProcessedUserVariablesFromUrlParams,
-  getRawInputsFromUrlParams,
-  getRawUserVariablesFromUrlParams,
-  getThreadMessages,
-  isValidGeneratedAnswer,
-} from '../utils'
+import { buildChatItemTree, getThreadMessages } from '../utils'
 import branchedTestMessages from './branchedTestMessages.json'
 import legacyTestMessages from './legacyTestMessages.json'
 import mixedTestMessages from './mixedTestMessages.json'
@@ -25,15 +13,6 @@ function visitNode(tree: ChatItemInTree | ChatItemInTree[], path: string): ChatI
   return get(tree, path)
 }
 
-class MockDecompressionStream {
-  readable: unknown
-  writable: unknown
-  constructor() {
-    this.readable = {}
-    this.writable = {}
-  }
-}
-
 describe('build chat item tree and get thread messages', () => {
   const tree1 = buildChatItemTree(branchedTestMessages as ChatItemInTree[])
 
@@ -268,12 +247,12 @@ describe('build chat item tree and get thread messages', () => {
     expect(tree6).toMatchSnapshot()
   })
 
-  it('should get thread messages from tree6, using the last message as target', () => {
+  it ('should get thread messages from tree6, using the last message as target', () => {
     const threadMessages6_1 = getThreadMessages(tree6)
     expect(threadMessages6_1).toMatchSnapshot()
   })
 
-  it('should get thread messages from tree6, using specified message as target', () => {
+  it ('should get thread messages from tree6, using specified message as target', () => {
     const threadMessages6_2 = getThreadMessages(tree6, 'ff4c2b43-48a5-47ad-9dc5-08b34ddba61b')
     expect(threadMessages6_2).toMatchSnapshot()
   })
@@ -290,285 +269,3 @@ describe('build chat item tree and get thread messages', () => {
     expect(tree8).toMatchSnapshot()
   })
 })
-
-describe('chat utils - url params and answer helpers', () => {
-  const setSearch = (search: string) => {
-    window.history.replaceState({}, '', `${window.location.pathname}${search}`)
-  }
-  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.stubGlobal('DecompressionStream', MockDecompressionStream)
-    vi.stubGlobal('TextDecoder', class {
-      decode() { return 'decompressed_text' }
-    })
-
-    const mockPipeThrough = vi.fn().mockReturnValue({})
-    vi.stubGlobal('Response', class {
-      body = { pipeThrough: mockPipeThrough }
-      arrayBuffer = vi.fn().mockResolvedValue(new ArrayBuffer(8))
-    })
-    setSearch('')
-  })
-
-  afterEach(() => {
-    vi.unstubAllGlobals()
-  })
-
-  describe('URL Parameter Extractors', () => {
-    it('getRawInputsFromUrlParams extracts inputs except sys. and user.', async () => {
-      setSearch('?custom=123&sys.param=456&user.param=789&encoded=a%20b')
-      const res = await getRawInputsFromUrlParams()
-      expect(res).toEqual({ custom: '123', encoded: 'a b' })
-    })
-
-    it('getRawUserVariablesFromUrlParams extracts only user. prefixed params', async () => {
-      setSearch('?custom=123&sys.param=456&user.param=789&user.encoded=a%20b')
-      const res = await getRawUserVariablesFromUrlParams()
-      expect(res).toEqual({ param: '789', encoded: 'a b' })
-    })
-
-    it('getProcessedInputsFromUrlParams decompresses base64 inputs', async () => {
-      setSearch('?custom=123&sys.param=456&user.param=789')
-      const res = await getProcessedInputsFromUrlParams()
-      expect(res).toEqual({ custom: 'decompressed_text' })
-    })
-
-    it('getProcessedSystemVariablesFromUrlParams decompresses sys. prefixed params', async () => {
-      setSearch('?custom=123&sys.param=456&user.param=789')
-      const res = await getProcessedSystemVariablesFromUrlParams()
-      expect(res).toEqual({ param: 'decompressed_text' })
-    })
-
-    it('getProcessedSystemVariablesFromUrlParams parses redirect_url without query string', async () => {
-      setSearch(`?redirect_url=${encodeURIComponent('http://example.com')}&sys.param=456`)
-      const res = await getProcessedSystemVariablesFromUrlParams()
-      expect(res).toEqual({ param: 'decompressed_text' })
-    })
-
-    it('getProcessedSystemVariablesFromUrlParams parses redirect_url', async () => {
-      setSearch(`?redirect_url=${encodeURIComponent('http://example.com?sys.redirected=abc')}&sys.param=456`)
-      const res = await getProcessedSystemVariablesFromUrlParams()
-      expect(res).toEqual({ param: 'decompressed_text', redirected: 'decompressed_text' })
-    })
-
-    it('getProcessedUserVariablesFromUrlParams decompresses user. prefixed params', async () => {
-      setSearch('?custom=123&sys.param=456&user.param=789')
-      const res = await getProcessedUserVariablesFromUrlParams()
-      expect(res).toEqual({ param: 'decompressed_text' })
-    })
-
-    it('decodeBase64AndDecompress failure returns undefined softly', async () => {
-      vi.stubGlobal('atob', () => {
-        throw new Error('invalid')
-      })
-      setSearch('?custom=invalid_base64')
-      const res = await getProcessedInputsFromUrlParams()
-      expect(res).toEqual({ custom: undefined })
-    })
-  })
-
-  describe('Answer Validation', () => {
-    it('isValidGeneratedAnswer returns true for typical answers', () => {
-      expect(isValidGeneratedAnswer({ isAnswer: true, id: '123', isOpeningStatement: false } as ChatItem)).toBe(true)
-    })
-
-    it('isValidGeneratedAnswer returns false for placeholders', () => {
-      expect(isValidGeneratedAnswer({ isAnswer: true, id: 'answer-placeholder-123', isOpeningStatement: false } as ChatItem)).toBe(false)
-    })
-
-    it('isValidGeneratedAnswer returns false for opening statements', () => {
-      expect(isValidGeneratedAnswer({ isAnswer: true, id: '123', isOpeningStatement: true } as ChatItem)).toBe(false)
-    })
-
-    it('isValidGeneratedAnswer returns false for questions', () => {
-      expect(isValidGeneratedAnswer({ isAnswer: false, id: '123', isOpeningStatement: false } as ChatItem)).toBe(false)
-    })
-
-    it('isValidGeneratedAnswer returns false for falsy items', () => {
-      expect(isValidGeneratedAnswer(undefined)).toBe(false)
-    })
-
-    it('getLastAnswer returns the last valid answer from a list', () => {
-      const list = [
-        { isAnswer: false, id: 'q1', isOpeningStatement: false },
-        { isAnswer: true, id: 'a1', isOpeningStatement: false },
-        { isAnswer: false, id: 'q2', isOpeningStatement: false },
-        { isAnswer: true, id: 'answer-placeholder-2', isOpeningStatement: false },
-      ] as ChatItem[]
-      expect(getLastAnswer(list)?.id).toBe('a1')
-    })
-
-    it('getLastAnswer returns null if no valid answer', () => {
-      const list = [
-        { isAnswer: false, id: 'q1', isOpeningStatement: false },
-        { isAnswer: true, id: 'answer-placeholder-2', isOpeningStatement: false },
-      ] as ChatItem[]
-      expect(getLastAnswer(list)).toBeNull()
-    })
-  })
-
-  describe('ChatItem Tree Builders', () => {
-    it('buildChatItemTree builds a flat tree for legacy messages (parentMessageId = UUID_NIL)', () => {
-      const list: IChatItem[] = [
-        { id: 'q1', isAnswer: false, parentMessageId: UUID_NIL } as IChatItem,
-        { id: 'a1', isAnswer: true, parentMessageId: UUID_NIL } as IChatItem,
-        { id: 'q2', isAnswer: false, parentMessageId: UUID_NIL } as IChatItem,
-        { id: 'a2', isAnswer: true, parentMessageId: UUID_NIL } as IChatItem,
-      ]
-
-      const tree = buildChatItemTree(list)
-      expect(tree.length).toBe(1)
-      expect(tree[0].id).toBe('q1')
-      expect(tree[0].children?.[0].id).toBe('a1')
-      expect(tree[0].children?.[0].children?.[0].id).toBe('q2')
-      expect(tree[0].children?.[0].children?.[0].children?.[0].id).toBe('a2')
-      expect(tree[0].children?.[0].children?.[0].children?.[0].siblingIndex).toBe(0)
-    })
-
-    it('buildChatItemTree builds nested tree based on parentMessageId', () => {
-      const list: IChatItem[] = [
-        { id: 'q1', isAnswer: false, parentMessageId: null } as IChatItem,
-        { id: 'a1', isAnswer: true } as IChatItem,
-        { id: 'q2', isAnswer: false, parentMessageId: 'a1' } as IChatItem,
-        { id: 'a2', isAnswer: true } as IChatItem,
-        { id: 'q3', isAnswer: false, parentMessageId: 'a1' } as IChatItem,
-        { id: 'a3', isAnswer: true } as IChatItem,
-        { id: 'q4', isAnswer: false, parentMessageId: 'missing-parent' } as IChatItem,
-        { id: 'a4', isAnswer: true } as IChatItem,
-      ]
-
-      const tree = buildChatItemTree(list)
-      expect(tree.length).toBe(2)
-      expect(tree[0].id).toBe('q1')
-      expect(tree[1].id).toBe('q4')
-
-      const a1 = tree[0].children![0]
-      expect(a1.id).toBe('a1')
-      expect(a1.children?.length).toBe(2)
-      expect(a1.children![0].id).toBe('q2')
-      expect(a1.children![1].id).toBe('q3')
-      expect(a1.children![0].children![0].siblingIndex).toBe(0)
-      expect(a1.children![1].children![0].siblingIndex).toBe(1)
-    })
-
-    it('getThreadMessages node without children', () => {
-      const tree = [{ id: 'q1', isAnswer: false }]
-      const thread = getThreadMessages(tree as unknown as ChatItemInTree[], 'q1')
-      expect(thread.length).toBe(1)
-      expect(thread[0].id).toBe('q1')
-    })
-
-    it('getThreadMessages target not found', () => {
-      const tree = [{ id: 'q1', isAnswer: false, children: [] }]
-      const thread = getThreadMessages(tree as unknown as ChatItemInTree[], 'missing')
-      expect(thread.length).toBe(0)
-    })
-
-    it('getThreadMessages target not found with undefined children', () => {
-      const tree = [{ id: 'q1', isAnswer: false }]
-      const thread = getThreadMessages(tree as unknown as ChatItemInTree[], 'missing')
-      expect(thread.length).toBe(0)
-    })
-
-    it('getThreadMessages flat path logic', () => {
-      const tree = [{
-        id: 'q1',
-        isAnswer: false,
-        children: [{
-          id: 'a1',
-          isAnswer: true,
-          siblingIndex: 0,
-          children: [{
-            id: 'q2',
-            isAnswer: false,
-            children: [{
-              id: 'a2',
-              isAnswer: true,
-              siblingIndex: 0,
-              children: [],
-            }],
-          }],
-        }],
-      }]
-
-      const thread = getThreadMessages(tree as unknown as ChatItemInTree[])
-      expect(thread.length).toBe(4)
-      expect(thread.map(t => t.id)).toEqual(['q1', 'a1', 'q2', 'a2'])
-      expect(thread[1].siblingCount).toBe(1)
-      expect(thread[3].siblingCount).toBe(1)
-    })
-
-    it('getThreadMessages to specific target', () => {
-      const tree = [{
-        id: 'q1',
-        isAnswer: false,
-        children: [{
-          id: 'a1',
-          isAnswer: true,
-          siblingIndex: 0,
-          children: [{
-            id: 'q2',
-            isAnswer: false,
-            children: [{
-              id: 'a2',
-              isAnswer: true,
-              siblingIndex: 0,
-              children: [],
-            }],
-          }, {
-            id: 'q3',
-            isAnswer: false,
-            children: [{
-              id: 'a3',
-              isAnswer: true,
-              siblingIndex: 1,
-              children: [],
-            }],
-          }],
-        }],
-      }]
-
-      const thread = getThreadMessages(tree as unknown as ChatItemInTree[], 'a3')
-      expect(thread.length).toBe(4)
-      expect(thread.map(t => t.id)).toEqual(['q1', 'a1', 'q3', 'a3'])
-      expect(thread[3].prevSibling).toBe('a2')
-      expect(thread[3].nextSibling).toBeUndefined()
-    })
-
-    it('getThreadMessages targetNode has descendants', () => {
-      const tree = [{
-        id: 'q1',
-        isAnswer: false,
-        children: [{
-          id: 'a1',
-          isAnswer: true,
-          siblingIndex: 0,
-          children: [{
-            id: 'q2',
-            isAnswer: false,
-            children: [{
-              id: 'a2',
-              isAnswer: true,
-              siblingIndex: 0,
-              children: [],
-            }],
-          }, {
-            id: 'q3',
-            isAnswer: false,
-            children: [{
-              id: 'a3',
-              isAnswer: true,
-              siblingIndex: 1,
-              children: [],
-            }],
-          }],
-        }],
-      }]
-
-      const thread = getThreadMessages(tree as unknown as ChatItemInTree[], 'a1')
-      expect(thread.length).toBe(4)
-      expect(thread.map(t => t.id)).toEqual(['q1', 'a1', 'q3', 'a3'])
-      expect(thread[3].prevSibling).toBe('a2')
-    })
-  })
-})

web/app/components/base/chat/chat-with-history/__tests__/chat-wrapper.spec.tsx

@@ -4,11 +4,12 @@ import type { FileEntity } from '@/app/components/base/file-uploader/types'
 import type { AppData, AppMeta, ConversationItem } from '@/models/share'
 import type { HumanInputFormData } from '@/types/workflow'
 import { fireEvent, render, screen, waitFor } from '@testing-library/react'
+import * as React from 'react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { InputVarType } from '@/app/components/workflow/types'
 import {
   fetchSuggestedQuestions,
   stopChatMessageResponding,
-  submitHumanInputForm,
 } from '@/service/share'
 import { TransferMethod } from '@/types/app'
 import { useChat } from '../../chat/hooks'
@@ -500,34 +501,6 @@ describe('ChatWrapper', () => {
     expect(handleSwitchSibling).toHaveBeenCalledWith('1', expect.any(Object))
   })
 
-  it('should call fetchSuggestedQuestions from workflow resumption options callback', () => {
-    const handleSwitchSibling = vi.fn()
-    vi.mocked(useChat).mockReturnValue({
-      ...defaultChatHookReturn,
-      chatList: [],
-      handleSwitchSibling,
-    } as unknown as ChatHookReturn)
-
-    vi.mocked(useChatWithHistoryContext).mockReturnValue({
-      ...defaultContextValue,
-      appPrevChatTree: [{
-        id: 'resume-node',
-        content: 'Paused answer',
-        isAnswer: true,
-        workflow_run_id: 'workflow-1',
-        humanInputFormDataList: [{ label: 'resume' }] as unknown as HumanInputFormData[],
-        children: [],
-      }],
-    })
-
-    render(<ChatWrapper />)
-
-    expect(handleSwitchSibling).toHaveBeenCalledWith('resume-node', expect.any(Object))
-    const resumeOptions = handleSwitchSibling.mock.calls[0][1]
-    resumeOptions.onGetSuggestedQuestions('response-from-resume')
-    expect(fetchSuggestedQuestions).toHaveBeenCalledWith('response-from-resume', 'webApp', 'test-app-id')
-  })
-
   it('should handle workflow resumption with nested children (DFS)', () => {
     const handleSwitchSibling = vi.fn()
     vi.mocked(useChat).mockReturnValue({
@@ -787,47 +760,6 @@ describe('ChatWrapper', () => {
     })
   })
 
-  it('should handle human input form submission for web app', async () => {
-    vi.mocked(useChatWithHistoryContext).mockReturnValue({
-      ...defaultContextValue,
-      isInstalledApp: false,
-    })
-
-    vi.mocked(useChat).mockReturnValue({
-      ...defaultChatHookReturn,
-      chatList: [
-        { id: 'q1', content: 'Question' },
-        {
-          id: 'a1',
-          isAnswer: true,
-          content: '',
-          humanInputFormDataList: [{
-            id: 'node1',
-            form_id: 'form1',
-            form_token: 'token-web-1',
-            node_id: 'node1',
-            node_title: 'Node Web 1',
-            display_in_ui: true,
-            form_content: '{{#$output.test#}}',
-            inputs: [{ variable: 'test', label: 'Test', type: 'paragraph', required: true, output_variable_name: 'test', default: { type: 'text', value: '' } }],
-            actions: [{ id: 'run', title: 'Run', button_style: 'primary' }],
-          }] as unknown as HumanInputFormData[],
-        },
-      ],
-    } as unknown as ChatHookReturn)
-
-    render(<ChatWrapper />)
-    expect(await screen.findByText('Node Web 1')).toBeInTheDocument()
-
-    const input = screen.getAllByRole('textbox').find(el => el.closest('.chat-answer-container')) || screen.getAllByRole('textbox')[0]
-    fireEvent.change(input, { target: { value: 'web-test' } })
-    fireEvent.click(screen.getByText('Run'))
-
-    await waitFor(() => {
-      expect(submitHumanInputForm).toHaveBeenCalledWith('token-web-1', expect.any(Object))
-    })
-  })
-
   it('should filter opening statement in new conversation with single item', () => {
     vi.mocked(useChat).mockReturnValue({
       ...defaultChatHookReturn,
@@ -956,16 +888,8 @@ describe('ChatWrapper', () => {
   })
 
   it('should render answer icon when configured', () => {
-    const appDataWithAnswerIcon = {
-      site: {
-        ...mockAppData.site,
-        use_icon_as_answer_icon: true,
-      },
-    } as unknown as AppData
-
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
-      appData: appDataWithAnswerIcon,
     } as ChatWithHistoryContextValue)
 
     vi.mocked(useChat).mockReturnValue({
@@ -975,7 +899,6 @@ describe('ChatWrapper', () => {
 
     render(<ChatWrapper />)
     expect(screen.getByText('Answer')).toBeInTheDocument()
-    expect(screen.getByAltText('answer icon')).toBeInTheDocument()
   })
 
   it('should render question icon when user avatar is available', () => {
@@ -997,26 +920,6 @@ describe('ChatWrapper', () => {
     expect(avatar).toBeInTheDocument()
   })
 
-  it('should use fallback values for nullable appData, appMeta and user name', () => {
-    vi.mocked(useChatWithHistoryContext).mockReturnValue({
-      ...defaultContextValue,
-      appData: null as unknown as AppData,
-      appMeta: null as unknown as AppMeta,
-      initUserVariables: {
-        avatar_url: 'https://example.com/avatar-fallback.png',
-      },
-    })
-
-    vi.mocked(useChat).mockReturnValue({
-      ...defaultChatHookReturn,
-      chatList: [{ id: 'q1', content: 'Question with fallback avatar name' }],
-    } as unknown as ChatHookReturn)
-
-    render(<ChatWrapper />)
-    expect(screen.getByText('Question with fallback avatar name')).toBeInTheDocument()
-    expect(screen.getByAltText('user')).toBeInTheDocument()
-  })
-
   it('should set handleStop on currentChatInstanceRef', () => {
     const handleStop = vi.fn()
     const currentChatInstanceRef = { current: { handleStop: vi.fn() } } as ChatWithHistoryContextValue['currentChatInstanceRef']
@@ -1309,45 +1212,20 @@ describe('ChatWrapper', () => {
 
   it('should handle doRegenerate with editedQuestion', async () => {
     const handleSend = vi.fn()
-
-    const mockFiles = [
-      {
-        id: 'file-q1',
-        name: 'q1.txt',
-        type: 'text/plain',
-        size: 100,
-        url: 'https://example.com/q1.txt',
-        extension: 'txt',
-        mime_type: 'text/plain',
-      } as unknown as FileEntity,
-    ] as FileEntity[]
-
     vi.mocked(useChat).mockReturnValue({
       ...defaultChatHookReturn,
       chatList: [
-        { id: 'q1', content: 'Original question', message_files: mockFiles },
+        { id: 'q1', content: 'Original question', message_files: [] },
         { id: 'a1', isAnswer: true, content: 'Answer', parentMessageId: 'q1' },
       ],
       handleSend,
     } as unknown as ChatHookReturn)
 
-    render(<ChatWrapper />)
+    const { container } = render(<ChatWrapper />)
 
-    fireEvent.click(await screen.findByTestId('edit-btn'))
-    const editedTextarea = await screen.findByDisplayValue('Original question')
-    fireEvent.change(editedTextarea, { target: { value: 'Edited question text' } })
-    fireEvent.click(screen.getByTestId('save-edit-btn'))
-
-    await waitFor(() => {
-      expect(handleSend).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          query: 'Edited question text',
-          files: mockFiles,
-        }),
-        expect.any(Object),
-      )
-    })
+    // This would test line 198-200 - the editedQuestion path
+    // The actual regenerate with edited question happens through the UI
+    expect(container).toBeInTheDocument()
   })
 
   it('should handle doRegenerate when parentAnswer is not a valid generated answer', async () => {
@@ -1814,31 +1692,4 @@ describe('ChatWrapper', () => {
     // Should not be disabled because it's not required
     expect(container).not.toBeInTheDocument()
   })
-
-  it('should handle fallback branches for appParams, appId and empty chat instance ref', async () => {
-    const handleSend = vi.fn()
-
-    vi.mocked(useChatWithHistoryContext).mockReturnValue({
-      ...defaultContextValue,
-      appParams: undefined as unknown as ChatConfig,
-      appId: '',
-      currentConversationId: '',
-      currentChatInstanceRef: { current: null } as unknown as ChatWithHistoryContextValue['currentChatInstanceRef'],
-    })
-
-    vi.mocked(useChat).mockReturnValue({
-      ...defaultChatHookReturn,
-      handleSend,
-    } as unknown as ChatHookReturn)
-
-    render(<ChatWrapper />)
-
-    const textarea = screen.getByRole('textbox')
-    fireEvent.change(textarea, { target: { value: 'trigger fallback path' } })
-    fireEvent.keyDown(textarea, { key: 'Enter', code: 'Enter', keyCode: 13 })
-
-    await waitFor(() => {
-      expect(handleSend).toHaveBeenCalled()
-    })
-  })
 })

web/app/components/base/chat/chat-with-history/__tests__/header-in-mobile.spec.tsx

@@ -1,9 +1,9 @@
-import type { i18n } from 'i18next'
 import type { ChatConfig } from '../../types'
 import type { ChatWithHistoryContextValue } from '../context'
-import type { AppData, AppMeta } from '@/models/share'
+import type { AppData, AppMeta, ConversationItem } from '@/models/share'
 import { fireEvent, render, screen, waitFor } from '@testing-library/react'
-import * as ReactI18next from 'react-i18next'
+import * as React from 'react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import useBreakpoints, { MediaType } from '@/hooks/use-breakpoints'
 import { useChatWithHistoryContext } from '../context'
 import HeaderInMobile from '../header-in-mobile'
@@ -80,14 +80,7 @@ vi.mock('@/app/components/base/modal', () => ({
 
 // Sidebar mock removed to use real component
 
-const mockAppData: AppData = {
-  app_id: 'test-app',
-  custom_config: null,
-  site: {
-    title: 'Test Chat',
-    chat_color_theme: 'blue',
-  },
-}
+const mockAppData = { site: { title: 'Test Chat', chat_color_theme: 'blue' } } as unknown as AppData
 const defaultContextValue: ChatWithHistoryContextValue = {
   appData: mockAppData,
   currentConversationId: '',
@@ -111,27 +104,18 @@ const defaultContextValue: ChatWithHistoryContextValue = {
   currentChatInstanceRef: { current: { handleStop: vi.fn() } } as ChatWithHistoryContextValue['currentChatInstanceRef'],
   setIsResponding: vi.fn(),
   setClearChatList: vi.fn(),
-  appParams: {
-    system_parameters: {
-      audio_file_size_limit: 10,
-      file_size_limit: 10,
-      image_file_size_limit: 10,
-      video_file_size_limit: 10,
-      workflow_file_upload_limit: 10,
-    },
-    more_like_this: { enabled: false },
-  } as ChatConfig,
-  appMeta: { tool_icons: {} } as AppMeta,
+  appParams: { system_parameters: { vision_config: { enabled: false } } } as unknown as ChatConfig,
+  appMeta: {} as AppMeta,
   appPrevChatTree: [],
   newConversationInputs: {},
-  newConversationInputsRef: { current: {} },
+  newConversationInputsRef: { current: {} } as ChatWithHistoryContextValue['newConversationInputsRef'],
   appChatListDataLoading: false,
   chatShouldReloadKey: '',
   isMobile: true,
   currentConversationInputs: null,
   setCurrentConversationInputs: vi.fn(),
   allInputsHidden: false,
-  conversationRenaming: false,
+  conversationRenaming: false, // Added missing property
 }
 
 describe('HeaderInMobile', () => {
@@ -150,7 +134,7 @@ describe('HeaderInMobile', () => {
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
       currentConversationId: '1',
-      currentConversationItem: { id: '1', name: 'Conv 1', inputs: null, introduction: '' },
+      currentConversationItem: { id: '1', name: 'Conv 1' } as unknown as ConversationItem,
     })
 
     render(<HeaderInMobile />)
@@ -286,7 +270,7 @@ describe('HeaderInMobile', () => {
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
       currentConversationId: '1',
-      currentConversationItem: { id: '1', name: 'Conv 1', inputs: null, introduction: '' },
+      currentConversationItem: { id: '1', name: 'Conv 1' } as unknown as ConversationItem,
       handlePinConversation: handlePin,
       pinnedConversationList: [],
     })
@@ -308,9 +292,9 @@ describe('HeaderInMobile', () => {
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
       currentConversationId: '1',
-      currentConversationItem: { id: '1', name: 'Conv 1', inputs: null, introduction: '' },
+      currentConversationItem: { id: '1', name: 'Conv 1' } as unknown as ConversationItem,
       handleUnpinConversation: handleUnpin,
-      pinnedConversationList: [{ id: '1', name: 'Conv 1', inputs: null, introduction: '' }],
+      pinnedConversationList: [{ id: '1' }] as unknown as ConversationItem[],
     })
 
     render(<HeaderInMobile />)
@@ -330,7 +314,7 @@ describe('HeaderInMobile', () => {
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
       currentConversationId: '1',
-      currentConversationItem: { id: '1', name: 'Conv 1', inputs: null, introduction: '' },
+      currentConversationItem: { id: '1', name: 'Conv 1' } as unknown as ConversationItem,
       handleRenameConversation: handleRename,
       pinnedConversationList: [],
     })
@@ -358,7 +342,7 @@ describe('HeaderInMobile', () => {
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
       currentConversationId: '1',
-      currentConversationItem: { id: '1', name: 'Conv 1', inputs: null, introduction: '' },
+      currentConversationItem: { id: '1', name: 'Conv 1' } as unknown as ConversationItem,
       handleRenameConversation: handleRename,
       pinnedConversationList: [],
     })
@@ -389,7 +373,7 @@ describe('HeaderInMobile', () => {
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
       currentConversationId: '1',
-      currentConversationItem: { id: '1', name: 'Conv 1', inputs: null, introduction: '' },
+      currentConversationItem: { id: '1', name: 'Conv 1' } as unknown as ConversationItem,
       handleRenameConversation: vi.fn(),
       conversationRenaming: true, // Loading state
       pinnedConversationList: [],
@@ -412,7 +396,7 @@ describe('HeaderInMobile', () => {
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
       currentConversationId: '1',
-      currentConversationItem: { id: '1', name: 'Conv 1', inputs: null, introduction: '' },
+      currentConversationItem: { id: '1', name: 'Conv 1' } as unknown as ConversationItem,
       handleDeleteConversation: handleDelete,
       pinnedConversationList: [],
     })
@@ -438,7 +422,7 @@ describe('HeaderInMobile', () => {
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
       currentConversationId: '1',
-      currentConversationItem: { id: '1', name: 'Conv 1', inputs: null, introduction: '' },
+      currentConversationItem: { id: '1', name: 'Conv 1' } as unknown as ConversationItem,
       handleDeleteConversation: handleDelete,
       pinnedConversationList: [],
     })
@@ -470,7 +454,7 @@ describe('HeaderInMobile', () => {
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
       currentConversationId: '1',
-      currentConversationItem: { id: '1', name: '', inputs: null, introduction: '' },
+      currentConversationItem: { id: '1', name: '' } as unknown as ConversationItem,
     })
 
     render(<HeaderInMobile />)
@@ -501,17 +485,16 @@ describe('HeaderInMobile', () => {
   })
 
   it('should render app icon and title correctly', () => {
-    const appDataWithIcon: AppData = {
-      app_id: 'test-app',
-      custom_config: null,
+    const appDataWithIcon = {
       site: {
         title: 'My App',
         icon: 'emoji',
         icon_type: 'emoji',
         icon_url: '',
         icon_background: '#FF0000',
+        chat_color_theme: 'blue',
       },
-    }
+    } as unknown as AppData
 
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
@@ -529,7 +512,7 @@ describe('HeaderInMobile', () => {
     vi.mocked(useChatWithHistoryContext).mockReturnValue({
       ...defaultContextValue,
       currentConversationId: '1',
-      currentConversationItem: { id: '1', name: 'Conv 1', inputs: null, introduction: '' },
+      currentConversationItem: { id: '1', name: 'Conv 1' } as unknown as ConversationItem,
       handleRenameConversation: handleRename,
       handleDeleteConversation: handleDelete,
       pinnedConversationList: [],
@@ -541,59 +524,4 @@ describe('HeaderInMobile', () => {
     expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
     expect(screen.queryByText('share.chat.deleteConversation.title')).not.toBeInTheDocument()
   })
-
-  it('should use empty string fallback for delete content translation', async () => {
-    const handleDelete = vi.fn()
-    const useTranslationSpy = vi.spyOn(ReactI18next, 'useTranslation')
-    useTranslationSpy.mockReturnValue({
-      t: (key: string) => key === 'chat.deleteConversation.content' ? '' : key,
-      i18n: {} as unknown as i18n,
-      ready: true,
-      tReady: true,
-    } as unknown as ReturnType<typeof ReactI18next.useTranslation>)
-
-    try {
-      vi.mocked(useChatWithHistoryContext).mockReturnValue({
-        ...defaultContextValue,
-        currentConversationId: '1',
-        currentConversationItem: { id: '1', name: 'Conv 1', inputs: null, introduction: '' },
-        handleDeleteConversation: handleDelete,
-        pinnedConversationList: [],
-      })
-
-      render(<HeaderInMobile />)
-      fireEvent.click(await screen.findByText('Conv 1'))
-      fireEvent.click(await screen.findByText(/sidebar\.action\.delete/i))
-
-      expect(await screen.findByRole('button', { name: /common\.operation\.confirm|operation\.confirm/i })).toBeInTheDocument()
-      fireEvent.click(screen.getByRole('button', { name: /common\.operation\.confirm|operation\.confirm/i }))
-      expect(handleDelete).toHaveBeenCalledWith('1', expect.any(Object))
-    }
-    finally {
-      useTranslationSpy.mockRestore()
-    }
-  })
-
-  it('should use empty string fallback for rename modal name', async () => {
-    const handleRename = vi.fn()
-    vi.mocked(useChatWithHistoryContext).mockReturnValue({
-      ...defaultContextValue,
-      currentConversationId: '1',
-      currentConversationItem: { id: '1', name: '', inputs: null, introduction: '' },
-      handleRenameConversation: handleRename,
-      pinnedConversationList: [],
-    })
-
-    const { container } = render(<HeaderInMobile />)
-    const operationTrigger = container.querySelector('.system-md-semibold')?.parentElement as HTMLElement
-    fireEvent.click(operationTrigger)
-    fireEvent.click(await screen.findByText(/explore\.sidebar\.action\.rename|sidebar\.action\.rename/i))
-
-    const input = await screen.findByRole('textbox')
-    expect(input).toHaveValue('')
-
-    fireEvent.change(input, { target: { value: 'Renamed from empty' } })
-    fireEvent.click(screen.getByRole('button', { name: /common\.operation\.save/i }))
-    expect(handleRename).toHaveBeenCalledWith('1', 'Renamed from empty', expect.any(Object))
-  })
 })

web/app/components/base/chat/chat-with-history/__tests__/index.spec.tsx

@@ -2,7 +2,9 @@ import type { RefObject } from 'react'
 import type { ChatConfig } from '../../types'
 import type { InstalledApp } from '@/models/explore'
 import type { AppConversationData, AppData, AppMeta, ConversationItem } from '@/models/share'
-import { fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { fireEvent, render, screen } from '@testing-library/react'
+import * as React from 'react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import useBreakpoints, { MediaType } from '@/hooks/use-breakpoints'
 import useDocumentTitle from '@/hooks/use-document-title'
 import { useChatWithHistory } from '../hooks'
@@ -111,22 +113,81 @@ describe('ChatWithHistory', () => {
     vi.mocked(useChatWithHistory).mockReturnValue(defaultHookReturn)
   })
 
-  it('renders desktop view with expanded sidebar and builds theme', async () => {
+  it('renders desktop view with expanded sidebar and builds theme', () => {
     vi.mocked(useBreakpoints).mockReturnValue(MediaType.pc)
 
     render(<ChatWithHistory />)
 
-    // header-in-mobile renders 'Test Chat'.
+    // Checks if the desktop elements render correctly
+    // Checks if the desktop elements render correctly
+    // Sidebar real component doesn't have data-testid="sidebar", so we check for its presence via class or content.
+    // Sidebar usually has "New Chat" button or similar.
+    // However, looking at the Sidebar mock it was just a div.
+    // Real Sidebar -> web/app/components/base/chat/chat-with-history/sidebar/index.tsx
+    // It likely has some text or distinct element.
+    // ChatWrapper also removed mock.
+    // Header also removed mock.
+
+    // For now, let's verify some key elements that should be present in these components.
+    // Sidebar: "Explore" or "Chats" or verify navigation structure.
+    // Header: Title or similar.
+    // ChatWrapper: "Start a new chat" or similar.
+
+    // Given the complexity of real components and lack of testIds, we might need to rely on:
+    // 1. Adding testIds to real components (preferred but might be out of scope if I can't touch them? Guidelines say "don't mock base components", but adding testIds is fine).
+    // But I can't see those files right now.
+    // 2. Use getByText for known static content.
+
+    // Let's assume some content based on `mockAppData` title 'Test Chat'.
+    // Header should contain 'Test Chat'.
+    // Check for "Test Chat" - might appear multiple times (header, sidebar, document title etc)
     const titles = screen.getAllByText('Test Chat')
     expect(titles.length).toBeGreaterThan(0)
 
+    // Sidebar should be present.
+    // We can check for a specific element in sidebar, e.g. "New Chat" button if it exists.
+    // Or we can check for the sidebar container class if possible.
+    // Let's look at `index.tsx` logic.
+    // Sidebar is rendered.
+    // Let's try to query by something generic or update to use `container.querySelector`.
+    // But `screen` is better.
+
+    // ChatWrapper is rendered.
+    // It renders "ChatWrapper" text? No, it's the real component now.
+    // Real ChatWrapper renders "Welcome" or chat list.
+    // In `chat-wrapper.spec.tsx`, we saw it renders "Welcome" or "Q1".
+    // Here `defaultHookReturn` returns empty chat list/conversation.
+    // So it might render nothing or empty state?
+    // Let's wait and see what `chat-wrapper.spec.tsx` expectations were.
+    // It expects "Welcome" if `isOpeningStatement` is true.
+    // In `index.spec.tsx` mock hook return:
+    // `currentConversationItem` is undefined.
+    // `conversationList` is [].
+    // `appPrevChatTree` is [].
+    // So ChatWrapper might render empty or loading?
+
+    // This is an integration test now.
+    // We need to ensure the hook return makes sense for the child components.
+
+    // Let's just assert the document title since we know that works?
+    // And check if we can find *something*.
+
+    // For now, I'll comment out the specific testId checks and rely on visual/text checks that are likely to flourish.
+    // header-in-mobile renders 'Test Chat'.
+    // Sidebar?
+
+    // Actually, `ChatWithHistory` renders `Sidebar` in a div with width.
+    // We can check if that div exists?
+
+    // Let's update to checks that are likely to pass or allow us to debug.
+
+    // expect(document.title).toBe('Test Chat')
+
     // Checks if the document title was set correctly
     expect(useDocumentTitle).toHaveBeenCalledWith('Test Chat')
 
     // Checks if the themeBuilder useEffect fired
-    await waitFor(() => {
-      expect(mockBuildTheme).toHaveBeenCalledWith('blue', false)
-    })
+    expect(mockBuildTheme).toHaveBeenCalledWith('blue', false)
   })
 
   it('renders desktop view with collapsed sidebar and tests hover effects', () => {

web/app/components/base/chat/chat-with-history/header-in-mobile.tsx

@@ -46,7 +46,6 @@ const HeaderInMobile = () => {
     setShowConfirm(null)
   }, [])
   const handleDelete = useCallback(() => {
-    /* v8 ignore next 2 -- @preserve */
     if (showConfirm)
       handleDeleteConversation(showConfirm.id, { onSuccess: handleCancelConfirm })
   }, [showConfirm, handleDeleteConversation, handleCancelConfirm])
@@ -54,7 +53,6 @@ const HeaderInMobile = () => {
     setShowRename(null)
   }, [])
   const handleRename = useCallback((newName: string) => {
-    /* v8 ignore next 2 -- @preserve */
     if (showRename)
       handleRenameConversation(showRename.id, newName, { onSuccess: handleCancelRename })
   }, [showRename, handleRenameConversation, handleCancelRename])

web/app/components/base/chat/chat/__tests__/check-input-forms-hooks.spec.tsx

@@ -1,128 +0,0 @@
-import type { InputForm } from '../type'
-import { renderHook } from '@testing-library/react'
-import { InputVarType } from '@/app/components/workflow/types'
-import { TransferMethod } from '@/types/app'
-import { useCheckInputsForms } from '../check-input-forms-hooks'
-
-const mockNotify = vi.fn()
-vi.mock('@/app/components/base/toast/context', () => ({
-  useToastContext: () => ({ notify: mockNotify }),
-}))
-
-describe('useCheckInputsForms', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('should return true when no inputs required', () => {
-    const { result } = renderHook(() => useCheckInputsForms())
-    const isValid = result.current.checkInputsForm({}, [])
-    expect(isValid).toBe(true)
-  })
-
-  it('should return false and notify when a required input is missing', () => {
-    const { result } = renderHook(() => useCheckInputsForms())
-    const inputsForm = [{ variable: 'test_var', label: 'Test Variable', required: true, type: InputVarType.textInput as string }]
-    const isValid = result.current.checkInputsForm({}, inputsForm as InputForm[])
-
-    expect(isValid).toBe(false)
-    expect(mockNotify).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'error',
-        message: expect.stringContaining('appDebug.errorMessage.valueOfVarRequired'),
-      }),
-    )
-  })
-
-  it('should ignore missing but not required inputs', () => {
-    const { result } = renderHook(() => useCheckInputsForms())
-    const inputsForm = [{ variable: 'test_var', label: 'Test Variable', required: false, type: InputVarType.textInput as string }]
-    const isValid = result.current.checkInputsForm({}, inputsForm as InputForm[])
-
-    expect(isValid).toBe(true)
-    expect(mockNotify).not.toHaveBeenCalled()
-  })
-
-  it('should notify and return undefined when a file is still uploading (singleFile)', () => {
-    const { result } = renderHook(() => useCheckInputsForms())
-    const inputsForm = [{ variable: 'test_file', label: 'Test File', required: true, type: InputVarType.singleFile as string }]
-    const inputs = {
-      test_file: { transferMethod: TransferMethod.local_file }, // no uploadedId means still uploading
-    }
-    const isValid = result.current.checkInputsForm(inputs, inputsForm as InputForm[])
-
-    expect(isValid).toBeUndefined()
-    expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
-      type: 'info',
-      message: 'appDebug.errorMessage.waitForFileUpload',
-    }))
-  })
-
-  it('should notify and return undefined when a file is still uploading (multiFiles)', () => {
-    const { result } = renderHook(() => useCheckInputsForms())
-    const inputsForm = [{ variable: 'test_files', label: 'Test Files', required: true, type: InputVarType.multiFiles as string }]
-    const inputs = {
-      test_files: [{ transferMethod: TransferMethod.local_file }], // no uploadedId
-    }
-    const isValid = result.current.checkInputsForm(inputs, inputsForm as InputForm[])
-
-    expect(isValid).toBeUndefined()
-    expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
-      type: 'info',
-      message: 'appDebug.errorMessage.waitForFileUpload',
-    }))
-  })
-
-  it('should return true when all files are uploaded and required variables are present', () => {
-    const { result } = renderHook(() => useCheckInputsForms())
-    const inputsForm = [{ variable: 'test_file', label: 'Test File', required: true, type: InputVarType.singleFile as string }]
-    const inputs = {
-      test_file: { transferMethod: TransferMethod.local_file, uploadedId: '123' }, // uploaded
-    }
-    const isValid = result.current.checkInputsForm(inputs, inputsForm as InputForm[])
-
-    expect(isValid).toBe(true)
-    expect(mockNotify).not.toHaveBeenCalled()
-  })
-
-  it('should short-circuit remaining fields after first required input is missing', () => {
-    const { result } = renderHook(() => useCheckInputsForms())
-    const inputsForm = [
-      { variable: 'missing_text', label: 'Missing Text', required: true, type: InputVarType.textInput as string },
-      { variable: 'later_file', label: 'Later File', required: true, type: InputVarType.singleFile as string },
-    ]
-    const inputs = {
-      later_file: { transferMethod: TransferMethod.local_file },
-    }
-
-    const isValid = result.current.checkInputsForm(inputs, inputsForm as InputForm[])
-
-    expect(isValid).toBe(false)
-    expect(mockNotify).toHaveBeenCalledTimes(1)
-    expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
-      type: 'error',
-      message: expect.stringContaining('appDebug.errorMessage.valueOfVarRequired'),
-    }))
-  })
-
-  it('should short-circuit remaining fields after detecting file upload in progress', () => {
-    const { result } = renderHook(() => useCheckInputsForms())
-    const inputsForm = [
-      { variable: 'uploading_file', label: 'Uploading File', required: true, type: InputVarType.singleFile as string },
-      { variable: 'later_required_text', label: 'Later Required Text', required: true, type: InputVarType.textInput as string },
-    ]
-    const inputs = {
-      uploading_file: { transferMethod: TransferMethod.local_file }, // still uploading
-      later_required_text: '',
-    }
-
-    const isValid = result.current.checkInputsForm(inputs, inputsForm as InputForm[])
-
-    expect(isValid).toBeUndefined()
-    expect(mockNotify).toHaveBeenCalledTimes(1)
-    expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
-      type: 'info',
-      message: 'appDebug.errorMessage.waitForFileUpload',
-    }))
-  })
-})