Merge branch 'main' into fix/workflow-sync-draft

2026-02-03 13:58:30 +08:00 · 2026-01-30 10:52:14 +08:00 · 2026-01-30 09:39:18 +08:00 · 2026-01-27 10:47:51 +08:00 · 2026-01-26 14:41:12 +08:00
77 changed files with 3851 additions and 3815 deletions
@@ -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.db_migration_lock import DbMigrationAutoRenewLock
 from libs.helper import email as email_validate
 from libs.password import hash_password, password_pattern, valid_password
 from libs.rsa import generate_key_pair
@@ -55,8 +54,6 @@ from tasks.remove_app_and_related_data_task import delete_draft_variables_batch

 logger = logging.getLogger(__name__)

-DB_UPGRADE_LOCK_TTL_SECONDS = 60
-

@click.command("reset-password", help="Reset the account password.")
@click.option("--email", prompt=True, help="Account email to reset password for")
@@ -730,15 +727,8 @@ def create_tenant(email: str, language: str | None = None, name: str | None = No
@click.command("upgrade-db", help="Upgrade the database")
 def upgrade_db():
    click.echo("Preparing database migration...")
-    lock = DbMigrationAutoRenewLock(
-        redis_client=redis_client,
-        name="db_upgrade_lock",
-        ttl_seconds=DB_UPGRADE_LOCK_TTL_SECONDS,
-        logger=logger,
-        log_context="db_migration",
-    )
+    lock = redis_client.lock(name="db_upgrade_lock", timeout=60)
    if lock.acquire(blocking=False):
-        migration_succeeded = False
        try:
            click.echo(click.style("Starting database migration.", fg="green"))

@@ -747,16 +737,12 @@ def upgrade_db():

            flask_migrate.upgrade()

-            migration_succeeded = True
            click.echo(click.style("Database migration successful!", fg="green"))

-        except Exception as e:
+        except Exception:
            logger.exception("Failed to execute database migration")
-            click.echo(click.style(f"Database migration failed: {e}", fg="red"))
-            raise SystemExit(1)
        finally:
-            status = "successful" if migration_succeeded else "failed"
-            lock.release_safely(status=status)
+            lock.release()
    else:
        click.echo("Database migration skipped")

@@ -1,4 +1,3 @@
-import logging
 import uuid
 from datetime import datetime
 from typing import Any, Literal, TypeAlias
@@ -55,8 +54,6 @@ ALLOW_CREATE_APP_MODES = ["chat", "agent-chat", "advanced-chat", "workflow", "co

 register_enum_models(console_ns, IconType)

-_logger = logging.getLogger(__name__)
-

 class AppListQuery(BaseModel):
    page: int = Field(default=1, ge=1, le=99999, description="Page number (1-99999)")
@@ -502,7 +499,6 @@ class AppListApi(Resource):
                    select(Workflow).where(
                        Workflow.version == Workflow.VERSION_DRAFT,
                        Workflow.app_id.in_(workflow_capable_app_ids),
-                        Workflow.tenant_id == current_tenant_id,
                    )
                )
                .scalars()
@@ -514,14 +510,12 @@ class AppListApi(Resource):
                NodeType.TRIGGER_PLUGIN,
            }
            for workflow in draft_workflows:
-                node_id = None
                try:
-                    for node_id, node_data in workflow.walk_nodes():
+                    for _, node_data in workflow.walk_nodes():
                        if node_data.get("type") in trigger_node_types:
                            draft_trigger_app_ids.add(str(workflow.app_id))
                            break
                except Exception:
-                    _logger.exception("error while walking nodes, workflow_id=%s, node_id=%s", workflow.id, node_id)
                    continue

        for app in app_pagination.items:
@@ -660,19 +654,6 @@ class AppCopyApi(Resource):
            )
            session.commit()

-            # Inherit web app permission from original app
-            if result.app_id and FeatureService.get_system_features().webapp_auth.enabled:
-                try:
-                    # Get the original app's access mode
-                    original_settings = EnterpriseService.WebAppAuth.get_app_access_mode_by_id(app_model.id)
-                    access_mode = original_settings.access_mode
-                except Exception:
-                    # If original app has no settings (old app), default to public to match fallback behavior
-                    access_mode = "public"
-
-                # Apply the same access mode to the copied app
-                EnterpriseService.WebAppAuth.update_app_access_mode(result.app_id, access_mode)
-
            stmt = select(App).where(App.id == result.app_id)
            app = session.scalar(stmt)

@@ -1,27 +1,14 @@
 from typing import Literal
+from uuid import UUID

-from flask import request
-from flask_restx import Namespace, Resource, fields, marshal_with
 from pydantic import BaseModel, Field
 from werkzeug.exceptions import Forbidden

-from controllers.common.schema import register_schema_models
-from controllers.console import console_ns
 from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
+from controllers.fastopenapi import console_router
 from libs.login import current_account_with_tenant, login_required
 from services.tag_service import TagService

-dataset_tag_fields = {
-    "id": fields.String,
-    "name": fields.String,
-    "type": fields.String,
-    "binding_count": fields.String,
-}
-
-
-def build_dataset_tag_fields(api_or_ns: Namespace):
-    return api_or_ns.model("DataSetTag", dataset_tag_fields)
-

 class TagBasePayload(BaseModel):
    name: str = Field(description="Tag name", min_length=1, max_length=50)
@@ -45,115 +32,129 @@ class TagListQueryParam(BaseModel):
    keyword: str | None = Field(None, description="Search keyword")


-register_schema_models(
-    console_ns,
-    TagBasePayload,
-    TagBindingPayload,
-    TagBindingRemovePayload,
-    TagListQueryParam,
+class TagResponse(BaseModel):
+    id: str = Field(description="Tag ID")
+    name: str = Field(description="Tag name")
+    type: str = Field(description="Tag type")
+    binding_count: int = Field(description="Number of bindings")
+
+
+class TagBindingResult(BaseModel):
+    result: Literal["success"] = Field(description="Operation result", examples=["success"])
+
+
+@console_router.get(
+    "/tags",
+    response_model=list[TagResponse],
+    tags=["console"],
 )
+@setup_required
+@login_required
+@account_initialization_required
+def list_tags(query: TagListQueryParam) -> list[TagResponse]:
+    _, current_tenant_id = current_account_with_tenant()
+    tags = TagService.get_tags(query.type, current_tenant_id, query.keyword)
+
+    return [
+        TagResponse(
+            id=tag.id,
+            name=tag.name,
+            type=tag.type,
+            binding_count=int(tag.binding_count),
+        )
+        for tag in tags
+    ]


-@console_ns.route("/tags")
-class TagListApi(Resource):
-    @setup_required
-    @login_required
-    @account_initialization_required
-    @console_ns.doc(
-        params={"type": 'Tag type filter. Can be "knowledge" or "app".', "keyword": "Search keyword for tag name."}
-    )
-    @marshal_with(dataset_tag_fields)
-    def get(self):
-        _, current_tenant_id = current_account_with_tenant()
-        raw_args = request.args.to_dict()
-        param = TagListQueryParam.model_validate(raw_args)
-        tags = TagService.get_tags(param.type, current_tenant_id, param.keyword)
+@console_router.post(
+    "/tags",
+    response_model=TagResponse,
+    tags=["console"],
+)
+@setup_required
+@login_required
+@account_initialization_required
+def create_tag(payload: TagBasePayload) -> TagResponse:
+    current_user, _ = current_account_with_tenant()
+    # The role of the current user in the tag table must be admin, owner, or editor
+    if not (current_user.has_edit_permission or current_user.is_dataset_editor):
+        raise Forbidden()

-        return tags, 200
+    tag = TagService.save_tags(payload.model_dump())

-    @console_ns.expect(console_ns.models[TagBasePayload.__name__])
-    @setup_required
-    @login_required
-    @account_initialization_required
-    def post(self):
-        current_user, _ = current_account_with_tenant()
-        # The role of the current user in the ta table must be admin, owner, or editor
-        if not (current_user.has_edit_permission or current_user.is_dataset_editor):
-            raise Forbidden()
-
-        payload = TagBasePayload.model_validate(console_ns.payload or {})
-        tag = TagService.save_tags(payload.model_dump())
-
-        response = {"id": tag.id, "name": tag.name, "type": tag.type, "binding_count": 0}
-
-        return response, 200
+    return TagResponse(id=tag.id, name=tag.name, type=tag.type, binding_count=0)


-@console_ns.route("/tags/<uuid:tag_id>")
-class TagUpdateDeleteApi(Resource):
-    @console_ns.expect(console_ns.models[TagBasePayload.__name__])
-    @setup_required
-    @login_required
-    @account_initialization_required
-    def patch(self, tag_id):
-        current_user, _ = current_account_with_tenant()
-        tag_id = str(tag_id)
-        # The role of the current user in the ta table must be admin, owner, or editor
-        if not (current_user.has_edit_permission or current_user.is_dataset_editor):
-            raise Forbidden()
+@console_router.patch(
+    "/tags/<uuid:tag_id>",
+    response_model=TagResponse,
+    tags=["console"],
+)
+@setup_required
+@login_required
+@account_initialization_required
+def update_tag(tag_id: UUID, payload: TagBasePayload) -> TagResponse:
+    current_user, _ = current_account_with_tenant()
+    tag_id_str = str(tag_id)
+    # The role of the current user in the ta table must be admin, owner, or editor
+    if not (current_user.has_edit_permission or current_user.is_dataset_editor):
+        raise Forbidden()

-        payload = TagBasePayload.model_validate(console_ns.payload or {})
-        tag = TagService.update_tags(payload.model_dump(), tag_id)
+    tag = TagService.update_tags(payload.model_dump(), tag_id_str)

-        binding_count = TagService.get_tag_binding_count(tag_id)
+    binding_count = TagService.get_tag_binding_count(tag_id_str)

-        response = {"id": tag.id, "name": tag.name, "type": tag.type, "binding_count": binding_count}
-
-        return response, 200
-
-    @setup_required
-    @login_required
-    @account_initialization_required
-    @edit_permission_required
-    def delete(self, tag_id):
-        tag_id = str(tag_id)
-
-        TagService.delete_tag(tag_id)
-
-        return 204
+    return TagResponse(id=tag.id, name=tag.name, type=tag.type, binding_count=binding_count)


-@console_ns.route("/tag-bindings/create")
-class TagBindingCreateApi(Resource):
-    @console_ns.expect(console_ns.models[TagBindingPayload.__name__])
-    @setup_required
-    @login_required
-    @account_initialization_required
-    def post(self):
-        current_user, _ = current_account_with_tenant()
-        # The role of the current user in the ta table must be admin, owner, editor, or dataset_operator
-        if not (current_user.has_edit_permission or current_user.is_dataset_editor):
-            raise Forbidden()
+@console_router.delete(
+    "/tags/<uuid:tag_id>",
+    tags=["console"],
+    status_code=204,
+)
+@setup_required
+@login_required
+@account_initialization_required
+@edit_permission_required
+def delete_tag(tag_id: UUID) -> None:
+    tag_id_str = str(tag_id)

-        payload = TagBindingPayload.model_validate(console_ns.payload or {})
-        TagService.save_tag_binding(payload.model_dump())
-
-        return {"result": "success"}, 200
+    TagService.delete_tag(tag_id_str)


-@console_ns.route("/tag-bindings/remove")
-class TagBindingDeleteApi(Resource):
-    @console_ns.expect(console_ns.models[TagBindingRemovePayload.__name__])
-    @setup_required
-    @login_required
-    @account_initialization_required
-    def post(self):
-        current_user, _ = current_account_with_tenant()
-        # The role of the current user in the ta table must be admin, owner, editor, or dataset_operator
-        if not (current_user.has_edit_permission or current_user.is_dataset_editor):
-            raise Forbidden()
+@console_router.post(
+    "/tag-bindings/create",
+    response_model=TagBindingResult,
+    tags=["console"],
+)
+@setup_required
+@login_required
+@account_initialization_required
+def create_tag_binding(payload: TagBindingPayload) -> TagBindingResult:
+    current_user, _ = current_account_with_tenant()
+    # The role of the current user in the tag table must be admin, owner, editor, or dataset_operator
+    if not (current_user.has_edit_permission or current_user.is_dataset_editor):
+        raise Forbidden()

-        payload = TagBindingRemovePayload.model_validate(console_ns.payload or {})
-        TagService.delete_tag_binding(payload.model_dump())
+    TagService.save_tag_binding(payload.model_dump())

-        return {"result": "success"}, 200
+    return TagBindingResult(result="success")
+
+
+@console_router.post(
+    "/tag-bindings/remove",
+    response_model=TagBindingResult,
+    tags=["console"],
+)
+@setup_required
+@login_required
+@account_initialization_required
+def delete_tag_binding(payload: TagBindingRemovePayload) -> TagBindingResult:
+    current_user, _ = current_account_with_tenant()
+    # The role of the current user in the tag table must be admin, owner, editor, or dataset_operator
+    if not (current_user.has_edit_permission or current_user.is_dataset_editor):
+        raise Forbidden()
+
+    TagService.delete_tag_binding(payload.model_dump())
+
+    return TagBindingResult(result="success")
@@ -878,11 +878,7 @@ class ToolBuiltinProviderSetDefaultApi(Resource):
        current_user, current_tenant_id = current_account_with_tenant()
        payload = BuiltinProviderDefaultCredentialPayload.model_validate(console_ns.payload or {})
        return BuiltinToolManageService.set_default_provider(
-            tenant_id=current_tenant_id,
-            user_id=current_user.id,
-            provider=provider,
-            id=args["id"],
-            account=current_user,
+            tenant_id=current_tenant_id, user_id=current_user.id, provider=provider, id=payload.id
        )


@@ -45,8 +45,6 @@ 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.base.tts import AppGeneratorTTSPublisher, AudioTrunk
-from core.file import helpers as file_helpers
-from core.file.enums import FileTransferMethod
 from core.model_manager import ModelInstance
 from core.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk, LLMResultChunkDelta, LLMUsage
 from core.model_runtime.entities.message_entities import (
@@ -58,11 +56,10 @@ 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 events.message_event import message_was_created
 from extensions.ext_database import db
 from libs.datetime_utils import naive_utc_now
-from models.model import AppMode, Conversation, Message, MessageAgentThought, MessageFile, UploadFile
+from models.model import AppMode, Conversation, Message, MessageAgentThought

 logger = logging.getLogger(__name__)

@@ -466,85 +463,6 @@ class EasyUIBasedGenerateTaskPipeline(BasedGenerateTaskPipeline):
            metadata=metadata_dict,
        )

-    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.
@@ -64,13 +64,7 @@ class MessageCycleManager:

        # Use SQLAlchemy 2.x style session.scalar(select(...))
        with session_factory.create_session() as session:
-            message_file = session.scalar(
-                select(MessageFile)
-                .where(
-                    MessageFile.message_id == message_id,
-                )
-                .where(MessageFile.belongs_to == "assistant")
-            )
+            message_file = session.scalar(select(MessageFile).where(MessageFile.message_id == message_id))

        if message_file:
            self._message_has_file.add(message_id)
@@ -1,213 +0,0 @@
-"""
-DB migration Redis lock with heartbeat renewal.
-
-This is intentionally migration-specific. Background renewal is a trade-off that makes sense
-for unbounded, blocking operations like DB migrations (DDL/DML) where the main thread cannot
-periodically refresh the lock TTL.
-
-Do NOT use this as a general-purpose lock primitive for normal application code. Prefer explicit
-lock lifecycle management (e.g. redis-py Lock context manager + `extend()` / `reacquire()` from
-the same thread) when execution flow is under control.
-"""
-
-from __future__ import annotations
-
-import logging
-import threading
-from typing import Any
-
-from redis.exceptions import LockNotOwnedError, RedisError
-
-logger = logging.getLogger(__name__)
-
-MIN_RENEW_INTERVAL_SECONDS = 0.1
-DEFAULT_RENEW_INTERVAL_DIVISOR = 3
-MIN_JOIN_TIMEOUT_SECONDS = 0.5
-MAX_JOIN_TIMEOUT_SECONDS = 5.0
-JOIN_TIMEOUT_MULTIPLIER = 2.0
-
-
-class DbMigrationAutoRenewLock:
-    """
-    Redis lock wrapper that automatically renews TTL while held (migration-only).
-
-    Notes:
-    - We force `thread_local=False` when creating the underlying redis-py lock, because the
-      lock token must be accessible from the heartbeat thread for `reacquire()` to work.
-    - `release_safely()` is best-effort: it never raises, so it won't mask the caller's
-      primary error/exit code.
-    """
-
-    _redis_client: Any
-    _name: str
-    _ttl_seconds: float
-    _renew_interval_seconds: float
-    _log_context: str | None
-    _logger: logging.Logger
-
-    _lock: Any
-    _stop_event: threading.Event | None
-    _thread: threading.Thread | None
-    _acquired: bool
-
-    def __init__(
-        self,
-        redis_client: Any,
-        name: str,
-        ttl_seconds: float = 60,
-        renew_interval_seconds: float | None = None,
-        *,
-        logger: logging.Logger | None = None,
-        log_context: str | None = None,
-    ) -> None:
-        self._redis_client = redis_client
-        self._name = name
-        self._ttl_seconds = float(ttl_seconds)
-        self._renew_interval_seconds = (
-            float(renew_interval_seconds)
-            if renew_interval_seconds is not None
-            else max(MIN_RENEW_INTERVAL_SECONDS, self._ttl_seconds / DEFAULT_RENEW_INTERVAL_DIVISOR)
-        )
-        self._logger = logger or logging.getLogger(__name__)
-        self._log_context = log_context
-
-        self._lock = None
-        self._stop_event = None
-        self._thread = None
-        self._acquired = False
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    def acquire(self, *args: Any, **kwargs: Any) -> bool:
-        """
-        Acquire the lock and start heartbeat renewal on success.
-
-        Accepts the same args/kwargs as redis-py `Lock.acquire()`.
-        """
-        # Prevent accidental double-acquire which could leave the previous heartbeat thread running.
-        if self._acquired:
-            raise RuntimeError("DB migration lock is already acquired; call release_safely() before acquiring again.")
-
-        # Reuse the lock object if we already created one.
-        if self._lock is None:
-            self._lock = self._redis_client.lock(
-                name=self._name,
-                timeout=self._ttl_seconds,
-                thread_local=False,
-            )
-        acquired = bool(self._lock.acquire(*args, **kwargs))
-        self._acquired = acquired
-        if acquired:
-            self._start_heartbeat()
-        return acquired
-
-    def owned(self) -> bool:
-        if self._lock is None:
-            return False
-        try:
-            return bool(self._lock.owned())
-        except Exception:
-            # Ownership checks are best-effort and must not break callers.
-            return False
-
-    def _start_heartbeat(self) -> None:
-        if self._lock is None:
-            return
-        if self._stop_event is not None:
-            return
-
-        self._stop_event = threading.Event()
-        self._thread = threading.Thread(
-            target=self._heartbeat_loop,
-            args=(self._lock, self._stop_event),
-            daemon=True,
-            name=f"DbMigrationAutoRenewLock({self._name})",
-        )
-        self._thread.start()
-
-    def _heartbeat_loop(self, lock: Any, stop_event: threading.Event) -> None:
-        while not stop_event.wait(self._renew_interval_seconds):
-            try:
-                lock.reacquire()
-            except LockNotOwnedError:
-                self._logger.warning(
-                    "DB migration lock is no longer owned during heartbeat; stop renewing. log_context=%s",
-                    self._log_context,
-                    exc_info=True,
-                )
-                return
-            except RedisError:
-                self._logger.warning(
-                    "Failed to renew DB migration lock due to Redis error; will retry. log_context=%s",
-                    self._log_context,
-                    exc_info=True,
-                )
-            except Exception:
-                self._logger.warning(
-                    "Unexpected error while renewing DB migration lock; will retry. log_context=%s",
-                    self._log_context,
-                    exc_info=True,
-                )
-
-    def release_safely(self, *, status: str | None = None) -> None:
-        """
-        Stop heartbeat and release lock. Never raises.
-
-        Args:
-            status: Optional caller-provided status (e.g. 'successful'/'failed') to add context to logs.
-        """
-        lock = self._lock
-        if lock is None:
-            return
-
-        self._stop_heartbeat()
-
-        # Lock release errors should never mask the real error/exit code.
-        try:
-            lock.release()
-        except LockNotOwnedError:
-            self._logger.warning(
-                "DB migration lock not owned on release; ignoring. status=%s log_context=%s",
-                status,
-                self._log_context,
-                exc_info=True,
-            )
-        except RedisError:
-            self._logger.warning(
-                "Failed to release DB migration lock due to Redis error; ignoring. status=%s log_context=%s",
-                status,
-                self._log_context,
-                exc_info=True,
-            )
-        except Exception:
-            self._logger.warning(
-                "Unexpected error while releasing DB migration lock; ignoring. status=%s log_context=%s",
-                status,
-                self._log_context,
-                exc_info=True,
-            )
-        finally:
-            self._acquired = False
-            self._lock = None
-
-    def _stop_heartbeat(self) -> None:
-        if self._stop_event is None:
-            return
-        self._stop_event.set()
-        if self._thread is not None:
-            # Best-effort join: if Redis calls are blocked, the daemon thread may remain alive.
-            join_timeout_seconds = max(
-                MIN_JOIN_TIMEOUT_SECONDS,
-                min(MAX_JOIN_TIMEOUT_SECONDS, self._renew_interval_seconds * JOIN_TIMEOUT_MULTIPLIER),
-            )
-            self._thread.join(timeout=join_timeout_seconds)
-            if self._thread.is_alive():
-                self._logger.warning(
-                    "DB migration lock heartbeat thread did not stop within %.2fs; ignoring. log_context=%s",
-                    join_timeout_seconds,
-                    self._log_context,
-                )
-        self._stop_event = None
-        self._thread = None
@@ -8,6 +8,7 @@ Create Date: 2025-12-25 10:39:15.139304
 from alembic import op
 import models as models
 import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql

 # revision identifiers, used by Alembic.
 revision = '7df29de0f6be'
@@ -19,7 +20,7 @@ depends_on = None
 def upgrade():
    # ### commands auto generated by Alembic - please adjust! ###
    op.create_table('tenant_credit_pools',
-    sa.Column('id', models.types.StringUUID(), nullable=False),
+    sa.Column('id', models.types.StringUUID(), server_default=sa.text('uuid_generate_v4()'), nullable=False),
    sa.Column('tenant_id', models.types.StringUUID(), nullable=False),
    sa.Column('pool_type', sa.String(length=40), server_default='trial', nullable=False),
    sa.Column('quota_limit', sa.BigInteger(), nullable=False),
@@ -8,6 +8,7 @@ Create Date: 2026-01-017 11:10:18.079355
 from alembic import op
 import models as models
 import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql

 # revision identifiers, used by Alembic.
 revision = 'f9f6d18a37f9'
@@ -19,7 +20,7 @@ depends_on = None
 def upgrade():
    # ### commands auto generated by Alembic - please adjust! ###
    op.create_table('account_trial_app_records',
-    sa.Column('id', models.types.StringUUID(), nullable=False),
+    sa.Column('id', models.types.StringUUID(), server_default=sa.text('uuid_generate_v4()'), nullable=False),
    sa.Column('account_id', models.types.StringUUID(), nullable=False),
    sa.Column('app_id', models.types.StringUUID(), nullable=False),
    sa.Column('count', sa.Integer(), nullable=False),
@@ -32,17 +33,17 @@ def upgrade():
        batch_op.create_index('account_trial_app_record_app_id_idx', ['app_id'], unique=False)

    op.create_table('exporle_banners',
-    sa.Column('id', models.types.StringUUID(), nullable=False),
+    sa.Column('id', models.types.StringUUID(), server_default=sa.text('uuid_generate_v4()'), nullable=False),
    sa.Column('content', sa.JSON(), nullable=False),
    sa.Column('link', sa.String(length=255), nullable=False),
    sa.Column('sort', sa.Integer(), nullable=False),
-    sa.Column('status', sa.String(length=255), server_default='enabled', nullable=False),
+    sa.Column('status', sa.String(length=255), server_default=sa.text("'enabled'::character varying"), nullable=False),
    sa.Column('created_at', sa.DateTime(), server_default=sa.text('CURRENT_TIMESTAMP'), nullable=False),
-    sa.Column('language', sa.String(length=255), server_default='en-US', nullable=False),
+    sa.Column('language', sa.String(length=255), server_default=sa.text("'en-US'::character varying"), nullable=False),
    sa.PrimaryKeyConstraint('id', name='exporler_banner_pkey')
    )
    op.create_table('trial_apps',
-    sa.Column('id', models.types.StringUUID(), nullable=False),
+    sa.Column('id', models.types.StringUUID(), server_default=sa.text('uuid_generate_v4()'), nullable=False),
    sa.Column('app_id', models.types.StringUUID(), nullable=False),
    sa.Column('tenant_id', models.types.StringUUID(), nullable=False),
    sa.Column('created_at', sa.DateTime(), server_default=sa.text('CURRENT_TIMESTAMP'), nullable=False),
@@ -620,7 +620,7 @@ class TrialApp(Base):
        sa.UniqueConstraint("app_id", name="unique_trail_app_id"),
    )

-    id = mapped_column(StringUUID, default=lambda: str(uuid4()))
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
    app_id = mapped_column(StringUUID, nullable=False)
    tenant_id = mapped_column(StringUUID, nullable=False)
    created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
@@ -640,7 +640,7 @@ class AccountTrialAppRecord(Base):
        sa.Index("account_trial_app_record_app_id_idx", "app_id"),
        sa.UniqueConstraint("account_id", "app_id", name="unique_account_trial_app_record"),
    )
-    id = mapped_column(StringUUID, default=lambda: str(uuid4()))
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
    account_id = mapped_column(StringUUID, nullable=False)
    app_id = mapped_column(StringUUID, nullable=False)
    count = mapped_column(sa.Integer, nullable=False, default=0)
@@ -660,18 +660,18 @@ class AccountTrialAppRecord(Base):
 class ExporleBanner(TypeBase):
    __tablename__ = "exporle_banners"
    __table_args__ = (sa.PrimaryKeyConstraint("id", name="exporler_banner_pkey"),)
-    id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"), init=False)
    content: Mapped[dict[str, Any]] = mapped_column(sa.JSON, nullable=False)
    link: Mapped[str] = mapped_column(String(255), nullable=False)
    sort: Mapped[int] = mapped_column(sa.Integer, nullable=False)
    status: Mapped[str] = mapped_column(
-        sa.String(255), nullable=False, server_default='enabled', default="enabled"
+        sa.String(255), nullable=False, server_default=sa.text("'enabled'::character varying"), default="enabled"
    )
    created_at: Mapped[datetime] = mapped_column(
        sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
    )
    language: Mapped[str] = mapped_column(
-        String(255), nullable=False, server_default='en-US', default="en-US"
+        String(255), nullable=False, server_default=sa.text("'en-US'::character varying"), default="en-US"
    )


@@ -2166,7 +2166,7 @@ class TenantCreditPool(TypeBase):
        sa.Index("tenant_credit_pool_pool_type_idx", "pool_type"),
    )

-    id: Mapped[str] = mapped_column(StringUUID, primary_key=True, default=lambda: str(uuid4()), init=False)
+    id: Mapped[str] = mapped_column(StringUUID, primary_key=True, server_default=text("uuid_generate_v4()"), init=False)
    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
    pool_type: Mapped[str] = mapped_column(String(40), nullable=False, default="trial", server_default="trial")
    quota_limit: Mapped[int] = mapped_column(BigInteger, nullable=False, default=0)
@@ -1,6 +1,6 @@
 [project]
 name = "dify-api"
-version = "1.12.1"
+version = "1.11.4"
 requires-python = ">=3.11,<3.13"

 dependencies = [
@@ -22,14 +22,14 @@ dependencies = [
    "flask-sqlalchemy~=3.1.1",
    "gevent~=25.9.1",
    "gmpy2~=2.2.1",
-    "google-api-core>=2.19.1",
+    "google-api-core==2.18.0",
    "google-api-python-client==2.90.0",
-    "google-auth>=2.47.0",
+    "google-auth==2.29.0",
    "google-auth-httplib2==0.2.0",
-    "google-cloud-aiplatform>=1.123.0",
-    "googleapis-common-protos>=1.65.0",
+    "google-cloud-aiplatform==1.49.0",
+    "googleapis-common-protos==1.63.0",
    "gunicorn~=23.0.0",
-    "httpx[socks]~=0.28.0",
+    "httpx[socks]~=0.27.0",
    "jieba==0.42.1",
    "json-repair>=0.55.1",
    "jsonschema>=4.25.1",
@@ -41,23 +41,26 @@ dependencies = [
    "openpyxl~=3.1.5",
    "opik~=1.8.72",
    "litellm==1.77.1", # Pinned to avoid madoka dependency issue
-    "opentelemetry-api==1.28.0",
-    "opentelemetry-distro==0.49b0",
-    "opentelemetry-exporter-otlp==1.28.0",
-    "opentelemetry-exporter-otlp-proto-common==1.28.0",
-    "opentelemetry-exporter-otlp-proto-grpc==1.28.0",
-    "opentelemetry-exporter-otlp-proto-http==1.28.0",
-    "opentelemetry-instrumentation==0.49b0",
-    "opentelemetry-instrumentation-celery==0.49b0",
-    "opentelemetry-instrumentation-flask==0.49b0",
-    "opentelemetry-instrumentation-httpx==0.49b0",
-    "opentelemetry-instrumentation-redis==0.49b0",
-    "opentelemetry-instrumentation-sqlalchemy==0.49b0",
-    "opentelemetry-propagator-b3==1.28.0",
-    "opentelemetry-proto==1.28.0",
-    "opentelemetry-sdk==1.28.0",
-    "opentelemetry-semantic-conventions==0.49b0",
-    "opentelemetry-util-http==0.49b0",
+    "opentelemetry-api==1.27.0",
+    "opentelemetry-distro==0.48b0",
+    "opentelemetry-exporter-otlp==1.27.0",
+    "opentelemetry-exporter-otlp-proto-common==1.27.0",
+    "opentelemetry-exporter-otlp-proto-grpc==1.27.0",
+    "opentelemetry-exporter-otlp-proto-http==1.27.0",
+    "opentelemetry-instrumentation==0.48b0",
+    "opentelemetry-instrumentation-celery==0.48b0",
+    "opentelemetry-instrumentation-flask==0.48b0",
+    "opentelemetry-instrumentation-httpx==0.48b0",
+    "opentelemetry-instrumentation-redis==0.48b0",
+    "opentelemetry-instrumentation-httpx==0.48b0",
+    "opentelemetry-instrumentation-sqlalchemy==0.48b0",
+    "opentelemetry-propagator-b3==1.27.0",
+    # opentelemetry-proto1.28.0 depends on protobuf (>=5.0,<6.0),
+    # which is conflict with googleapis-common-protos (1.63.0)
+    "opentelemetry-proto==1.27.0",
+    "opentelemetry-sdk==1.27.0",
+    "opentelemetry-semantic-conventions==0.48b0",
+    "opentelemetry-util-http==0.48b0",
    "pandas[excel,output-formatting,performance]~=2.2.2",
    "psycogreen~=1.0.2",
    "psycopg2-binary~=2.9.6",
@@ -78,7 +81,7 @@ dependencies = [
    "starlette==0.49.1",
    "tiktoken~=0.9.0",
    "transformers~=4.56.1",
-    "unstructured[docx,epub,md,ppt,pptx]~=0.18.18",
+    "unstructured[docx,epub,md,ppt,pptx]~=0.16.1",
    "yarl~=1.18.3",
    "webvtt-py~=0.5.1",
    "sseclient-py~=1.8.0",
@@ -327,12 +327,6 @@ class AccountService:
    @staticmethod
    def delete_account(account: Account):
        """Delete account. This method only adds a task to the queue for deletion."""
-        # Queue account deletion sync tasks for all workspaces BEFORE account deletion (enterprise only)
-        from services.enterprise.account_deletion_sync import sync_account_deletion
-
-        sync_account_deletion(account_id=account.id, source="account_deleted")
-
-        # Now proceed with async account deletion
        delete_account_task.delay(account.id)

    @staticmethod
@@ -1236,11 +1230,6 @@ class TenantService:
        if dify_config.BILLING_ENABLED:
            BillingService.clean_billing_info_cache(tenant.id)

-        # Queue account deletion sync task for enterprise backend to reassign resources (enterprise only)
-        from services.enterprise.account_deletion_sync import sync_workspace_member_removal
-
-        sync_workspace_member_removal(workspace_id=tenant.id, member_id=account.id, source="workspace_member_removed")
-
    @staticmethod
    def update_member_role(tenant: Tenant, member: Account, new_role: str, operator: Account):
        """Update member role"""
@@ -1,115 +0,0 @@
-import json
-import logging
-import uuid
-from datetime import UTC, datetime
-
-from redis import RedisError
-
-from configs import dify_config
-from extensions.ext_database import db
-from extensions.ext_redis import redis_client
-from models.account import TenantAccountJoin
-
-logger = logging.getLogger(__name__)
-
-ACCOUNT_DELETION_SYNC_QUEUE = "enterprise:member:sync:queue"
-ACCOUNT_DELETION_SYNC_TASK_TYPE = "sync_member_deletion_from_workspace"
-
-
-def _queue_task(workspace_id: str, member_id: str, *, source: str) -> bool:
-    """
-    Queue an account deletion sync task to Redis.
-
-    Internal helper function. Do not call directly - use the public functions instead.
-
-    Args:
-        workspace_id: The workspace/tenant ID to sync
-        member_id: The member/account ID that was removed
-        source: Source of the sync request (for debugging/tracking)
-
-    Returns:
-        bool: True if task was queued successfully, False otherwise
-    """
-    try:
-        task = {
-            "task_id": str(uuid.uuid4()),
-            "workspace_id": workspace_id,
-            "member_id": member_id,
-            "retry_count": 0,
-            "created_at": datetime.now(UTC).isoformat(),
-            "source": source,
-            "type": ACCOUNT_DELETION_SYNC_TASK_TYPE,
-        }
-
-        # Push to Redis list (queue) - LPUSH adds to the head, worker consumes from tail with RPOP
-        redis_client.lpush(ACCOUNT_DELETION_SYNC_QUEUE, json.dumps(task))
-
-        logger.info(
-            "Queued account deletion sync task for workspace %s, member %s, task_id: %s, source: %s",
-            workspace_id,
-            member_id,
-            task["task_id"],
-            source,
-        )
-        return True
-
-    except (RedisError, TypeError) as e:
-        logger.error(
-            "Failed to queue account deletion sync for workspace %s, member %s: %s",
-            workspace_id,
-            member_id,
-            str(e),
-            exc_info=True,
-        )
-        # Don't raise - we don't want to fail member deletion if queueing fails
-        return False
-
-
-def sync_workspace_member_removal(workspace_id: str, member_id: str, *, source: str) -> bool:
-    """
-    Sync a single workspace member removal (enterprise only).
-
-    Queues a task for the enterprise backend to reassign resources from the removed member.
-    Handles enterprise edition check internally. Safe to call in community edition (no-op).
-
-    Args:
-        workspace_id: The workspace/tenant ID
-        member_id: The member/account ID that was removed
-        source: Source of the sync request (e.g., "workspace_member_removed")
-
-    Returns:
-        bool: True if task was queued (or skipped in community), False if queueing failed
-    """
-    if not dify_config.ENTERPRISE_ENABLED:
-        return True 
-
-    return _queue_task(workspace_id=workspace_id, member_id=member_id, source=source)
-
-
-def sync_account_deletion(account_id: str, *, source: str) -> bool:
-    """
-    Sync full account deletion across all workspaces (enterprise only).
-
-    Fetches all workspace memberships for the account and queues a sync task for each.
-    Handles enterprise edition check internally. Safe to call in community edition (no-op).
-
-    Args:
-        account_id: The account ID being deleted
-        source: Source of the sync request (e.g., "account_deleted")
-
-    Returns:
-        bool: True if all tasks were queued (or skipped in community), False if any queueing failed
-    """
-    if not dify_config.ENTERPRISE_ENABLED:
-        return True 
-
-    # Fetch all workspaces the account belongs to
-    workspace_joins = db.session.query(TenantAccountJoin).filter_by(account_id=account_id).all()
-
-    # Queue sync task for each workspace
-    success = True
-    for join in workspace_joins:
-        if not _queue_task(workspace_id=join.tenant_id, member_id=account_id, source=source):
-            success = False
-
-    return success
@@ -4,8 +4,6 @@ from pydantic import BaseModel, Field

 from services.enterprise.base import EnterpriseRequest

-ALLOWED_ACCESS_MODES = ["public", "private", "private_all", "sso_verified"]
-

 class WebAppSettings(BaseModel):
    access_mode: str = Field(
@@ -125,8 +123,8 @@ class EnterpriseService:
        def update_app_access_mode(cls, app_id: str, access_mode: str):
            if not app_id:
                raise ValueError("app_id must be provided.")
-            if access_mode not in ALLOWED_ACCESS_MODES:
-                raise ValueError(f"access_mode must be one of: {', '.join(ALLOWED_ACCESS_MODES)}")
+            if access_mode not in ["public", "private", "private_all"]:
+                raise ValueError("access_mode must be either 'public', 'private', or 'private_all'")

            data = {"appId": app_id, "accessMode": access_mode}

@@ -24,7 +24,7 @@ class TagService:
            escaped_keyword = escape_like_pattern(keyword)
            query = query.where(sa.and_(Tag.name.ilike(f"%{escaped_keyword}%", escape="\\")))
        query = query.group_by(Tag.id, Tag.type, Tag.name, Tag.created_at)
-        results: list = query.order_by(Tag.created_at.desc()).all()
+        results = query.order_by(Tag.created_at.desc()).all()
        return results

    @staticmethod
@@ -2,10 +2,7 @@ import json
 import logging
 from collections.abc import Mapping
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from models.account import Account
+from typing import Any

 from sqlalchemy import exists, select
 from sqlalchemy.orm import Session
@@ -409,37 +406,20 @@ class BuiltinToolManageService:
        return {"result": "success"}

    @staticmethod
-    def set_default_provider(tenant_id: str, user_id: str, provider: str, id: str, account: "Account | None" = None):
+    def set_default_provider(tenant_id: str, user_id: str, provider: str, id: str):
        """
        set default provider
        """
        with Session(db.engine) as session:
-            # get provider (verify tenant ownership to prevent IDOR)
-            target_provider = session.query(BuiltinToolProvider).filter_by(id=id, tenant_id=tenant_id).first()
+            # get provider
+            target_provider = session.query(BuiltinToolProvider).filter_by(id=id).first()
            if target_provider is None:
                raise ValueError("provider not found")

            # clear default provider
-            if dify_config.ENTERPRISE_ENABLED:
-                # Enterprise: verify admin permission for tenant-wide operation
-                from models.account import TenantAccountRole
-
-                if account is None:
-                    # In enterprise mode, an account context is required to perform permission checks
-                    raise ValueError("Account is required to set default credentials in enterprise mode")
-
-                if not TenantAccountRole.is_privileged_role(account.current_role):
-                    raise ValueError("Only workspace admins/owners can set default credentials in enterprise mode")
-                # Enterprise: clear ALL defaults for this provider in the tenant
-                # (regardless of user_id, since enterprise credentials may have different user_id)
-                session.query(BuiltinToolProvider).filter_by(
-                    tenant_id=tenant_id, provider=provider, is_default=True
-                ).update({"is_default": False})
-            else:
-                # Non-enterprise: only clear defaults for the current user
-                session.query(BuiltinToolProvider).filter_by(
-                    tenant_id=tenant_id, user_id=user_id, provider=provider, is_default=True
-                ).update({"is_default": False})
+            session.query(BuiltinToolProvider).filter_by(
+                tenant_id=tenant_id, user_id=user_id, provider=provider, is_default=True
+            ).update({"is_default": False})

            # set new default provider
            target_provider.is_default = True
@@ -6,6 +6,7 @@ from celery import shared_task

 from core.rag.datasource.vdb.vector_factory import Vector
 from core.rag.models.document import Document
+from extensions.ext_database import db
 from models.dataset import Dataset
 from services.dataset_service import DatasetCollectionBindingService

@@ -57,3 +58,5 @@ def add_annotation_to_index_task(
        )
    except Exception:
        logger.exception("Build index for annotation failed")
+    finally:
+        db.session.close()
@@ -5,6 +5,7 @@ import click
 from celery import shared_task

 from core.rag.datasource.vdb.vector_factory import Vector
+from extensions.ext_database import db
 from models.dataset import Dataset
 from services.dataset_service import DatasetCollectionBindingService

@@ -39,3 +40,5 @@ def delete_annotation_index_task(annotation_id: str, app_id: str, tenant_id: str
        logger.info(click.style(f"App annotations index deleted : {app_id} latency: {end_at - start_at}", fg="green"))
    except Exception:
        logger.exception("Annotation deleted index failed")
+    finally:
+        db.session.close()
@@ -6,6 +6,7 @@ from celery import shared_task

 from core.rag.datasource.vdb.vector_factory import Vector
 from core.rag.models.document import Document
+from extensions.ext_database import db
 from models.dataset import Dataset
 from services.dataset_service import DatasetCollectionBindingService

@@ -58,3 +59,5 @@ def update_annotation_to_index_task(
        )
    except Exception:
        logger.exception("Build index for annotation failed")
+    finally:
+        db.session.close()
@@ -14,9 +14,6 @@ from models.model import UploadFile

 logger = logging.getLogger(__name__)

-# Batch size for database operations to keep transactions short
-BATCH_SIZE = 1000
-

@shared_task(queue="dataset")
 def batch_clean_document_task(document_ids: list[str], dataset_id: str, doc_form: str | None, file_ids: list[str]):
@@ -34,179 +31,63 @@ def batch_clean_document_task(document_ids: list[str], dataset_id: str, doc_form
    if not doc_form:
        raise ValueError("doc_form is required")

-    storage_keys_to_delete: list[str] = []
-    index_node_ids: list[str] = []
-    segment_ids: list[str] = []
-    total_image_upload_file_ids: list[str] = []
+    with session_factory.create_session() as session:
+        try:
+            dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
+
+            if not dataset:
+                raise Exception("Document has no dataset")
+
+            session.query(DatasetMetadataBinding).where(
+                DatasetMetadataBinding.dataset_id == dataset_id,
+                DatasetMetadataBinding.document_id.in_(document_ids),
+            ).delete(synchronize_session=False)

-    try:
-        # ============ Step 1: Query segment and file data (short read-only transaction) ============
-        with session_factory.create_session() as session:
-            # Get segments info
            segments = session.scalars(
                select(DocumentSegment).where(DocumentSegment.document_id.in_(document_ids))
            ).all()
-
+            # check segment is exist
            if segments:
                index_node_ids = [segment.index_node_id for segment in segments]
-                segment_ids = [segment.id for segment in segments]
+                index_processor = IndexProcessorFactory(doc_form).init_index_processor()
+                index_processor.clean(
+                    dataset, index_node_ids, with_keywords=True, delete_child_chunks=True, delete_summaries=True
+                )

-                # Collect image file IDs from segment content
                for segment in segments:
                    image_upload_file_ids = get_image_upload_file_ids(segment.content)
-                    total_image_upload_file_ids.extend(image_upload_file_ids)
-
-            # Query storage keys for image files
-            if total_image_upload_file_ids:
-                image_files = session.scalars(
-                    select(UploadFile).where(UploadFile.id.in_(total_image_upload_file_ids))
-                ).all()
-                storage_keys_to_delete.extend([f.key for f in image_files if f and f.key])
-
-            # Query storage keys for document files
+                    image_files = session.query(UploadFile).where(UploadFile.id.in_(image_upload_file_ids)).all()
+                    for image_file in image_files:
+                        try:
+                            if image_file and image_file.key:
+                                storage.delete(image_file.key)
+                        except Exception:
+                            logger.exception(
+                                "Delete image_files failed when storage deleted, \
+                                              image_upload_file_is: %s",
+                                image_file.id,
+                            )
+                    stmt = delete(UploadFile).where(UploadFile.id.in_(image_upload_file_ids))
+                    session.execute(stmt)
+                    session.delete(segment)
            if file_ids:
                files = session.scalars(select(UploadFile).where(UploadFile.id.in_(file_ids))).all()
-                storage_keys_to_delete.extend([f.key for f in files if f and f.key])
+                for file in files:
+                    try:
+                        storage.delete(file.key)
+                    except Exception:
+                        logger.exception("Delete file failed when document deleted, file_id: %s", file.id)
+                stmt = delete(UploadFile).where(UploadFile.id.in_(file_ids))
+                session.execute(stmt)

-        # ============ Step 2: Clean vector index (external service, fresh session for dataset) ============
-        if index_node_ids:
-            try:
-                # Fetch dataset in a fresh session to avoid DetachedInstanceError
-                with session_factory.create_session() as session:
-                    dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
-                    if not dataset:
-                        logger.warning("Dataset not found for vector index cleanup, dataset_id: %s", dataset_id)
-                    else:
-                        index_processor = IndexProcessorFactory(doc_form).init_index_processor()
-                        index_processor.clean(
-                            dataset, index_node_ids, with_keywords=True, delete_child_chunks=True, delete_summaries=True
-                        )
-            except Exception:
-                logger.exception(
-                    "Failed to clean vector index for dataset_id: %s, document_ids: %s, index_node_ids count: %d",
-                    dataset_id,
-                    document_ids,
-                    len(index_node_ids),
-                )
+            session.commit()

-        # ============ Step 3: Delete metadata binding (separate short transaction) ============
-        try:
-            with session_factory.create_session() as session:
-                deleted_count = (
-                    session.query(DatasetMetadataBinding)
-                    .where(
-                        DatasetMetadataBinding.dataset_id == dataset_id,
-                        DatasetMetadataBinding.document_id.in_(document_ids),
-                    )
-                    .delete(synchronize_session=False)
+            end_at = time.perf_counter()
+            logger.info(
+                click.style(
+                    f"Cleaned documents when documents deleted latency: {end_at - start_at}",
+                    fg="green",
                )
-                session.commit()
-                logger.debug("Deleted %d metadata bindings for dataset_id: %s", deleted_count, dataset_id)
+            )
        except Exception:
-            logger.exception(
-                "Failed to delete metadata bindings for dataset_id: %s, document_ids: %s",
-                dataset_id,
-                document_ids,
-            )
-
-        # ============ Step 4: Batch delete UploadFile records (multiple short transactions) ============
-        if total_image_upload_file_ids:
-            failed_batches = 0
-            total_batches = (len(total_image_upload_file_ids) + BATCH_SIZE - 1) // BATCH_SIZE
-            for i in range(0, len(total_image_upload_file_ids), BATCH_SIZE):
-                batch = total_image_upload_file_ids[i : i + BATCH_SIZE]
-                try:
-                    with session_factory.create_session() as session:
-                        stmt = delete(UploadFile).where(UploadFile.id.in_(batch))
-                        session.execute(stmt)
-                        session.commit()
-                except Exception:
-                    failed_batches += 1
-                    logger.exception(
-                        "Failed to delete image UploadFile batch %d-%d for dataset_id: %s",
-                        i,
-                        i + len(batch),
-                        dataset_id,
-                    )
-            if failed_batches > 0:
-                logger.warning(
-                    "Image UploadFile deletion: %d/%d batches failed for dataset_id: %s",
-                    failed_batches,
-                    total_batches,
-                    dataset_id,
-                )
-
-        # ============ Step 5: Batch delete DocumentSegment records (multiple short transactions) ============
-        if segment_ids:
-            failed_batches = 0
-            total_batches = (len(segment_ids) + BATCH_SIZE - 1) // BATCH_SIZE
-            for i in range(0, len(segment_ids), BATCH_SIZE):
-                batch = segment_ids[i : i + BATCH_SIZE]
-                try:
-                    with session_factory.create_session() as session:
-                        segment_delete_stmt = delete(DocumentSegment).where(DocumentSegment.id.in_(batch))
-                        session.execute(segment_delete_stmt)
-                        session.commit()
-                except Exception:
-                    failed_batches += 1
-                    logger.exception(
-                        "Failed to delete DocumentSegment batch %d-%d for dataset_id: %s, document_ids: %s",
-                        i,
-                        i + len(batch),
-                        dataset_id,
-                        document_ids,
-                    )
-            if failed_batches > 0:
-                logger.warning(
-                    "DocumentSegment deletion: %d/%d batches failed, document_ids: %s",
-                    failed_batches,
-                    total_batches,
-                    document_ids,
-                )
-
-        # ============ Step 6: Delete document-associated files (separate short transaction) ============
-        if file_ids:
-            try:
-                with session_factory.create_session() as session:
-                    stmt = delete(UploadFile).where(UploadFile.id.in_(file_ids))
-                    session.execute(stmt)
-                    session.commit()
-            except Exception:
-                logger.exception(
-                    "Failed to delete document UploadFile records for dataset_id: %s, file_ids: %s",
-                    dataset_id,
-                    file_ids,
-                )
-
-        # ============ Step 7: Delete storage files (I/O operations, no DB transaction) ============
-        storage_delete_failures = 0
-        for storage_key in storage_keys_to_delete:
-            try:
-                storage.delete(storage_key)
-            except Exception:
-                storage_delete_failures += 1
-                logger.exception("Failed to delete file from storage, key: %s", storage_key)
-        if storage_delete_failures > 0:
-            logger.warning(
-                "Storage file deletion completed with %d failures out of %d total files for dataset_id: %s",
-                storage_delete_failures,
-                len(storage_keys_to_delete),
-                dataset_id,
-            )
-
-        end_at = time.perf_counter()
-        logger.info(
-            click.style(
-                f"Cleaned documents when documents deleted latency: {end_at - start_at:.2f}s, "
-                f"dataset_id: {dataset_id}, document_ids: {document_ids}, "
-                f"segments: {len(segment_ids)}, image_files: {len(total_image_upload_file_ids)}, "
-                f"storage_files: {len(storage_keys_to_delete)}",
-                fg="green",
-            )
-        )
-    except Exception:
-        logger.exception(
-            "Batch clean documents failed for dataset_id: %s, document_ids: %s",
-            dataset_id,
-            document_ids,
-        )
+            logger.exception("Cleaned documents when documents deleted failed")
@@ -48,11 +48,6 @@ def batch_create_segment_to_index_task(

    indexing_cache_key = f"segment_batch_import_{job_id}"

-    # Initialize variables with default values
-    upload_file_key: str | None = None
-    dataset_config: dict | None = None
-    document_config: dict | None = None
-
    with session_factory.create_session() as session:
        try:
            dataset = session.get(Dataset, dataset_id)
@@ -74,115 +69,86 @@ def batch_create_segment_to_index_task(
            if not upload_file:
                raise ValueError("UploadFile not found.")

-            dataset_config = {
-                "id": dataset.id,
-                "indexing_technique": dataset.indexing_technique,
-                "tenant_id": dataset.tenant_id,
-                "embedding_model_provider": dataset.embedding_model_provider,
-                "embedding_model": dataset.embedding_model,
-            }
+            with tempfile.TemporaryDirectory() as temp_dir:
+                suffix = Path(upload_file.key).suffix
+                file_path = f"{temp_dir}/{next(tempfile._get_candidate_names())}{suffix}"  # type: ignore
+                storage.download(upload_file.key, file_path)

-            document_config = {
-                "id": dataset_document.id,
-                "doc_form": dataset_document.doc_form,
-                "word_count": dataset_document.word_count or 0,
-            }
+                df = pd.read_csv(file_path)
+                content = []
+                for _, row in df.iterrows():
+                    if dataset_document.doc_form == "qa_model":
+                        data = {"content": row.iloc[0], "answer": row.iloc[1]}
+                    else:
+                        data = {"content": row.iloc[0]}
+                    content.append(data)
+                if len(content) == 0:
+                    raise ValueError("The CSV file is empty.")

-            upload_file_key = upload_file.key
+            document_segments = []
+            embedding_model = None
+            if dataset.indexing_technique == "high_quality":
+                model_manager = ModelManager()
+                embedding_model = model_manager.get_model_instance(
+                    tenant_id=dataset.tenant_id,
+                    provider=dataset.embedding_model_provider,
+                    model_type=ModelType.TEXT_EMBEDDING,
+                    model=dataset.embedding_model,
+                )

-        except Exception:
-            logger.exception("Segments batch created index failed")
-            redis_client.setex(indexing_cache_key, 600, "error")
-            return
-
-    # Ensure required variables are set before proceeding
-    if upload_file_key is None or dataset_config is None or document_config is None:
-        logger.error("Required configuration not set due to session error")
-        redis_client.setex(indexing_cache_key, 600, "error")
-        return
-
-    with tempfile.TemporaryDirectory() as temp_dir:
-        suffix = Path(upload_file_key).suffix
-        file_path = f"{temp_dir}/{next(tempfile._get_candidate_names())}{suffix}"  # type: ignore
-        storage.download(upload_file_key, file_path)
-
-        df = pd.read_csv(file_path)
-        content = []
-        for _, row in df.iterrows():
-            if document_config["doc_form"] == "qa_model":
-                data = {"content": row.iloc[0], "answer": row.iloc[1]}
+            word_count_change = 0
+            if embedding_model:
+                tokens_list = embedding_model.get_text_embedding_num_tokens(
+                    texts=[segment["content"] for segment in content]
+                )
            else:
-                data = {"content": row.iloc[0]}
-            content.append(data)
-        if len(content) == 0:
-            raise ValueError("The CSV file is empty.")
+                tokens_list = [0] * len(content)

-    document_segments = []
-    embedding_model = None
-    if dataset_config["indexing_technique"] == "high_quality":
-        model_manager = ModelManager()
-        embedding_model = model_manager.get_model_instance(
-            tenant_id=dataset_config["tenant_id"],
-            provider=dataset_config["embedding_model_provider"],
-            model_type=ModelType.TEXT_EMBEDDING,
-            model=dataset_config["embedding_model"],
-        )
+            for segment, tokens in zip(content, tokens_list):
+                content = segment["content"]
+                doc_id = str(uuid.uuid4())
+                segment_hash = helper.generate_text_hash(content)
+                max_position = (
+                    session.query(func.max(DocumentSegment.position))
+                    .where(DocumentSegment.document_id == dataset_document.id)
+                    .scalar()
+                )
+                segment_document = DocumentSegment(
+                    tenant_id=tenant_id,
+                    dataset_id=dataset_id,
+                    document_id=document_id,
+                    index_node_id=doc_id,
+                    index_node_hash=segment_hash,
+                    position=max_position + 1 if max_position else 1,
+                    content=content,
+                    word_count=len(content),
+                    tokens=tokens,
+                    created_by=user_id,
+                    indexing_at=naive_utc_now(),
+                    status="completed",
+                    completed_at=naive_utc_now(),
+                )
+                if dataset_document.doc_form == "qa_model":
+                    segment_document.answer = segment["answer"]
+                    segment_document.word_count += len(segment["answer"])
+                word_count_change += segment_document.word_count
+                session.add(segment_document)
+                document_segments.append(segment_document)

-    word_count_change = 0
-    if embedding_model:
-        tokens_list = embedding_model.get_text_embedding_num_tokens(texts=[segment["content"] for segment in content])
-    else:
-        tokens_list = [0] * len(content)
-
-    with session_factory.create_session() as session, session.begin():
-        for segment, tokens in zip(content, tokens_list):
-            content = segment["content"]
-            doc_id = str(uuid.uuid4())
-            segment_hash = helper.generate_text_hash(content)
-            max_position = (
-                session.query(func.max(DocumentSegment.position))
-                .where(DocumentSegment.document_id == document_config["id"])
-                .scalar()
-            )
-            segment_document = DocumentSegment(
-                tenant_id=tenant_id,
-                dataset_id=dataset_id,
-                document_id=document_id,
-                index_node_id=doc_id,
-                index_node_hash=segment_hash,
-                position=max_position + 1 if max_position else 1,
-                content=content,
-                word_count=len(content),
-                tokens=tokens,
-                created_by=user_id,
-                indexing_at=naive_utc_now(),
-                status="completed",
-                completed_at=naive_utc_now(),
-            )
-            if document_config["doc_form"] == "qa_model":
-                segment_document.answer = segment["answer"]
-                segment_document.word_count += len(segment["answer"])
-            word_count_change += segment_document.word_count
-            session.add(segment_document)
-            document_segments.append(segment_document)
-
-    with session_factory.create_session() as session, session.begin():
-        dataset_document = session.get(Document, document_id)
-        if dataset_document:
            assert dataset_document.word_count is not None
            dataset_document.word_count += word_count_change
            session.add(dataset_document)

-    with session_factory.create_session() as session:
-        dataset = session.get(Dataset, dataset_id)
-        if dataset:
-            VectorService.create_segments_vector(None, document_segments, dataset, document_config["doc_form"])
-
-    redis_client.setex(indexing_cache_key, 600, "completed")
-    end_at = time.perf_counter()
-    logger.info(
-        click.style(
-            f"Segment batch created job: {job_id} latency: {end_at - start_at}",
-            fg="green",
-        )
-    )
+            VectorService.create_segments_vector(None, document_segments, dataset, dataset_document.doc_form)
+            session.commit()
+            redis_client.setex(indexing_cache_key, 600, "completed")
+            end_at = time.perf_counter()
+            logger.info(
+                click.style(
+                    f"Segment batch created job: {job_id} latency: {end_at - start_at}",
+                    fg="green",
+                )
+            )
+        except Exception:
+            logger.exception("Segments batch created index failed")
+            redis_client.setex(indexing_cache_key, 600, "error")
@@ -28,7 +28,6 @@ def clean_document_task(document_id: str, dataset_id: str, doc_form: str, file_i
    """
    logger.info(click.style(f"Start clean document when document deleted: {document_id}", fg="green"))
    start_at = time.perf_counter()
-    total_attachment_files = []

    with session_factory.create_session() as session:
        try:
@@ -48,91 +47,78 @@ def clean_document_task(document_id: str, dataset_id: str, doc_form: str, file_i
                    SegmentAttachmentBinding.document_id == document_id,
                )
            ).all()
-
-            attachment_ids = [attachment_file.id for _, attachment_file in attachments_with_bindings]
-            binding_ids = [binding.id for binding, _ in attachments_with_bindings]
-            total_attachment_files.extend([attachment_file.key for _, attachment_file in attachments_with_bindings])
-
-            index_node_ids = [segment.index_node_id for segment in segments]
-            segment_contents = [segment.content for segment in segments]
-        except Exception:
-            logger.exception("Cleaned document when document deleted failed")
-            return
-
-    # check segment is exist
-    if index_node_ids:
-        index_processor = IndexProcessorFactory(doc_form).init_index_processor()
-        with session_factory.create_session() as session:
-            dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
-            if dataset:
+            # check segment is exist
+            if segments:
+                index_node_ids = [segment.index_node_id for segment in segments]
+                index_processor = IndexProcessorFactory(doc_form).init_index_processor()
                index_processor.clean(
                    dataset, index_node_ids, with_keywords=True, delete_child_chunks=True, delete_summaries=True
                )

-    total_image_files = []
-    with session_factory.create_session() as session, session.begin():
-        for segment_content in segment_contents:
-            image_upload_file_ids = get_image_upload_file_ids(segment_content)
-            image_files = session.scalars(select(UploadFile).where(UploadFile.id.in_(image_upload_file_ids))).all()
-            total_image_files.extend([image_file.key for image_file in image_files])
-            image_file_delete_stmt = delete(UploadFile).where(UploadFile.id.in_(image_upload_file_ids))
-            session.execute(image_file_delete_stmt)
+                for segment in segments:
+                    image_upload_file_ids = get_image_upload_file_ids(segment.content)
+                    image_files = session.scalars(
+                        select(UploadFile).where(UploadFile.id.in_(image_upload_file_ids))
+                    ).all()
+                    for image_file in image_files:
+                        if image_file is None:
+                            continue
+                        try:
+                            storage.delete(image_file.key)
+                        except Exception:
+                            logger.exception(
+                                "Delete image_files failed when storage deleted, \
+                                                  image_upload_file_is: %s",
+                                image_file.id,
+                            )

-    with session_factory.create_session() as session, session.begin():
-        segment_delete_stmt = delete(DocumentSegment).where(DocumentSegment.document_id == document_id)
-        session.execute(segment_delete_stmt)
+                    image_file_delete_stmt = delete(UploadFile).where(UploadFile.id.in_(image_upload_file_ids))
+                    session.execute(image_file_delete_stmt)
+                    session.delete(segment)

-    for image_file_key in total_image_files:
-        try:
-            storage.delete(image_file_key)
-        except Exception:
-            logger.exception(
-                "Delete image_files failed when storage deleted, \
-                                          image_upload_file_is: %s",
-                image_file_key,
+                session.commit()
+            if file_id:
+                file = session.query(UploadFile).where(UploadFile.id == file_id).first()
+                if file:
+                    try:
+                        storage.delete(file.key)
+                    except Exception:
+                        logger.exception("Delete file failed when document deleted, file_id: %s", file_id)
+                    session.delete(file)
+            # delete segment attachments
+            if attachments_with_bindings:
+                attachment_ids = [attachment_file.id for _, attachment_file in attachments_with_bindings]
+                binding_ids = [binding.id for binding, _ in attachments_with_bindings]
+                for binding, attachment_file in attachments_with_bindings:
+                    try:
+                        storage.delete(attachment_file.key)
+                    except Exception:
+                        logger.exception(
+                            "Delete attachment_file failed when storage deleted, \
+                                            attachment_file_id: %s",
+                            binding.attachment_id,
+                        )
+                attachment_file_delete_stmt = delete(UploadFile).where(UploadFile.id.in_(attachment_ids))
+                session.execute(attachment_file_delete_stmt)
+
+                binding_delete_stmt = delete(SegmentAttachmentBinding).where(
+                    SegmentAttachmentBinding.id.in_(binding_ids)
+                )
+                session.execute(binding_delete_stmt)
+
+            # delete dataset metadata binding
+            session.query(DatasetMetadataBinding).where(
+                DatasetMetadataBinding.dataset_id == dataset_id,
+                DatasetMetadataBinding.document_id == document_id,
+            ).delete()
+            session.commit()
+
+            end_at = time.perf_counter()
+            logger.info(
+                click.style(
+                    f"Cleaned document when document deleted: {document_id} latency: {end_at - start_at}",
+                    fg="green",
+                )
            )
-
-    with session_factory.create_session() as session, session.begin():
-        if file_id:
-            file = session.query(UploadFile).where(UploadFile.id == file_id).first()
-            if file:
-                try:
-                    storage.delete(file.key)
-                except Exception:
-                    logger.exception("Delete file failed when document deleted, file_id: %s", file_id)
-                session.delete(file)
-
-    with session_factory.create_session() as session, session.begin():
-        # delete segment attachments
-        if attachment_ids:
-            attachment_file_delete_stmt = delete(UploadFile).where(UploadFile.id.in_(attachment_ids))
-            session.execute(attachment_file_delete_stmt)
-
-        if binding_ids:
-            binding_delete_stmt = delete(SegmentAttachmentBinding).where(SegmentAttachmentBinding.id.in_(binding_ids))
-            session.execute(binding_delete_stmt)
-
-    for attachment_file_key in total_attachment_files:
-        try:
-            storage.delete(attachment_file_key)
        except Exception:
-            logger.exception(
-                "Delete attachment_file failed when storage deleted, \
-                                    attachment_file_id: %s",
-                attachment_file_key,
-            )
-
-    with session_factory.create_session() as session, session.begin():
-        # delete dataset metadata binding
-        session.query(DatasetMetadataBinding).where(
-            DatasetMetadataBinding.dataset_id == dataset_id,
-            DatasetMetadataBinding.document_id == document_id,
-        ).delete()
-
-    end_at = time.perf_counter()
-    logger.info(
-        click.style(
-            f"Cleaned document when document deleted: {document_id} latency: {end_at - start_at}",
-            fg="green",
-        )
-    )
+            logger.exception("Cleaned document when document deleted failed")
@@ -23,40 +23,40 @@ def clean_notion_document_task(document_ids: list[str], dataset_id: str):
    """
    logger.info(click.style(f"Start clean document when import form notion document deleted: {dataset_id}", fg="green"))
    start_at = time.perf_counter()
-    total_index_node_ids = []

    with session_factory.create_session() as session:
-        dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
+        try:
+            dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()

-        if not dataset:
-            raise Exception("Document has no dataset")
-        index_type = dataset.doc_form
-        index_processor = IndexProcessorFactory(index_type).init_index_processor()
+            if not dataset:
+                raise Exception("Document has no dataset")
+            index_type = dataset.doc_form
+            index_processor = IndexProcessorFactory(index_type).init_index_processor()

-        document_delete_stmt = delete(Document).where(Document.id.in_(document_ids))
-        session.execute(document_delete_stmt)
+            document_delete_stmt = delete(Document).where(Document.id.in_(document_ids))
+            session.execute(document_delete_stmt)

-        for document_id in document_ids:
-            segments = session.scalars(select(DocumentSegment).where(DocumentSegment.document_id == document_id)).all()
-            total_index_node_ids.extend([segment.index_node_id for segment in segments])
+            for document_id in document_ids:
+                segments = session.scalars(
+                    select(DocumentSegment).where(DocumentSegment.document_id == document_id)
+                ).all()
+                index_node_ids = [segment.index_node_id for segment in segments]

-    with session_factory.create_session() as session:
-        dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
-        if dataset:
-            index_processor.clean(
-                dataset, total_index_node_ids, with_keywords=True, delete_child_chunks=True, delete_summaries=True
+                index_processor.clean(
+                    dataset, index_node_ids, with_keywords=True, delete_child_chunks=True, delete_summaries=True
+                )
+                segment_ids = [segment.id for segment in segments]
+                segment_delete_stmt = delete(DocumentSegment).where(DocumentSegment.id.in_(segment_ids))
+                session.execute(segment_delete_stmt)
+            session.commit()
+            end_at = time.perf_counter()
+            logger.info(
+                click.style(
+                    "Clean document when import form notion document deleted end :: {} latency: {}".format(
+                        dataset_id, end_at - start_at
+                    ),
+                    fg="green",
+                )
            )
-
-    with session_factory.create_session() as session, session.begin():
-        segment_delete_stmt = delete(DocumentSegment).where(DocumentSegment.document_id.in_(document_ids))
-        session.execute(segment_delete_stmt)
-
-    end_at = time.perf_counter()
-    logger.info(
-        click.style(
-            "Clean document when import form notion document deleted end :: {} latency: {}".format(
-                dataset_id, end_at - start_at
-            ),
-            fg="green",
-        )
-    )
+        except Exception:
+            logger.exception("Cleaned document when import form notion document deleted  failed")
@@ -3,7 +3,6 @@ import time

 import click
 from celery import shared_task
-from sqlalchemy import delete

 from core.db.session_factory import session_factory
 from core.rag.index_processor.index_processor_factory import IndexProcessorFactory
@@ -68,14 +67,8 @@ def delete_segment_from_index_task(
                if segment_attachment_bindings:
                    attachment_ids = [binding.attachment_id for binding in segment_attachment_bindings]
                    index_processor.clean(dataset=dataset, node_ids=attachment_ids, with_keywords=False)
-                    segment_attachment_bind_ids = [i.id for i in segment_attachment_bindings]
-
-                    for i in range(0, len(segment_attachment_bind_ids), 1000):
-                        segment_attachment_bind_delete_stmt = delete(SegmentAttachmentBinding).where(
-                            SegmentAttachmentBinding.id.in_(segment_attachment_bind_ids[i : i + 1000])
-                        )
-                        session.execute(segment_attachment_bind_delete_stmt)
-
+                    for binding in segment_attachment_bindings:
+                        session.delete(binding)
                    # delete upload file
                    session.query(UploadFile).where(UploadFile.id.in_(attachment_ids)).delete(synchronize_session=False)
                    session.commit()
@@ -27,129 +27,104 @@ def document_indexing_sync_task(dataset_id: str, document_id: str):
    """
    logger.info(click.style(f"Start sync document: {document_id}", fg="green"))
    start_at = time.perf_counter()
-    tenant_id = None

-    with session_factory.create_session() as session, session.begin():
+    with session_factory.create_session() as session:
        document = session.query(Document).where(Document.id == document_id, Document.dataset_id == dataset_id).first()

        if not document:
            logger.info(click.style(f"Document not found: {document_id}", fg="red"))
            return

-        if document.indexing_status == "parsing":
-            logger.info(click.style(f"Document {document_id} is already being processed, skipping", fg="yellow"))
-            return
-
-        dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
-        if not dataset:
-            raise Exception("Dataset not found")
-
        data_source_info = document.data_source_info_dict
-        if document.data_source_type != "notion_import":
-            logger.info(click.style(f"Document {document_id} is not a notion_import, skipping", fg="yellow"))
-            return
+        if document.data_source_type == "notion_import":
+            if (
+                not data_source_info
+                or "notion_page_id" not in data_source_info
+                or "notion_workspace_id" not in data_source_info
+            ):
+                raise ValueError("no notion page found")
+            workspace_id = data_source_info["notion_workspace_id"]
+            page_id = data_source_info["notion_page_id"]
+            page_type = data_source_info["type"]
+            page_edited_time = data_source_info["last_edited_time"]
+            credential_id = data_source_info.get("credential_id")

-        if (
-            not data_source_info
-            or "notion_page_id" not in data_source_info
-            or "notion_workspace_id" not in data_source_info
-        ):
-            raise ValueError("no notion page found")
+            # Get credentials from datasource provider
+            datasource_provider_service = DatasourceProviderService()
+            credential = datasource_provider_service.get_datasource_credentials(
+                tenant_id=document.tenant_id,
+                credential_id=credential_id,
+                provider="notion_datasource",
+                plugin_id="langgenius/notion_datasource",
+            )

-        workspace_id = data_source_info["notion_workspace_id"]
-        page_id = data_source_info["notion_page_id"]
-        page_type = data_source_info["type"]
-        page_edited_time = data_source_info["last_edited_time"]
-        credential_id = data_source_info.get("credential_id")
-        tenant_id = document.tenant_id
-        index_type = document.doc_form
-
-        segments = session.scalars(select(DocumentSegment).where(DocumentSegment.document_id == document_id)).all()
-        index_node_ids = [segment.index_node_id for segment in segments]
-
-    # Get credentials from datasource provider
-    datasource_provider_service = DatasourceProviderService()
-    credential = datasource_provider_service.get_datasource_credentials(
-        tenant_id=tenant_id,
-        credential_id=credential_id,
-        provider="notion_datasource",
-        plugin_id="langgenius/notion_datasource",
-    )
-
-    if not credential:
-        logger.error(
-            "Datasource credential not found for document %s, tenant_id: %s, credential_id: %s",
-            document_id,
-            tenant_id,
-            credential_id,
-        )
-
-        with session_factory.create_session() as session, session.begin():
-            document = session.query(Document).filter_by(id=document_id).first()
-            if document:
+            if not credential:
+                logger.error(
+                    "Datasource credential not found for document %s, tenant_id: %s, credential_id: %s",
+                    document_id,
+                    document.tenant_id,
+                    credential_id,
+                )
                document.indexing_status = "error"
                document.error = "Datasource credential not found. Please reconnect your Notion workspace."
                document.stopped_at = naive_utc_now()
-        return
+                session.commit()
+                return

-    loader = NotionExtractor(
-        notion_workspace_id=workspace_id,
-        notion_obj_id=page_id,
-        notion_page_type=page_type,
-        notion_access_token=credential.get("integration_secret"),
-        tenant_id=tenant_id,
-    )
+            loader = NotionExtractor(
+                notion_workspace_id=workspace_id,
+                notion_obj_id=page_id,
+                notion_page_type=page_type,
+                notion_access_token=credential.get("integration_secret"),
+                tenant_id=document.tenant_id,
+            )

-    last_edited_time = loader.get_notion_last_edited_time()
-    if last_edited_time == page_edited_time:
-        logger.info(click.style(f"Document {document_id} content unchanged, skipping sync", fg="yellow"))
-        return
+            last_edited_time = loader.get_notion_last_edited_time()

-    logger.info(click.style(f"Document {document_id} content changed, starting sync", fg="green"))
+            # check the page is updated
+            if last_edited_time != page_edited_time:
+                document.indexing_status = "parsing"
+                document.processing_started_at = naive_utc_now()
+                session.commit()

-    try:
-        index_processor = IndexProcessorFactory(index_type).init_index_processor()
-        with session_factory.create_session() as session:
-            dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
-            if dataset:
-                index_processor.clean(dataset, index_node_ids, with_keywords=True, delete_child_chunks=True)
-        logger.info(click.style(f"Cleaned vector index for document {document_id}", fg="green"))
-    except Exception:
-        logger.exception("Failed to clean vector index for document %s", document_id)
+                # delete all document segment and index
+                try:
+                    dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
+                    if not dataset:
+                        raise Exception("Dataset not found")
+                    index_type = document.doc_form
+                    index_processor = IndexProcessorFactory(index_type).init_index_processor()

-    with session_factory.create_session() as session, session.begin():
-        document = session.query(Document).filter_by(id=document_id).first()
-        if not document:
-            logger.warning(click.style(f"Document {document_id} not found during sync", fg="yellow"))
-            return
+                    segments = session.scalars(
+                        select(DocumentSegment).where(DocumentSegment.document_id == document_id)
+                    ).all()
+                    index_node_ids = [segment.index_node_id for segment in segments]

-        data_source_info = document.data_source_info_dict
-        data_source_info["last_edited_time"] = last_edited_time
-        document.data_source_info = data_source_info
+                    # delete from vector index
+                    index_processor.clean(dataset, index_node_ids, with_keywords=True, delete_child_chunks=True)

-        document.indexing_status = "parsing"
-        document.processing_started_at = naive_utc_now()
+                    segment_ids = [segment.id for segment in segments]
+                    segment_delete_stmt = delete(DocumentSegment).where(DocumentSegment.id.in_(segment_ids))
+                    session.execute(segment_delete_stmt)

-        segment_delete_stmt = delete(DocumentSegment).where(DocumentSegment.document_id == document_id)
-        session.execute(segment_delete_stmt)
+                    end_at = time.perf_counter()
+                    logger.info(
+                        click.style(
+                            "Cleaned document when document update data source or process rule: {} latency: {}".format(
+                                document_id, end_at - start_at
+                            ),
+                            fg="green",
+                        )
+                    )
+                except Exception:
+                    logger.exception("Cleaned document when document update data source or process rule failed")

-        logger.info(click.style(f"Deleted segments for document {document_id}", fg="green"))
-
-    try:
-        indexing_runner = IndexingRunner()
-        with session_factory.create_session() as session:
-            document = session.query(Document).filter_by(id=document_id).first()
-            if document:
-                indexing_runner.run([document])
-        end_at = time.perf_counter()
-        logger.info(click.style(f"Sync completed for document {document_id} latency: {end_at - start_at}", fg="green"))
-    except DocumentIsPausedError as ex:
-        logger.info(click.style(str(ex), fg="yellow"))
-    except Exception as e:
-        logger.exception("document_indexing_sync_task failed for document_id: %s", document_id)
-        with session_factory.create_session() as session, session.begin():
-            document = session.query(Document).filter_by(id=document_id).first()
-            if document:
-                document.indexing_status = "error"
-                document.error = str(e)
-                document.stopped_at = naive_utc_now()
+                try:
+                    indexing_runner = IndexingRunner()
+                    indexing_runner.run([document])
+                    end_at = time.perf_counter()
+                    logger.info(click.style(f"update document: {document.id} latency: {end_at - start_at}", fg="green"))
+                except DocumentIsPausedError as ex:
+                    logger.info(click.style(str(ex), fg="yellow"))
+                except Exception:
+                    logger.exception("document_indexing_sync_task failed, document_id: %s", document_id)
@@ -81,35 +81,26 @@ def _document_indexing(dataset_id: str, document_ids: Sequence[str]):
            session.commit()
            return

-    # Phase 1: Update status to parsing (short transaction)
-    with session_factory.create_session() as session, session.begin():
-        documents = (
-            session.query(Document).where(Document.id.in_(document_ids), Document.dataset_id == dataset_id).all()
-        )
+        for document_id in document_ids:
+            logger.info(click.style(f"Start process document: {document_id}", fg="green"))
+
+            document = (
+                session.query(Document).where(Document.id == document_id, Document.dataset_id == dataset_id).first()
+            )

-        for document in documents:
            if document:
                document.indexing_status = "parsing"
                document.processing_started_at = naive_utc_now()
+                documents.append(document)
                session.add(document)
-    # Transaction committed and closed
+        session.commit()

-    # Phase 2: Execute indexing (no transaction - IndexingRunner creates its own sessions)
-    has_error = False
-    try:
-        indexing_runner = IndexingRunner()
-        indexing_runner.run(documents)
-        end_at = time.perf_counter()
-        logger.info(click.style(f"Processed dataset: {dataset_id} latency: {end_at - start_at}", fg="green"))
-    except DocumentIsPausedError as ex:
-        logger.info(click.style(str(ex), fg="yellow"))
-        has_error = True
-    except Exception:
-        logger.exception("Document indexing task failed, dataset_id: %s", dataset_id)
-        has_error = True
+        try:
+            indexing_runner = IndexingRunner()
+            indexing_runner.run(documents)
+            end_at = time.perf_counter()
+            logger.info(click.style(f"Processed dataset: {dataset_id} latency: {end_at - start_at}", fg="green"))

-    if not has_error:
-        with session_factory.create_session() as session:
            # Trigger summary index generation for completed documents if enabled
            # Only generate for high_quality indexing technique and when summary_index_setting is enabled
            # Re-query dataset to get latest summary_index_setting (in case it was updated)
@@ -124,18 +115,17 @@ def _document_indexing(dataset_id: str, document_ids: Sequence[str]):
                    # expire all session to get latest document's indexing status
                    session.expire_all()
                    # Check each document's indexing status and trigger summary generation if completed
-
-                    documents = (
-                        session.query(Document)
-                        .where(Document.id.in_(document_ids), Document.dataset_id == dataset_id)
-                        .all()
-                    )
-
-                    for document in documents:
+                    for document_id in document_ids:
+                        # Re-query document to get latest status (IndexingRunner may have updated it)
+                        document = (
+                            session.query(Document)
+                            .where(Document.id == document_id, Document.dataset_id == dataset_id)
+                            .first()
+                        )
                        if document:
                            logger.info(
                                "Checking document %s for summary generation: status=%s, doc_form=%s, need_summary=%s",
-                                document.id,
+                                document_id,
                                document.indexing_status,
                                document.doc_form,
                                document.need_summary,
@@ -146,36 +136,46 @@ def _document_indexing(dataset_id: str, document_ids: Sequence[str]):
                                and document.need_summary is True
                            ):
                                try:
-                                    generate_summary_index_task.delay(dataset.id, document.id, None)
+                                    generate_summary_index_task.delay(dataset.id, document_id, None)
                                    logger.info(
                                        "Queued summary index generation task for document %s in dataset %s "
                                        "after indexing completed",
-                                        document.id,
+                                        document_id,
                                        dataset.id,
                                    )
                                except Exception:
                                    logger.exception(
                                        "Failed to queue summary index generation task for document %s",
-                                        document.id,
+                                        document_id,
                                    )
                                    # Don't fail the entire indexing process if summary task queuing fails
                            else:
                                logger.info(
                                    "Skipping summary generation for document %s: "
                                    "status=%s, doc_form=%s, need_summary=%s",
-                                    document.id,
+                                    document_id,
                                    document.indexing_status,
                                    document.doc_form,
                                    document.need_summary,
                                )
                        else:
-                            logger.warning("Document %s not found after indexing", document.id)
+                            logger.warning("Document %s not found after indexing", document_id)
+                else:
+                    logger.info(
+                        "Summary index generation skipped for dataset %s: summary_index_setting.enable=%s",
+                        dataset.id,
+                        summary_index_setting.get("enable") if summary_index_setting else None,
+                    )
            else:
                logger.info(
                    "Summary index generation skipped for dataset %s: indexing_technique=%s (not 'high_quality')",
                    dataset.id,
                    dataset.indexing_technique,
                )
+        except DocumentIsPausedError as ex:
+            logger.info(click.style(str(ex), fg="yellow"))
+        except Exception:
+            logger.exception("Document indexing task failed, dataset_id: %s", dataset_id)


 def _document_indexing_with_tenant_queue(
@@ -8,6 +8,7 @@ from sqlalchemy import delete, select
 from core.db.session_factory import session_factory
 from core.indexing_runner import DocumentIsPausedError, IndexingRunner
 from core.rag.index_processor.index_processor_factory import IndexProcessorFactory
+from extensions.ext_database import db
 from libs.datetime_utils import naive_utc_now
 from models.dataset import Dataset, Document, DocumentSegment

@@ -26,7 +27,7 @@ def document_indexing_update_task(dataset_id: str, document_id: str):
    logger.info(click.style(f"Start update document: {document_id}", fg="green"))
    start_at = time.perf_counter()

-    with session_factory.create_session() as session, session.begin():
+    with session_factory.create_session() as session:
        document = session.query(Document).where(Document.id == document_id, Document.dataset_id == dataset_id).first()

        if not document:
@@ -35,20 +36,27 @@ def document_indexing_update_task(dataset_id: str, document_id: str):

        document.indexing_status = "parsing"
        document.processing_started_at = naive_utc_now()
+        session.commit()

-        dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
-        if not dataset:
-            return
+        # delete all document segment and index
+        try:
+            dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
+            if not dataset:
+                raise Exception("Dataset not found")

-        index_type = document.doc_form
-        segments = session.scalars(select(DocumentSegment).where(DocumentSegment.document_id == document_id)).all()
-        index_node_ids = [segment.index_node_id for segment in segments]
+            index_type = document.doc_form
+            index_processor = IndexProcessorFactory(index_type).init_index_processor()

-    clean_success = False
-    try:
-        index_processor = IndexProcessorFactory(index_type).init_index_processor()
-        if index_node_ids:
-            index_processor.clean(dataset, index_node_ids, with_keywords=True, delete_child_chunks=True)
+            segments = session.scalars(select(DocumentSegment).where(DocumentSegment.document_id == document_id)).all()
+            if segments:
+                index_node_ids = [segment.index_node_id for segment in segments]
+
+                # delete from vector index
+                index_processor.clean(dataset, index_node_ids, with_keywords=True, delete_child_chunks=True)
+                segment_ids = [segment.id for segment in segments]
+                segment_delete_stmt = delete(DocumentSegment).where(DocumentSegment.id.in_(segment_ids))
+                session.execute(segment_delete_stmt)
+                db.session.commit()
            end_at = time.perf_counter()
            logger.info(
                click.style(
@@ -58,21 +66,15 @@ def document_indexing_update_task(dataset_id: str, document_id: str):
                    fg="green",
                )
            )
-            clean_success = True
-    except Exception:
-        logger.exception("Failed to clean document index during update, document_id: %s", document_id)
+        except Exception:
+            logger.exception("Cleaned document when document update data source or process rule failed")

-    if clean_success:
-        with session_factory.create_session() as session, session.begin():
-            segment_delete_stmt = delete(DocumentSegment).where(DocumentSegment.document_id == document_id)
-            session.execute(segment_delete_stmt)
-
-    try:
-        indexing_runner = IndexingRunner()
-        indexing_runner.run([document])
-        end_at = time.perf_counter()
-        logger.info(click.style(f"update document: {document.id} latency: {end_at - start_at}", fg="green"))
-    except DocumentIsPausedError as ex:
-        logger.info(click.style(str(ex), fg="yellow"))
-    except Exception:
-        logger.exception("document_indexing_update_task failed, document_id: %s", document_id)
+        try:
+            indexing_runner = IndexingRunner()
+            indexing_runner.run([document])
+            end_at = time.perf_counter()
+            logger.info(click.style(f"update document: {document.id} latency: {end_at - start_at}", fg="green"))
+        except DocumentIsPausedError as ex:
+            logger.info(click.style(str(ex), fg="yellow"))
+        except Exception:
+            logger.exception("document_indexing_update_task failed, document_id: %s", document_id)
@@ -259,8 +259,8 @@ def _delete_app_workflow_app_logs(tenant_id: str, app_id: str):


 def _delete_app_workflow_archive_logs(tenant_id: str, app_id: str):
-    def del_workflow_archive_log(session, workflow_archive_log_id: str):
-        session.query(WorkflowArchiveLog).where(WorkflowArchiveLog.id == workflow_archive_log_id).delete(
+    def del_workflow_archive_log(workflow_archive_log_id: str):
+        db.session.query(WorkflowArchiveLog).where(WorkflowArchiveLog.id == workflow_archive_log_id).delete(
            synchronize_session=False
        )

@@ -420,7 +420,7 @@ def delete_draft_variables_batch(app_id: str, batch_size: int = 1000) -> int:
    total_files_deleted = 0

    while True:
-        with session_factory.create_session() as session, session.begin():
+        with session_factory.create_session() as session:
            # Get a batch of draft variable IDs along with their file_ids
            query_sql = """
                SELECT id, file_id FROM workflow_draft_variables
@@ -6,8 +6,9 @@ improving performance by offloading storage operations to background workers.
 """

 from celery import shared_task  # type: ignore[import-untyped]
+from sqlalchemy.orm import Session

-from core.db.session_factory import session_factory
+from extensions.ext_database import db
 from services.workflow_draft_variable_service import DraftVarFileDeletion, WorkflowDraftVariableService


@@ -16,6 +17,6 @@ def save_workflow_execution_task(
    self,
    deletions: list[DraftVarFileDeletion],
 ):
-    with session_factory.create_session() as session, session.begin():
+    with Session(bind=db.engine) as session, session.begin():
        srv = WorkflowDraftVariableService(session=session)
        srv.delete_workflow_draft_variable_file(deletions=deletions)
@@ -10,10 +10,7 @@ from models import Tenant
 from models.enums import CreatorUserRole
 from models.model import App, UploadFile
 from models.workflow import WorkflowDraftVariable, WorkflowDraftVariableFile
-from tasks.remove_app_and_related_data_task import (
-    _delete_draft_variables,
-    delete_draft_variables_batch,
-)
+from tasks.remove_app_and_related_data_task import _delete_draft_variables, delete_draft_variables_batch


@pytest.fixture
@@ -300,18 +297,12 @@ class TestDeleteDraftVariablesWithOffloadIntegration:
    def test_delete_draft_variables_with_offload_data(self, mock_storage, setup_offload_test_data):
        data = setup_offload_test_data
        app_id = data["app"].id
-        upload_file_ids = [uf.id for uf in data["upload_files"]]
-        variable_file_ids = [vf.id for vf in data["variable_files"]]
        mock_storage.delete.return_value = None

        with session_factory.create_session() as session:
            draft_vars_before = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
-            var_files_before = (
-                session.query(WorkflowDraftVariableFile)
-                .where(WorkflowDraftVariableFile.id.in_(variable_file_ids))
-                .count()
-            )
-            upload_files_before = session.query(UploadFile).where(UploadFile.id.in_(upload_file_ids)).count()
+            var_files_before = session.query(WorkflowDraftVariableFile).count()
+            upload_files_before = session.query(UploadFile).count()
        assert draft_vars_before == 3
        assert var_files_before == 2
        assert upload_files_before == 2
@@ -324,12 +315,8 @@ class TestDeleteDraftVariablesWithOffloadIntegration:
        assert draft_vars_after == 0

        with session_factory.create_session() as session:
-            var_files_after = (
-                session.query(WorkflowDraftVariableFile)
-                .where(WorkflowDraftVariableFile.id.in_(variable_file_ids))
-                .count()
-            )
-            upload_files_after = session.query(UploadFile).where(UploadFile.id.in_(upload_file_ids)).count()
+            var_files_after = session.query(WorkflowDraftVariableFile).count()
+            upload_files_after = session.query(UploadFile).count()
        assert var_files_after == 0
        assert upload_files_after == 0

@@ -342,8 +329,6 @@ class TestDeleteDraftVariablesWithOffloadIntegration:
    def test_delete_draft_variables_storage_failure_continues_cleanup(self, mock_storage, setup_offload_test_data):
        data = setup_offload_test_data
        app_id = data["app"].id
-        upload_file_ids = [uf.id for uf in data["upload_files"]]
-        variable_file_ids = [vf.id for vf in data["variable_files"]]
        mock_storage.delete.side_effect = [Exception("Storage error"), None]

        deleted_count = delete_draft_variables_batch(app_id, batch_size=10)
@@ -354,12 +339,8 @@ class TestDeleteDraftVariablesWithOffloadIntegration:
        assert draft_vars_after == 0

        with session_factory.create_session() as session:
-            var_files_after = (
-                session.query(WorkflowDraftVariableFile)
-                .where(WorkflowDraftVariableFile.id.in_(variable_file_ids))
-                .count()
-            )
-            upload_files_after = session.query(UploadFile).where(UploadFile.id.in_(upload_file_ids)).count()
+            var_files_after = session.query(WorkflowDraftVariableFile).count()
+            upload_files_after = session.query(UploadFile).count()
        assert var_files_after == 0
        assert upload_files_after == 0

@@ -414,275 +395,3 @@ class TestDeleteDraftVariablesWithOffloadIntegration:
                if app2_obj:
                    session.delete(app2_obj)
                session.commit()
-
-
-class TestDeleteDraftVariablesSessionCommit:
-    """Test suite to verify session commit behavior in delete_draft_variables_batch."""
-
-    @pytest.fixture
-    def setup_offload_test_data(self, app_and_tenant):
-        """Create test data with offload files for session commit tests."""
-        from core.variables.types import SegmentType
-        from libs.datetime_utils import naive_utc_now
-
-        tenant, app = app_and_tenant
-
-        with session_factory.create_session() as session:
-            upload_file1 = UploadFile(
-                tenant_id=tenant.id,
-                storage_type="local",
-                key="test/file1.json",
-                name="file1.json",
-                size=1024,
-                extension="json",
-                mime_type="application/json",
-                created_by_role=CreatorUserRole.ACCOUNT,
-                created_by=str(uuid.uuid4()),
-                created_at=naive_utc_now(),
-                used=False,
-            )
-            upload_file2 = UploadFile(
-                tenant_id=tenant.id,
-                storage_type="local",
-                key="test/file2.json",
-                name="file2.json",
-                size=2048,
-                extension="json",
-                mime_type="application/json",
-                created_by_role=CreatorUserRole.ACCOUNT,
-                created_by=str(uuid.uuid4()),
-                created_at=naive_utc_now(),
-                used=False,
-            )
-            session.add(upload_file1)
-            session.add(upload_file2)
-            session.flush()
-
-            var_file1 = WorkflowDraftVariableFile(
-                tenant_id=tenant.id,
-                app_id=app.id,
-                user_id=str(uuid.uuid4()),
-                upload_file_id=upload_file1.id,
-                size=1024,
-                length=10,
-                value_type=SegmentType.STRING,
-            )
-            var_file2 = WorkflowDraftVariableFile(
-                tenant_id=tenant.id,
-                app_id=app.id,
-                user_id=str(uuid.uuid4()),
-                upload_file_id=upload_file2.id,
-                size=2048,
-                length=20,
-                value_type=SegmentType.OBJECT,
-            )
-            session.add(var_file1)
-            session.add(var_file2)
-            session.flush()
-
-            draft_var1 = WorkflowDraftVariable.new_node_variable(
-                app_id=app.id,
-                node_id="node_1",
-                name="large_var_1",
-                value=StringSegment(value="truncated..."),
-                node_execution_id=str(uuid.uuid4()),
-                file_id=var_file1.id,
-            )
-            draft_var2 = WorkflowDraftVariable.new_node_variable(
-                app_id=app.id,
-                node_id="node_2",
-                name="large_var_2",
-                value=StringSegment(value="truncated..."),
-                node_execution_id=str(uuid.uuid4()),
-                file_id=var_file2.id,
-            )
-            draft_var3 = WorkflowDraftVariable.new_node_variable(
-                app_id=app.id,
-                node_id="node_3",
-                name="regular_var",
-                value=StringSegment(value="regular_value"),
-                node_execution_id=str(uuid.uuid4()),
-            )
-            session.add(draft_var1)
-            session.add(draft_var2)
-            session.add(draft_var3)
-            session.commit()
-
-            data = {
-                "app": app,
-                "tenant": tenant,
-                "upload_files": [upload_file1, upload_file2],
-                "variable_files": [var_file1, var_file2],
-                "draft_variables": [draft_var1, draft_var2, draft_var3],
-            }
-
-        yield data
-
-        with session_factory.create_session() as session:
-            for table, ids in [
-                (WorkflowDraftVariable, [v.id for v in data["draft_variables"]]),
-                (WorkflowDraftVariableFile, [vf.id for vf in data["variable_files"]]),
-                (UploadFile, [uf.id for uf in data["upload_files"]]),
-            ]:
-                cleanup_query = delete(table).where(table.id.in_(ids)).execution_options(synchronize_session=False)
-                session.execute(cleanup_query)
-            session.commit()
-
-    @pytest.fixture
-    def setup_commit_test_data(self, app_and_tenant):
-        """Create test data for session commit tests."""
-        tenant, app = app_and_tenant
-        variable_ids: list[str] = []
-
-        with session_factory.create_session() as session:
-            variables = []
-            for i in range(10):
-                var = WorkflowDraftVariable.new_node_variable(
-                    app_id=app.id,
-                    node_id=f"node_{i}",
-                    name=f"var_{i}",
-                    value=StringSegment(value="test_value"),
-                    node_execution_id=str(uuid.uuid4()),
-                )
-                session.add(var)
-                variables.append(var)
-            session.commit()
-            variable_ids = [v.id for v in variables]
-
-        yield {
-            "app": app,
-            "tenant": tenant,
-            "variable_ids": variable_ids,
-        }
-
-        with session_factory.create_session() as session:
-            cleanup_query = (
-                delete(WorkflowDraftVariable)
-                .where(WorkflowDraftVariable.id.in_(variable_ids))
-                .execution_options(synchronize_session=False)
-            )
-            session.execute(cleanup_query)
-            session.commit()
-
-    def test_session_commit_is_called_after_each_batch(self, setup_commit_test_data):
-        """Test that session.begin() is used for automatic transaction management."""
-        data = setup_commit_test_data
-        app_id = data["app"].id
-
-        # Since session.begin() is used, the transaction is automatically committed
-        # when the with block exits successfully. We verify this by checking that
-        # data is actually persisted.
-        deleted_count = delete_draft_variables_batch(app_id, batch_size=3)
-
-        # Verify all data was deleted (proves transaction was committed)
-        with session_factory.create_session() as session:
-            remaining_count = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
-
-        assert deleted_count == 10
-        assert remaining_count == 0
-
-    def test_data_persisted_after_batch_deletion(self, setup_commit_test_data):
-        """Test that data is actually persisted to database after batch deletion with commits."""
-        data = setup_commit_test_data
-        app_id = data["app"].id
-        variable_ids = data["variable_ids"]
-
-        # Verify initial state
-        with session_factory.create_session() as session:
-            initial_count = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
-        assert initial_count == 10
-
-        # Perform deletion with small batch size to force multiple commits
-        deleted_count = delete_draft_variables_batch(app_id, batch_size=3)
-
-        assert deleted_count == 10
-
-        # Verify all data is deleted in a new session (proves commits worked)
-        with session_factory.create_session() as session:
-            final_count = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
-        assert final_count == 0
-
-        # Verify specific IDs are deleted
-        with session_factory.create_session() as session:
-            remaining_vars = (
-                session.query(WorkflowDraftVariable).where(WorkflowDraftVariable.id.in_(variable_ids)).count()
-            )
-        assert remaining_vars == 0
-
-    def test_session_commit_with_empty_dataset(self, setup_commit_test_data):
-        """Test session behavior when deleting from an empty dataset."""
-        nonexistent_app_id = str(uuid.uuid4())
-
-        # Should not raise any errors and should return 0
-        deleted_count = delete_draft_variables_batch(nonexistent_app_id, batch_size=10)
-        assert deleted_count == 0
-
-    def test_session_commit_with_single_batch(self, setup_commit_test_data):
-        """Test that commit happens correctly when all data fits in a single batch."""
-        data = setup_commit_test_data
-        app_id = data["app"].id
-
-        with session_factory.create_session() as session:
-            initial_count = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
-        assert initial_count == 10
-
-        # Delete all in a single batch
-        deleted_count = delete_draft_variables_batch(app_id, batch_size=100)
-        assert deleted_count == 10
-
-        # Verify data is persisted
-        with session_factory.create_session() as session:
-            final_count = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
-        assert final_count == 0
-
-    def test_invalid_batch_size_raises_error(self, setup_commit_test_data):
-        """Test that invalid batch size raises ValueError."""
-        data = setup_commit_test_data
-        app_id = data["app"].id
-
-        with pytest.raises(ValueError, match="batch_size must be positive"):
-            delete_draft_variables_batch(app_id, batch_size=0)
-
-        with pytest.raises(ValueError, match="batch_size must be positive"):
-            delete_draft_variables_batch(app_id, batch_size=-1)
-
-    @patch("extensions.ext_storage.storage")
-    def test_session_commit_with_offload_data_cleanup(self, mock_storage, setup_offload_test_data):
-        """Test that session commits correctly when cleaning up offload data."""
-        data = setup_offload_test_data
-        app_id = data["app"].id
-        upload_file_ids = [uf.id for uf in data["upload_files"]]
-        mock_storage.delete.return_value = None
-
-        # Verify initial state
-        with session_factory.create_session() as session:
-            draft_vars_before = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
-            var_files_before = (
-                session.query(WorkflowDraftVariableFile)
-                .where(WorkflowDraftVariableFile.id.in_([vf.id for vf in data["variable_files"]]))
-                .count()
-            )
-            upload_files_before = session.query(UploadFile).where(UploadFile.id.in_(upload_file_ids)).count()
-        assert draft_vars_before == 3
-        assert var_files_before == 2
-        assert upload_files_before == 2
-
-        # Delete variables with offload data
-        deleted_count = delete_draft_variables_batch(app_id, batch_size=10)
-        assert deleted_count == 3
-
-        # Verify all data is persisted (deleted) in new session
-        with session_factory.create_session() as session:
-            draft_vars_after = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
-            var_files_after = (
-                session.query(WorkflowDraftVariableFile)
-                .where(WorkflowDraftVariableFile.id.in_([vf.id for vf in data["variable_files"]]))
-                .count()
-            )
-            upload_files_after = session.query(UploadFile).where(UploadFile.id.in_(upload_file_ids)).count()
-        assert draft_vars_after == 0
-        assert var_files_after == 0
-        assert upload_files_after == 0
-
-        # Verify storage cleanup was called
-        assert mock_storage.delete.call_count == 2
@@ -1,38 +0,0 @@
-"""
-Integration tests for DbMigrationAutoRenewLock using real Redis via TestContainers.
-"""
-
-import time
-import uuid
-
-import pytest
-
-from extensions.ext_redis import redis_client
-from libs.db_migration_lock import DbMigrationAutoRenewLock
-
-
-@pytest.mark.usefixtures("flask_app_with_containers")
-def test_db_migration_lock_renews_ttl_and_releases():
-    lock_name = f"test:db_migration_auto_renew_lock:{uuid.uuid4().hex}"
-
-    # Keep base TTL very small, and renew frequently so the test is stable even on slower CI.
-    lock = DbMigrationAutoRenewLock(
-        redis_client=redis_client,
-        name=lock_name,
-        ttl_seconds=1.0,
-        renew_interval_seconds=0.2,
-        log_context="test_db_migration_lock",
-    )
-
-    acquired = lock.acquire(blocking=True, blocking_timeout=5)
-    assert acquired is True
-
-    # Wait beyond the base TTL; key should still exist due to renewal.
-    time.sleep(1.5)
-    ttl = redis_client.ttl(lock_name)
-    assert ttl > 0
-
-    lock.release_safely(status="successful")
-
-    # After release, the key should not exist.
-    assert redis_client.exists(lock_name) == 0
@@ -605,20 +605,26 @@ class TestBatchCreateSegmentToIndexTask:

        mock_storage.download.side_effect = mock_download

-        # Execute the task - should raise ValueError for empty CSV
+        # Execute the task
        job_id = str(uuid.uuid4())
-        with pytest.raises(ValueError, match="The CSV file is empty"):
-            batch_create_segment_to_index_task(
-                job_id=job_id,
-                upload_file_id=upload_file.id,
-                dataset_id=dataset.id,
-                document_id=document.id,
-                tenant_id=tenant.id,
-                user_id=account.id,
-            )
+        batch_create_segment_to_index_task(
+            job_id=job_id,
+            upload_file_id=upload_file.id,
+            dataset_id=dataset.id,
+            document_id=document.id,
+            tenant_id=tenant.id,
+            user_id=account.id,
+        )

        # Verify error handling
-        # Since exception was raised, no segments should be created
+        # Check Redis cache was set to error status
+        from extensions.ext_redis import redis_client
+
+        cache_key = f"segment_batch_import_{job_id}"
+        cache_value = redis_client.get(cache_key)
+        assert cache_value == b"error"
+
+        # Verify no segments were created
        from extensions.ext_database import db

        segments = db.session.query(DocumentSegment).all()
@@ -153,7 +153,8 @@ class TestCleanNotionDocumentTask:
        # Execute cleanup task
        clean_notion_document_task(document_ids, dataset.id)

-        # Verify segments are deleted
+        # Verify documents and segments are deleted
+        assert db_session_with_containers.query(Document).filter(Document.id.in_(document_ids)).count() == 0
        assert (
            db_session_with_containers.query(DocumentSegment)
            .filter(DocumentSegment.document_id.in_(document_ids))
@@ -161,9 +162,9 @@ class TestCleanNotionDocumentTask:
            == 0
        )

-        # Verify index processor was called
+        # Verify index processor was called for each document
        mock_processor = mock_index_processor_factory.return_value.init_index_processor.return_value
-        mock_processor.clean.assert_called_once()
+        assert mock_processor.clean.call_count == len(document_ids)

        # This test successfully verifies:
        # 1. Document records are properly deleted from the database
@@ -185,12 +186,12 @@ class TestCleanNotionDocumentTask:
        non_existent_dataset_id = str(uuid.uuid4())
        document_ids = [str(uuid.uuid4()), str(uuid.uuid4())]

-        # Execute cleanup task with non-existent dataset - expect exception
-        with pytest.raises(Exception, match="Document has no dataset"):
-            clean_notion_document_task(document_ids, non_existent_dataset_id)
+        # Execute cleanup task with non-existent dataset
+        clean_notion_document_task(document_ids, non_existent_dataset_id)

-        # Verify that the index processor factory was not used
-        mock_index_processor_factory.return_value.init_index_processor.assert_not_called()
+        # Verify that the index processor was not called
+        mock_processor = mock_index_processor_factory.return_value.init_index_processor.return_value
+        mock_processor.clean.assert_not_called()

    def test_clean_notion_document_task_empty_document_list(
        self, db_session_with_containers, mock_index_processor_factory, mock_external_service_dependencies
@@ -228,13 +229,9 @@ class TestCleanNotionDocumentTask:
        # Execute cleanup task with empty document list
        clean_notion_document_task([], dataset.id)

-        # Verify that the index processor was called once with empty node list
+        # Verify that the index processor was not called
        mock_processor = mock_index_processor_factory.return_value.init_index_processor.return_value
-        assert mock_processor.clean.call_count == 1
-        args, kwargs = mock_processor.clean.call_args
-        # args: (dataset, total_index_node_ids)
-        assert isinstance(args[0], Dataset)
-        assert args[1] == []
+        mock_processor.clean.assert_not_called()

    def test_clean_notion_document_task_with_different_index_types(
        self, db_session_with_containers, mock_index_processor_factory, mock_external_service_dependencies
@@ -318,7 +315,8 @@ class TestCleanNotionDocumentTask:
            # Note: This test successfully verifies cleanup with different document types.
            # The task properly handles various index types and document configurations.

-            # Verify segments are deleted
+            # Verify documents and segments are deleted
+            assert db_session_with_containers.query(Document).filter(Document.id == document.id).count() == 0
            assert (
                db_session_with_containers.query(DocumentSegment)
                .filter(DocumentSegment.document_id == document.id)
@@ -406,7 +404,8 @@ class TestCleanNotionDocumentTask:
        # Execute cleanup task
        clean_notion_document_task([document.id], dataset.id)

-        # Verify segments are deleted
+        # Verify documents and segments are deleted
+        assert db_session_with_containers.query(Document).filter(Document.id == document.id).count() == 0
        assert (
            db_session_with_containers.query(DocumentSegment).filter(DocumentSegment.document_id == document.id).count()
            == 0
@@ -509,7 +508,8 @@ class TestCleanNotionDocumentTask:

        clean_notion_document_task(documents_to_clean, dataset.id)

-        # Verify only specified documents' segments are deleted
+        # Verify only specified documents and segments are deleted
+        assert db_session_with_containers.query(Document).filter(Document.id.in_(documents_to_clean)).count() == 0
        assert (
            db_session_with_containers.query(DocumentSegment)
            .filter(DocumentSegment.document_id.in_(documents_to_clean))
@@ -697,12 +697,11 @@ class TestCleanNotionDocumentTask:
        db_session_with_containers.commit()

        # Mock index processor to raise an exception
-        mock_index_processor = mock_index_processor_factory.return_value.init_index_processor.return_value
+        mock_index_processor = mock_index_processor_factory.init_index_processor.return_value
        mock_index_processor.clean.side_effect = Exception("Index processor error")

-        # Execute cleanup task - current implementation propagates the exception
-        with pytest.raises(Exception, match="Index processor error"):
-            clean_notion_document_task([document.id], dataset.id)
+        # Execute cleanup task - it should handle the exception gracefully
+        clean_notion_document_task([document.id], dataset.id)

        # Note: This test demonstrates the task's error handling capability.
        # Even with external service errors, the database operations complete successfully.
@@ -804,7 +803,8 @@ class TestCleanNotionDocumentTask:
        all_document_ids = [doc.id for doc in documents]
        clean_notion_document_task(all_document_ids, dataset.id)

-        # Verify all segments are deleted
+        # Verify all documents and segments are deleted
+        assert db_session_with_containers.query(Document).filter(Document.dataset_id == dataset.id).count() == 0
        assert (
            db_session_with_containers.query(DocumentSegment).filter(DocumentSegment.dataset_id == dataset.id).count()
            == 0
@@ -914,7 +914,8 @@ class TestCleanNotionDocumentTask:

        clean_notion_document_task([target_document.id], target_dataset.id)

-        # Verify only documents' segments from target dataset are deleted
+        # Verify only documents from target dataset are deleted
+        assert db_session_with_containers.query(Document).filter(Document.id == target_document.id).count() == 0
        assert (
            db_session_with_containers.query(DocumentSegment)
            .filter(DocumentSegment.document_id == target_document.id)
@@ -1029,7 +1030,8 @@ class TestCleanNotionDocumentTask:
        all_document_ids = [doc.id for doc in documents]
        clean_notion_document_task(all_document_ids, dataset.id)

-        # Verify all segments are deleted regardless of status
+        # Verify all documents and segments are deleted regardless of status
+        assert db_session_with_containers.query(Document).filter(Document.dataset_id == dataset.id).count() == 0
        assert (
            db_session_with_containers.query(DocumentSegment).filter(DocumentSegment.dataset_id == dataset.id).count()
            == 0
@@ -1140,7 +1142,8 @@ class TestCleanNotionDocumentTask:
        # Execute cleanup task
        clean_notion_document_task([document.id], dataset.id)

-        # Verify segments are deleted
+        # Verify documents and segments are deleted
+        assert db_session_with_containers.query(Document).filter(Document.id == document.id).count() == 0
        assert (
            db_session_with_containers.query(DocumentSegment).filter(DocumentSegment.document_id == document.id).count()
            == 0
@@ -1,182 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pytest
-from faker import Faker
-
-from models import Account, Tenant, TenantAccountJoin, TenantAccountRole
-from models.dataset import Dataset, Document, DocumentSegment
-from tasks.document_indexing_update_task import document_indexing_update_task
-
-
-class TestDocumentIndexingUpdateTask:
-    @pytest.fixture
-    def mock_external_dependencies(self):
-        """Patch external collaborators used by the update task.
-        - IndexProcessorFactory.init_index_processor().clean(...)
-        - IndexingRunner.run([...])
-        """
-        with (
-            patch("tasks.document_indexing_update_task.IndexProcessorFactory") as mock_factory,
-            patch("tasks.document_indexing_update_task.IndexingRunner") as mock_runner,
-        ):
-            processor_instance = MagicMock()
-            mock_factory.return_value.init_index_processor.return_value = processor_instance
-
-            runner_instance = MagicMock()
-            mock_runner.return_value = runner_instance
-
-            yield {
-                "factory": mock_factory,
-                "processor": processor_instance,
-                "runner": mock_runner,
-                "runner_instance": runner_instance,
-            }
-
-    def _create_dataset_document_with_segments(self, db_session_with_containers, *, segment_count: int = 2):
-        fake = Faker()
-
-        # Account and tenant
-        account = Account(
-            email=fake.email(),
-            name=fake.name(),
-            interface_language="en-US",
-            status="active",
-        )
-        db_session_with_containers.add(account)
-        db_session_with_containers.commit()
-
-        tenant = Tenant(name=fake.company(), status="normal")
-        db_session_with_containers.add(tenant)
-        db_session_with_containers.commit()
-
-        join = TenantAccountJoin(
-            tenant_id=tenant.id,
-            account_id=account.id,
-            role=TenantAccountRole.OWNER,
-            current=True,
-        )
-        db_session_with_containers.add(join)
-        db_session_with_containers.commit()
-
-        # Dataset and document
-        dataset = Dataset(
-            tenant_id=tenant.id,
-            name=fake.company(),
-            description=fake.text(max_nb_chars=64),
-            data_source_type="upload_file",
-            indexing_technique="high_quality",
-            created_by=account.id,
-        )
-        db_session_with_containers.add(dataset)
-        db_session_with_containers.commit()
-
-        document = Document(
-            tenant_id=tenant.id,
-            dataset_id=dataset.id,
-            position=0,
-            data_source_type="upload_file",
-            batch="test_batch",
-            name=fake.file_name(),
-            created_from="upload_file",
-            created_by=account.id,
-            indexing_status="waiting",
-            enabled=True,
-            doc_form="text_model",
-        )
-        db_session_with_containers.add(document)
-        db_session_with_containers.commit()
-
-        # Segments
-        node_ids = []
-        for i in range(segment_count):
-            node_id = f"node-{i + 1}"
-            seg = DocumentSegment(
-                tenant_id=tenant.id,
-                dataset_id=dataset.id,
-                document_id=document.id,
-                position=i,
-                content=fake.text(max_nb_chars=32),
-                answer=None,
-                word_count=10,
-                tokens=5,
-                index_node_id=node_id,
-                status="completed",
-                created_by=account.id,
-            )
-            db_session_with_containers.add(seg)
-            node_ids.append(node_id)
-        db_session_with_containers.commit()
-
-        # Refresh to ensure ORM state
-        db_session_with_containers.refresh(dataset)
-        db_session_with_containers.refresh(document)
-
-        return dataset, document, node_ids
-
-    def test_cleans_segments_and_reindexes(self, db_session_with_containers, mock_external_dependencies):
-        dataset, document, node_ids = self._create_dataset_document_with_segments(db_session_with_containers)
-
-        # Act
-        document_indexing_update_task(dataset.id, document.id)
-
-        # Ensure we see committed changes from another session
-        db_session_with_containers.expire_all()
-
-        # Assert document status updated before reindex
-        updated = db_session_with_containers.query(Document).where(Document.id == document.id).first()
-        assert updated.indexing_status == "parsing"
-        assert updated.processing_started_at is not None
-
-        # Segments should be deleted
-        remaining = (
-            db_session_with_containers.query(DocumentSegment).where(DocumentSegment.document_id == document.id).count()
-        )
-        assert remaining == 0
-
-        # Assert index processor clean was called with expected args
-        clean_call = mock_external_dependencies["processor"].clean.call_args
-        assert clean_call is not None
-        args, kwargs = clean_call
-        # args[0] is a Dataset instance (from another session) — validate by id
-        assert getattr(args[0], "id", None) == dataset.id
-        # args[1] should contain our node_ids
-        assert set(args[1]) == set(node_ids)
-        assert kwargs.get("with_keywords") is True
-        assert kwargs.get("delete_child_chunks") is True
-
-        # Assert indexing runner invoked with the updated document
-        run_call = mock_external_dependencies["runner_instance"].run.call_args
-        assert run_call is not None
-        run_docs = run_call[0][0]
-        assert len(run_docs) == 1
-        first = run_docs[0]
-        assert getattr(first, "id", None) == document.id
-
-    def test_clean_error_is_logged_and_indexing_continues(self, db_session_with_containers, mock_external_dependencies):
-        dataset, document, node_ids = self._create_dataset_document_with_segments(db_session_with_containers)
-
-        # Force clean to raise; task should continue to indexing
-        mock_external_dependencies["processor"].clean.side_effect = Exception("boom")
-
-        document_indexing_update_task(dataset.id, document.id)
-
-        # Ensure we see committed changes from another session
-        db_session_with_containers.expire_all()
-
-        # Indexing should still be triggered
-        mock_external_dependencies["runner_instance"].run.assert_called_once()
-
-        # Segments should remain (since clean failed before DB delete)
-        remaining = (
-            db_session_with_containers.query(DocumentSegment).where(DocumentSegment.document_id == document.id).count()
-        )
-        assert remaining > 0
-
-    def test_document_not_found_noop(self, db_session_with_containers, mock_external_dependencies):
-        fake = Faker()
-        # Act with non-existent document id
-        document_indexing_update_task(dataset_id=fake.uuid4(), document_id=fake.uuid4())
-
-        # Neither processor nor runner should be called
-        mock_external_dependencies["processor"].clean.assert_not_called()
-        mock_external_dependencies["runner_instance"].run.assert_not_called()
@@ -1,146 +0,0 @@
-import sys
-import threading
-import types
-from unittest.mock import MagicMock
-
-import commands
-from libs.db_migration_lock import LockNotOwnedError, RedisError
-
-HEARTBEAT_WAIT_TIMEOUT_SECONDS = 5.0
-
-
-def _install_fake_flask_migrate(monkeypatch, upgrade_impl) -> None:
-    module = types.ModuleType("flask_migrate")
-    module.upgrade = upgrade_impl
-    monkeypatch.setitem(sys.modules, "flask_migrate", module)
-
-
-def _invoke_upgrade_db() -> int:
-    try:
-        commands.upgrade_db.callback()
-    except SystemExit as e:
-        return int(e.code or 0)
-    return 0
-
-
-def test_upgrade_db_skips_when_lock_not_acquired(monkeypatch, capsys):
-    monkeypatch.setattr(commands, "DB_UPGRADE_LOCK_TTL_SECONDS", 1234)
-
-    lock = MagicMock()
-    lock.acquire.return_value = False
-    commands.redis_client.lock.return_value = lock
-
-    exit_code = _invoke_upgrade_db()
-    captured = capsys.readouterr()
-
-    assert exit_code == 0
-    assert "Database migration skipped" in captured.out
-
-    commands.redis_client.lock.assert_called_once_with(name="db_upgrade_lock", timeout=1234, thread_local=False)
-    lock.acquire.assert_called_once_with(blocking=False)
-    lock.release.assert_not_called()
-
-
-def test_upgrade_db_failure_not_masked_by_lock_release(monkeypatch, capsys):
-    monkeypatch.setattr(commands, "DB_UPGRADE_LOCK_TTL_SECONDS", 321)
-
-    lock = MagicMock()
-    lock.acquire.return_value = True
-    lock.release.side_effect = LockNotOwnedError("simulated")
-    commands.redis_client.lock.return_value = lock
-
-    def _upgrade():
-        raise RuntimeError("boom")
-
-    _install_fake_flask_migrate(monkeypatch, _upgrade)
-
-    exit_code = _invoke_upgrade_db()
-    captured = capsys.readouterr()
-
-    assert exit_code == 1
-    assert "Database migration failed: boom" in captured.out
-
-    commands.redis_client.lock.assert_called_once_with(name="db_upgrade_lock", timeout=321, thread_local=False)
-    lock.acquire.assert_called_once_with(blocking=False)
-    lock.release.assert_called_once()
-
-
-def test_upgrade_db_success_ignores_lock_not_owned_on_release(monkeypatch, capsys):
-    monkeypatch.setattr(commands, "DB_UPGRADE_LOCK_TTL_SECONDS", 999)
-
-    lock = MagicMock()
-    lock.acquire.return_value = True
-    lock.release.side_effect = LockNotOwnedError("simulated")
-    commands.redis_client.lock.return_value = lock
-
-    _install_fake_flask_migrate(monkeypatch, lambda: None)
-
-    exit_code = _invoke_upgrade_db()
-    captured = capsys.readouterr()
-
-    assert exit_code == 0
-    assert "Database migration successful!" in captured.out
-
-    commands.redis_client.lock.assert_called_once_with(name="db_upgrade_lock", timeout=999, thread_local=False)
-    lock.acquire.assert_called_once_with(blocking=False)
-    lock.release.assert_called_once()
-
-
-def test_upgrade_db_renews_lock_during_migration(monkeypatch, capsys):
-    """
-    Ensure the lock is renewed while migrations are running, so the base TTL can stay short.
-    """
-
-    # Use a small TTL so the heartbeat interval triggers quickly.
-    monkeypatch.setattr(commands, "DB_UPGRADE_LOCK_TTL_SECONDS", 0.3)
-
-    lock = MagicMock()
-    lock.acquire.return_value = True
-    commands.redis_client.lock.return_value = lock
-
-    renewed = threading.Event()
-
-    def _reacquire():
-        renewed.set()
-        return True
-
-    lock.reacquire.side_effect = _reacquire
-
-    def _upgrade():
-        assert renewed.wait(HEARTBEAT_WAIT_TIMEOUT_SECONDS)
-
-    _install_fake_flask_migrate(monkeypatch, _upgrade)
-
-    exit_code = _invoke_upgrade_db()
-    _ = capsys.readouterr()
-
-    assert exit_code == 0
-    assert lock.reacquire.call_count >= 1
-
-
-def test_upgrade_db_ignores_reacquire_errors(monkeypatch, capsys):
-    # Use a small TTL so heartbeat runs during the upgrade call.
-    monkeypatch.setattr(commands, "DB_UPGRADE_LOCK_TTL_SECONDS", 0.3)
-
-    lock = MagicMock()
-    lock.acquire.return_value = True
-    commands.redis_client.lock.return_value = lock
-
-    attempted = threading.Event()
-
-    def _reacquire():
-        attempted.set()
-        raise RedisError("simulated")
-
-    lock.reacquire.side_effect = _reacquire
-
-    def _upgrade():
-        assert attempted.wait(HEARTBEAT_WAIT_TIMEOUT_SECONDS)
-
-    _install_fake_flask_migrate(monkeypatch, _upgrade)
-
-    exit_code = _invoke_upgrade_db()
-    _ = capsys.readouterr()
-
-    assert exit_code == 0
-    assert lock.reacquire.call_count >= 1
@@ -0,0 +1,222 @@
+import builtins
+import contextlib
+import importlib
+import sys
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+import pytest
+from flask import Flask
+from flask.views import MethodView
+
+from extensions import ext_fastopenapi
+from extensions.ext_database import db
+
+
+@pytest.fixture
+def app():
+    app = Flask(__name__)
+    app.config["TESTING"] = True
+    app.config["SECRET_KEY"] = "test-secret"
+    app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
+
+    db.init_app(app)
+
+    return app
+
+
+@pytest.fixture(autouse=True)
+def fix_method_view_issue(monkeypatch):
+    if not hasattr(builtins, "MethodView"):
+        monkeypatch.setattr(builtins, "MethodView", MethodView, raising=False)
+
+
+def _create_isolated_router():
+    import controllers.fastopenapi
+
+    router_class = type(controllers.fastopenapi.console_router)
+    return router_class()
+
+
+@contextlib.contextmanager
+def _patch_auth_and_router(temp_router):
+    def noop(func):
+        return func
+
+    default_user = MagicMock(has_edit_permission=True, is_dataset_editor=False)
+
+    with (
+        patch("controllers.fastopenapi.console_router", temp_router),
+        patch("extensions.ext_fastopenapi.console_router", temp_router),
+        patch("controllers.console.wraps.setup_required", side_effect=noop),
+        patch("libs.login.login_required", side_effect=noop),
+        patch("controllers.console.wraps.account_initialization_required", side_effect=noop),
+        patch("controllers.console.wraps.edit_permission_required", side_effect=noop),
+        patch("libs.login.current_account_with_tenant", return_value=(default_user, "tenant-id")),
+        patch("configs.dify_config.EDITION", "CLOUD"),
+    ):
+        import extensions.ext_fastopenapi
+
+        importlib.reload(extensions.ext_fastopenapi)
+
+        yield
+
+
+def _force_reload_module(target_module: str, alias_module: str):
+    if target_module in sys.modules:
+        del sys.modules[target_module]
+    if alias_module in sys.modules:
+        del sys.modules[alias_module]
+
+    module = importlib.import_module(target_module)
+    sys.modules[alias_module] = sys.modules[target_module]
+
+    return module
+
+
+def _dedupe_routes(router):
+    seen = set()
+    unique_routes = []
+    for path, method, endpoint in reversed(router.get_routes()):
+        key = (path, method, endpoint.__name__)
+        if key in seen:
+            continue
+        seen.add(key)
+        unique_routes.append((path, method, endpoint))
+    router._routes = list(reversed(unique_routes))
+
+
+def _cleanup_modules(target_module: str, alias_module: str):
+    if target_module in sys.modules:
+        del sys.modules[target_module]
+    if alias_module in sys.modules:
+        del sys.modules[alias_module]
+
+
+@pytest.fixture
+def mock_tags_module_env():
+    target_module = "controllers.console.tag.tags"
+    alias_module = "api.controllers.console.tag.tags"
+    temp_router = _create_isolated_router()
+
+    try:
+        with _patch_auth_and_router(temp_router):
+            tags_module = _force_reload_module(target_module, alias_module)
+            _dedupe_routes(temp_router)
+            yield tags_module
+    finally:
+        _cleanup_modules(target_module, alias_module)
+
+
+def test_list_tags_success(app: Flask, mock_tags_module_env):
+    # Arrange
+    tag = SimpleNamespace(id="tag-1", name="Alpha", type="app", binding_count=2)
+    with patch("controllers.console.tag.tags.TagService.get_tags", return_value=[tag]):
+        ext_fastopenapi.init_app(app)
+        client = app.test_client()
+
+        # Act
+        response = client.get("/console/api/tags?type=app&keyword=Alpha")
+
+    # Assert
+    assert response.status_code == 200
+    assert response.get_json() == [
+        {"id": "tag-1", "name": "Alpha", "type": "app", "binding_count": 2},
+    ]
+
+
+def test_create_tag_success(app: Flask, mock_tags_module_env):
+    # Arrange
+    tag = SimpleNamespace(id="tag-2", name="Beta", type="app")
+    with patch("controllers.console.tag.tags.TagService.save_tags", return_value=tag) as mock_save:
+        ext_fastopenapi.init_app(app)
+        client = app.test_client()
+
+        # Act
+        response = client.post("/console/api/tags", json={"name": "Beta", "type": "app"})
+
+    # Assert
+    assert response.status_code == 200
+    assert response.get_json() == {
+        "id": "tag-2",
+        "name": "Beta",
+        "type": "app",
+        "binding_count": 0,
+    }
+    mock_save.assert_called_once_with({"name": "Beta", "type": "app"})
+
+
+def test_update_tag_success(app: Flask, mock_tags_module_env):
+    # Arrange
+    tag = SimpleNamespace(id="tag-3", name="Gamma", type="app")
+    with (
+        patch("controllers.console.tag.tags.TagService.update_tags", return_value=tag) as mock_update,
+        patch("controllers.console.tag.tags.TagService.get_tag_binding_count", return_value=4),
+    ):
+        ext_fastopenapi.init_app(app)
+        client = app.test_client()
+
+        # Act
+        response = client.patch(
+            "/console/api/tags/11111111-1111-1111-1111-111111111111",
+            json={"name": "Gamma", "type": "app"},
+        )
+
+    # Assert
+    assert response.status_code == 200
+    assert response.get_json() == {
+        "id": "tag-3",
+        "name": "Gamma",
+        "type": "app",
+        "binding_count": 4,
+    }
+    mock_update.assert_called_once_with(
+        {"name": "Gamma", "type": "app"},
+        "11111111-1111-1111-1111-111111111111",
+    )
+
+
+def test_delete_tag_success(app: Flask, mock_tags_module_env):
+    # Arrange
+    with patch("controllers.console.tag.tags.TagService.delete_tag") as mock_delete:
+        ext_fastopenapi.init_app(app)
+        client = app.test_client()
+
+        # Act
+        response = client.delete("/console/api/tags/11111111-1111-1111-1111-111111111111")
+
+    # Assert
+    assert response.status_code == 204
+    mock_delete.assert_called_once_with("11111111-1111-1111-1111-111111111111")
+
+
+def test_create_tag_binding_success(app: Flask, mock_tags_module_env):
+    # Arrange
+    payload = {"tag_ids": ["tag-1", "tag-2"], "target_id": "target-1", "type": "app"}
+    with patch("controllers.console.tag.tags.TagService.save_tag_binding") as mock_bind:
+        ext_fastopenapi.init_app(app)
+        client = app.test_client()
+
+        # Act
+        response = client.post("/console/api/tag-bindings/create", json=payload)
+
+    # Assert
+    assert response.status_code == 200
+    assert response.get_json() == {"result": "success"}
+    mock_bind.assert_called_once_with(payload)
+
+
+def test_delete_tag_binding_success(app: Flask, mock_tags_module_env):
+    # Arrange
+    payload = {"tag_id": "tag-1", "target_id": "target-1", "type": "app"}
+    with patch("controllers.console.tag.tags.TagService.delete_tag_binding") as mock_unbind:
+        ext_fastopenapi.init_app(app)
+        client = app.test_client()
+
+        # Act
+        response = client.post("/console/api/tag-bindings/remove", json=payload)
+
+    # Assert
+    assert response.status_code == 200
+    assert response.get_json() == {"result": "success"}
+    mock_unbind.assert_called_once_with(payload)
@@ -25,19 +25,15 @@ class TestMessageCycleManagerOptimization:
        task_state = Mock()
        return MessageCycleManager(application_generate_entity=mock_application_generate_entity, task_state=task_state)

-    def test_get_message_event_type_with_assistant_file(self, message_cycle_manager):
-        """Test get_message_event_type returns MESSAGE_FILE when message has assistant-generated files.
-
-        This ensures that AI-generated images (belongs_to='assistant') trigger the MESSAGE_FILE event,
-        allowing the frontend to properly display generated image files with url field.
-        """
+    def test_get_message_event_type_with_message_file(self, message_cycle_manager):
+        """Test get_message_event_type returns MESSAGE_FILE when message has files."""
        with patch("core.app.task_pipeline.message_cycle_manager.session_factory") as mock_session_factory:
            # Setup mock session and message file
            mock_session = Mock()
            mock_session_factory.create_session.return_value.__enter__.return_value = mock_session

            mock_message_file = Mock()
-            mock_message_file.belongs_to = "assistant"
+            # Current implementation uses session.scalar(select(...))
            mock_session.scalar.return_value = mock_message_file

            # Execute
@@ -48,31 +44,6 @@ class TestMessageCycleManagerOptimization:
            assert result == StreamEvent.MESSAGE_FILE
            mock_session.scalar.assert_called_once()

-    def test_get_message_event_type_with_user_file(self, message_cycle_manager):
-        """Test get_message_event_type returns MESSAGE when message only has user-uploaded files.
-
-        This is a regression test for the issue where user-uploaded images (belongs_to='user')
-        caused the LLM text response to be incorrectly tagged with MESSAGE_FILE event,
-        resulting in broken images in the chat UI. The query filters for belongs_to='assistant',
-        so when only user files exist, the database query returns None, resulting in MESSAGE event type.
-        """
-        with patch("core.app.task_pipeline.message_cycle_manager.session_factory") as mock_session_factory:
-            # Setup mock session and message file
-            mock_session = Mock()
-            mock_session_factory.create_session.return_value.__enter__.return_value = mock_session
-
-            # When querying for assistant files with only user files present, return None
-            # (simulates database query with belongs_to='assistant' filter returning no results)
-            mock_session.scalar.return_value = None
-
-            # Execute
-            with current_app.app_context():
-                result = message_cycle_manager.get_message_event_type("test-message-id")
-
-            # Assert
-            assert result == StreamEvent.MESSAGE
-            mock_session.scalar.assert_called_once()
-
    def test_get_message_event_type_without_message_file(self, message_cycle_manager):
        """Test get_message_event_type returns MESSAGE when message has no files."""
        with patch("core.app.task_pipeline.message_cycle_manager.session_factory") as mock_session_factory:
@@ -98,7 +69,7 @@ class TestMessageCycleManagerOptimization:
            mock_session_factory.create_session.return_value.__enter__.return_value = mock_session

            mock_message_file = Mock()
-            mock_message_file.belongs_to = "assistant"
+            # Current implementation uses session.scalar(select(...))
            mock_session.scalar.return_value = mock_message_file

            # Execute: compute event type once, then pass to message_to_stream_response
@@ -4,7 +4,7 @@ from typing import Any
 from uuid import uuid4

 import pytest
-from hypothesis import HealthCheck, given, settings
+from hypothesis import given, settings
 from hypothesis import strategies as st

 from core.file import File, FileTransferMethod, FileType
@@ -493,7 +493,7 @@ def _scalar_value() -> st.SearchStrategy[int | float | str | File | None]:
    )


-@settings(max_examples=30, suppress_health_check=[HealthCheck.too_slow, HealthCheck.filter_too_much], deadline=None)
+@settings(max_examples=50)
@given(_scalar_value())
 def test_build_segment_and_extract_values_for_scalar_types(value):
    seg = variable_factory.build_segment(value)
@@ -504,7 +504,7 @@ def test_build_segment_and_extract_values_for_scalar_types(value):
        assert seg.value == value


-@settings(max_examples=30, suppress_health_check=[HealthCheck.too_slow, HealthCheck.filter_too_much], deadline=None)
+@settings(max_examples=50)
@given(values=st.lists(_scalar_value(), max_size=20))
 def test_build_segment_and_extract_values_for_array_types(values):
    seg = variable_factory.build_segment(values)
@@ -83,127 +83,23 @@ def mock_documents(document_ids, dataset_id):
 def mock_db_session():
    """Mock database session via session_factory.create_session()."""
    with patch("tasks.document_indexing_task.session_factory") as mock_sf:
-        sessions = []  # Track all created sessions
-        # Shared mock data that all sessions will access
-        shared_mock_data = {"dataset": None, "documents": None, "doc_iter": None}
+        session = MagicMock()
+        # Ensure tests that expect session.close() to be called can observe it via the context manager
+        session.close = MagicMock()
+        cm = MagicMock()
+        cm.__enter__.return_value = session
+        # Link __exit__ to session.close so "close" expectations reflect context manager teardown

-        def create_session_side_effect():
-            session = MagicMock()
-            session.close = MagicMock()
+        def _exit_side_effect(*args, **kwargs):
+            session.close()

-            # Track commit calls
-            commit_mock = MagicMock()
-            session.commit = commit_mock
-            cm = MagicMock()
-            cm.__enter__.return_value = session
+        cm.__exit__.side_effect = _exit_side_effect
+        mock_sf.create_session.return_value = cm

-            def _exit_side_effect(*args, **kwargs):
-                session.close()
-
-            cm.__exit__.side_effect = _exit_side_effect
-
-            # Support session.begin() for transactions
-            begin_cm = MagicMock()
-            begin_cm.__enter__.return_value = session
-
-            def begin_exit_side_effect(*args, **kwargs):
-                # Auto-commit on transaction exit (like SQLAlchemy)
-                session.commit()
-                # Also mark wrapper's commit as called
-                if sessions:
-                    sessions[0].commit()
-
-            begin_cm.__exit__ = MagicMock(side_effect=begin_exit_side_effect)
-            session.begin = MagicMock(return_value=begin_cm)
-
-            sessions.append(session)
-
-            # Setup query with side_effect to handle both Dataset and Document queries
-            def query_side_effect(*args):
-                query = MagicMock()
-                if args and args[0] == Dataset and shared_mock_data["dataset"] is not None:
-                    where_result = MagicMock()
-                    where_result.first.return_value = shared_mock_data["dataset"]
-                    query.where = MagicMock(return_value=where_result)
-                elif args and args[0] == Document and shared_mock_data["documents"] is not None:
-                    # Support both .first() and .all() calls with chaining
-                    where_result = MagicMock()
-                    where_result.where = MagicMock(return_value=where_result)
-
-                    # Create an iterator for .first() calls if not exists
-                    if shared_mock_data["doc_iter"] is None:
-                        docs = shared_mock_data["documents"] or [None]
-                        shared_mock_data["doc_iter"] = iter(docs)
-
-                    where_result.first = lambda: next(shared_mock_data["doc_iter"], None)
-                    docs_or_empty = shared_mock_data["documents"] or []
-                    where_result.all = MagicMock(return_value=docs_or_empty)
-                    query.where = MagicMock(return_value=where_result)
-                else:
-                    query.where = MagicMock(return_value=query)
-                return query
-
-            session.query = MagicMock(side_effect=query_side_effect)
-            return cm
-
-        mock_sf.create_session.side_effect = create_session_side_effect
-
-        # Create a wrapper that behaves like the first session but has access to all sessions
-        class SessionWrapper:
-            def __init__(self):
-                self._sessions = sessions
-                self._shared_data = shared_mock_data
-                # Create a default session for setup phase
-                self._default_session = MagicMock()
-                self._default_session.close = MagicMock()
-                self._default_session.commit = MagicMock()
-
-                # Support session.begin() for default session too
-                begin_cm = MagicMock()
-                begin_cm.__enter__.return_value = self._default_session
-
-                def default_begin_exit_side_effect(*args, **kwargs):
-                    self._default_session.commit()
-
-                begin_cm.__exit__ = MagicMock(side_effect=default_begin_exit_side_effect)
-                self._default_session.begin = MagicMock(return_value=begin_cm)
-
-                def default_query_side_effect(*args):
-                    query = MagicMock()
-                    if args and args[0] == Dataset and shared_mock_data["dataset"] is not None:
-                        where_result = MagicMock()
-                        where_result.first.return_value = shared_mock_data["dataset"]
-                        query.where = MagicMock(return_value=where_result)
-                    elif args and args[0] == Document and shared_mock_data["documents"] is not None:
-                        where_result = MagicMock()
-                        where_result.where = MagicMock(return_value=where_result)
-
-                        if shared_mock_data["doc_iter"] is None:
-                            docs = shared_mock_data["documents"] or [None]
-                            shared_mock_data["doc_iter"] = iter(docs)
-
-                        where_result.first = lambda: next(shared_mock_data["doc_iter"], None)
-                        docs_or_empty = shared_mock_data["documents"] or []
-                        where_result.all = MagicMock(return_value=docs_or_empty)
-                        query.where = MagicMock(return_value=where_result)
-                    else:
-                        query.where = MagicMock(return_value=query)
-                    return query
-
-                self._default_session.query = MagicMock(side_effect=default_query_side_effect)
-
-            def __getattr__(self, name):
-                # Forward all attribute access to the first session, or default if none created yet
-                target_session = self._sessions[0] if self._sessions else self._default_session
-                return getattr(target_session, name)
-
-            @property
-            def all_sessions(self):
-                """Access all created sessions for testing."""
-                return self._sessions
-
-        wrapper = SessionWrapper()
-        yield wrapper
+        query = MagicMock()
+        session.query.return_value = query
+        query.where.return_value = query
+        yield session


@pytest.fixture
@@ -356,9 +252,18 @@ class TestTaskEnqueuing:
        use the deprecated function.
        """
        # Arrange
-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                # Return documents one by one for each call
+                mock_query.where.return_value.first.side_effect = mock_documents
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -399,9 +304,21 @@ class TestBatchProcessing:
            doc.processing_started_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        # Create an iterator for documents
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                # Return documents one by one for each call
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -440,9 +357,19 @@ class TestBatchProcessing:
            doc.stopped_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        mock_feature_service.get_features.return_value.billing.enabled = True
        mock_feature_service.get_features.return_value.billing.subscription.plan = CloudPlan.PROFESSIONAL
@@ -480,9 +407,19 @@ class TestBatchProcessing:
            doc.stopped_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        mock_feature_service.get_features.return_value.billing.enabled = True
        mock_feature_service.get_features.return_value.billing.subscription.plan = CloudPlan.SANDBOX
@@ -507,10 +444,7 @@ class TestBatchProcessing:
        """
        # Arrange
        document_ids = []
-
-        # Set shared mock data with empty documents list
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = []
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -548,9 +482,19 @@ class TestProgressTracking:
            doc.processing_started_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -584,9 +528,19 @@ class TestProgressTracking:
            doc.processing_started_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -681,9 +635,19 @@ class TestErrorHandling:
            doc.stopped_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        # Set up to trigger vector space limit error
        mock_feature_service.get_features.return_value.billing.enabled = True
@@ -710,9 +674,17 @@ class TestErrorHandling:
        Errors during indexing should be caught and logged, but not crash the task.
        """
        # Arrange
-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first.side_effect = mock_documents
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        # Make IndexingRunner raise an exception
        mock_indexing_runner.run.side_effect = Exception("Indexing failed")
@@ -736,9 +708,17 @@ class TestErrorHandling:
        but not treated as a failure.
        """
        # Arrange
-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first.side_effect = mock_documents
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        # Make IndexingRunner raise DocumentIsPausedError
        mock_indexing_runner.run.side_effect = DocumentIsPausedError("Document is paused")
@@ -873,9 +853,17 @@ class TestTaskCancellation:
        Session cleanup should happen in finally block.
        """
        # Arrange
-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first.side_effect = mock_documents
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -895,9 +883,17 @@ class TestTaskCancellation:
        Session cleanup should happen even when errors occur.
        """
        # Arrange
-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first.side_effect = mock_documents
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        # Make IndexingRunner raise an exception
        mock_indexing_runner.run.side_effect = Exception("Test error")
@@ -966,7 +962,6 @@ class TestAdvancedScenarios:
        document_ids = [str(uuid.uuid4()) for _ in range(3)]

        # Create only 2 documents (simulate one missing)
-        # The new code uses .all() which will only return existing documents
        mock_documents = []
        for i, doc_id in enumerate([document_ids[0], document_ids[2]]):  # Skip middle one
            doc = MagicMock(spec=Document)
@@ -976,9 +971,21 @@ class TestAdvancedScenarios:
            doc.processing_started_at = None
            mock_documents.append(doc)

-        # Set shared mock data - .all() will only return existing documents
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        # Create iterator that returns None for missing document
+        doc_responses = [mock_documents[0], None, mock_documents[1]]
+        doc_iter = iter(doc_responses)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -1068,9 +1075,19 @@ class TestAdvancedScenarios:
            doc.stopped_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        # Set vector space exactly at limit
        mock_feature_service.get_features.return_value.billing.enabled = True
@@ -1202,9 +1219,19 @@ class TestAdvancedScenarios:
            doc.processing_started_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        # Billing disabled - limits should not be checked
        mock_feature_service.get_features.return_value.billing.enabled = False
@@ -1246,9 +1273,19 @@ class TestIntegration:

        # Set up rpop to return None for concurrency check (no more tasks)
        mock_redis.rpop.side_effect = [None]
-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -1284,9 +1321,19 @@ class TestIntegration:

        # Set up rpop to return None for concurrency check (no more tasks)
        mock_redis.rpop.side_effect = [None]
-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -1368,9 +1415,17 @@ class TestEdgeCases:
        mock_document.indexing_status = "waiting"
        mock_document.processing_started_at = None

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = [mock_document]
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: mock_document
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -1410,9 +1465,17 @@ class TestEdgeCases:
        mock_document.indexing_status = "waiting"
        mock_document.processing_started_at = None

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = [mock_document]
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: mock_document
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -1492,9 +1555,19 @@ class TestEdgeCases:
            doc.processing_started_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        # Set vector space limit to 0 (unlimited)
        mock_feature_service.get_features.return_value.billing.enabled = True
@@ -1539,9 +1612,19 @@ class TestEdgeCases:
            doc.processing_started_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        # Set negative vector space limit
        mock_feature_service.get_features.return_value.billing.enabled = True
@@ -1592,9 +1675,19 @@ class TestPerformanceScenarios:
            doc.processing_started_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        # Configure billing with sufficient limits
        mock_feature_service.get_features.return_value.billing.enabled = True
@@ -1733,9 +1826,19 @@ class TestRobustness:
            doc.processing_started_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        # Make IndexingRunner raise an exception
        mock_indexing_runner.run.side_effect = RuntimeError("Unexpected indexing error")
@@ -1763,7 +1866,7 @@ class TestRobustness:
        - No exceptions occur

        Expected behavior:
-        - All database sessions are closed
+        - Database session is closed
        - No connection leaks
        """
        # Arrange
@@ -1776,9 +1879,19 @@ class TestRobustness:
            doc.processing_started_at = None
            mock_documents.append(doc)

-        # Set shared mock data so all sessions can access it
-        mock_db_session._shared_data["dataset"] = mock_dataset
-        mock_db_session._shared_data["documents"] = mock_documents
+        mock_db_session.query.return_value.where.return_value.first.return_value = mock_dataset
+
+        doc_iter = iter(mock_documents)
+
+        def mock_query_side_effect(*args):
+            mock_query = MagicMock()
+            if args[0] == Dataset:
+                mock_query.where.return_value.first.return_value = mock_dataset
+            elif args[0] == Document:
+                mock_query.where.return_value.first = lambda: next(doc_iter, None)
+            return mock_query
+
+        mock_db_session.query.side_effect = mock_query_side_effect

        with patch("tasks.document_indexing_task.FeatureService.get_features") as mock_features:
            mock_features.return_value.billing.enabled = False
@@ -1786,11 +1899,10 @@ class TestRobustness:
            # Act
            _document_indexing(dataset_id, document_ids)

-            # Assert - All created sessions should be closed
-            # The code creates multiple sessions: validation, Phase 1 (parsing), Phase 3 (summary)
-            assert len(mock_db_session.all_sessions) >= 1
-            for session in mock_db_session.all_sessions:
-                assert session.close.called, "All sessions should be closed"
+            # Assert
+            assert mock_db_session.close.called
+            # Verify close is called exactly once
+            assert mock_db_session.close.call_count == 1

    def test_task_proxy_handles_feature_service_failure(self, tenant_id, dataset_id, document_ids, mock_redis):
        """
@@ -109,87 +109,25 @@ def mock_document_segments(document_id):

@pytest.fixture
 def mock_db_session():
-    """Mock database session via session_factory.create_session().
-
-    After session split refactor, the code calls create_session() multiple times.
-    This fixture creates shared query mocks so all sessions use the same
-    query configuration, simulating database persistence across sessions.
-
-    The fixture automatically converts side_effect to cycle to prevent StopIteration.
-    Tests configure mocks the same way as before, but behind the scenes the values
-    are cycled infinitely for all sessions.
-    """
-    from itertools import cycle
-
+    """Mock database session via session_factory.create_session()."""
    with patch("tasks.document_indexing_sync_task.session_factory") as mock_sf:
-        sessions = []
+        session = MagicMock()
+        # Ensure tests can observe session.close() via context manager teardown
+        session.close = MagicMock()
+        cm = MagicMock()
+        cm.__enter__.return_value = session

-        # Shared query mocks - all sessions use these
-        shared_query = MagicMock()
-        shared_filter_by = MagicMock()
-        shared_scalars_result = MagicMock()
+        def _exit_side_effect(*args, **kwargs):
+            session.close()

-        # Create custom first mock that auto-cycles side_effect
-        class CyclicMock(MagicMock):
-            def __setattr__(self, name, value):
-                if name == "side_effect" and value is not None:
-                    # Convert list/tuple to infinite cycle
-                    if isinstance(value, (list, tuple)):
-                        value = cycle(value)
-                super().__setattr__(name, value)
+        cm.__exit__.side_effect = _exit_side_effect
+        mock_sf.create_session.return_value = cm

-        shared_query.where.return_value.first = CyclicMock()
-        shared_filter_by.first = CyclicMock()
-
-        def _create_session():
-            """Create a new mock session for each create_session() call."""
-            session = MagicMock()
-            session.close = MagicMock()
-            session.commit = MagicMock()
-
-            # Mock session.begin() context manager
-            begin_cm = MagicMock()
-            begin_cm.__enter__.return_value = session
-
-            def _begin_exit_side_effect(exc_type, exc, tb):
-                # commit on success
-                if exc_type is None:
-                    session.commit()
-                # return False to propagate exceptions
-                return False
-
-            begin_cm.__exit__.side_effect = _begin_exit_side_effect
-            session.begin.return_value = begin_cm
-
-            # Mock create_session() context manager
-            cm = MagicMock()
-            cm.__enter__.return_value = session
-
-            def _exit_side_effect(exc_type, exc, tb):
-                session.close()
-                return False
-
-            cm.__exit__.side_effect = _exit_side_effect
-
-            # All sessions use the same shared query mocks
-            session.query.return_value = shared_query
-            shared_query.where.return_value = shared_query
-            shared_query.filter_by.return_value = shared_filter_by
-            session.scalars.return_value = shared_scalars_result
-
-            sessions.append(session)
-            # Attach helpers on the first created session for assertions across all sessions
-            if len(sessions) == 1:
-                session.get_all_sessions = lambda: sessions
-                session.any_close_called = lambda: any(s.close.called for s in sessions)
-                session.any_commit_called = lambda: any(s.commit.called for s in sessions)
-            return cm
-
-        mock_sf.create_session.side_effect = _create_session
-
-        # Create first session and return it
-        _create_session()
-        yield sessions[0]
+        query = MagicMock()
+        session.query.return_value = query
+        query.where.return_value = query
+        session.scalars.return_value = MagicMock()
+        yield session


@pytest.fixture
@@ -248,8 +186,8 @@ class TestDocumentIndexingSyncTask:
        # Act
        document_indexing_sync_task(dataset_id, document_id)

-        # Assert - at least one session should have been closed
-        assert mock_db_session.any_close_called()
+        # Assert
+        mock_db_session.close.assert_called_once()

    def test_missing_notion_workspace_id(self, mock_db_session, mock_document, dataset_id, document_id):
        """Test that task raises error when notion_workspace_id is missing."""
@@ -292,7 +230,6 @@ class TestDocumentIndexingSyncTask:
        """Test that task handles missing credentials by updating document status."""
        # Arrange
        mock_db_session.query.return_value.where.return_value.first.return_value = mock_document
-        mock_db_session.query.return_value.filter_by.return_value.first.return_value = mock_document
        mock_datasource_provider_service.get_datasource_credentials.return_value = None

        # Act
@@ -302,8 +239,8 @@ class TestDocumentIndexingSyncTask:
        assert mock_document.indexing_status == "error"
        assert "Datasource credential not found" in mock_document.error
        assert mock_document.stopped_at is not None
-        assert mock_db_session.any_commit_called()
-        assert mock_db_session.any_close_called()
+        mock_db_session.commit.assert_called()
+        mock_db_session.close.assert_called()

    def test_page_not_updated(
        self,
@@ -317,7 +254,6 @@ class TestDocumentIndexingSyncTask:
        """Test that task does nothing when page has not been updated."""
        # Arrange
        mock_db_session.query.return_value.where.return_value.first.return_value = mock_document
-        mock_db_session.query.return_value.filter_by.return_value.first.return_value = mock_document
        # Return same time as stored in document
        mock_notion_extractor.get_notion_last_edited_time.return_value = "2024-01-01T00:00:00Z"

@@ -327,8 +263,8 @@ class TestDocumentIndexingSyncTask:
        # Assert
        # Document status should remain unchanged
        assert mock_document.indexing_status == "completed"
-        # At least one session should have been closed via context manager teardown
-        assert mock_db_session.any_close_called()
+        # Session should still be closed via context manager teardown
+        assert mock_db_session.close.called

    def test_successful_sync_when_page_updated(
        self,
@@ -345,20 +281,7 @@ class TestDocumentIndexingSyncTask:
    ):
        """Test successful sync flow when Notion page has been updated."""
        # Arrange
-        # Set exact sequence of returns across calls to `.first()`:
-        # 1) document (initial fetch)
-        # 2) dataset (pre-check)
-        # 3) dataset (cleaning phase)
-        # 4) document (pre-indexing update)
-        # 5) document (indexing runner fetch)
-        mock_db_session.query.return_value.where.return_value.first.side_effect = [
-            mock_document,
-            mock_dataset,
-            mock_dataset,
-            mock_document,
-            mock_document,
-        ]
-        mock_db_session.query.return_value.filter_by.return_value.first.return_value = mock_document
+        mock_db_session.query.return_value.where.return_value.first.side_effect = [mock_document, mock_dataset]
        mock_db_session.scalars.return_value.all.return_value = mock_document_segments
        # NotionExtractor returns updated time
        mock_notion_extractor.get_notion_last_edited_time.return_value = "2024-01-02T00:00:00Z"
@@ -376,40 +299,28 @@ class TestDocumentIndexingSyncTask:
        mock_processor.clean.assert_called_once()

        # Verify segments were deleted from database in batch (DELETE FROM document_segments)
-        # Aggregate execute calls across all created sessions
-        execute_sqls = []
-        for s in mock_db_session.get_all_sessions():
-            execute_sqls.extend([" ".join(str(c[0][0]).split()) for c in s.execute.call_args_list])
+        execute_sqls = [" ".join(str(c[0][0]).split()) for c in mock_db_session.execute.call_args_list]
        assert any("DELETE FROM document_segments" in sql for sql in execute_sqls)

        # Verify indexing runner was called
        mock_indexing_runner.run.assert_called_once_with([mock_document])

-        # Verify session operations (across any created session)
-        assert mock_db_session.any_commit_called()
-        assert mock_db_session.any_close_called()
+        # Verify session operations
+        assert mock_db_session.commit.called
+        mock_db_session.close.assert_called_once()

    def test_dataset_not_found_during_cleaning(
        self,
        mock_db_session,
        mock_datasource_provider_service,
        mock_notion_extractor,
-        mock_indexing_runner,
        mock_document,
        dataset_id,
        document_id,
    ):
        """Test that task handles dataset not found during cleaning phase."""
        # Arrange
-        # Sequence: document (initial), dataset (pre-check), None (cleaning), document (update), document (indexing)
-        mock_db_session.query.return_value.where.return_value.first.side_effect = [
-            mock_document,
-            mock_dataset,
-            None,
-            mock_document,
-            mock_document,
-        ]
-        mock_db_session.query.return_value.filter_by.return_value.first.return_value = mock_document
+        mock_db_session.query.return_value.where.return_value.first.side_effect = [mock_document, None]
        mock_notion_extractor.get_notion_last_edited_time.return_value = "2024-01-02T00:00:00Z"

        # Act
@@ -418,8 +329,8 @@ class TestDocumentIndexingSyncTask:
        # Assert
        # Document should still be set to parsing
        assert mock_document.indexing_status == "parsing"
-        # At least one session should be closed after error
-        assert mock_db_session.any_close_called()
+        # Session should be closed after error
+        mock_db_session.close.assert_called_once()

    def test_cleaning_error_continues_to_indexing(
        self,
@@ -435,14 +346,8 @@ class TestDocumentIndexingSyncTask:
    ):
        """Test that indexing continues even if cleaning fails."""
        # Arrange
-        from itertools import cycle
-
-        mock_db_session.query.return_value.where.return_value.first.side_effect = cycle([mock_document, mock_dataset])
-        mock_db_session.query.return_value.filter_by.return_value.first.return_value = mock_document
-        # Make the cleaning step fail but not the segment fetch
-        processor = mock_index_processor_factory.return_value.init_index_processor.return_value
-        processor.clean.side_effect = Exception("Cleaning error")
-        mock_db_session.scalars.return_value.all.return_value = []
+        mock_db_session.query.return_value.where.return_value.first.side_effect = [mock_document, mock_dataset]
+        mock_db_session.scalars.return_value.all.side_effect = Exception("Cleaning error")
        mock_notion_extractor.get_notion_last_edited_time.return_value = "2024-01-02T00:00:00Z"

        # Act
@@ -451,7 +356,7 @@ class TestDocumentIndexingSyncTask:
        # Assert
        # Indexing should still be attempted despite cleaning error
        mock_indexing_runner.run.assert_called_once_with([mock_document])
-        assert mock_db_session.any_close_called()
+        mock_db_session.close.assert_called_once()

    def test_indexing_runner_document_paused_error(
        self,
@@ -468,10 +373,7 @@ class TestDocumentIndexingSyncTask:
    ):
        """Test that DocumentIsPausedError is handled gracefully."""
        # Arrange
-        from itertools import cycle
-
-        mock_db_session.query.return_value.where.return_value.first.side_effect = cycle([mock_document, mock_dataset])
-        mock_db_session.query.return_value.filter_by.return_value.first.return_value = mock_document
+        mock_db_session.query.return_value.where.return_value.first.side_effect = [mock_document, mock_dataset]
        mock_db_session.scalars.return_value.all.return_value = mock_document_segments
        mock_notion_extractor.get_notion_last_edited_time.return_value = "2024-01-02T00:00:00Z"
        mock_indexing_runner.run.side_effect = DocumentIsPausedError("Document paused")
@@ -481,7 +383,7 @@ class TestDocumentIndexingSyncTask:

        # Assert
        # Session should be closed after handling error
-        assert mock_db_session.any_close_called()
+        mock_db_session.close.assert_called_once()

    def test_indexing_runner_general_error(
        self,
@@ -498,10 +400,7 @@ class TestDocumentIndexingSyncTask:
    ):
        """Test that general exceptions during indexing are handled."""
        # Arrange
-        from itertools import cycle
-
-        mock_db_session.query.return_value.where.return_value.first.side_effect = cycle([mock_document, mock_dataset])
-        mock_db_session.query.return_value.filter_by.return_value.first.return_value = mock_document
+        mock_db_session.query.return_value.where.return_value.first.side_effect = [mock_document, mock_dataset]
        mock_db_session.scalars.return_value.all.return_value = mock_document_segments
        mock_notion_extractor.get_notion_last_edited_time.return_value = "2024-01-02T00:00:00Z"
        mock_indexing_runner.run.side_effect = Exception("Indexing error")
@@ -511,7 +410,7 @@ class TestDocumentIndexingSyncTask:

        # Assert
        # Session should be closed after error
-        assert mock_db_session.any_close_called()
+        mock_db_session.close.assert_called_once()

    def test_notion_extractor_initialized_with_correct_params(
        self,
@@ -618,14 +517,7 @@ class TestDocumentIndexingSyncTask:
    ):
        """Test that index processor clean is called with correct parameters."""
        # Arrange
-        # Sequence: document (initial), dataset (pre-check), dataset (cleaning), document (update), document (indexing)
-        mock_db_session.query.return_value.where.return_value.first.side_effect = [
-            mock_document,
-            mock_dataset,
-            mock_dataset,
-            mock_document,
-            mock_document,
-        ]
+        mock_db_session.query.return_value.where.return_value.first.side_effect = [mock_document, mock_dataset]
        mock_db_session.scalars.return_value.all.return_value = mock_document_segments
        mock_notion_extractor.get_notion_last_edited_time.return_value = "2024-01-02T00:00:00Z"

@@ -350,7 +350,7 @@ class TestDeleteWorkflowArchiveLogs:
        mock_query.where.return_value = mock_delete_query
        mock_db.session.query.return_value = mock_query

-        delete_func(mock_db.session, "log-1")
+        delete_func("log-1")

        mock_db.session.query.assert_called_once_with(WorkflowArchiveLog)
        mock_query.where.assert_called_once()
@@ -1368,7 +1368,7 @@ wheels = [

 [[package]]
 name = "dify-api"
-version = "1.12.1"
+version = "1.11.4"
 source = { virtual = "." }
 dependencies = [
    { name = "aliyun-log-python-sdk" },
@@ -1593,14 +1593,14 @@ requires-dist = [
    { name = "flask-sqlalchemy", specifier = "~=3.1.1" },
    { name = "gevent", specifier = "~=25.9.1" },
    { name = "gmpy2", specifier = "~=2.2.1" },
-    { name = "google-api-core", specifier = ">=2.19.1" },
+    { name = "google-api-core", specifier = "==2.18.0" },
    { name = "google-api-python-client", specifier = "==2.90.0" },
-    { name = "google-auth", specifier = ">=2.47.0" },
+    { name = "google-auth", specifier = "==2.29.0" },
    { name = "google-auth-httplib2", specifier = "==0.2.0" },
-    { name = "google-cloud-aiplatform", specifier = ">=1.123.0" },
-    { name = "googleapis-common-protos", specifier = ">=1.65.0" },
+    { name = "google-cloud-aiplatform", specifier = "==1.49.0" },
+    { name = "googleapis-common-protos", specifier = "==1.63.0" },
    { name = "gunicorn", specifier = "~=23.0.0" },
-    { name = "httpx", extras = ["socks"], specifier = "~=0.28.0" },
+    { name = "httpx", extras = ["socks"], specifier = "~=0.27.0" },
    { name = "httpx-sse", specifier = "~=0.4.0" },
    { name = "jieba", specifier = "==0.42.1" },
    { name = "json-repair", specifier = ">=0.55.1" },
@@ -1612,23 +1612,23 @@ requires-dist = [
    { name = "mlflow-skinny", specifier = ">=3.0.0" },
    { name = "numpy", specifier = "~=1.26.4" },
    { name = "openpyxl", specifier = "~=3.1.5" },
-    { name = "opentelemetry-api", specifier = "==1.28.0" },
-    { name = "opentelemetry-distro", specifier = "==0.49b0" },
-    { name = "opentelemetry-exporter-otlp", specifier = "==1.28.0" },
-    { name = "opentelemetry-exporter-otlp-proto-common", specifier = "==1.28.0" },
-    { name = "opentelemetry-exporter-otlp-proto-grpc", specifier = "==1.28.0" },
-    { name = "opentelemetry-exporter-otlp-proto-http", specifier = "==1.28.0" },
-    { name = "opentelemetry-instrumentation", specifier = "==0.49b0" },
-    { name = "opentelemetry-instrumentation-celery", specifier = "==0.49b0" },
-    { name = "opentelemetry-instrumentation-flask", specifier = "==0.49b0" },
-    { name = "opentelemetry-instrumentation-httpx", specifier = "==0.49b0" },
-    { name = "opentelemetry-instrumentation-redis", specifier = "==0.49b0" },
-    { name = "opentelemetry-instrumentation-sqlalchemy", specifier = "==0.49b0" },
-    { name = "opentelemetry-propagator-b3", specifier = "==1.28.0" },
-    { name = "opentelemetry-proto", specifier = "==1.28.0" },
-    { name = "opentelemetry-sdk", specifier = "==1.28.0" },
-    { name = "opentelemetry-semantic-conventions", specifier = "==0.49b0" },
-    { name = "opentelemetry-util-http", specifier = "==0.49b0" },
+    { name = "opentelemetry-api", specifier = "==1.27.0" },
+    { name = "opentelemetry-distro", specifier = "==0.48b0" },
+    { name = "opentelemetry-exporter-otlp", specifier = "==1.27.0" },
+    { name = "opentelemetry-exporter-otlp-proto-common", specifier = "==1.27.0" },
+    { name = "opentelemetry-exporter-otlp-proto-grpc", specifier = "==1.27.0" },
+    { name = "opentelemetry-exporter-otlp-proto-http", specifier = "==1.27.0" },
+    { name = "opentelemetry-instrumentation", specifier = "==0.48b0" },
+    { name = "opentelemetry-instrumentation-celery", specifier = "==0.48b0" },
+    { name = "opentelemetry-instrumentation-flask", specifier = "==0.48b0" },
+    { name = "opentelemetry-instrumentation-httpx", specifier = "==0.48b0" },
+    { name = "opentelemetry-instrumentation-redis", specifier = "==0.48b0" },
+    { name = "opentelemetry-instrumentation-sqlalchemy", specifier = "==0.48b0" },
+    { name = "opentelemetry-propagator-b3", specifier = "==1.27.0" },
+    { name = "opentelemetry-proto", specifier = "==1.27.0" },
+    { name = "opentelemetry-sdk", specifier = "==1.27.0" },
+    { name = "opentelemetry-semantic-conventions", specifier = "==0.48b0" },
+    { name = "opentelemetry-util-http", specifier = "==0.48b0" },
    { name = "opik", specifier = "~=1.8.72" },
    { name = "packaging", specifier = "~=23.2" },
    { name = "pandas", extras = ["excel", "output-formatting", "performance"], specifier = "~=2.2.2" },
@@ -1653,7 +1653,7 @@ requires-dist = [
    { name = "starlette", specifier = "==0.49.1" },
    { name = "tiktoken", specifier = "~=0.9.0" },
    { name = "transformers", specifier = "~=4.56.1" },
-    { name = "unstructured", extras = ["docx", "epub", "md", "ppt", "pptx"], specifier = "~=0.18.18" },
+    { name = "unstructured", extras = ["docx", "epub", "md", "ppt", "pptx"], specifier = "~=0.16.1" },
    { name = "weave", specifier = ">=0.52.16" },
    { name = "weaviate-client", specifier = "==4.17.0" },
    { name = "webvtt-py", specifier = "~=0.5.1" },
@@ -2284,7 +2284,7 @@ wheels = [

 [[package]]
 name = "google-api-core"
-version = "2.30.0"
+version = "2.18.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "google-auth" },
@@ -2293,9 +2293,9 @@ dependencies = [
    { name = "protobuf" },
    { name = "requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/22/98/586ec94553b569080caef635f98a3723db36a38eac0e3d7eb3ea9d2e4b9a/google_api_core-2.30.0.tar.gz", hash = "sha256:02edfa9fab31e17fc0befb5f161b3bf93c9096d99aed584625f38065c511ad9b", size = 176959, upload-time = "2026-02-18T20:28:11.926Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/8f/ecd68579bd2bf5e9321df60dcdee6e575adf77fedacb1d8378760b2b16b6/google-api-core-2.18.0.tar.gz", hash = "sha256:62d97417bfc674d6cef251e5c4d639a9655e00c45528c4364fbfebb478ce72a9", size = 148047, upload-time = "2024-03-21T20:16:56.269Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/45/27/09c33d67f7e0dcf06d7ac17d196594e66989299374bfb0d4331d1038e76b/google_api_core-2.30.0-py3-none-any.whl", hash = "sha256:80be49ee937ff9aba0fd79a6eddfde35fe658b9953ab9b79c57dd7061afa8df5", size = 173288, upload-time = "2026-02-18T20:28:10.367Z" },
+    { url = "https://files.pythonhosted.org/packages/86/75/59a3ad90d9b4ff5b3e0537611dbe885aeb96124521c9d35aa079f1e0f2c9/google_api_core-2.18.0-py3-none-any.whl", hash = "sha256:5a63aa102e0049abe85b5b88cb9409234c1f70afcda21ce1e40b285b9629c1d6", size = 138293, upload-time = "2024-03-21T20:16:53.645Z" },
 ]

 [package.optional-dependencies]
@@ -2322,21 +2322,16 @@ wheels = [

 [[package]]
 name = "google-auth"
-version = "2.48.0"
+version = "2.29.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cryptography" },
+    { name = "cachetools" },
    { name = "pyasn1-modules" },
    { name = "rsa" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0c/41/242044323fbd746615884b1c16639749e73665b718209946ebad7ba8a813/google_auth-2.48.0.tar.gz", hash = "sha256:4f7e706b0cd3208a3d940a19a822c37a476ddba5450156c3e6624a71f7c841ce", size = 326522, upload-time = "2026-01-26T19:22:47.157Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/b2/f14129111cfd61793609643a07ecb03651a71dd65c6974f63b0310ff4b45/google-auth-2.29.0.tar.gz", hash = "sha256:672dff332d073227550ffc7457868ac4218d6c500b155fe6cc17d2b13602c360", size = 244326, upload-time = "2024-03-20T17:24:27.72Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/83/1d/d6466de3a5249d35e832a52834115ca9d1d0de6abc22065f049707516d47/google_auth-2.48.0-py3-none-any.whl", hash = "sha256:2e2a537873d449434252a9632c28bfc268b0adb1e53f9fb62afc5333a975903f", size = 236499, upload-time = "2026-01-26T19:22:45.099Z" },
-]
-
-[package.optional-dependencies]
-requests = [
-    { name = "requests" },
+    { url = "https://files.pythonhosted.org/packages/9e/8d/ddbcf81ec751d8ee5fd18ac11ff38a0e110f39dfbf105e6d9db69d556dd0/google_auth-2.29.0-py2.py3-none-any.whl", hash = "sha256:d452ad095688cd52bae0ad6fafe027f6a6d6f560e810fec20914e17a09526415", size = 189186, upload-time = "2024-03-20T17:24:24.292Z" },
 ]

 [[package]]
@@ -2354,7 +2349,7 @@ wheels = [

 [[package]]
 name = "google-cloud-aiplatform"
-version = "1.139.0"
+version = "1.49.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "docstring-parser" },
@@ -2363,16 +2358,15 @@ dependencies = [
    { name = "google-cloud-bigquery" },
    { name = "google-cloud-resource-manager" },
    { name = "google-cloud-storage" },
-    { name = "google-genai" },
    { name = "packaging" },
    { name = "proto-plus" },
    { name = "protobuf" },
    { name = "pydantic" },
-    { name = "typing-extensions" },
+    { name = "shapely" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/20/40/6767bd4d694354fd55842990da66f7b6ccfdce283d10f65d4a82d9a8e8df/google_cloud_aiplatform-1.139.0.tar.gz", hash = "sha256:cfaa95375bfb79a97b8c949c3ec1600505a4a9c08ca2b01c36ed659a5e05e37c", size = 9964138, upload-time = "2026-02-25T00:51:06.976Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/21/5930a1420f82bec246ae09e1b7cc8458544f3befe669193b33a7b5c0691c/google-cloud-aiplatform-1.49.0.tar.gz", hash = "sha256:e6e6d01079bb5def49e4be4db4d12b13c624b5c661079c869c13c855e5807429", size = 5766450, upload-time = "2024-04-29T17:25:31.646Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/20/a8a77dfdbf2a8169a3cce2d4e9cfbbfc168454ddd435891e59908ea8bf33/google_cloud_aiplatform-1.139.0-py2.py3-none-any.whl", hash = "sha256:3190b255cf510bce9e4b1adc8162ab0b3f9eca48801657d7af058d8e1d5ad9d0", size = 8209776, upload-time = "2026-02-25T00:51:03.526Z" },
+    { url = "https://files.pythonhosted.org/packages/39/6a/7d9e1c03c814e760361fe8b0ffd373ead4124ace66ed33bb16d526ae1ecf/google_cloud_aiplatform-1.49.0-py2.py3-none-any.whl", hash = "sha256:8072d9e0c18d8942c704233d1a93b8d6312fc7b278786a283247950e28ae98df", size = 4914049, upload-time = "2024-04-29T17:25:27.625Z" },
 ]

 [[package]]
@@ -2460,27 +2454,6 @@ wheels = [
    { url = "https://files.pythonhosted.org/packages/fd/3c/2a19a60a473de48717b4efb19398c3f914795b64a96cf3fbe82588044f78/google_crc32c-1.7.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6efb97eb4369d52593ad6f75e7e10d053cf00c48983f7a973105bc70b0ac4d82", size = 28048, upload-time = "2025-03-26T14:41:46.696Z" },
 ]

-[[package]]
-name = "google-genai"
-version = "1.65.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "distro" },
-    { name = "google-auth", extra = ["requests"] },
-    { name = "httpx" },
-    { name = "pydantic" },
-    { name = "requests" },
-    { name = "sniffio" },
-    { name = "tenacity" },
-    { name = "typing-extensions" },
-    { name = "websockets" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/79/f9/cc1191c2540d6a4e24609a586c4ed45d2db57cfef47931c139ee70e5874a/google_genai-1.65.0.tar.gz", hash = "sha256:d470eb600af802d58a79c7f13342d9ea0d05d965007cae8f76c7adff3d7a4750", size = 497206, upload-time = "2026-02-26T00:20:33.824Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/3c/3fea4e7c91357c71782d7dcaad7a2577d636c90317e003386893c25bc62c/google_genai-1.65.0-py3-none-any.whl", hash = "sha256:68c025205856919bc03edb0155c11b4b833810b7ce17ad4b7a9eeba5158f6c44", size = 724429, upload-time = "2026-02-26T00:20:32.186Z" },
-]
-
 [[package]]
 name = "google-resumable-media"
 version = "2.8.0"
@@ -2495,14 +2468,14 @@ wheels = [

 [[package]]
 name = "googleapis-common-protos"
-version = "1.72.0"
+version = "1.63.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e5/7b/adfd75544c415c487b33061fe7ae526165241c1ea133f9a9125a56b39fd8/googleapis_common_protos-1.72.0.tar.gz", hash = "sha256:e55a601c1b32b52d7a3e65f43563e2aa61bcd737998ee672ac9b951cd49319f5", size = 147433, upload-time = "2025-11-06T18:29:24.087Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d2/dc/291cebf3c73e108ef8210f19cb83d671691354f4f7dd956445560d778715/googleapis-common-protos-1.63.0.tar.gz", hash = "sha256:17ad01b11d5f1d0171c06d3ba5c04c54474e883b66b949722b4938ee2694ef4e", size = 121646, upload-time = "2024-03-11T12:33:15.765Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/ab/09169d5a4612a5f92490806649ac8d41e3ec9129c636754575b3553f4ea4/googleapis_common_protos-1.72.0-py3-none-any.whl", hash = "sha256:4299c5a82d5ae1a9702ada957347726b167f9f8d1fc352477702a1e851ff4038", size = 297515, upload-time = "2025-11-06T18:29:13.14Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/a6/12a0c976140511d8bc8a16ad15793b2aef29ac927baa0786ccb7ddbb6e1c/googleapis_common_protos-1.63.0-py2.py3-none-any.whl", hash = "sha256:ae45f75702f7c08b541f750854a678bd8f534a1a6bace6afe975f1d0a82d6632", size = 229141, upload-time = "2024-03-11T12:33:14.052Z" },
 ]

 [package.optional-dependencies]
@@ -2692,35 +2665,31 @@ wheels = [

 [[package]]
 name = "grpcio-tools"
-version = "1.71.2"
+version = "1.62.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "grpcio" },
    { name = "protobuf" },
    { name = "setuptools" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ad/9a/edfefb47f11ef6b0f39eea4d8f022c5bb05ac1d14fcc7058e84a51305b73/grpcio_tools-1.71.2.tar.gz", hash = "sha256:b5304d65c7569b21270b568e404a5a843cf027c66552a6a0978b23f137679c09", size = 5330655, upload-time = "2025-06-28T04:22:00.308Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/54/fa/b69bd8040eafc09b88bb0ec0fea59e8aacd1a801e688af087cead213b0d0/grpcio-tools-1.62.3.tar.gz", hash = "sha256:7c7136015c3d62c3eef493efabaf9e3380e3e66d24ee8e94c01cb71377f57833", size = 4538520, upload-time = "2024-08-06T00:37:11.035Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/17/e4/0568d38b8da6237ea8ea15abb960fb7ab83eb7bb51e0ea5926dab3d865b1/grpcio_tools-1.71.2-cp311-cp311-linux_armv7l.whl", hash = "sha256:0acb8151ea866be5b35233877fbee6445c36644c0aa77e230c9d1b46bf34b18b", size = 2385557, upload-time = "2025-06-28T04:20:54.323Z" },
-    { url = "https://files.pythonhosted.org/packages/76/fb/700d46f72b0f636cf0e625f3c18a4f74543ff127471377e49a071f64f1e7/grpcio_tools-1.71.2-cp311-cp311-macosx_10_14_universal2.whl", hash = "sha256:b28f8606f4123edb4e6da281547465d6e449e89f0c943c376d1732dc65e6d8b3", size = 5447590, upload-time = "2025-06-28T04:20:55.836Z" },
-    { url = "https://files.pythonhosted.org/packages/12/69/d9bb2aec3de305162b23c5c884b9f79b1a195d42b1e6dabcc084cc9d0804/grpcio_tools-1.71.2-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:cbae6f849ad2d1f5e26cd55448b9828e678cb947fa32c8729d01998238266a6a", size = 2348495, upload-time = "2025-06-28T04:20:57.33Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/83/f840aba1690461b65330efbca96170893ee02fae66651bcc75f28b33a46c/grpcio_tools-1.71.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e4d1027615cfb1e9b1f31f2f384251c847d68c2f3e025697e5f5c72e26ed1316", size = 2742333, upload-time = "2025-06-28T04:20:59.051Z" },
-    { url = "https://files.pythonhosted.org/packages/30/34/c02cd9b37de26045190ba665ee6ab8597d47f033d098968f812d253bbf8c/grpcio_tools-1.71.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9bac95662dc69338edb9eb727cc3dd92342131b84b12b3e8ec6abe973d4cbf1b", size = 2473490, upload-time = "2025-06-28T04:21:00.614Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/c7/375718ae091c8f5776828ce97bdcb014ca26244296f8b7f70af1a803ed2f/grpcio_tools-1.71.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c50250c7248055040f89eb29ecad39d3a260a4b6d3696af1575945f7a8d5dcdc", size = 2850333, upload-time = "2025-06-28T04:21:01.95Z" },
-    { url = "https://files.pythonhosted.org/packages/19/37/efc69345bd92a73b2bc80f4f9e53d42dfdc234b2491ae58c87da20ca0ea5/grpcio_tools-1.71.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:6ab1ad955e69027ef12ace4d700c5fc36341bdc2f420e87881e9d6d02af3d7b8", size = 3300748, upload-time = "2025-06-28T04:21:03.451Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/1f/15f787eb25ae42086f55ed3e4260e85f385921c788debf0f7583b34446e3/grpcio_tools-1.71.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:dd75dde575781262b6b96cc6d0b2ac6002b2f50882bf5e06713f1bf364ee6e09", size = 2913178, upload-time = "2025-06-28T04:21:04.879Z" },
-    { url = "https://files.pythonhosted.org/packages/12/aa/69cb3a9dff7d143a05e4021c3c9b5cde07aacb8eb1c892b7c5b9fb4973e3/grpcio_tools-1.71.2-cp311-cp311-win32.whl", hash = "sha256:9a3cb244d2bfe0d187f858c5408d17cb0e76ca60ec9a274c8fd94cc81457c7fc", size = 946256, upload-time = "2025-06-28T04:21:06.518Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/df/fb951c5c87eadb507a832243942e56e67d50d7667b0e5324616ffd51b845/grpcio_tools-1.71.2-cp311-cp311-win_amd64.whl", hash = "sha256:00eb909997fd359a39b789342b476cbe291f4dd9c01ae9887a474f35972a257e", size = 1117661, upload-time = "2025-06-28T04:21:08.18Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/d3/3ed30a9c5b2424627b4b8411e2cd6a1a3f997d3812dbc6a8630a78bcfe26/grpcio_tools-1.71.2-cp312-cp312-linux_armv7l.whl", hash = "sha256:bfc0b5d289e383bc7d317f0e64c9dfb59dc4bef078ecd23afa1a816358fb1473", size = 2385479, upload-time = "2025-06-28T04:21:10.413Z" },
-    { url = "https://files.pythonhosted.org/packages/54/61/e0b7295456c7e21ef777eae60403c06835160c8d0e1e58ebfc7d024c51d3/grpcio_tools-1.71.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:b4669827716355fa913b1376b1b985855d5cfdb63443f8d18faf210180199006", size = 5431521, upload-time = "2025-06-28T04:21:12.261Z" },
-    { url = "https://files.pythonhosted.org/packages/75/d7/7bcad6bcc5f5b7fab53e6bce5db87041f38ef3e740b1ec2d8c49534fa286/grpcio_tools-1.71.2-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:d4071f9b44564e3f75cdf0f05b10b3e8c7ea0ca5220acbf4dc50b148552eef2f", size = 2350289, upload-time = "2025-06-28T04:21:13.625Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/8a/e4c1c4cb8c9ff7f50b7b2bba94abe8d1e98ea05f52a5db476e7f1c1a3c70/grpcio_tools-1.71.2-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a28eda8137d587eb30081384c256f5e5de7feda34776f89848b846da64e4be35", size = 2743321, upload-time = "2025-06-28T04:21:15.007Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/aa/95bc77fda5c2d56fb4a318c1b22bdba8914d5d84602525c99047114de531/grpcio_tools-1.71.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b19c083198f5eb15cc69c0a2f2c415540cbc636bfe76cea268e5894f34023b40", size = 2474005, upload-time = "2025-06-28T04:21:16.443Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/ff/ca11f930fe1daa799ee0ce1ac9630d58a3a3deed3dd2f465edb9a32f299d/grpcio_tools-1.71.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:784c284acda0d925052be19053d35afbf78300f4d025836d424cf632404f676a", size = 2851559, upload-time = "2025-06-28T04:21:18.139Z" },
-    { url = "https://files.pythonhosted.org/packages/64/10/c6fc97914c7e19c9bb061722e55052fa3f575165da9f6510e2038d6e8643/grpcio_tools-1.71.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:381e684d29a5d052194e095546eef067201f5af30fd99b07b5d94766f44bf1ae", size = 3300622, upload-time = "2025-06-28T04:21:20.291Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/d6/965f36cfc367c276799b730d5dd1311b90a54a33726e561393b808339b04/grpcio_tools-1.71.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3e4b4801fabd0427fc61d50d09588a01b1cfab0ec5e8a5f5d515fbdd0891fd11", size = 2913863, upload-time = "2025-06-28T04:21:22.196Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/f0/c05d5c3d0c1d79ac87df964e9d36f1e3a77b60d948af65bec35d3e5c75a3/grpcio_tools-1.71.2-cp312-cp312-win32.whl", hash = "sha256:84ad86332c44572305138eafa4cc30040c9a5e81826993eae8227863b700b490", size = 945744, upload-time = "2025-06-28T04:21:23.463Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/e9/c84c1078f0b7af7d8a40f5214a9bdd8d2a567ad6c09975e6e2613a08d29d/grpcio_tools-1.71.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e1108d37eecc73b1c4a27350a6ed921b5dda25091700c1da17cfe30761cd462", size = 1117695, upload-time = "2025-06-28T04:21:25.22Z" },
+    { url = "https://files.pythonhosted.org/packages/23/52/2dfe0a46b63f5ebcd976570aa5fc62f793d5a8b169e211c6a5aede72b7ae/grpcio_tools-1.62.3-cp311-cp311-macosx_10_10_universal2.whl", hash = "sha256:703f46e0012af83a36082b5f30341113474ed0d91e36640da713355cd0ea5d23", size = 5147623, upload-time = "2024-08-06T00:30:54.894Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/2e/29fdc6c034e058482e054b4a3c2432f84ff2e2765c1342d4f0aa8a5c5b9a/grpcio_tools-1.62.3-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:7cc83023acd8bc72cf74c2edbe85b52098501d5b74d8377bfa06f3e929803492", size = 2719538, upload-time = "2024-08-06T00:30:57.928Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/60/abe5deba32d9ec2c76cdf1a2f34e404c50787074a2fee6169568986273f1/grpcio_tools-1.62.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ff7d58a45b75df67d25f8f144936a3e44aabd91afec833ee06826bd02b7fbe7", size = 3070964, upload-time = "2024-08-06T00:31:00.267Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/ad/e2b066684c75f8d9a48508cde080a3a36618064b9cadac16d019ca511444/grpcio_tools-1.62.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f2483ea232bd72d98a6dc6d7aefd97e5bc80b15cd909b9e356d6f3e326b6e43", size = 2805003, upload-time = "2024-08-06T00:31:02.565Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/3f/59bf7af786eae3f9d24ee05ce75318b87f541d0950190ecb5ffb776a1a58/grpcio_tools-1.62.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:962c84b4da0f3b14b3cdb10bc3837ebc5f136b67d919aea8d7bb3fd3df39528a", size = 3685154, upload-time = "2024-08-06T00:31:05.339Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/79/4dd62478b91e27084c67b35a2316ce8a967bd8b6cb8d6ed6c86c3a0df7cb/grpcio_tools-1.62.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8ad0473af5544f89fc5a1ece8676dd03bdf160fb3230f967e05d0f4bf89620e3", size = 3297942, upload-time = "2024-08-06T00:31:08.456Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/cb/86449ecc58bea056b52c0b891f26977afc8c4464d88c738f9648da941a75/grpcio_tools-1.62.3-cp311-cp311-win32.whl", hash = "sha256:db3bc9fa39afc5e4e2767da4459df82b095ef0cab2f257707be06c44a1c2c3e5", size = 910231, upload-time = "2024-08-06T00:31:11.464Z" },
+    { url = "https://files.pythonhosted.org/packages/45/a4/9736215e3945c30ab6843280b0c6e1bff502910156ea2414cd77fbf1738c/grpcio_tools-1.62.3-cp311-cp311-win_amd64.whl", hash = "sha256:e0898d412a434e768a0c7e365acabe13ff1558b767e400936e26b5b6ed1ee51f", size = 1052496, upload-time = "2024-08-06T00:31:13.665Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/a5/d6887eba415ce318ae5005e8dfac3fa74892400b54b6d37b79e8b4f14f5e/grpcio_tools-1.62.3-cp312-cp312-macosx_10_10_universal2.whl", hash = "sha256:d102b9b21c4e1e40af9a2ab3c6d41afba6bd29c0aa50ca013bf85c99cdc44ac5", size = 5147690, upload-time = "2024-08-06T00:31:16.436Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/7c/3cde447a045e83ceb4b570af8afe67ffc86896a2fe7f59594dc8e5d0a645/grpcio_tools-1.62.3-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:0a52cc9444df978438b8d2332c0ca99000521895229934a59f94f37ed896b133", size = 2720538, upload-time = "2024-08-06T00:31:18.905Z" },
+    { url = "https://files.pythonhosted.org/packages/88/07/f83f2750d44ac4f06c07c37395b9c1383ef5c994745f73c6bfaf767f0944/grpcio_tools-1.62.3-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:141d028bf5762d4a97f981c501da873589df3f7e02f4c1260e1921e565b376fa", size = 3071571, upload-time = "2024-08-06T00:31:21.684Z" },
+    { url = "https://files.pythonhosted.org/packages/37/74/40175897deb61e54aca716bc2e8919155b48f33aafec8043dda9592d8768/grpcio_tools-1.62.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47a5c093ab256dec5714a7a345f8cc89315cb57c298b276fa244f37a0ba507f0", size = 2806207, upload-time = "2024-08-06T00:31:24.208Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/ee/d8de915105a217cbcb9084d684abdc032030dcd887277f2ef167372287fe/grpcio_tools-1.62.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:f6831fdec2b853c9daa3358535c55eed3694325889aa714070528cf8f92d7d6d", size = 3685815, upload-time = "2024-08-06T00:31:26.917Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d9/4360a6c12be3d7521b0b8c39e5d3801d622fbb81cc2721dbd3eee31e28c8/grpcio_tools-1.62.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e02d7c1a02e3814c94ba0cfe43d93e872c758bd8fd5c2797f894d0c49b4a1dfc", size = 3298378, upload-time = "2024-08-06T00:31:30.401Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3b/7cdf4a9e5a3e0a35a528b48b111355cd14da601413a4f887aa99b6da468f/grpcio_tools-1.62.3-cp312-cp312-win32.whl", hash = "sha256:b881fd9505a84457e9f7e99362eeedd86497b659030cf57c6f0070df6d9c2b9b", size = 910416, upload-time = "2024-08-06T00:31:33.118Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/66/dd3ec249e44c1cc15e902e783747819ed41ead1336fcba72bf841f72c6e9/grpcio_tools-1.62.3-cp312-cp312-win_amd64.whl", hash = "sha256:11c625eebefd1fd40a228fc8bae385e448c7e32a6ae134e43cf13bbc23f902b7", size = 1052856, upload-time = "2024-08-06T00:31:36.519Z" },
 ]

 [[package]]
@@ -2877,17 +2846,18 @@ wheels = [

 [[package]]
 name = "httpx"
-version = "0.28.1"
+version = "0.27.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "anyio" },
    { name = "certifi" },
    { name = "httpcore" },
    { name = "idna" },
+    { name = "sniffio" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/78/82/08f8c936781f67d9e6b9eeb8a0c8b4e406136ea4c3d1f89a5db71d42e0e6/httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2", size = 144189, upload-time = "2024-08-27T12:54:01.334Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+    { url = "https://files.pythonhosted.org/packages/56/95/9377bcb415797e44274b51d46e3249eba641711cf3348050f76ee7b15ffc/httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0", size = 76395, upload-time = "2024-08-27T12:53:59.653Z" },
 ]

 [package.optional-dependencies]
@@ -3971,59 +3941,59 @@ wheels = [

 [[package]]
 name = "opentelemetry-api"
-version = "1.28.0"
+version = "1.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "deprecated" },
    { name = "importlib-metadata" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/79/36/260eaea0f74fdd0c0d8f22ed3a3031109ea1c85531f94f4fde266c29e29a/opentelemetry_api-1.28.0.tar.gz", hash = "sha256:578610bcb8aa5cdcb11169d136cc752958548fb6ccffb0969c1036b0ee9e5353", size = 62803, upload-time = "2024-11-05T19:14:45.497Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/83/93114b6de85a98963aec218a51509a52ed3f8de918fe91eb0f7299805c3f/opentelemetry_api-1.27.0.tar.gz", hash = "sha256:ed673583eaa5f81b5ce5e86ef7cdaf622f88ef65f0b9aab40b843dcae5bef342", size = 62693, upload-time = "2024-08-28T21:35:31.445Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/22/e4/3b25d8b856791c04d8a62b1257b5fc09dc41a057800db06885af8ddcdce1/opentelemetry_api-1.28.0-py3-none-any.whl", hash = "sha256:8457cd2c59ea1bd0988560f021656cecd254ad7ef6be4ba09dbefeca2409ce52", size = 64314, upload-time = "2024-11-05T19:14:21.659Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/1f/737dcdbc9fea2fa96c1b392ae47275165a7c641663fbb08a8d252968eed2/opentelemetry_api-1.27.0-py3-none-any.whl", hash = "sha256:953d5871815e7c30c81b56d910c707588000fff7a3ca1c73e6531911d53065e7", size = 63970, upload-time = "2024-08-28T21:35:00.598Z" },
 ]

 [[package]]
 name = "opentelemetry-distro"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-api" },
    { name = "opentelemetry-instrumentation" },
    { name = "opentelemetry-sdk" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4d/75/7cb7c33899e66bb366d40a889111a78c22df0951038b6699f1663e715a9f/opentelemetry_distro-0.49b0.tar.gz", hash = "sha256:1bafa274f9e83baa0d2a5d47ed02caffcf9bcca60107b389b145400d82b07513", size = 2560, upload-time = "2024-11-05T19:21:39.379Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f4/09/423e17c439ed24c45110affe84aad886a536b7871a42637d2ad14a179b47/opentelemetry_distro-0.48b0.tar.gz", hash = "sha256:5cb15915780ac4972583286a56683d43bd4ca95371d72f5f3f179c8b0b2ddc91", size = 2556, upload-time = "2024-08-28T21:27:40.455Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4c/db/806172b6a4933966eee518db814b375e620602f7fe776b74ef795690f135/opentelemetry_distro-0.49b0-py3-none-any.whl", hash = "sha256:1af4074702f605ea210753dd41947dc2fd61b39724f23cdcf15d5654867cd3c2", size = 3318, upload-time = "2024-11-05T19:20:34.065Z" },
+    { url = "https://files.pythonhosted.org/packages/82/cf/fa9a5fe954f1942e03b319ae0e319ebc93d9f984b548bcd9b3f232a1434d/opentelemetry_distro-0.48b0-py3-none-any.whl", hash = "sha256:b2f8fce114325b020769af3b9bf503efb8af07efc190bd1b9deac7843171664a", size = 3321, upload-time = "2024-08-28T21:26:26.584Z" },
 ]

 [[package]]
 name = "opentelemetry-exporter-otlp"
-version = "1.28.0"
+version = "1.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-exporter-otlp-proto-grpc" },
    { name = "opentelemetry-exporter-otlp-proto-http" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/eb/16/14e3fc163930ea68f0980a4cdd4ae5796e60aeb898965990e13263d64baf/opentelemetry_exporter_otlp-1.28.0.tar.gz", hash = "sha256:31ae7495831681dd3da34ac457f6970f147465ae4b9aae3a888d7a581c7cd868", size = 6170, upload-time = "2024-11-05T19:14:47.349Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fc/d3/8156cc14e8f4573a3572ee7f30badc7aabd02961a09acc72ab5f2c789ef1/opentelemetry_exporter_otlp-1.27.0.tar.gz", hash = "sha256:4a599459e623868cc95d933c301199c2367e530f089750e115599fccd67cb2a1", size = 6166, upload-time = "2024-08-28T21:35:33.746Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/82/3f521b3c1f2a411ed60a24a8c9f486c1beeaf8c6c55337c87d3ae1642151/opentelemetry_exporter_otlp-1.28.0-py3-none-any.whl", hash = "sha256:1fd02d70f2c1b7ac5579c81e78de4594b188d3317c8ceb69e8b53900fb7b40fd", size = 7024, upload-time = "2024-11-05T19:14:24.534Z" },
+    { url = "https://files.pythonhosted.org/packages/59/6d/95e1fc2c8d945a734db32e87a5aa7a804f847c1657a21351df9338bd1c9c/opentelemetry_exporter_otlp-1.27.0-py3-none-any.whl", hash = "sha256:7688791cbdd951d71eb6445951d1cfbb7b6b2d7ee5948fac805d404802931145", size = 7001, upload-time = "2024-08-28T21:35:04.02Z" },
 ]

 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.28.0"
+version = "1.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c2/8d/5d411084ac441052f4c9bae03a1aec65ae5d16b439fea7b9c5ac3842c013/opentelemetry_exporter_otlp_proto_common-1.28.0.tar.gz", hash = "sha256:5fa0419b0c8e291180b0fc8430a20dd44a3f3236f8e0827992145914f273ec4f", size = 18505, upload-time = "2024-11-05T19:14:48.204Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/2e/7eaf4ba595fb5213cf639c9158dfb64aacb2e4c7d74bfa664af89fa111f4/opentelemetry_exporter_otlp_proto_common-1.27.0.tar.gz", hash = "sha256:159d27cf49f359e3798c4c3eb8da6ef4020e292571bd8c5604a2a573231dd5c8", size = 17860, upload-time = "2024-08-28T21:35:34.896Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e1/72/3c44aabc74db325aaba09361b6a0d80f6d601f0ff86ecea8ee655c9538fc/opentelemetry_exporter_otlp_proto_common-1.28.0-py3-none-any.whl", hash = "sha256:467e6437d24e020156dffecece8c0a4471a8a60f6a34afeda7386df31a092410", size = 18403, upload-time = "2024-11-05T19:14:25.798Z" },
+    { url = "https://files.pythonhosted.org/packages/41/27/4610ab3d9bb3cde4309b6505f98b3aabca04a26aa480aa18cede23149837/opentelemetry_exporter_otlp_proto_common-1.27.0-py3-none-any.whl", hash = "sha256:675db7fffcb60946f3a5c43e17d1168a3307a94a930ecf8d2ea1f286f3d4f79a", size = 17848, upload-time = "2024-08-28T21:35:05.412Z" },
 ]

 [[package]]
 name = "opentelemetry-exporter-otlp-proto-grpc"
-version = "1.28.0"
+version = "1.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "deprecated" },
@@ -4034,14 +4004,14 @@ dependencies = [
    { name = "opentelemetry-proto" },
    { name = "opentelemetry-sdk" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/43/4d/f215162e58041afb4bdf5dbd0d8faf0b7fc9bf7b3d3fc0e44e06f9e7e869/opentelemetry_exporter_otlp_proto_grpc-1.28.0.tar.gz", hash = "sha256:47a11c19dc7f4289e220108e113b7de90d59791cb4c37fc29f69a6a56f2c3735", size = 26237, upload-time = "2024-11-05T19:14:49.026Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d0/c1e375b292df26e0ffebf194e82cd197e4c26cc298582bda626ce3ce74c5/opentelemetry_exporter_otlp_proto_grpc-1.27.0.tar.gz", hash = "sha256:af6f72f76bcf425dfb5ad11c1a6d6eca2863b91e63575f89bb7b4b55099d968f", size = 26244, upload-time = "2024-08-28T21:35:36.314Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/b5/afabc8106abc0f9cfeecf5b3e682622b3e04bba1d9b967dbfcd91b9c4ebe/opentelemetry_exporter_otlp_proto_grpc-1.28.0-py3-none-any.whl", hash = "sha256:edbdc53e7783f88d4535db5807cb91bd7b1ec9e9b9cdbfee14cd378f29a3b328", size = 18532, upload-time = "2024-11-05T19:14:26.853Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/80/32217460c2c64c0568cea38410124ff680a9b65f6732867bbf857c4d8626/opentelemetry_exporter_otlp_proto_grpc-1.27.0-py3-none-any.whl", hash = "sha256:56b5bbd5d61aab05e300d9d62a6b3c134827bbd28d0b12f2649c2da368006c9e", size = 18541, upload-time = "2024-08-28T21:35:06.493Z" },
 ]

 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.28.0"
+version = "1.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "deprecated" },
@@ -4052,29 +4022,28 @@ dependencies = [
    { name = "opentelemetry-sdk" },
    { name = "requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f1/2a/555f2845928086cd51aa6941c7a546470805b68ed631ec139ce7d841763d/opentelemetry_exporter_otlp_proto_http-1.28.0.tar.gz", hash = "sha256:d83a9a03a8367ead577f02a64127d827c79567de91560029688dd5cfd0152a8e", size = 15051, upload-time = "2024-11-05T19:14:49.813Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/31/0a/f05c55e8913bf58a033583f2580a0ec31a5f4cf2beacc9e286dcb74d6979/opentelemetry_exporter_otlp_proto_http-1.27.0.tar.gz", hash = "sha256:2103479092d8eb18f61f3fbff084f67cc7f2d4a7d37e75304b8b56c1d09ebef5", size = 15059, upload-time = "2024-08-28T21:35:37.079Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/ce/80d5adabbf7ab4a0ca7b5e0f4039b24d273be370c3ba85fc05b13794411c/opentelemetry_exporter_otlp_proto_http-1.28.0-py3-none-any.whl", hash = "sha256:e8f3f7961b747edb6b44d51de4901a61e9c01d50debd747b120a08c4996c7e7b", size = 17228, upload-time = "2024-11-05T19:14:28.613Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/8d/4755884afc0b1db6000527cac0ca17273063b6142c773ce4ecd307a82e72/opentelemetry_exporter_otlp_proto_http-1.27.0-py3-none-any.whl", hash = "sha256:688027575c9da42e179a69fe17e2d1eba9b14d81de8d13553a21d3114f3b4d75", size = 17203, upload-time = "2024-08-28T21:35:08.141Z" },
 ]

 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-api" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "packaging" },
+    { name = "setuptools" },
    { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/de/6b/6c25b15063c92a011cf3f68375971e2c58a9c764690847edc97df2d94eeb/opentelemetry_instrumentation-0.49b0.tar.gz", hash = "sha256:398a93e0b9dc2d11cc8627e1761665c506fe08c6b2df252a2ab3ade53d751c46", size = 26478, upload-time = "2024-11-05T19:21:41.402Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/0e/d9394839af5d55c8feb3b22cd11138b953b49739b20678ca96289e30f904/opentelemetry_instrumentation-0.48b0.tar.gz", hash = "sha256:94929685d906380743a71c3970f76b5f07476eea1834abd5dd9d17abfe23cc35", size = 24724, upload-time = "2024-08-28T21:27:42.82Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/93/61/e0d21e958d6072ce25c4f5e26a1d22835fc86f80836660adf6badb6038ce/opentelemetry_instrumentation-0.49b0-py3-none-any.whl", hash = "sha256:68364d73a1ff40894574cbc6138c5f98674790cae1f3b0865e21cf702f24dcb3", size = 30694, upload-time = "2024-11-05T19:20:38.584Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/7f/405c41d4f359121376c9d5117dcf68149b8122d3f6c718996d037bd4d800/opentelemetry_instrumentation-0.48b0-py3-none-any.whl", hash = "sha256:a69750dc4ba6a5c3eb67986a337185a25b739966d80479befe37b546fc870b44", size = 29449, upload-time = "2024-08-28T21:26:31.288Z" },
 ]

 [[package]]
 name = "opentelemetry-instrumentation-asgi"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "asgiref" },
@@ -4083,28 +4052,28 @@ dependencies = [
    { name = "opentelemetry-semantic-conventions" },
    { name = "opentelemetry-util-http" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e8/55/693c3d0938ba5fead5c3aa4ac7022a992b4ff99a8e9979800d0feb843ff4/opentelemetry_instrumentation_asgi-0.49b0.tar.gz", hash = "sha256:959fd9b1345c92f20c6ef1d42f92ef6a76b3c3083fbc4104d59da6859b15b083", size = 24117, upload-time = "2024-11-05T19:21:46.769Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/44/ac/fd3d40bab3234ec3f5c052a815100676baaae1832fa1067935f11e5c59c6/opentelemetry_instrumentation_asgi-0.48b0.tar.gz", hash = "sha256:04c32174b23c7fa72ddfe192dad874954968a6a924608079af9952964ecdf785", size = 23435, upload-time = "2024-08-28T21:27:47.276Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/0b/7900c782a1dfaa584588d724bc3bbdf8405a32497537dd96b3fcbf8461b9/opentelemetry_instrumentation_asgi-0.49b0-py3-none-any.whl", hash = "sha256:722a90856457c81956c88f35a6db606cc7db3231046b708aae2ddde065723dbe", size = 16326, upload-time = "2024-11-05T19:20:46.176Z" },
+    { url = "https://files.pythonhosted.org/packages/db/74/a0e0d38622856597dd8e630f2bd793760485eb165708e11b8be1696bbb5a/opentelemetry_instrumentation_asgi-0.48b0-py3-none-any.whl", hash = "sha256:ddb1b5fc800ae66e85a4e2eca4d9ecd66367a8c7b556169d9e7b57e10676e44d", size = 15958, upload-time = "2024-08-28T21:26:38.139Z" },
 ]

 [[package]]
 name = "opentelemetry-instrumentation-celery"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-api" },
    { name = "opentelemetry-instrumentation" },
    { name = "opentelemetry-semantic-conventions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/8b/9b8a9dda3ed53354c6f707a45cdb7a4730e1c109b50fc1b413525493f811/opentelemetry_instrumentation_celery-0.49b0.tar.gz", hash = "sha256:afbaee97cc9c75f29bcc9784f16f8e37c415d4fe9b334748c5b90a3d30d12473", size = 14702, upload-time = "2024-11-05T19:21:53.672Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/42/68/72975eff50cc22d8f65f96c425a2e8844f91488e78ffcfb603ac7cee0e5a/opentelemetry_instrumentation_celery-0.48b0.tar.gz", hash = "sha256:1d33aa6c4a1e6c5d17a64215245208a96e56c9d07611685dbae09a557704af26", size = 14445, upload-time = "2024-08-28T21:27:56.392Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/21/8c/d7d4adb36abbc0e517a69f7a069f32742122ae22d6017202f64570d9f4c5/opentelemetry_instrumentation_celery-0.49b0-py3-none-any.whl", hash = "sha256:38d4a78c78f33020032ef77ef0ead756bdf7838bcfb603de10f5925d39f14929", size = 13749, upload-time = "2024-11-05T19:20:54.98Z" },
+    { url = "https://files.pythonhosted.org/packages/28/59/f09e8f9f596d375fd86b7677751525bbc485c8cc8c5388e39786a3d3b968/opentelemetry_instrumentation_celery-0.48b0-py3-none-any.whl", hash = "sha256:c1904e38cc58fb2a33cd657d6e296285c5ffb0dca3f164762f94b905e5abc88e", size = 13697, upload-time = "2024-08-28T21:26:50.01Z" },
 ]

 [[package]]
 name = "opentelemetry-instrumentation-fastapi"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-api" },
@@ -4113,16 +4082,17 @@ dependencies = [
    { name = "opentelemetry-semantic-conventions" },
    { name = "opentelemetry-util-http" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fe/bf/8e6d2a4807360f2203192017eb4845f5628dbeaf0597adf3d141cc5c24e1/opentelemetry_instrumentation_fastapi-0.49b0.tar.gz", hash = "sha256:6d14935c41fd3e49328188b6a59dd4c37bd17a66b01c15b0c64afa9714a1f905", size = 19230, upload-time = "2024-11-05T19:21:59.361Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/20/43477da5850ef2cd3792715d442aecd051e885e0603b6ee5783b2104ba8f/opentelemetry_instrumentation_fastapi-0.48b0.tar.gz", hash = "sha256:21a72563ea412c0b535815aeed75fc580240f1f02ebc72381cfab672648637a2", size = 18497, upload-time = "2024-08-28T21:28:01.14Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/f4/0895b9410c10abf987c90dee1b7688a8f2214a284fe15e575648f6a1473a/opentelemetry_instrumentation_fastapi-0.49b0-py3-none-any.whl", hash = "sha256:646e1b18523cbe6860ae9711eb2c7b9c85466c3c7697cd6b8fb5180d85d3fe6e", size = 12101, upload-time = "2024-11-05T19:21:01.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/50/745ab075a3041b7a5f29a579d2c28eaad54f64b4589d8f9fd364c62cf0f3/opentelemetry_instrumentation_fastapi-0.48b0-py3-none-any.whl", hash = "sha256:afeb820a59e139d3e5d96619600f11ce0187658b8ae9e3480857dd790bc024f2", size = 11777, upload-time = "2024-08-28T21:26:57.457Z" },
 ]

 [[package]]
 name = "opentelemetry-instrumentation-flask"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "importlib-metadata" },
    { name = "opentelemetry-api" },
    { name = "opentelemetry-instrumentation" },
    { name = "opentelemetry-instrumentation-wsgi" },
@@ -4130,30 +4100,29 @@ dependencies = [
    { name = "opentelemetry-util-http" },
    { name = "packaging" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/17/12/dc72873fb1e35699941d8eb6a53ef25e8c5843dea37665dad33bd720f047/opentelemetry_instrumentation_flask-0.49b0.tar.gz", hash = "sha256:f7c5ab67753c4781a2e21c8f43dc5fc02ece74fdd819466c75d025db80aa7576", size = 19176, upload-time = "2024-11-05T19:22:00.816Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ed/2f/5c3af780a69f9ba78445fe0e5035c41f67281a31b08f3c3e7ec460bda726/opentelemetry_instrumentation_flask-0.48b0.tar.gz", hash = "sha256:e03a34428071aebf4864ea6c6a564acef64f88c13eb3818e64ea90da61266c3d", size = 19196, upload-time = "2024-08-28T21:28:01.986Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/fc/354da8f33ef0daebfc8e4eac995d342ae13a35097bbad512cfe0d2f3c61a/opentelemetry_instrumentation_flask-0.49b0-py3-none-any.whl", hash = "sha256:f3ef330c3cee3e2c161f27f1e7017c8800b9bfb6f9204f2f7bfb0b274874be0e", size = 14582, upload-time = "2024-11-05T19:21:02.793Z" },
+    { url = "https://files.pythonhosted.org/packages/78/3d/fcde4f8f0bf9fa1ee73a12304fa538076fb83fe0a2ae966ab0f0b7da5109/opentelemetry_instrumentation_flask-0.48b0-py3-none-any.whl", hash = "sha256:26b045420b9d76e85493b1c23fcf27517972423480dc6cf78fd6924248ba5808", size = 14588, upload-time = "2024-08-28T21:26:58.504Z" },
 ]

 [[package]]
 name = "opentelemetry-instrumentation-httpx"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-api" },
    { name = "opentelemetry-instrumentation" },
    { name = "opentelemetry-semantic-conventions" },
    { name = "opentelemetry-util-http" },
-    { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a0/53/8b5e05e55a513d846ead5afb0509bec37a34a1c3e82f30b13d14156334b1/opentelemetry_instrumentation_httpx-0.49b0.tar.gz", hash = "sha256:07165b624f3e58638cee47ecf1c81939a8c2beb7e42ce9f69e25a9f21dc3f4cf", size = 17750, upload-time = "2024-11-05T19:22:02.911Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/d9/c65d818607c16d1b7ea8d2de6111c6cecadf8d2fd38c1885a72733a7c6d3/opentelemetry_instrumentation_httpx-0.48b0.tar.gz", hash = "sha256:ee977479e10398931921fb995ac27ccdeea2e14e392cb27ef012fc549089b60a", size = 16931, upload-time = "2024-08-28T21:28:03.794Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/9f/843391c6d645cd4f6914b27bc807fc1ff52b97f84cbe3ca675641976b23f/opentelemetry_instrumentation_httpx-0.49b0-py3-none-any.whl", hash = "sha256:e59e0d2fda5ef841630c68da1d78ff9192f63590a9099f12f0eab614abdf239a", size = 14110, upload-time = "2024-11-05T19:21:04.698Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/fe/f2daa9d6d988c093b8c7b1d35df675761a8ece0b600b035dc04982746c9d/opentelemetry_instrumentation_httpx-0.48b0-py3-none-any.whl", hash = "sha256:d94f9d612c82d09fe22944d1904a30a464c19bea2ba76be656c99a28ad8be8e5", size = 13900, upload-time = "2024-08-28T21:27:01.566Z" },
 ]

 [[package]]
 name = "opentelemetry-instrumentation-redis"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-api" },
@@ -4161,14 +4130,14 @@ dependencies = [
    { name = "opentelemetry-semantic-conventions" },
    { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/19/5b/1398eb2f92fd76787ccec28d24dc4c7dfaaf97a7557e7729e2f7c2c05d84/opentelemetry_instrumentation_redis-0.49b0.tar.gz", hash = "sha256:922542c3bd192ad4ba74e2c7e0a253c7c58a5cefbd6f89da2aba4d193a974703", size = 11353, upload-time = "2024-11-05T19:22:12.822Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/70/be/92e98e4c7f275be3d373899a41b0a7d4df64266657d985dbbdb9a54de0d5/opentelemetry_instrumentation_redis-0.48b0.tar.gz", hash = "sha256:61e33e984b4120e1b980d9fba6e9f7ca0c8d972f9970654d8f6e9f27fa115a8c", size = 10511, upload-time = "2024-08-28T21:28:15.061Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/24/e4/4f258fef0759629f2e8a0210d5533cfef3ecad69ff35be044637a3e2783e/opentelemetry_instrumentation_redis-0.49b0-py3-none-any.whl", hash = "sha256:b7d8f758bac53e77b7e7ca98ce80f91230577502dacb619ebe8e8b6058042067", size = 12453, upload-time = "2024-11-05T19:21:18.534Z" },
+    { url = "https://files.pythonhosted.org/packages/94/40/892f30d400091106309cc047fd3f6d76a828fedd984a953fd5386b78a2fb/opentelemetry_instrumentation_redis-0.48b0-py3-none-any.whl", hash = "sha256:48c7f2e25cbb30bde749dc0d8b9c74c404c851f554af832956b9630b27f5bcb7", size = 11610, upload-time = "2024-08-28T21:27:18.759Z" },
 ]

 [[package]]
 name = "opentelemetry-instrumentation-sqlalchemy"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-api" },
@@ -4177,14 +4146,14 @@ dependencies = [
    { name = "packaging" },
    { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a0/a7/24f6cce3808ae1802dd1b60d752fbab877db5655198929cf4ee8ea416923/opentelemetry_instrumentation_sqlalchemy-0.49b0.tar.gz", hash = "sha256:32658e520fc8b35823c722f5d8831d3a410b76dd2724adb2887befc041ddef04", size = 13194, upload-time = "2024-11-05T19:22:14.92Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/77/3fcebbca8bd729da50dc2130d8ca869a235aa5483a85ef06c5dc8643476b/opentelemetry_instrumentation_sqlalchemy-0.48b0.tar.gz", hash = "sha256:dbf2d5a755b470e64e5e2762b56f8d56313787e4c7d71a87fe25c33f48eb3493", size = 13194, upload-time = "2024-08-28T21:28:18.122Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ec/6b/a1a3685fed593282999cdc374ece15efbd56f8d774bd368bf7ff2cf5923c/opentelemetry_instrumentation_sqlalchemy-0.49b0-py3-none-any.whl", hash = "sha256:d854052d2b02cd0562e5628a514c8153fceada7f585137e173165dfd0a46ef6a", size = 13358, upload-time = "2024-11-05T19:21:23.654Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/84/4b6f1e9e9f83a52d966e91963f5a8424edc4a3d5ea32854c96c2d1618284/opentelemetry_instrumentation_sqlalchemy-0.48b0-py3-none-any.whl", hash = "sha256:625848a34aa5770cb4b1dcdbd95afce4307a0230338711101325261d739f391f", size = 13360, upload-time = "2024-08-28T21:27:22.102Z" },
 ]

 [[package]]
 name = "opentelemetry-instrumentation-wsgi"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-api" },
@@ -4192,70 +4161,70 @@ dependencies = [
    { name = "opentelemetry-semantic-conventions" },
    { name = "opentelemetry-util-http" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/17/2b/91b022b004ac9e9ab0eefd10bc4257975291f88adc81b4ef2c601ddb1adf/opentelemetry_instrumentation_wsgi-0.49b0.tar.gz", hash = "sha256:0812a02e132f8fc3d5c897bba84e530c37b85c315b199bb97ca6508279e7eb23", size = 17733, upload-time = "2024-11-05T19:22:24.3Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/a5/f45cdfba18f22aefd2378eac8c07c1f8c9656d6bf7ce315ced48c67f3437/opentelemetry_instrumentation_wsgi-0.48b0.tar.gz", hash = "sha256:1a1e752367b0df4397e0b835839225ef5c2c3c053743a261551af13434fc4d51", size = 17974, upload-time = "2024-08-28T21:28:24.902Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/02/1d/59979665778ed8c85bc31c92b75571cd7afb8e3322fb513c87fe1bad6d78/opentelemetry_instrumentation_wsgi-0.49b0-py3-none-any.whl", hash = "sha256:8869ccf96611827e4448417718920e9eec6d25bffb5bf72c7952c7346ec33fbc", size = 13699, upload-time = "2024-11-05T19:21:35.039Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/87/fa420007e0ba7e8cd43799ab204717ab515f000236fa2726a6be3299efdd/opentelemetry_instrumentation_wsgi-0.48b0-py3-none-any.whl", hash = "sha256:c6051124d741972090fe94b2fa302555e1e2a22e9cdda32dd39ed49a5b34e0c6", size = 13691, upload-time = "2024-08-28T21:27:33.257Z" },
 ]

 [[package]]
 name = "opentelemetry-propagator-b3"
-version = "1.28.0"
+version = "1.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "deprecated" },
    { name = "opentelemetry-api" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6f/1d/225ea036785119964509e92f4e1bc0313ba6ec790fbf51bd363abafeafae/opentelemetry_propagator_b3-1.28.0.tar.gz", hash = "sha256:cf6f0d2a1881c4858898be47e8a94b11bc5b16fc73b6c37ebfa2121c4825adc6", size = 9592, upload-time = "2024-11-05T19:14:57.193Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/3ceeb5ff5a1906371834d5c594e24e5b84f35528d219054833deca4ac44c/opentelemetry_propagator_b3-1.27.0.tar.gz", hash = "sha256:39377b6aa619234e08fbc6db79bf880aff36d7e2761efa9afa28b78d5937308f", size = 9590, upload-time = "2024-08-28T21:35:43.971Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4e/fa/438d53d73a6c45df5d416b56dc371a65d0b07859bc107ab632349a079d4a/opentelemetry_propagator_b3-1.28.0-py3-none-any.whl", hash = "sha256:9f6923a5da56d7da6724e4fdd758a67ede2a2732efb929e538cf6fea337700c5", size = 8917, upload-time = "2024-11-05T19:14:37.317Z" },
+    { url = "https://files.pythonhosted.org/packages/03/3f/75ba77b8d9938bae575bc457a5c56ca2246ff5367b54c7d4252a31d1c91f/opentelemetry_propagator_b3-1.27.0-py3-none-any.whl", hash = "sha256:1dd75e9801ba02e870df3830097d35771a64c123127c984d9b05c352a35aa9cc", size = 8899, upload-time = "2024-08-28T21:35:18.317Z" },
 ]

 [[package]]
 name = "opentelemetry-proto"
-version = "1.28.0"
+version = "1.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c9/63/ac4cef4d30ea0ca1d2153ad2fc62d91d1cf3b89b0e4e5cbd61a8c567885f/opentelemetry_proto-1.28.0.tar.gz", hash = "sha256:4a45728dfefa33f7908b828b9b7c9f2c6de42a05d5ec7b285662ddae71c4c870", size = 34331, upload-time = "2024-11-05T19:14:59.503Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/59/959f0beea798ae0ee9c979b90f220736fbec924eedbefc60ca581232e659/opentelemetry_proto-1.27.0.tar.gz", hash = "sha256:33c9345d91dafd8a74fc3d7576c5a38f18b7fdf8d02983ac67485386132aedd6", size = 34749, upload-time = "2024-08-28T21:35:45.839Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/86/94/c0b43d16e1d96ee1e699373aa59f14a3aa2e7126af3f11d6adc5dcc531cd/opentelemetry_proto-1.28.0-py3-none-any.whl", hash = "sha256:d5ad31b997846543b8e15504657d9a8cf1ad3c71dcbbb6c4799b1ab29e38f7f9", size = 55832, upload-time = "2024-11-05T19:14:40.446Z" },
+    { url = "https://files.pythonhosted.org/packages/94/56/3d2d826834209b19a5141eed717f7922150224d1a982385d19a9444cbf8d/opentelemetry_proto-1.27.0-py3-none-any.whl", hash = "sha256:b133873de5581a50063e1e4b29cdcf0c5e253a8c2d8dc1229add20a4c3830ace", size = 52464, upload-time = "2024-08-28T21:35:21.434Z" },
 ]

 [[package]]
 name = "opentelemetry-sdk"
-version = "1.28.0"
+version = "1.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "opentelemetry-api" },
    { name = "opentelemetry-semantic-conventions" },
    { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0c/5b/a509ccab93eacc6044591d5ec437d8266e76f893d0389bbf7e5592c7da32/opentelemetry_sdk-1.28.0.tar.gz", hash = "sha256:41d5420b2e3fb7716ff4981b510d551eff1fc60eb5a95cf7335b31166812a893", size = 156155, upload-time = "2024-11-05T19:15:00.451Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0d/9a/82a6ac0f06590f3d72241a587cb8b0b751bd98728e896cc4cbd4847248e6/opentelemetry_sdk-1.27.0.tar.gz", hash = "sha256:d525017dea0ccce9ba4e0245100ec46ecdc043f2d7b8315d56b19aff0904fa6f", size = 145019, upload-time = "2024-08-28T21:35:46.708Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/fe/c8decbebb5660529f1d6ba65e50a45b1294022dfcba2968fc9c8697c42b2/opentelemetry_sdk-1.28.0-py3-none-any.whl", hash = "sha256:4b37da81d7fad67f6683c4420288c97f4ed0d988845d5886435f428ec4b8429a", size = 118692, upload-time = "2024-11-05T19:14:41.669Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/bd/a6602e71e315055d63b2ff07172bd2d012b4cba2d4e00735d74ba42fc4d6/opentelemetry_sdk-1.27.0-py3-none-any.whl", hash = "sha256:365f5e32f920faf0fd9e14fdfd92c086e317eaa5f860edba9cdc17a380d9197d", size = 110505, upload-time = "2024-08-28T21:35:24.769Z" },
 ]

 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "deprecated" },
    { name = "opentelemetry-api" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ee/c8/433b0e54143f8c9369f5c4a7a83e73eec7eb2ee7d0b7e81a9243e78c8e80/opentelemetry_semantic_conventions-0.49b0.tar.gz", hash = "sha256:dbc7b28339e5390b6b28e022835f9bac4e134a80ebf640848306d3c5192557e8", size = 95227, upload-time = "2024-11-05T19:15:01.443Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0a/89/1724ad69f7411772446067cdfa73b598694c8c91f7f8c922e344d96d81f9/opentelemetry_semantic_conventions-0.48b0.tar.gz", hash = "sha256:12d74983783b6878162208be57c9effcb89dc88691c64992d70bb89dc00daa1a", size = 89445, upload-time = "2024-08-28T21:35:47.673Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/25/05/20104df4ef07d3bf5c3fd6bcc796ef70ab4ea4309378a9ba57bc4b4d01fa/opentelemetry_semantic_conventions-0.49b0-py3-none-any.whl", hash = "sha256:0458117f6ead0b12e3221813e3e511d85698c31901cac84682052adb9c17c7cd", size = 159214, upload-time = "2024-11-05T19:14:43.047Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/7a/4f0063dbb0b6c971568291a8bc19a4ca70d3c185db2d956230dd67429dfc/opentelemetry_semantic_conventions-0.48b0-py3-none-any.whl", hash = "sha256:a0de9f45c413a8669788a38569c7e0a11ce6ce97861a628cca785deecdc32a1f", size = 149685, upload-time = "2024-08-28T21:35:25.983Z" },
 ]

 [[package]]
 name = "opentelemetry-util-http"
-version = "0.49b0"
+version = "0.48b0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a3/99/377ef446928808211b127b9ab31c348bc465c8da4514ebeec6e4a3de3d21/opentelemetry_util_http-0.49b0.tar.gz", hash = "sha256:02928496afcffd58a7c15baf99d2cedae9b8325a8ac52b0d0877b2e8f936dd1b", size = 7863, upload-time = "2024-11-05T19:22:26.973Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/d7/185c494754340e0a3928fd39fde2616ee78f2c9d66253affaad62d5b7935/opentelemetry_util_http-0.48b0.tar.gz", hash = "sha256:60312015153580cc20f322e5cdc3d3ecad80a71743235bdb77716e742814623c", size = 7863, upload-time = "2024-08-28T21:28:27.266Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/0e/ab0a89b315d0bacdd355a345bb69b20c50fc1f0804b52b56fe1c35a60e68/opentelemetry_util_http-0.49b0-py3-none-any.whl", hash = "sha256:8661bbd6aea1839badc44de067ec9c15c05eab05f729f496c856c50a1203caf1", size = 6945, upload-time = "2024-11-05T19:21:37.81Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/2e/36097c0a4d0115b8c7e377c90bab7783ac183bc5cb4071308f8959454311/opentelemetry_util_http-0.48b0-py3-none-any.whl", hash = "sha256:76f598af93aab50328d2a69c786beaedc8b6a7770f7a818cc307eb353debfffb", size = 6946, upload-time = "2024-08-28T21:27:37.975Z" },
 ]

 [[package]]
@@ -4464,15 +4433,15 @@ wheels = [

 [[package]]
 name = "pdfminer-six"
-version = "20260107"
+version = "20251230"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "charset-normalizer" },
    { name = "cryptography" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/34/a4/5cec1112009f0439a5ca6afa8ace321f0ab2f48da3255b7a1c8953014670/pdfminer_six-20260107.tar.gz", hash = "sha256:96bfd431e3577a55a0efd25676968ca4ce8fd5b53f14565f85716ff363889602", size = 8512094, upload-time = "2026-01-07T13:29:12.937Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/9a/d79d8fa6d47a0338846bb558b39b9963b8eb2dfedec61867c138c1b17eeb/pdfminer_six-20251230.tar.gz", hash = "sha256:e8f68a14c57e00c2d7276d26519ea64be1b48f91db1cdc776faa80528ca06c1e", size = 8511285, upload-time = "2025-12-30T15:49:13.104Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/8b/28c4eaec9d6b036a52cb44720408f26b1a143ca9bce76cc19e8f5de00ab4/pdfminer_six-20260107-py3-none-any.whl", hash = "sha256:366585ba97e80dffa8f00cebe303d2f381884d8637af4ce422f1df3ef38111a9", size = 6592252, upload-time = "2026-01-07T13:29:10.742Z" },
+    { url = "https://files.pythonhosted.org/packages/65/d7/b288ea32deb752a09aab73c75e1e7572ab2a2b56c3124a5d1eb24c62ceb3/pdfminer_six-20251230-py3-none-any.whl", hash = "sha256:9ff2e3466a7dfc6de6fd779478850b6b7c2d9e9405aa2a5869376a822771f485", size = 6591909, upload-time = "2025-12-30T15:49:10.76Z" },
 ]

 [[package]]
@@ -4701,16 +4670,16 @@ wheels = [

 [[package]]
 name = "protobuf"
-version = "5.29.6"
+version = "4.25.8"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7e/57/394a763c103e0edf87f0938dafcd918d53b4c011dfc5c8ae80f3b0452dbb/protobuf-5.29.6.tar.gz", hash = "sha256:da9ee6a5424b6b30fd5e45c5ea663aef540ca95f9ad99d1e887e819cdf9b8723", size = 425623, upload-time = "2026-02-04T22:54:40.584Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/01/34c8d2b6354906d728703cb9d546a0e534de479e25f1b581e4094c4a85cc/protobuf-4.25.8.tar.gz", hash = "sha256:6135cf8affe1fc6f76cced2641e4ea8d3e59518d1f24ae41ba97bcad82d397cd", size = 380920, upload-time = "2025-05-28T14:22:25.153Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d4/88/9ee58ff7863c479d6f8346686d4636dd4c415b0cbeed7a6a7d0617639c2a/protobuf-5.29.6-cp310-abi3-win32.whl", hash = "sha256:62e8a3114992c7c647bce37dcc93647575fc52d50e48de30c6fcb28a6a291eb1", size = 423357, upload-time = "2026-02-04T22:54:25.805Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/66/2dc736a4d576847134fb6d80bd995c569b13cdc7b815d669050bf0ce2d2c/protobuf-5.29.6-cp310-abi3-win_amd64.whl", hash = "sha256:7e6ad413275be172f67fdee0f43484b6de5a904cc1c3ea9804cb6fe2ff366eda", size = 435175, upload-time = "2026-02-04T22:54:28.592Z" },
-    { url = "https://files.pythonhosted.org/packages/06/db/49b05966fd208ae3f44dcd33837b6243b4915c57561d730a43f881f24dea/protobuf-5.29.6-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:b5a169e664b4057183a34bdc424540e86eea47560f3c123a0d64de4e137f9269", size = 418619, upload-time = "2026-02-04T22:54:30.266Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/d7/48cbf6b0c3c39761e47a99cb483405f0fde2be22cf00d71ef316ce52b458/protobuf-5.29.6-cp38-abi3-manylinux2014_aarch64.whl", hash = "sha256:a8866b2cff111f0f863c1b3b9e7572dc7eaea23a7fae27f6fc613304046483e6", size = 320284, upload-time = "2026-02-04T22:54:31.782Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/dd/cadd6ec43069247d91f6345fa7a0d2858bef6af366dbd7ba8f05d2c77d3b/protobuf-5.29.6-cp38-abi3-manylinux2014_x86_64.whl", hash = "sha256:e3387f44798ac1106af0233c04fb8abf543772ff241169946f698b3a9a3d3ab9", size = 320478, upload-time = "2026-02-04T22:54:32.909Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/cb/e3065b447186cb70aa65acc70c86baf482d82bf75625bf5a2c4f6919c6a3/protobuf-5.29.6-py3-none-any.whl", hash = "sha256:6b9edb641441b2da9fa8f428760fc136a49cf97a52076010cf22a2ff73438a86", size = 173126, upload-time = "2026-02-04T22:54:39.462Z" },
+    { url = "https://files.pythonhosted.org/packages/45/ff/05f34305fe6b85bbfbecbc559d423a5985605cad5eda4f47eae9e9c9c5c5/protobuf-4.25.8-cp310-abi3-win32.whl", hash = "sha256:504435d831565f7cfac9f0714440028907f1975e4bed228e58e72ecfff58a1e0", size = 392745, upload-time = "2025-05-28T14:22:10.524Z" },
+    { url = "https://files.pythonhosted.org/packages/08/35/8b8a8405c564caf4ba835b1fdf554da869954712b26d8f2a98c0e434469b/protobuf-4.25.8-cp310-abi3-win_amd64.whl", hash = "sha256:bd551eb1fe1d7e92c1af1d75bdfa572eff1ab0e5bf1736716814cdccdb2360f9", size = 413736, upload-time = "2025-05-28T14:22:13.156Z" },
+    { url = "https://files.pythonhosted.org/packages/28/d7/ab27049a035b258dab43445eb6ec84a26277b16105b277cbe0a7698bdc6c/protobuf-4.25.8-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:ca809b42f4444f144f2115c4c1a747b9a404d590f18f37e9402422033e464e0f", size = 394537, upload-time = "2025-05-28T14:22:14.768Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/6d/a4a198b61808dd3d1ee187082ccc21499bc949d639feb948961b48be9a7e/protobuf-4.25.8-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:9ad7ef62d92baf5a8654fbb88dac7fa5594cfa70fd3440488a5ca3bfc6d795a7", size = 294005, upload-time = "2025-05-28T14:22:16.052Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/c6/c9deaa6e789b6fc41b88ccbdfe7a42d2b82663248b715f55aa77fbc00724/protobuf-4.25.8-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:83e6e54e93d2b696a92cad6e6efc924f3850f82b52e1563778dfab8b355101b0", size = 294924, upload-time = "2025-05-28T14:22:17.105Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c1/6aece0ab5209981a70cd186f164c133fdba2f51e124ff92b73de7fd24d78/protobuf-4.25.8-py3-none-any.whl", hash = "sha256:15a0af558aa3b13efef102ae6e4f3efac06f1eea11afb3a57db2901447d9fb59", size = 156757, upload-time = "2025-05-28T14:22:24.135Z" },
 ]

 [[package]]
@@ -5793,6 +5762,33 @@ wheels = [
    { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" },
 ]

+[[package]]
+name = "shapely"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", hash = "sha256:2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9", size = 315489, upload-time = "2025-09-24T13:51:41.432Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/8d/1ff672dea9ec6a7b5d422eb6d095ed886e2e523733329f75fdcb14ee1149/shapely-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:91121757b0a36c9aac3427a651a7e6567110a4a67c97edf04f8d55d4765f6618", size = 1820038, upload-time = "2025-09-24T13:50:15.628Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/ce/28fab8c772ce5db23a0d86bf0adaee0c4c79d5ad1db766055fa3dab442e2/shapely-2.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:16a9c722ba774cf50b5d4541242b4cce05aafd44a015290c82ba8a16931ff63d", size = 1626039, upload-time = "2025-09-24T13:50:16.881Z" },
+    { url = "https://files.pythonhosted.org/packages/70/8b/868b7e3f4982f5006e9395c1e12343c66a8155c0374fdc07c0e6a1ab547d/shapely-2.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cc4f7397459b12c0b196c9efe1f9d7e92463cbba142632b4cc6d8bbbbd3e2b09", size = 3001519, upload-time = "2025-09-24T13:50:18.606Z" },
+    { url = "https://files.pythonhosted.org/packages/13/02/58b0b8d9c17c93ab6340edd8b7308c0c5a5b81f94ce65705819b7416dba5/shapely-2.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:136ab87b17e733e22f0961504d05e77e7be8c9b5a8184f685b4a91a84efe3c26", size = 3110842, upload-time = "2025-09-24T13:50:21.77Z" },
+    { url = "https://files.pythonhosted.org/packages/af/61/8e389c97994d5f331dcffb25e2fa761aeedfb52b3ad9bcdd7b8671f4810a/shapely-2.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:16c5d0fc45d3aa0a69074979f4f1928ca2734fb2e0dde8af9611e134e46774e7", size = 4021316, upload-time = "2025-09-24T13:50:23.626Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/d4/9b2a9fe6039f9e42ccf2cb3e84f219fd8364b0c3b8e7bbc857b5fbe9c14c/shapely-2.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6ddc759f72b5b2b0f54a7e7cde44acef680a55019eb52ac63a7af2cf17cb9cd2", size = 4178586, upload-time = "2025-09-24T13:50:25.443Z" },
+    { url = "https://files.pythonhosted.org/packages/16/f6/9840f6963ed4decf76b08fd6d7fed14f8779fb7a62cb45c5617fa8ac6eab/shapely-2.1.2-cp311-cp311-win32.whl", hash = "sha256:2fa78b49485391224755a856ed3b3bd91c8455f6121fee0db0e71cefb07d0ef6", size = 1543961, upload-time = "2025-09-24T13:50:26.968Z" },
+    { url = "https://files.pythonhosted.org/packages/38/1e/3f8ea46353c2a33c1669eb7327f9665103aa3a8dfe7f2e4ef714c210b2c2/shapely-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:c64d5c97b2f47e3cd9b712eaced3b061f2b71234b3fc263e0fcf7d889c6559dc", size = 1722856, upload-time = "2025-09-24T13:50:28.497Z" },
+    { url = "https://files.pythonhosted.org/packages/24/c0/f3b6453cf2dfa99adc0ba6675f9aaff9e526d2224cbd7ff9c1a879238693/shapely-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe2533caae6a91a543dec62e8360fe86ffcdc42a7c55f9dfd0128a977a896b94", size = 1833550, upload-time = "2025-09-24T13:50:30.019Z" },
+    { url = "https://files.pythonhosted.org/packages/86/07/59dee0bc4b913b7ab59ab1086225baca5b8f19865e6101db9ebb7243e132/shapely-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ba4d1333cc0bc94381d6d4308d2e4e008e0bd128bdcff5573199742ee3634359", size = 1643556, upload-time = "2025-09-24T13:50:32.291Z" },
+    { url = "https://files.pythonhosted.org/packages/26/29/a5397e75b435b9895cd53e165083faed5d12fd9626eadec15a83a2411f0f/shapely-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0bd308103340030feef6c111d3eb98d50dc13feea33affc8a6f9fa549e9458a3", size = 2988308, upload-time = "2025-09-24T13:50:33.862Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/37/e781683abac55dde9771e086b790e554811a71ed0b2b8a1e789b7430dd44/shapely-2.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1e7d4d7ad262a48bb44277ca12c7c78cb1b0f56b32c10734ec9a1d30c0b0c54b", size = 3099844, upload-time = "2025-09-24T13:50:35.459Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/f3/9876b64d4a5a321b9dc482c92bb6f061f2fa42131cba643c699f39317cb9/shapely-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e9eddfe513096a71896441a7c37db72da0687b34752c4e193577a145c71736fc", size = 3988842, upload-time = "2025-09-24T13:50:37.478Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a0/704c7292f7014c7e74ec84eddb7b109e1fbae74a16deae9c1504b1d15565/shapely-2.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:980c777c612514c0cf99bc8a9de6d286f5e186dcaf9091252fcd444e5638193d", size = 4152714, upload-time = "2025-09-24T13:50:39.9Z" },
+    { url = "https://files.pythonhosted.org/packages/53/46/319c9dc788884ad0785242543cdffac0e6530e4d0deb6c4862bc4143dcf3/shapely-2.1.2-cp312-cp312-win32.whl", hash = "sha256:9111274b88e4d7b54a95218e243282709b330ef52b7b86bc6aaf4f805306f454", size = 1542745, upload-time = "2025-09-24T13:50:41.414Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/bf/cb6c1c505cb31e818e900b9312d514f381fbfa5c4363edfce0fcc4f8c1a4/shapely-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:743044b4cfb34f9a67205cee9279feaf60ba7d02e69febc2afc609047cb49179", size = 1722861, upload-time = "2025-09-24T13:50:43.35Z" },
+]
+
 [[package]]
 name = "shellingham"
 version = "1.5.4"
@@ -6818,12 +6814,12 @@ wheels = [

 [[package]]
 name = "unstructured"
-version = "0.18.31"
+version = "0.16.25"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "backoff" },
    { name = "beautifulsoup4" },
-    { name = "charset-normalizer" },
+    { name = "chardet" },
    { name = "dataclasses-json" },
    { name = "emoji" },
    { name = "filetype" },
@@ -6831,7 +6827,6 @@ dependencies = [
    { name = "langdetect" },
    { name = "lxml" },
    { name = "nltk" },
-    { name = "numba" },
    { name = "numpy" },
    { name = "psutil" },
    { name = "python-iso639" },
@@ -6844,9 +6839,9 @@ dependencies = [
    { name = "unstructured-client" },
    { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a9/5f/64285bd69a538bc28753f1423fcaa9d64cd79a9e7c097171b1f0d27e9cdb/unstructured-0.18.31.tar.gz", hash = "sha256:af4bbe32d1894ae6e755f0da6fc0dd307a1d0adeebe0e7cc6278f6cf744339ca", size = 1707700, upload-time = "2026-01-27T15:33:05.378Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/64/31/98c4c78e305d1294888adf87fd5ee30577a4c393951341ca32b43f167f1e/unstructured-0.16.25.tar.gz", hash = "sha256:73b9b0f51dbb687af572ecdb849a6811710b9cac797ddeab8ee80fa07d8aa5e6", size = 1683097, upload-time = "2025-03-07T11:19:39.507Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/4a/9c43f39d9e443c9bc3f2e379b305bca27110adc653b071221b3132c18de5/unstructured-0.18.31-py3-none-any.whl", hash = "sha256:fab4641176cb9b192ed38048758aa0d9843121d03626d18f42275afb31e5b2d3", size = 1794889, upload-time = "2026-01-27T15:33:03.136Z" },
+    { url = "https://files.pythonhosted.org/packages/12/4f/ad08585b5c8a33c82ea119494c4d3023f4796958c56e668b15cc282ec0a0/unstructured-0.16.25-py3-none-any.whl", hash = "sha256:14719ccef2830216cf1c5bf654f75e2bf07b17ca5dcee9da5ac74618130fd337", size = 1769286, upload-time = "2025-03-07T11:19:37.299Z" },
 ]

 [package.optional-dependencies]
@@ -1,5 +1,5 @@
 #!/bin/bash
-set -euxo pipefail
+set -x

 SCRIPT_DIR="$(dirname "$(realpath "$0")")"
 cd "$SCRIPT_DIR/../.."
@@ -21,7 +21,7 @@ services:

  # API service
  api:
-    image: langgenius/dify-api:1.12.1
+    image: langgenius/dify-api:1.11.4
    restart: always
    environment:
      # Use the shared environment variables.
@@ -63,7 +63,7 @@ services:
  # worker service
  # The Celery worker for processing all queues (dataset, workflow, mail, etc.)
  worker:
-    image: langgenius/dify-api:1.12.1
+    image: langgenius/dify-api:1.11.4
    restart: always
    environment:
      # Use the shared environment variables.
@@ -102,7 +102,7 @@ services:
  # worker_beat service
  # Celery beat for scheduling periodic tasks.
  worker_beat:
-    image: langgenius/dify-api:1.12.1
+    image: langgenius/dify-api:1.11.4
    restart: always
    environment:
      # Use the shared environment variables.
@@ -132,7 +132,7 @@ services:

  # Frontend web application.
  web:
-    image: langgenius/dify-web:1.12.1
+    image: langgenius/dify-web:1.11.4
    restart: always
    environment:
      CONSOLE_API_URL: ${CONSOLE_API_URL:-}
@@ -662,14 +662,13 @@ services:
      - "${IRIS_SUPER_SERVER_PORT:-1972}:1972"
      - "${IRIS_WEB_SERVER_PORT:-52773}:52773"
    volumes:
-      - ./volumes/iris:/durable
+      - ./volumes/iris:/opt/iris
      - ./iris/iris-init.script:/iris-init.script
      - ./iris/docker-entrypoint.sh:/custom-entrypoint.sh
    entrypoint: ["/custom-entrypoint.sh"]
    tty: true
    environment:
      TZ: ${IRIS_TIMEZONE:-UTC}
-      ISC_DATA_DIRECTORY: /durable/iris

  # Oracle vector database
  oracle:
@@ -707,7 +707,7 @@ services:

  # API service
  api:
-    image: langgenius/dify-api:1.12.1
+    image: langgenius/dify-api:1.11.4
    restart: always
    environment:
      # Use the shared environment variables.
@@ -749,7 +749,7 @@ services:
  # worker service
  # The Celery worker for processing all queues (dataset, workflow, mail, etc.)
  worker:
-    image: langgenius/dify-api:1.12.1
+    image: langgenius/dify-api:1.11.4
    restart: always
    environment:
      # Use the shared environment variables.
@@ -788,7 +788,7 @@ services:
  # worker_beat service
  # Celery beat for scheduling periodic tasks.
  worker_beat:
-    image: langgenius/dify-api:1.12.1
+    image: langgenius/dify-api:1.11.4
    restart: always
    environment:
      # Use the shared environment variables.
@@ -818,7 +818,7 @@ services:

  # Frontend web application.
  web:
-    image: langgenius/dify-web:1.12.1
+    image: langgenius/dify-web:1.11.4
    restart: always
    environment:
      CONSOLE_API_URL: ${CONSOLE_API_URL:-}
@@ -1348,14 +1348,13 @@ services:
      - "${IRIS_SUPER_SERVER_PORT:-1972}:1972"
      - "${IRIS_WEB_SERVER_PORT:-52773}:52773"
    volumes:
-      - ./volumes/iris:/durable
+      - ./volumes/iris:/opt/iris
      - ./iris/iris-init.script:/iris-init.script
      - ./iris/docker-entrypoint.sh:/custom-entrypoint.sh
    entrypoint: ["/custom-entrypoint.sh"]
    tty: true
    environment:
      TZ: ${IRIS_TIMEZONE:-UTC}
-      ISC_DATA_DIRECTORY: /durable/iris

  # Oracle vector database
  oracle:
@@ -1,33 +1,15 @@
 #!/bin/bash
 set -e

-# IRIS configuration flag file (stored in durable directory to persist with data)
-IRIS_CONFIG_DONE="/durable/.iris-configured"
-
-# Function to wait for IRIS to be ready
-wait_for_iris() {
-    echo "Waiting for IRIS to be ready..."
-    local max_attempts=30
-    local attempt=1
-    while [ "$attempt" -le "$max_attempts" ]; do
-        if iris qlist IRIS 2>/dev/null | grep -q "running"; then
-            echo "IRIS is ready."
-            return 0
-        fi
-        echo "Attempt $attempt/$max_attempts: IRIS not ready yet, waiting..."
-        sleep 2
-        attempt=$((attempt + 1))
-    done
-    echo "ERROR: IRIS failed to start within expected time." >&2
-    return 1
-}
+# IRIS configuration flag file
+IRIS_CONFIG_DONE="/opt/iris/.iris-configured"

 # Function to configure IRIS
 configure_iris() {
    echo "Configuring IRIS for first-time setup..."

    # Wait for IRIS to be fully started
-    wait_for_iris
+    sleep 5

    # Execute the initialization script
    iris session IRIS < /iris-init.script
@@ -3,7 +3,7 @@
 import type { ReactNode } from 'react'
 import Cookies from 'js-cookie'
 import { usePathname, useRouter, useSearchParams } from 'next/navigation'
-import { parseAsBoolean, useQueryState } from 'nuqs'
+import { parseAsString, useQueryState } from 'nuqs'
 import { useCallback, useEffect, useState } from 'react'
 import {
  EDUCATION_VERIFY_URL_SEARCHPARAMS_ACTION,
@@ -28,7 +28,7 @@ export const AppInitializer = ({
  const [init, setInit] = useState(false)
  const [oauthNewUser, setOauthNewUser] = useQueryState(
    'oauth_new_user',
-    parseAsBoolean.withOptions({ history: 'replace' }),
+    parseAsString.withOptions({ history: 'replace' }),
  )

  const isSetupFinished = useCallback(async () => {
@@ -46,7 +46,7 @@ export const AppInitializer = ({
    (async () => {
      const action = searchParams.get('action')

-      if (oauthNewUser) {
+      if (oauthNewUser === 'true') {
        let utmInfo = null
        const utmInfoStr = Cookies.get('utm_info')
        if (utmInfoStr) {
@@ -109,7 +109,6 @@ const AgentTools: FC = () => {
      tool_parameters: paramsWithDefaultValue,
      notAuthor: !tool.is_team_authorization,
      enabled: true,
-      type: tool.provider_type as CollectionType,
    }
  }
  const handleSelectTool = (tool: ToolDefaultValue) => {
@@ -19,21 +19,19 @@ import { useBoolean, useSessionStorageState } from 'ahooks'
 import * as React from 'react'
 import { useCallback, useEffect, useState } from 'react'
 import { useTranslation } from 'react-i18next'
-import { useShallow } from 'zustand/react/shallow'
 import Button from '@/app/components/base/button'
 import Confirm from '@/app/components/base/confirm'
 import { Generator } from '@/app/components/base/icons/src/vender/other'
-
 import Loading from '@/app/components/base/loading'
+
 import Modal from '@/app/components/base/modal'
 import Toast from '@/app/components/base/toast'
-
 import { ModelTypeEnum } from '@/app/components/header/account-setting/model-provider-page/declarations'
+
 import { useModelListAndDefaultModelAndCurrentProviderAndModel } from '@/app/components/header/account-setting/model-provider-page/hooks'
 import ModelParameterModal from '@/app/components/header/account-setting/model-provider-page/model-parameter-modal'
 import { generateBasicAppFirstTimeRule, generateRule } from '@/service/debug'
 import { useGenerateRuleTemplate } from '@/service/use-apps'
-import { useStore } from '../../../store'
 import IdeaOutput from './idea-output'
 import InstructionEditorInBasic from './instruction-editor'
 import InstructionEditorInWorkflow from './instruction-editor-in-workflow'
@@ -85,9 +83,6 @@ const GetAutomaticRes: FC<IGetAutomaticResProps> = ({
  onFinished,
 }) => {
  const { t } = useTranslation()
-  const { appDetail } = useStore(useShallow(state => ({
-    appDetail: state.appDetail,
-  })))
  const localModel = localStorage.getItem('auto-gen-model')
    ? JSON.parse(localStorage.getItem('auto-gen-model') as string) as Model
    : null
@@ -240,7 +235,6 @@ const GetAutomaticRes: FC<IGetAutomaticResProps> = ({
          instruction,
          model_config: model,
          no_variable: false,
-          app_id: appDetail?.id,
        })
        apiRes = {
          ...res,
@@ -262,7 +256,6 @@ const GetAutomaticRes: FC<IGetAutomaticResProps> = ({
          instruction,
          ideal_output: ideaOutput,
          model_config: model,
-          app_id: appDetail?.id,
        })
        apiRes = res
        if (error) {
@@ -62,19 +62,19 @@ const AppCard = ({
          {app.description}
        </div>
      </div>
-      {(canCreate || isTrialApp) && (
+      {canCreate && (
        <div className={cn('absolute bottom-0 left-0 right-0 hidden bg-gradient-to-t from-components-panel-gradient-2 from-[60.27%] to-transparent p-4 pt-8 group-hover:flex')}>
-          <div className={cn('grid h-8 w-full grid-cols-1 items-center space-x-2', canCreate && 'grid-cols-2')}>
-            {canCreate && (
-              <Button variant="primary" onClick={() => onCreate()}>
-                <PlusIcon className="mr-1 h-4 w-4" />
-                <span className="text-xs">{t('newApp.useTemplate', { ns: 'app' })}</span>
+          <div className={cn('grid h-8 w-full grid-cols-1 items-center space-x-2', isTrialApp && 'grid-cols-2')}>
+            <Button variant="primary" onClick={() => onCreate()}>
+              <PlusIcon className="mr-1 h-4 w-4" />
+              <span className="text-xs">{t('newApp.useTemplate', { ns: 'app' })}</span>
+            </Button>
+            {isTrialApp && (
+              <Button onClick={showTryAPPPanel(app.app_id)}>
+                <RiInformation2Line className="mr-1 size-4" />
+                <span>{t('appCard.try', { ns: 'explore' })}</span>
              </Button>
            )}
-            <Button onClick={showTryAPPPanel(app.app_id)}>
-              <RiInformation2Line className="mr-1 size-4" />
-              <span>{t('appCard.try', { ns: 'explore' })}</span>
-            </Button>
          </div>
        </div>
      )}
@@ -154,7 +154,7 @@ export const GeneralChunkingOptions: FC<GeneralChunkingOptionsProps> = ({
              </div>
            ))}
            {
-              showSummaryIndexSetting && IS_CE_EDITION && (
+              showSummaryIndexSetting && (
                <div className="mt-3">
                  <SummaryIndexSetting
                    entry="create-document"
@@ -12,7 +12,6 @@ import Divider from '@/app/components/base/divider'
 import { ParentChildChunk } from '@/app/components/base/icons/src/vender/knowledge'
 import RadioCard from '@/app/components/base/radio-card'
 import SummaryIndexSetting from '@/app/components/datasets/settings/summary-index-setting'
-import { IS_CE_EDITION } from '@/config'
 import { ChunkingMode } from '@/models/datasets'
 import FileList from '../../assets/file-list-3-fill.svg'
 import Note from '../../assets/note-mod.svg'
@@ -192,7 +191,7 @@ export const ParentChildOptions: FC<ParentChildOptionsProps> = ({
              </div>
            ))}
            {
-              showSummaryIndexSetting && IS_CE_EDITION && (
+              showSummaryIndexSetting && (
                <div className="mt-3">
                  <SummaryIndexSetting
                    entry="create-document"
@@ -26,7 +26,6 @@ import CustomPopover from '@/app/components/base/popover'
 import Switch from '@/app/components/base/switch'
 import { ToastContext } from '@/app/components/base/toast'
 import Tooltip from '@/app/components/base/tooltip'
-import { IS_CE_EDITION } from '@/config'
 import { DataSourceType, DocumentActionType } from '@/models/datasets'
 import {
  useDocumentArchive,
@@ -264,14 +263,10 @@ const Operations = ({
                        <span className={s.actionName}>{t('list.action.sync', { ns: 'datasetDocuments' })}</span>
                      </div>
                    )}
-                    {
-                      IS_CE_EDITION && (
-                        <div className={s.actionItem} onClick={() => onOperate('summary')}>
-                          <SearchLinesSparkle className="h-4 w-4 text-text-tertiary" />
-                          <span className={s.actionName}>{t('list.action.summary', { ns: 'datasetDocuments' })}</span>
-                        </div>
-                      )
-                    }
+                    <div className={s.actionItem} onClick={() => onOperate('summary')}>
+                      <SearchLinesSparkle className="h-4 w-4 text-text-tertiary" />
+                      <span className={s.actionName}>{t('list.action.summary', { ns: 'datasetDocuments' })}</span>
+                    </div>
                    <Divider className="my-1" />
                  </>
                )}
@@ -7,7 +7,6 @@ import Button from '@/app/components/base/button'
 import Confirm from '@/app/components/base/confirm'
 import Divider from '@/app/components/base/divider'
 import { SearchLinesSparkle } from '@/app/components/base/icons/src/vender/knowledge'
-import { IS_CE_EDITION } from '@/config'
 import { cn } from '@/utils/classnames'

 const i18nPrefix = 'batchAction'
@@ -88,7 +87,7 @@ const BatchAction: FC<IBatchActionProps> = ({
            <span className="px-0.5">{t('metadata.metadata', { ns: 'dataset' })}</span>
          </Button>
        )}
-        {onBatchSummary && IS_CE_EDITION && (
+        {onBatchSummary && (
          <Button
            variant="ghost"
            className="gap-x-0.5 px-3"
@@ -3,6 +3,8 @@ import type { FC, ReactNode } from 'react'
 import type { SliceProps } from './type'
 import { autoUpdate, flip, FloatingFocusManager, offset, shift, useDismiss, useFloating, useHover, useInteractions, useRole } from '@floating-ui/react'
 import { RiDeleteBinLine } from '@remixicon/react'
+// @ts-expect-error no types available
+import lineClamp from 'line-clamp'
 import { useState } from 'react'
 import ActionButton, { ActionButtonState } from '@/app/components/base/action-button'
 import { cn } from '@/utils/classnames'
@@ -56,8 +58,12 @@ export const EditSlice: FC<EditSliceProps> = (props) => {
    <>
      <SliceContainer
        {...rest}
-        className={cn('mr-0 line-clamp-4 block', className)}
-        ref={refs.setReference}
+        className={cn('mr-0 block', className)}
+        ref={(ref) => {
+          refs.setReference(ref)
+          if (ref)
+            lineClamp(ref, 4)
+        }}
        {...getReferenceProps()}
      >
        <SliceLabel
@@ -21,7 +21,6 @@ import RetrievalMethodConfig from '@/app/components/datasets/common/retrieval-me
 import { ModelTypeEnum } from '@/app/components/header/account-setting/model-provider-page/declarations'
 import { useModelList } from '@/app/components/header/account-setting/model-provider-page/hooks'
 import ModelSelector from '@/app/components/header/account-setting/model-provider-page/model-selector'
-import { IS_CE_EDITION } from '@/config'
 import { useSelector as useAppContextWithSelector } from '@/context/app-context'
 import { useDatasetDetailContextWithSelector } from '@/context/dataset-detail'
 import { useDocLink } from '@/context/i18n'
@@ -360,7 +359,7 @@ const Form = () => {
      {
        indexMethod === IndexingType.QUALIFIED
        && [ChunkingMode.text, ChunkingMode.parentChild].includes(currentDataset?.doc_form as ChunkingMode)
-        && IS_CE_EDITION && (
+        && (
          <>
            <Divider
              type="horizontal"
@@ -74,15 +74,11 @@ const AppCard = ({
      </div>
      {isExplore && (canCreate || isTrialApp) && (
        <div className={cn('absolute bottom-0 left-0 right-0 hidden bg-gradient-to-t from-components-panel-gradient-2 from-[60.27%] to-transparent p-4 pt-8 group-hover:flex')}>
-          <div className={cn('grid h-8 w-full grid-cols-1 space-x-2', canCreate && 'grid-cols-2')}>
-            {
-              canCreate && (
-                <Button variant="primary" className="h-7" onClick={() => onCreate()}>
-                  <PlusIcon className="mr-1 h-4 w-4" />
-                  <span className="text-xs">{t('appCard.addToWorkspace', { ns: 'explore' })}</span>
-                </Button>
-              )
-            }
+          <div className={cn('grid h-8 w-full grid-cols-2 space-x-2')}>
+            <Button variant="primary" className="h-7" onClick={() => onCreate()}>
+              <PlusIcon className="mr-1 h-4 w-4" />
+              <span className="text-xs">{t('appCard.addToWorkspace', { ns: 'explore' })}</span>
+            </Button>
            <Button className="h-7" onClick={showTryAPPPanel(app.app_id)}>
              <RiInformation2Line className="mr-1 size-4" />
              <span>{t('appCard.try', { ns: 'explore' })}</span>
@@ -16,14 +16,6 @@ vi.mock('react-i18next', () => ({
  }),
 }))

-vi.mock('@/config', async (importOriginal) => {
-  const actual = await importOriginal() as object
-  return {
-    ...actual,
-    IS_CLOUD_EDITION: true,
-  }
-})
-
 const mockUseGetTryAppInfo = vi.fn()

 vi.mock('@/service/use-try-app', () => ({
@@ -14,14 +14,6 @@ vi.mock('react-i18next', () => ({
  }),
 }))

-vi.mock('@/config', async (importOriginal) => {
-  const actual = await importOriginal() as object
-  return {
-    ...actual,
-    IS_CLOUD_EDITION: true,
-  }
-})
-
 describe('Tab', () => {
  afterEach(() => {
    cleanup()
@@ -104,7 +104,7 @@ const MembersPage = () => {
            <UpgradeBtn className="mr-2" loc="member-invite" />
          )}
          <div className="shrink-0">
-            {isCurrentWorkspaceManager && <InviteButton disabled={isMemberFull} onClick={() => setInviteModalVisible(true)} />}
+            <InviteButton disabled={!isCurrentWorkspaceManager || isMemberFull} onClick={() => setInviteModalVisible(true)} />
          </div>
        </div>
        <div className="overflow-visible lg:overflow-visible">
@@ -1,5 +1,5 @@
 import type { TriggerSubscriptionBuilder } from '@/app/components/workflow/block-selector/types'
-import { act, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { fireEvent, render, screen, waitFor } from '@testing-library/react'
 import * as React from 'react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 // Import after mocks
@@ -821,9 +821,6 @@ describe('CommonCreateModal', () => {
        expect(mockCreateBuilder).toHaveBeenCalled()
      })

-      // Flush pending state updates from createBuilder promise resolution
-      await act(async () => {})
-
      const input = screen.getByTestId('form-field-webhook_url')
      fireEvent.change(input, { target: { value: 'https://example.com/webhook' } })

@@ -129,7 +129,6 @@ export const useToolSelectorState = ({
      extra: {
        description: tool.tool_description,
      },
-      type: tool.provider_type,
    }
  }, [])

@@ -1,5 +1,5 @@
 import type { PropsWithChildren } from 'react'
-import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { DSLImportStatus } from '@/models/app'
 import UpdateDSLModal from './update-dsl-modal'
@@ -140,13 +140,13 @@ class MockFileReader {
  onload: ((e: { target: { result: string | null } }) => void) | null = null

  readAsText(_file: File) {
-    // Simulate async file reading using queueMicrotask for more reliable async behavior
-    queueMicrotask(() => {
+    // Simulate async file reading
+    setTimeout(() => {
      this.result = 'test file content'
      if (this.onload) {
        this.onload({ target: { result: this.result } })
      }
-    })
+    }, 0)
  }
 }

@@ -174,7 +174,6 @@ describe('UpdateDSLModal', () => {
      status: DSLImportStatus.COMPLETED,
      pipeline_id: 'test-pipeline-id',
    })
-    mockHandleCheckPluginDependencies.mockResolvedValue(undefined)

    // Mock FileReader
    originalFileReader = globalThis.FileReader
@@ -473,14 +472,14 @@ describe('UpdateDSLModal', () => {
      await waitFor(() => {
        const importButton = screen.getByText('common.overwriteAndImport')
        expect(importButton).not.toBeDisabled()
-      }, { timeout: 1000 })
+      })

      const importButton = screen.getByText('common.overwriteAndImport')
      fireEvent.click(importButton)

      await waitFor(() => {
        expect(mockOnImport).toHaveBeenCalled()
-      }, { timeout: 1000 })
+      })
    })

    it('should show warning notification on import with warnings', async () => {
@@ -648,8 +647,6 @@ describe('UpdateDSLModal', () => {
    })

    it('should show error modal when import status is PENDING', async () => {
-      vi.useFakeTimers({ shouldAdvanceTime: true })
-
      mockImportDSL.mockResolvedValue({
        id: 'import-id',
        status: DSLImportStatus.PENDING,
@@ -662,29 +659,20 @@ describe('UpdateDSLModal', () => {

      const fileInput = screen.getByTestId('file-input')
      const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
+      fireEvent.change(fileInput, { target: { files: [file] } })

-      await act(async () => {
-        fireEvent.change(fileInput, { target: { files: [file] } })
-        // Flush microtasks scheduled by the FileReader mock (which uses queueMicrotask)
-        await new Promise<void>(resolve => queueMicrotask(resolve))
+      await waitFor(() => {
+        const importButton = screen.getByText('common.overwriteAndImport')
+        expect(importButton).not.toBeDisabled()
      })

      const importButton = screen.getByText('common.overwriteAndImport')
-      expect(importButton).not.toBeDisabled()
-
-      await act(async () => {
-        fireEvent.click(importButton)
-        // Flush the promise resolution from mockImportDSL
-        await Promise.resolve()
-        // Advance past the 300ms setTimeout in the component
-        await vi.advanceTimersByTimeAsync(350)
-      })
+      fireEvent.click(importButton)

+      // Wait for the error modal to be shown after setTimeout
      await waitFor(() => {
        expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
-      })
-
-      vi.useRealTimers()
+      }, { timeout: 500 })
    })

    it('should show version info in error modal', async () => {
@@ -61,12 +61,6 @@ vi.mock('@/service/use-pipeline', () => ({
  }),
 }))

-// Mock download utility
-const mockDownloadBlob = vi.fn()
-vi.mock('@/utils/download', () => ({
-  downloadBlob: (...args: unknown[]) => mockDownloadBlob(...args),
-}))
-
 // Mock workflow service
 const mockFetchWorkflowDraft = vi.fn()
 vi.mock('@/service/workflow', () => ({
@@ -83,9 +77,33 @@ vi.mock('@/app/components/workflow/constants', () => ({
 // ============================================================================

 describe('useDSL', () => {
+  let mockLink: { href: string, download: string, click: ReturnType<typeof vi.fn> }
+  let originalCreateElement: typeof document.createElement
+  let mockCreateObjectURL: ReturnType<typeof vi.spyOn>
+  let mockRevokeObjectURL: ReturnType<typeof vi.spyOn>
+
  beforeEach(() => {
    vi.clearAllMocks()

+    // Create a proper mock link element
+    mockLink = {
+      href: '',
+      download: '',
+      click: vi.fn(),
+    }
+
+    // Save original and mock selectively - only intercept 'a' elements
+    originalCreateElement = document.createElement.bind(document)
+    document.createElement = vi.fn((tagName: string) => {
+      if (tagName === 'a') {
+        return mockLink as unknown as HTMLElement
+      }
+      return originalCreateElement(tagName)
+    }) as typeof document.createElement
+
+    mockCreateObjectURL = vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:test-url')
+    mockRevokeObjectURL = vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {})
+
    // Default store state
    mockWorkflowStoreGetState.mockReturnValue({
      pipelineId: 'test-pipeline-id',
@@ -100,6 +118,9 @@ describe('useDSL', () => {
  })

  afterEach(() => {
+    document.createElement = originalCreateElement
+    mockCreateObjectURL.mockRestore()
+    mockRevokeObjectURL.mockRestore()
    vi.clearAllMocks()
  })

@@ -166,7 +187,9 @@ describe('useDSL', () => {
        await result.current.handleExportDSL()
      })

-      expect(mockDownloadBlob).toHaveBeenCalled()
+      expect(document.createElement).toHaveBeenCalledWith('a')
+      expect(mockCreateObjectURL).toHaveBeenCalled()
+      expect(mockRevokeObjectURL).toHaveBeenCalledWith('blob:test-url')
    })

    it('should use correct file extension for download', async () => {
@@ -176,25 +199,17 @@ describe('useDSL', () => {
        await result.current.handleExportDSL()
      })

-      expect(mockDownloadBlob).toHaveBeenCalledWith(
-        expect.objectContaining({
-          fileName: 'Test Knowledge Base.pipeline',
-        }),
-      )
+      expect(mockLink.download).toBe('Test Knowledge Base.pipeline')
    })

-    it('should pass blob data to downloadBlob', async () => {
+    it('should trigger download click', async () => {
      const { result } = renderHook(() => useDSL())

      await act(async () => {
        await result.current.handleExportDSL()
      })

-      expect(mockDownloadBlob).toHaveBeenCalledWith(
-        expect.objectContaining({
-          data: expect.any(Blob),
-        }),
-      )
+      expect(mockLink.click).toHaveBeenCalled()
    })

    it('should show error notification on export failure', async () => {
@@ -172,9 +172,6 @@ describe('EditCustomCollectionModal', () => {
        expect(parseParamsSchemaMock).toHaveBeenCalledWith('{}')
      })

-      // Flush pending state updates from parseParamsSchema promise resolution
-      await act(async () => {})
-
      await act(async () => {
        fireEvent.click(screen.getByText('common.operation.save'))
      })
@@ -187,10 +184,6 @@ describe('EditCustomCollectionModal', () => {
          credentials: {
            auth_type: 'none',
          },
-          icon: {
-            content: '🕵️',
-            background: '#FEF7C3',
-          },
          labels: [],
        }))
        expect(toastNotifySpy).not.toHaveBeenCalled()
@@ -0,0 +1,705 @@
+/**
+ * Test Suite for useNodesSyncDraft Hook
+ *
+ * PURPOSE:
+ * This hook handles syncing workflow draft to the server. The key fix being tested
+ * is the error handling behavior when `draft_workflow_not_sync` error occurs.
+ *
+ * MULTI-TAB PROBLEM SCENARIO:
+ * 1. User opens the same workflow in Tab A and Tab B (both have hash: v1)
+ * 2. Tab A saves successfully, server returns new hash: v2
+ * 3. Tab B tries to save with old hash: v1, server returns 400 error with code
+ *    'draft_workflow_not_sync'
+ * 4. BEFORE FIX: handleRefreshWorkflowDraft() was called without args, which fetched
+ *    draft AND overwrote canvas - user lost unsaved changes in Tab B
+ * 5. AFTER FIX: handleRefreshWorkflowDraft(true) is called, which fetches draft but
+ *    only updates hash (notUpdateCanvas=true), preserving user's canvas changes
+ *
+ * TESTING STRATEGY:
+ * We don't simulate actual tab switching UI behavior. Instead, we mock the API to
+ * return `draft_workflow_not_sync` error and verify:
+ * - The hook calls handleRefreshWorkflowDraft(true) - not handleRefreshWorkflowDraft()
+ * - This ensures canvas data is preserved while hash is updated for retry
+ *
+ * This is behavior-driven testing - we verify "what the code does when receiving
+ * specific API errors" rather than simulating complete user interaction flows.
+ * True multi-tab integration testing would require E2E frameworks like Playwright.
+ */
+
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useNodesSyncDraft } from './use-nodes-sync-draft'
+
+// Mock reactflow store
+const mockGetNodes = vi.fn()
+
+type MockEdge = {
+  id: string
+  source: string
+  target: string
+  data: Record<string, unknown>
+}
+
+const mockStoreState: {
+  getNodes: ReturnType<typeof vi.fn>
+  edges: MockEdge[]
+  transform: number[]
+} = {
+  getNodes: mockGetNodes,
+  edges: [],
+  transform: [0, 0, 1],
+}
+vi.mock('reactflow', () => ({
+  useStoreApi: () => ({
+    getState: () => mockStoreState,
+  }),
+}))
+
+// Mock features store
+const mockFeaturesState = {
+  features: {
+    opening: { enabled: false, opening_statement: '', suggested_questions: [] },
+    suggested: {},
+    text2speech: {},
+    speech2text: {},
+    citation: {},
+    moderation: {},
+    file: {},
+  },
+}
+vi.mock('@/app/components/base/features/hooks', () => ({
+  useFeaturesStore: () => ({
+    getState: () => mockFeaturesState,
+  }),
+}))
+
+// Mock workflow service
+const mockSyncWorkflowDraft = vi.fn()
+vi.mock('@/service/workflow', () => ({
+  syncWorkflowDraft: (...args: unknown[]) => mockSyncWorkflowDraft(...args),
+}))
+
+// Mock useNodesReadOnly
+const mockGetNodesReadOnly = vi.fn()
+vi.mock('@/app/components/workflow/hooks/use-workflow', () => ({
+  useNodesReadOnly: () => ({
+    getNodesReadOnly: mockGetNodesReadOnly,
+  }),
+}))
+
+// Mock useSerialAsyncCallback - pass through the callback
+vi.mock('@/app/components/workflow/hooks/use-serial-async-callback', () => ({
+  useSerialAsyncCallback: (callback: (...args: unknown[]) => unknown) => callback,
+}))
+
+// Mock workflow store
+const mockSetSyncWorkflowDraftHash = vi.fn()
+const mockSetDraftUpdatedAt = vi.fn()
+
+const createMockWorkflowStoreState = (overrides = {}) => ({
+  appId: 'test-app-id',
+  conversationVariables: [],
+  environmentVariables: [],
+  syncWorkflowDraftHash: 'current-hash-123',
+  isWorkflowDataLoaded: true,
+  setSyncWorkflowDraftHash: mockSetSyncWorkflowDraftHash,
+  setDraftUpdatedAt: mockSetDraftUpdatedAt,
+  ...overrides,
+})
+
+const mockWorkflowStoreGetState = vi.fn()
+vi.mock('@/app/components/workflow/store', () => ({
+  useWorkflowStore: () => ({
+    getState: mockWorkflowStoreGetState,
+  }),
+}))
+
+// Mock useWorkflowRefreshDraft (THE KEY DEPENDENCY FOR THIS TEST)
+const mockHandleRefreshWorkflowDraft = vi.fn()
+vi.mock('.', () => ({
+  useWorkflowRefreshDraft: () => ({
+    handleRefreshWorkflowDraft: mockHandleRefreshWorkflowDraft,
+  }),
+}))
+
+// Mock API_PREFIX
+vi.mock('@/config', () => ({
+  API_PREFIX: '/api',
+}))
+
+// Create a mock error response that mimics the actual API error
+const createMockErrorResponse = (code: string) => {
+  const errorBody = { code, message: 'Draft not in sync' }
+  let bodyUsed = false
+
+  return {
+    json: vi.fn().mockImplementation(() => {
+      bodyUsed = true
+      return Promise.resolve(errorBody)
+    }),
+    get bodyUsed() {
+      return bodyUsed
+    },
+  }
+}
+
+describe('useNodesSyncDraft', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockGetNodesReadOnly.mockReturnValue(false)
+    mockGetNodes.mockReturnValue([
+      { id: 'node-1', type: 'start', data: { type: 'start' } },
+      { id: 'node-2', type: 'llm', data: { type: 'llm' } },
+    ])
+    mockStoreState.edges = [
+      { id: 'edge-1', source: 'node-1', target: 'node-2', data: {} },
+    ]
+    mockWorkflowStoreGetState.mockReturnValue(createMockWorkflowStoreState())
+    mockSyncWorkflowDraft.mockResolvedValue({
+      hash: 'new-hash-456',
+      updated_at: Date.now(),
+    })
+  })
+
+  afterEach(() => {
+    vi.resetAllMocks()
+  })
+
+  describe('doSyncWorkflowDraft function', () => {
+    it('should return doSyncWorkflowDraft function', () => {
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      expect(result.current.doSyncWorkflowDraft).toBeDefined()
+      expect(typeof result.current.doSyncWorkflowDraft).toBe('function')
+    })
+
+    it('should return syncWorkflowDraftWhenPageClose function', () => {
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      expect(result.current.syncWorkflowDraftWhenPageClose).toBeDefined()
+      expect(typeof result.current.syncWorkflowDraftWhenPageClose).toBe('function')
+    })
+  })
+
+  describe('successful sync', () => {
+    it('should call syncWorkflowDraft service on successful sync', async () => {
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      expect(mockSyncWorkflowDraft).toHaveBeenCalledWith({
+        url: '/apps/test-app-id/workflows/draft',
+        params: expect.objectContaining({
+          hash: 'current-hash-123',
+          graph: expect.objectContaining({
+            nodes: expect.any(Array),
+            edges: expect.any(Array),
+            viewport: expect.any(Object),
+          }),
+        }),
+      })
+    })
+
+    it('should update syncWorkflowDraftHash on success', async () => {
+      mockSyncWorkflowDraft.mockResolvedValue({
+        hash: 'new-hash-789',
+        updated_at: 1234567890,
+      })
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      expect(mockSetSyncWorkflowDraftHash).toHaveBeenCalledWith('new-hash-789')
+    })
+
+    it('should update draftUpdatedAt on success', async () => {
+      const updatedAt = 1234567890
+      mockSyncWorkflowDraft.mockResolvedValue({
+        hash: 'new-hash',
+        updated_at: updatedAt,
+      })
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      expect(mockSetDraftUpdatedAt).toHaveBeenCalledWith(updatedAt)
+    })
+
+    it('should call onSuccess callback on success', async () => {
+      const onSuccess = vi.fn()
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft(false, { onSuccess })
+      })
+
+      expect(onSuccess).toHaveBeenCalled()
+    })
+
+    it('should call onSettled callback after success', async () => {
+      const onSettled = vi.fn()
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft(false, { onSettled })
+      })
+
+      expect(onSettled).toHaveBeenCalled()
+    })
+  })
+
+  describe('sync error handling - draft_workflow_not_sync (THE KEY FIX)', () => {
+    /**
+     * This is THE KEY TEST for the bug fix.
+     *
+     * SCENARIO: Multi-tab editing
+     * 1. User opens workflow in Tab A and Tab B
+     * 2. Tab A saves draft successfully, gets new hash
+     * 3. Tab B tries to save with old hash
+     * 4. Server returns 400 with code 'draft_workflow_not_sync'
+     *
+     * BEFORE FIX:
+     * - handleRefreshWorkflowDraft() was called without arguments
+     * - This would fetch draft AND overwrite the canvas
+     * - User loses their unsaved changes in Tab B
+     *
+     * AFTER FIX:
+     * - handleRefreshWorkflowDraft(true) is called
+     * - This fetches draft but DOES NOT overwrite canvas
+     * - Only hash is updated for the next sync attempt
+     * - User's unsaved changes are preserved
+     */
+    it('should call handleRefreshWorkflowDraft with notUpdateCanvas=true when draft_workflow_not_sync error occurs', async () => {
+      const mockError = createMockErrorResponse('draft_workflow_not_sync')
+      mockSyncWorkflowDraft.mockRejectedValue(mockError)
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      // THE KEY ASSERTION: handleRefreshWorkflowDraft must be called with true
+      await waitFor(() => {
+        expect(mockHandleRefreshWorkflowDraft).toHaveBeenCalledWith(true)
+      })
+    })
+
+    it('should NOT call handleRefreshWorkflowDraft when notRefreshWhenSyncError is true', async () => {
+      const mockError = createMockErrorResponse('draft_workflow_not_sync')
+      mockSyncWorkflowDraft.mockRejectedValue(mockError)
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        // First parameter is notRefreshWhenSyncError
+        await result.current.doSyncWorkflowDraft(true)
+      })
+
+      // Wait a bit for async operations
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      expect(mockHandleRefreshWorkflowDraft).not.toHaveBeenCalled()
+    })
+
+    it('should call onError callback when draft_workflow_not_sync error occurs', async () => {
+      const mockError = createMockErrorResponse('draft_workflow_not_sync')
+      mockSyncWorkflowDraft.mockRejectedValue(mockError)
+      const onError = vi.fn()
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft(false, { onError })
+      })
+
+      expect(onError).toHaveBeenCalled()
+    })
+
+    it('should call onSettled callback after error', async () => {
+      const mockError = createMockErrorResponse('draft_workflow_not_sync')
+      mockSyncWorkflowDraft.mockRejectedValue(mockError)
+      const onSettled = vi.fn()
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft(false, { onSettled })
+      })
+
+      expect(onSettled).toHaveBeenCalled()
+    })
+  })
+
+  describe('other error handling', () => {
+    it('should NOT call handleRefreshWorkflowDraft for non-draft_workflow_not_sync errors', async () => {
+      const mockError = createMockErrorResponse('some_other_error')
+      mockSyncWorkflowDraft.mockRejectedValue(mockError)
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      // Wait a bit for async operations
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      expect(mockHandleRefreshWorkflowDraft).not.toHaveBeenCalled()
+    })
+
+    it('should handle error without json method', async () => {
+      const mockError = new Error('Network error')
+      mockSyncWorkflowDraft.mockRejectedValue(mockError)
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+      const onError = vi.fn()
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft(false, { onError })
+      })
+
+      expect(onError).toHaveBeenCalled()
+      expect(mockHandleRefreshWorkflowDraft).not.toHaveBeenCalled()
+    })
+
+    it('should handle error with bodyUsed already true', async () => {
+      const mockError = {
+        json: vi.fn(),
+        bodyUsed: true,
+      }
+      mockSyncWorkflowDraft.mockRejectedValue(mockError)
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      // Should not call json() when bodyUsed is true
+      expect(mockError.json).not.toHaveBeenCalled()
+      expect(mockHandleRefreshWorkflowDraft).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('read-only mode', () => {
+    it('should not sync when nodes are read-only', async () => {
+      mockGetNodesReadOnly.mockReturnValue(true)
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
+    })
+
+    it('should not sync on page close when nodes are read-only', () => {
+      mockGetNodesReadOnly.mockReturnValue(true)
+
+      // Mock sendBeacon
+      const mockSendBeacon = vi.fn()
+      Object.defineProperty(navigator, 'sendBeacon', {
+        value: mockSendBeacon,
+        writable: true,
+      })
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      act(() => {
+        result.current.syncWorkflowDraftWhenPageClose()
+      })
+
+      expect(mockSendBeacon).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('workflow data not loaded', () => {
+    it('should not sync when workflow data is not loaded', async () => {
+      mockWorkflowStoreGetState.mockReturnValue(
+        createMockWorkflowStoreState({ isWorkflowDataLoaded: false }),
+      )
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('no appId', () => {
+    it('should not sync when appId is not set', async () => {
+      mockWorkflowStoreGetState.mockReturnValue(
+        createMockWorkflowStoreState({ appId: null }),
+      )
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      expect(mockSyncWorkflowDraft).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('node filtering', () => {
+    it('should filter out temp nodes', async () => {
+      mockGetNodes.mockReturnValue([
+        { id: 'node-1', type: 'start', data: { type: 'start' } },
+        { id: 'node-temp', type: 'custom', data: { type: 'custom', _isTempNode: true } },
+        { id: 'node-2', type: 'llm', data: { type: 'llm' } },
+      ])
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      expect(mockSyncWorkflowDraft).toHaveBeenCalledWith(
+        expect.objectContaining({
+          params: expect.objectContaining({
+            graph: expect.objectContaining({
+              nodes: expect.not.arrayContaining([
+                expect.objectContaining({ id: 'node-temp' }),
+              ]),
+            }),
+          }),
+        }),
+      )
+    })
+
+    it('should remove internal underscore properties from nodes', async () => {
+      mockGetNodes.mockReturnValue([
+        {
+          id: 'node-1',
+          type: 'start',
+          data: {
+            type: 'start',
+            _internalProp: 'should be removed',
+            _anotherInternal: true,
+            publicProp: 'should remain',
+          },
+        },
+      ])
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      const callArgs = mockSyncWorkflowDraft.mock.calls[0][0]
+      const sentNode = callArgs.params.graph.nodes[0]
+
+      expect(sentNode.data).not.toHaveProperty('_internalProp')
+      expect(sentNode.data).not.toHaveProperty('_anotherInternal')
+      expect(sentNode.data).toHaveProperty('publicProp', 'should remain')
+    })
+  })
+
+  describe('edge filtering', () => {
+    it('should filter out temp edges', async () => {
+      mockStoreState.edges = [
+        { id: 'edge-1', source: 'node-1', target: 'node-2', data: {} },
+        { id: 'edge-temp', source: 'node-1', target: 'node-3', data: { _isTemp: true } },
+      ]
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      const callArgs = mockSyncWorkflowDraft.mock.calls[0][0]
+      const sentEdges = callArgs.params.graph.edges
+
+      expect(sentEdges).toHaveLength(1)
+      expect(sentEdges[0].id).toBe('edge-1')
+    })
+
+    it('should remove internal underscore properties from edges', async () => {
+      mockStoreState.edges = [
+        {
+          id: 'edge-1',
+          source: 'node-1',
+          target: 'node-2',
+          data: {
+            _internalEdgeProp: 'should be removed',
+            publicEdgeProp: 'should remain',
+          },
+        },
+      ]
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      const callArgs = mockSyncWorkflowDraft.mock.calls[0][0]
+      const sentEdge = callArgs.params.graph.edges[0]
+
+      expect(sentEdge.data).not.toHaveProperty('_internalEdgeProp')
+      expect(sentEdge.data).toHaveProperty('publicEdgeProp', 'should remain')
+    })
+  })
+
+  describe('viewport handling', () => {
+    it('should send current viewport from transform', async () => {
+      mockStoreState.transform = [100, 200, 1.5]
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      expect(mockSyncWorkflowDraft).toHaveBeenCalledWith(
+        expect.objectContaining({
+          params: expect.objectContaining({
+            graph: expect.objectContaining({
+              viewport: { x: 100, y: 200, zoom: 1.5 },
+            }),
+          }),
+        }),
+      )
+    })
+  })
+
+  describe('multi-tab concurrent editing scenario (END-TO-END TEST)', () => {
+    /**
+     * Simulates the complete multi-tab scenario to verify the fix works correctly.
+     *
+     * Scenario:
+     * 1. Tab A and Tab B both have the workflow open with hash 'hash-v1'
+     * 2. Tab A saves successfully, server returns 'hash-v2'
+     * 3. Tab B tries to save with 'hash-v1', gets 'draft_workflow_not_sync' error
+     * 4. Tab B should only update hash to 'hash-v2', not overwrite canvas
+     * 5. Tab B can now retry save with correct hash
+     */
+    it('should preserve canvas data during hash conflict resolution', async () => {
+      // Initial state: both tabs have hash-v1
+      mockWorkflowStoreGetState.mockReturnValue(
+        createMockWorkflowStoreState({ syncWorkflowDraftHash: 'hash-v1' }),
+      )
+
+      // Tab B tries to save with old hash, server returns error
+      const syncError = createMockErrorResponse('draft_workflow_not_sync')
+      mockSyncWorkflowDraft.mockRejectedValue(syncError)
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      // Tab B attempts to sync
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      // Verify the sync was attempted with old hash
+      expect(mockSyncWorkflowDraft).toHaveBeenCalledWith(
+        expect.objectContaining({
+          params: expect.objectContaining({
+            hash: 'hash-v1',
+          }),
+        }),
+      )
+
+      // Verify handleRefreshWorkflowDraft was called with true (not overwrite canvas)
+      await waitFor(() => {
+        expect(mockHandleRefreshWorkflowDraft).toHaveBeenCalledWith(true)
+      })
+
+      // The key assertion: only one argument (true) was passed
+      expect(mockHandleRefreshWorkflowDraft).toHaveBeenCalledTimes(1)
+      expect(mockHandleRefreshWorkflowDraft.mock.calls[0]).toEqual([true])
+    })
+
+    it('should handle multiple consecutive sync failures gracefully', async () => {
+      // Create fresh error for each call to avoid bodyUsed issue
+      mockSyncWorkflowDraft
+        .mockRejectedValueOnce(createMockErrorResponse('draft_workflow_not_sync'))
+        .mockRejectedValueOnce(createMockErrorResponse('draft_workflow_not_sync'))
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      // First sync attempt
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      // Wait for first refresh call
+      await waitFor(() => {
+        expect(mockHandleRefreshWorkflowDraft).toHaveBeenCalledTimes(1)
+      })
+
+      // Second sync attempt
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft()
+      })
+
+      // Both should call handleRefreshWorkflowDraft with true
+      await waitFor(() => {
+        expect(mockHandleRefreshWorkflowDraft).toHaveBeenCalledTimes(2)
+      })
+
+      mockHandleRefreshWorkflowDraft.mock.calls.forEach((call) => {
+        expect(call).toEqual([true])
+      })
+    })
+  })
+
+  describe('callbacks behavior', () => {
+    it('should not call onSuccess when sync fails', async () => {
+      const syncError = createMockErrorResponse('draft_workflow_not_sync')
+      mockSyncWorkflowDraft.mockRejectedValue(syncError)
+      const onSuccess = vi.fn()
+      const onError = vi.fn()
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft(false, { onSuccess, onError })
+      })
+
+      expect(onSuccess).not.toHaveBeenCalled()
+      expect(onError).toHaveBeenCalled()
+    })
+
+    it('should always call onSettled regardless of success or failure', async () => {
+      const onSettled = vi.fn()
+
+      const { result } = renderHook(() => useNodesSyncDraft())
+
+      // Test success case
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft(false, { onSettled })
+      })
+      expect(onSettled).toHaveBeenCalledTimes(1)
+
+      // Reset
+      onSettled.mockClear()
+
+      // Test failure case
+      const syncError = createMockErrorResponse('draft_workflow_not_sync')
+      mockSyncWorkflowDraft.mockRejectedValue(syncError)
+
+      await act(async () => {
+        await result.current.doSyncWorkflowDraft(false, { onSettled })
+      })
+      expect(onSettled).toHaveBeenCalledTimes(1)
+    })
+  })
+})
@@ -115,7 +115,7 @@ export const useNodesSyncDraft = () => {
        if (error && error.json && !error.bodyUsed) {
          error.json().then((err: any) => {
            if (err.code === 'draft_workflow_not_sync' && !notRefreshWhenSyncError)
-              handleRefreshWorkflowDraft()
+              handleRefreshWorkflowDraft(true)
          })
        }
        callback?.onError?.()
@@ -0,0 +1,556 @@
+/**
+ * Test Suite for useWorkflowRefreshDraft Hook
+ *
+ * PURPOSE:
+ * This hook is responsible for refreshing workflow draft data from the server.
+ * The key fix being tested is the `notUpdateCanvas` parameter behavior.
+ *
+ * MULTI-TAB PROBLEM SCENARIO:
+ * 1. User opens the same workflow in Tab A and Tab B (both have hash: v1)
+ * 2. Tab A saves successfully, server returns new hash: v2
+ * 3. Tab B tries to save with old hash: v1, server returns 400 error (draft_workflow_not_sync)
+ * 4. BEFORE FIX: handleRefreshWorkflowDraft() was called without args, which fetched
+ *    draft AND overwrote canvas - user lost unsaved changes in Tab B
+ * 5. AFTER FIX: handleRefreshWorkflowDraft(true) is called, which fetches draft but
+ *    only updates hash, preserving user's canvas changes
+ *
+ * TESTING STRATEGY:
+ * We don't simulate actual tab switching UI behavior. Instead, we test the hook's
+ * response to specific inputs:
+ * - When notUpdateCanvas=true: should NOT call handleUpdateWorkflowCanvas
+ * - When notUpdateCanvas=false/undefined: should call handleUpdateWorkflowCanvas
+ *
+ * This is behavior-driven testing - we verify "what the code does when given specific
+ * inputs" rather than simulating complete user interaction flows.
+ */
+
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useWorkflowRefreshDraft } from './use-workflow-refresh-draft'
+
+// Mock the workflow service
+const mockFetchWorkflowDraft = vi.fn()
+vi.mock('@/service/workflow', () => ({
+  fetchWorkflowDraft: (...args: unknown[]) => mockFetchWorkflowDraft(...args),
+}))
+
+// Mock the workflow update hook
+const mockHandleUpdateWorkflowCanvas = vi.fn()
+vi.mock('@/app/components/workflow/hooks', () => ({
+  useWorkflowUpdate: () => ({
+    handleUpdateWorkflowCanvas: mockHandleUpdateWorkflowCanvas,
+  }),
+}))
+
+// Mock store state
+const mockSetSyncWorkflowDraftHash = vi.fn()
+const mockSetIsSyncingWorkflowDraft = vi.fn()
+const mockSetEnvironmentVariables = vi.fn()
+const mockSetEnvSecrets = vi.fn()
+const mockSetConversationVariables = vi.fn()
+const mockSetIsWorkflowDataLoaded = vi.fn()
+const mockCancelDebouncedSync = vi.fn()
+
+const createMockStoreState = (overrides = {}) => ({
+  appId: 'test-app-id',
+  setSyncWorkflowDraftHash: mockSetSyncWorkflowDraftHash,
+  setIsSyncingWorkflowDraft: mockSetIsSyncingWorkflowDraft,
+  setEnvironmentVariables: mockSetEnvironmentVariables,
+  setEnvSecrets: mockSetEnvSecrets,
+  setConversationVariables: mockSetConversationVariables,
+  setIsWorkflowDataLoaded: mockSetIsWorkflowDataLoaded,
+  isWorkflowDataLoaded: true,
+  debouncedSyncWorkflowDraft: {
+    cancel: mockCancelDebouncedSync,
+  },
+  ...overrides,
+})
+
+const mockWorkflowStoreGetState = vi.fn()
+vi.mock('@/app/components/workflow/store', () => ({
+  useWorkflowStore: () => ({
+    getState: mockWorkflowStoreGetState,
+  }),
+}))
+
+// Default mock response from fetchWorkflowDraft
+const createMockDraftResponse = (overrides = {}) => ({
+  hash: 'new-hash-12345',
+  graph: {
+    nodes: [{ id: 'node-1', type: 'start', data: {} }],
+    edges: [{ id: 'edge-1', source: 'node-1', target: 'node-2' }],
+    viewport: { x: 100, y: 200, zoom: 1.5 },
+  },
+  environment_variables: [
+    { id: 'env-1', name: 'API_KEY', value: 'secret-key', value_type: 'secret' },
+    { id: 'env-2', name: 'BASE_URL', value: 'https://api.example.com', value_type: 'string' },
+  ],
+  conversation_variables: [
+    { id: 'conv-1', name: 'user_input', value: 'test' },
+  ],
+  ...overrides,
+})
+
+describe('useWorkflowRefreshDraft', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockWorkflowStoreGetState.mockReturnValue(createMockStoreState())
+    mockFetchWorkflowDraft.mockResolvedValue(createMockDraftResponse())
+  })
+
+  afterEach(() => {
+    vi.resetAllMocks()
+  })
+
+  describe('handleRefreshWorkflowDraft function', () => {
+    it('should return handleRefreshWorkflowDraft function', () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      expect(result.current.handleRefreshWorkflowDraft).toBeDefined()
+      expect(typeof result.current.handleRefreshWorkflowDraft).toBe('function')
+    })
+  })
+
+  describe('notUpdateCanvas parameter behavior (THE KEY FIX)', () => {
+    it('should NOT call handleUpdateWorkflowCanvas when notUpdateCanvas is true', async () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(true)
+      })
+
+      await waitFor(() => {
+        expect(mockFetchWorkflowDraft).toHaveBeenCalledWith('/apps/test-app-id/workflows/draft')
+      })
+
+      await waitFor(() => {
+        expect(mockSetSyncWorkflowDraftHash).toHaveBeenCalledWith('new-hash-12345')
+      })
+
+      // THE KEY ASSERTION: Canvas should NOT be updated when notUpdateCanvas is true
+      expect(mockHandleUpdateWorkflowCanvas).not.toHaveBeenCalled()
+    })
+
+    it('should call handleUpdateWorkflowCanvas when notUpdateCanvas is false', async () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(false)
+      })
+
+      await waitFor(() => {
+        expect(mockFetchWorkflowDraft).toHaveBeenCalledWith('/apps/test-app-id/workflows/draft')
+      })
+
+      await waitFor(() => {
+        // Canvas SHOULD be updated when notUpdateCanvas is false
+        expect(mockHandleUpdateWorkflowCanvas).toHaveBeenCalledWith({
+          nodes: [{ id: 'node-1', type: 'start', data: {} }],
+          edges: [{ id: 'edge-1', source: 'node-1', target: 'node-2' }],
+          viewport: { x: 100, y: 200, zoom: 1.5 },
+        })
+      })
+
+      await waitFor(() => {
+        expect(mockSetSyncWorkflowDraftHash).toHaveBeenCalledWith('new-hash-12345')
+      })
+    })
+
+    it('should call handleUpdateWorkflowCanvas when notUpdateCanvas is undefined (default)', async () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft()
+      })
+
+      await waitFor(() => {
+        expect(mockFetchWorkflowDraft).toHaveBeenCalled()
+      })
+
+      await waitFor(() => {
+        // Canvas SHOULD be updated when notUpdateCanvas is undefined
+        expect(mockHandleUpdateWorkflowCanvas).toHaveBeenCalled()
+      })
+    })
+
+    it('should still update hash even when notUpdateCanvas is true', async () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(true)
+      })
+
+      await waitFor(() => {
+        expect(mockSetSyncWorkflowDraftHash).toHaveBeenCalledWith('new-hash-12345')
+      })
+
+      // Verify canvas was NOT updated
+      expect(mockHandleUpdateWorkflowCanvas).not.toHaveBeenCalled()
+    })
+
+    it('should still update environment variables when notUpdateCanvas is true', async () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(true)
+      })
+
+      await waitFor(() => {
+        expect(mockSetEnvironmentVariables).toHaveBeenCalledWith([
+          { id: 'env-1', name: 'API_KEY', value: '[__HIDDEN__]', value_type: 'secret' },
+          { id: 'env-2', name: 'BASE_URL', value: 'https://api.example.com', value_type: 'string' },
+        ])
+      })
+
+      expect(mockHandleUpdateWorkflowCanvas).not.toHaveBeenCalled()
+    })
+
+    it('should still update env secrets when notUpdateCanvas is true', async () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(true)
+      })
+
+      await waitFor(() => {
+        expect(mockSetEnvSecrets).toHaveBeenCalledWith({
+          'env-1': 'secret-key',
+        })
+      })
+
+      expect(mockHandleUpdateWorkflowCanvas).not.toHaveBeenCalled()
+    })
+
+    it('should still update conversation variables when notUpdateCanvas is true', async () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(true)
+      })
+
+      await waitFor(() => {
+        expect(mockSetConversationVariables).toHaveBeenCalledWith([
+          { id: 'conv-1', name: 'user_input', value: 'test' },
+        ])
+      })
+
+      expect(mockHandleUpdateWorkflowCanvas).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('syncing state management', () => {
+    it('should set isSyncingWorkflowDraft to true before fetch', () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft()
+      })
+
+      expect(mockSetIsSyncingWorkflowDraft).toHaveBeenCalledWith(true)
+    })
+
+    it('should set isSyncingWorkflowDraft to false after fetch completes', async () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft()
+      })
+
+      await waitFor(() => {
+        expect(mockSetIsSyncingWorkflowDraft).toHaveBeenCalledWith(false)
+      })
+    })
+
+    it('should set isSyncingWorkflowDraft to false even when fetch fails', async () => {
+      mockFetchWorkflowDraft.mockRejectedValue(new Error('Network error'))
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft()
+      })
+
+      await waitFor(() => {
+        expect(mockSetIsSyncingWorkflowDraft).toHaveBeenCalledWith(false)
+      })
+    })
+  })
+
+  describe('isWorkflowDataLoaded flag management', () => {
+    it('should set isWorkflowDataLoaded to false before fetch when it was true', () => {
+      mockWorkflowStoreGetState.mockReturnValue(
+        createMockStoreState({ isWorkflowDataLoaded: true }),
+      )
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft()
+      })
+
+      expect(mockSetIsWorkflowDataLoaded).toHaveBeenCalledWith(false)
+    })
+
+    it('should set isWorkflowDataLoaded to true after fetch succeeds', async () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft()
+      })
+
+      await waitFor(() => {
+        expect(mockSetIsWorkflowDataLoaded).toHaveBeenCalledWith(true)
+      })
+    })
+
+    it('should restore isWorkflowDataLoaded when fetch fails and it was previously loaded', async () => {
+      mockWorkflowStoreGetState.mockReturnValue(
+        createMockStoreState({ isWorkflowDataLoaded: true }),
+      )
+      mockFetchWorkflowDraft.mockRejectedValue(new Error('Network error'))
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft()
+      })
+
+      await waitFor(() => {
+        // Should restore to true because wasLoaded was true
+        expect(mockSetIsWorkflowDataLoaded).toHaveBeenLastCalledWith(true)
+      })
+    })
+  })
+
+  describe('debounced sync cancellation', () => {
+    it('should cancel debounced sync before fetching draft', () => {
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft()
+      })
+
+      expect(mockCancelDebouncedSync).toHaveBeenCalled()
+    })
+
+    it('should handle case when debouncedSyncWorkflowDraft has no cancel method', () => {
+      mockWorkflowStoreGetState.mockReturnValue(
+        createMockStoreState({ debouncedSyncWorkflowDraft: {} }),
+      )
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      // Should not throw
+      expect(() => {
+        act(() => {
+          result.current.handleRefreshWorkflowDraft()
+        })
+      }).not.toThrow()
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should handle empty graph in response', async () => {
+      mockFetchWorkflowDraft.mockResolvedValue({
+        hash: 'hash-empty',
+        graph: null,
+        environment_variables: [],
+        conversation_variables: [],
+      })
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(false)
+      })
+
+      await waitFor(() => {
+        expect(mockHandleUpdateWorkflowCanvas).toHaveBeenCalledWith({
+          nodes: [],
+          edges: [],
+          viewport: { x: 0, y: 0, zoom: 1 },
+        })
+      })
+    })
+
+    it('should handle missing viewport in response', async () => {
+      mockFetchWorkflowDraft.mockResolvedValue({
+        hash: 'hash-no-viewport',
+        graph: {
+          nodes: [{ id: 'node-1' }],
+          edges: [],
+          viewport: null,
+        },
+        environment_variables: [],
+        conversation_variables: [],
+      })
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(false)
+      })
+
+      await waitFor(() => {
+        expect(mockHandleUpdateWorkflowCanvas).toHaveBeenCalledWith({
+          nodes: [{ id: 'node-1' }],
+          edges: [],
+          viewport: { x: 0, y: 0, zoom: 1 },
+        })
+      })
+    })
+
+    it('should handle missing environment_variables in response', async () => {
+      mockFetchWorkflowDraft.mockResolvedValue({
+        hash: 'hash-no-env',
+        graph: { nodes: [], edges: [], viewport: { x: 0, y: 0, zoom: 1 } },
+        environment_variables: undefined,
+        conversation_variables: [],
+      })
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(true)
+      })
+
+      await waitFor(() => {
+        expect(mockSetEnvironmentVariables).toHaveBeenCalledWith([])
+        expect(mockSetEnvSecrets).toHaveBeenCalledWith({})
+      })
+    })
+
+    it('should handle missing conversation_variables in response', async () => {
+      mockFetchWorkflowDraft.mockResolvedValue({
+        hash: 'hash-no-conv',
+        graph: { nodes: [], edges: [], viewport: { x: 0, y: 0, zoom: 1 } },
+        environment_variables: [],
+        conversation_variables: undefined,
+      })
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(true)
+      })
+
+      await waitFor(() => {
+        expect(mockSetConversationVariables).toHaveBeenCalledWith([])
+      })
+    })
+
+    it('should filter only secret type for envSecrets', async () => {
+      mockFetchWorkflowDraft.mockResolvedValue({
+        hash: 'hash-mixed-env',
+        graph: { nodes: [], edges: [], viewport: { x: 0, y: 0, zoom: 1 } },
+        environment_variables: [
+          { id: 'env-1', name: 'SECRET_KEY', value: 'secret-value', value_type: 'secret' },
+          { id: 'env-2', name: 'PUBLIC_URL', value: 'https://example.com', value_type: 'string' },
+          { id: 'env-3', name: 'ANOTHER_SECRET', value: 'another-secret', value_type: 'secret' },
+        ],
+        conversation_variables: [],
+      })
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(true)
+      })
+
+      await waitFor(() => {
+        expect(mockSetEnvSecrets).toHaveBeenCalledWith({
+          'env-1': 'secret-value',
+          'env-3': 'another-secret',
+        })
+      })
+    })
+
+    it('should hide secret values in environment variables', async () => {
+      mockFetchWorkflowDraft.mockResolvedValue({
+        hash: 'hash-secrets',
+        graph: { nodes: [], edges: [], viewport: { x: 0, y: 0, zoom: 1 } },
+        environment_variables: [
+          { id: 'env-1', name: 'SECRET_KEY', value: 'super-secret', value_type: 'secret' },
+          { id: 'env-2', name: 'PUBLIC_URL', value: 'https://example.com', value_type: 'string' },
+        ],
+        conversation_variables: [],
+      })
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(true)
+      })
+
+      await waitFor(() => {
+        expect(mockSetEnvironmentVariables).toHaveBeenCalledWith([
+          { id: 'env-1', name: 'SECRET_KEY', value: '[__HIDDEN__]', value_type: 'secret' },
+          { id: 'env-2', name: 'PUBLIC_URL', value: 'https://example.com', value_type: 'string' },
+        ])
+      })
+    })
+  })
+
+  describe('multi-tab scenario simulation (THE BUG FIX VERIFICATION)', () => {
+    /**
+     * This test verifies the fix for the multi-tab scenario:
+     * 1. User opens workflow in Tab A and Tab B
+     * 2. Tab A saves draft successfully
+     * 3. Tab B tries to save but gets 'draft_workflow_not_sync' error (hash mismatch)
+     * 4. BEFORE FIX: Tab B would fetch draft and overwrite canvas with old data
+     * 5. AFTER FIX: Tab B only updates hash, preserving user's canvas changes
+     */
+    it('should only update hash when called with notUpdateCanvas=true (simulating sync error recovery)', async () => {
+      const mockResponse = createMockDraftResponse()
+      mockFetchWorkflowDraft.mockResolvedValue(mockResponse)
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      // Simulate the sync error recovery scenario where notUpdateCanvas is true
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(true)
+      })
+
+      await waitFor(() => {
+        expect(mockFetchWorkflowDraft).toHaveBeenCalled()
+      })
+
+      await waitFor(() => {
+        // Hash should be updated for next sync attempt
+        expect(mockSetSyncWorkflowDraftHash).toHaveBeenCalledWith('new-hash-12345')
+      })
+
+      // Canvas should NOT be updated - user's changes are preserved
+      expect(mockHandleUpdateWorkflowCanvas).not.toHaveBeenCalled()
+
+      // Other states should still be updated
+      expect(mockSetEnvironmentVariables).toHaveBeenCalled()
+      expect(mockSetConversationVariables).toHaveBeenCalled()
+    })
+
+    it('should update canvas when called with notUpdateCanvas=false (normal refresh)', async () => {
+      const mockResponse = createMockDraftResponse()
+      mockFetchWorkflowDraft.mockResolvedValue(mockResponse)
+
+      const { result } = renderHook(() => useWorkflowRefreshDraft())
+
+      // Simulate normal refresh scenario
+      act(() => {
+        result.current.handleRefreshWorkflowDraft(false)
+      })
+
+      await waitFor(() => {
+        expect(mockFetchWorkflowDraft).toHaveBeenCalled()
+      })
+
+      await waitFor(() => {
+        expect(mockSetSyncWorkflowDraftHash).toHaveBeenCalledWith('new-hash-12345')
+      })
+
+      // Canvas SHOULD be updated in normal refresh
+      await waitFor(() => {
+        expect(mockHandleUpdateWorkflowCanvas).toHaveBeenCalled()
+      })
+    })
+  })
+})
@@ -8,7 +8,7 @@ export const useWorkflowRefreshDraft = () => {
  const workflowStore = useWorkflowStore()
  const { handleUpdateWorkflowCanvas } = useWorkflowUpdate()

-  const handleRefreshWorkflowDraft = useCallback(() => {
+  const handleRefreshWorkflowDraft = useCallback((notUpdateCanvas?: boolean) => {
    const {
      appId,
      setSyncWorkflowDraftHash,
@@ -31,12 +31,14 @@ export const useWorkflowRefreshDraft = () => {
    fetchWorkflowDraft(`/apps/${appId}/workflows/draft`)
      .then((response) => {
        // Ensure we have a valid workflow structure with viewport
-        const workflowData: WorkflowDataUpdater = {
-          nodes: response.graph?.nodes || [],
-          edges: response.graph?.edges || [],
-          viewport: response.graph?.viewport || { x: 0, y: 0, zoom: 1 },
+        if (!notUpdateCanvas) {
+          const workflowData: WorkflowDataUpdater = {
+            nodes: response.graph?.nodes || [],
+            edges: response.graph?.edges || [],
+            viewport: response.graph?.viewport || { x: 0, y: 0, zoom: 1 },
+          }
+          handleUpdateWorkflowCanvas(workflowData)
        }
-        handleUpdateWorkflowCanvas(workflowData)
        setSyncWorkflowDraftHash(response.hash)
        setEnvSecrets((response.environment_variables || []).filter(env => env.value_type === 'secret').reduce((acc, env) => {
          acc[env.id] = env.value
@@ -87,7 +87,6 @@ export type ToolValue = {
  enabled?: boolean
  extra?: { description?: string } & Record<string, unknown>
  credential_id?: string
-  type?: string
 }

 export type DataSourceItem = {
@@ -18,7 +18,6 @@ import {
  Group,
 } from '@/app/components/workflow/nodes/_base/components/layout'
 import VarReferencePicker from '@/app/components/workflow/nodes/_base/components/variable/var-reference-picker'
-import { IS_CE_EDITION } from '@/config'
 import Split from '../_base/components/split'
 import ChunkStructure from './components/chunk-structure'
 import EmbeddingModel from './components/embedding-model'
@@ -173,7 +172,7 @@ const Panel: FC<NodePanelProps<KnowledgeBaseNodeType>> = ({
                {
                  data.indexing_technique === IndexMethodEnum.QUALIFIED
                  && [ChunkStructureEnum.general, ChunkStructureEnum.parent_child].includes(data.chunk_structure)
-                  && IS_CE_EDITION && (
+                  && (
                    <>
                      <SummaryIndexSetting
                        summaryIndexSetting={data.summary_index_setting}
@@ -1,7 +1,7 @@
 {
  "name": "dify-web",
  "type": "module",
-  "version": "1.12.1",
+  "version": "1.11.4",
  "private": true,
  "packageManager": "[email protected]+sha512.72d699da16b1179c14ba9e64dc71c9a40988cbdc65c264cb0e489db7de917f20dcf4d64d8723625f2969ba52d4b7e2a1170682d9ac2a5dcaeaab732b7e16f04a",
  "imports": {
@@ -117,6 +117,7 @@
    "ky": "1.12.0",
    "lamejs": "1.2.1",
    "lexical": "0.38.2",
+    "line-clamp": "1.0.0",
    "mermaid": "11.11.0",
    "mime": "4.1.0",
    "mitt": "3.0.1",
@@ -1,80 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-const loadGetBaseURL = async (isClientValue: boolean) => {
-  vi.resetModules()
-  vi.doMock('@/utils/client', () => ({ isClient: isClientValue }))
-  const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-  // eslint-disable-next-line next/no-assign-module-variable
-  const module = await import('./client')
-  warnSpy.mockClear()
-  return { getBaseURL: module.getBaseURL, warnSpy }
-}
-
-// Scenario: base URL selection and warnings.
-describe('getBaseURL', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  // Scenario: client environment uses window origin.
-  it('should use window origin when running on the client', async () => {
-    // Arrange
-    const { origin } = window.location
-    const { getBaseURL, warnSpy } = await loadGetBaseURL(true)
-
-    // Act
-    const url = getBaseURL('/api')
-
-    // Assert
-    expect(url.href).toBe(`${origin}/api`)
-    expect(warnSpy).not.toHaveBeenCalled()
-  })
-
-  // Scenario: server environment falls back to localhost with warning.
-  it('should fall back to localhost and warn on the server', async () => {
-    // Arrange
-    const { getBaseURL, warnSpy } = await loadGetBaseURL(false)
-
-    // Act
-    const url = getBaseURL('/api')
-
-    // Assert
-    expect(url.href).toBe('http://localhost/api')
-    expect(warnSpy).toHaveBeenCalledTimes(1)
-    expect(warnSpy).toHaveBeenCalledWith('Using localhost as base URL in server environment, please configure accordingly.')
-  })
-
-  // Scenario: non-http protocols surface warnings.
-  it('should warn when protocol is not http or https', async () => {
-    // Arrange
-    const { getBaseURL, warnSpy } = await loadGetBaseURL(true)
-
-    // Act
-    const url = getBaseURL('localhost:5001/console/api')
-
-    // Assert
-    expect(url.protocol).toBe('localhost:')
-    expect(url.href).toBe('localhost:5001/console/api')
-    expect(warnSpy).toHaveBeenCalledTimes(1)
-    expect(warnSpy).toHaveBeenCalledWith(
-      'Unexpected protocol for API requests, expected http or https. Current protocol: localhost:. Please configure accordingly.',
-    )
-  })
-
-  // Scenario: absolute http URLs are preserved.
-  it('should keep absolute http URLs intact', async () => {
-    // Arrange
-    const { getBaseURL, warnSpy } = await loadGetBaseURL(true)
-
-    // Act
-    const url = getBaseURL('https://api.example.com/console/api')
-
-    // Assert
-    expect(url.href).toBe('https://api.example.com/console/api')
-    expect(warnSpy).not.toHaveBeenCalled()
-  })
-})
@@ -13,38 +13,12 @@ import {
  consoleRouterContract,
  marketplaceRouterContract,
 } from '@/contract/router'
-import { isClient } from '@/utils/client'
 import { request } from './base'

 const getMarketplaceHeaders = () => new Headers({
  'X-Dify-Version': !IS_MARKETPLACE ? APP_VERSION : '999.0.0',
 })

-function isURL(path: string) {
-  try {
-    // eslint-disable-next-line no-new
-    new URL(path)
-    return true
-  }
-  catch {
-    return false
-  }
-}
-
-export function getBaseURL(path: string) {
-  const url = new URL(path, isURL(path) ? undefined : isClient ? window.location.origin : 'http://localhost')
-
-  if (!isClient && !isURL(path)) {
-    console.warn('Using localhost as base URL in server environment, please configure accordingly.')
-  }
-
-  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-    console.warn(`Unexpected protocol for API requests, expected http or https. Current protocol: ${url.protocol}. Please configure accordingly.`)
-  }
-
-  return url
-}
-
 const marketplaceLink = new OpenAPILink(marketplaceRouterContract, {
  url: MARKETPLACE_API_PREFIX,
  headers: () => (getMarketplaceHeaders()),
@@ -65,7 +39,7 @@ export const marketplaceClient: JsonifiedClient<ContractRouterClient<typeof mark
 export const marketplaceQuery = createTanstackQueryUtils(marketplaceClient, { path: ['marketplace'] })

 const consoleLink = new OpenAPILink(consoleRouterContract, {
-  url: getBaseURL(API_PREFIX),
+  url: API_PREFIX,
  fetch: (input, init) => {
    return request(
      input.url,
@@ -9,6 +9,7 @@ import type {
 } from '@/types/workflow'
 import { get, post } from './base'
 import { getFlowPrefix } from './utils'
+import { sanitizeWorkflowDraftPayload } from './workflow-payload'

 export const fetchWorkflowDraft = (url: string) => {
  return get(url, {}, { silent: true }) as Promise<FetchWorkflowDraftResponse>
@@ -18,7 +19,8 @@ export const syncWorkflowDraft = ({ url, params }: {
  url: string
  params: Pick<FetchWorkflowDraftResponse, 'graph' | 'features' | 'environment_variables' | 'conversation_variables'>
 }) => {
-  return post<CommonResponse & { updated_at: number, hash: string }>(url, { body: params }, { silent: true })
+  const sanitized = sanitizeWorkflowDraftPayload(params)
+  return post<CommonResponse & { updated_at: number, hash: string }>(url, { body: sanitized }, { silent: true })
 }

 export const fetchNodesDefaultConfigs = (url: string) => {
Author	SHA1	Message	Date
zxhlyh	031565579a	Merge branch 'main' into fix/workflow-sync-draft	2026-02-03 13:58:30 +08:00
zxhlyh	7815d33871	Merge branch 'main' into fix/workflow-sync-draft	2026-01-30 10:52:14 +08:00
zxhlyh	aeb41d3b2c	Merge branch 'main' into fix/workflow-sync-draft	2026-01-30 09:39:18 +08:00
zxhlyh	4275aa729f	Merge branch 'main' into fix/workflow-sync-draft	2026-01-27 10:47:51 +08:00
zxhlyh	0ed0a31ed6	fix: workflow sync draft	2026-01-26 14:41:12 +08:00